原创

一文读懂【代理模式】

什么是代理模式

在代理模式（Proxy Pattern）中，一个类代表（增强）另一个类的功能。这种类型的设计模式属于结构型模式。
举个栗子：
传闻马云在上海买房子，但是马云可能不懂房地产但是自己钱多，这个时候马云找自己的小秘代自己就行了，因为小秘最懂这，只需要马云付款就ok。这个时候马云就是目标类，小秘就是代理类。和中介的性质相似。
简单来说就是我们使用代理对象来代替对真实对象(real object)的访问，这样就可以在不修改原目标对象的前提下，提供额外的功能操作，扩展目标对象的功能。
代理模式的主要作用是扩展目标对象的功能，比如说在目标对象的某个方法执行前后你可以增加一些自定义的操作。

代理模式有哪些

静态代理

静态代理实现步骤:
1.定义一个接口及其实现类；
2.创建一个代理类同样实现这个接口
3.将目标对象注入进代理类，然后在代理类的对应方法调用目标类中的对应方法。这样的话，我们就可以通过代理类屏蔽对目标对象的访问，并且可以在目标方法执行前后做一些自己想做的事情。
下面我们来看一个简单的例子
1.创建个接口

public interface BuyHouse {
    void buyHouse();
}

2.创建目标类

public class BuyHouseImpl implements BuyHouse {
    @Override
    public void buyHouse() {
        System.out.println("马云出钱");
    }
}

3.创建代理类

public class BuyHouseProxy implements BuyHouse{
    private BuyHouse buyHouse;

    public BuyHouseProxy(BuyHouse buyHouse) {
        this.buyHouse = buyHouse;
    }

    @Override
    public void buyHouse() {
        System.out.println("小秘跑腿办手续。");
        buyHouse.buyHouse();
        System.out.println("小秘交钥匙给马云。");
    }
}

4.主方法

public class Main {
    public static void main(String[] args) {
        BuyHouseProxy buyHouseProxy = new BuyHouseProxy(new BuyHouseImpl());
        buyHouseProxy.buyHouse();
    }
}

这里的三个类的命名并没有那么严格，仅仅是为了通俗易懂。
运行结果：

可以输出结果看出，我们已经增强了马云买房。
有的人可能会有这个疑问，为什么需要接口呢，不创建接口我们不是也能实现增强，只要把目标类传入代理就行了嘛。
1.因为代理类和目标类必须有一样的结构，你这只有有一个方法，如果目标类有n多方法，你是自己一个个在p中去写比较方便呢？还是让他两都实现一个接口比较方便呢？
2.保证外部在调用代理类和目标类的感觉上是一致的。让外部在使用代理类和目标类时没有区别。
3.用什么方式传入实现类呢?A.构造 B.通过set方法

动态代理

相比于静态代理来说，动态代理更加灵活。我们不需要针对每个目标类都单独创建一个代理类，并且也不需要我们必须实现接口，我们可以直接代理实现类( CGLIB 动态代理机制)。

说到动态代理，Spring AOP、RPC 框架应该是两个不得不的提的，它们的实现都依赖了动态代理
就 Java 来说，动态代理的实现方式有很多种，比如 JDK 动态代理、CGLIB 动态代理等等。

JDK动态代理

在 Java 动态代理机制中 InvocationHandler 接口和 Proxy 类是核心。

Proxy 类中使用频率最高的方法是：newProxyInstance() ，这个方法主要用来生成一个代理对象。

public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)
    throws IllegalArgumentException
{
    ......
}

这个方法一共有 3 个参数：

loader :类加载器，用于加载代理对象。
interfaces : 被代理类实现的一些接口；
h : 实现了 InvocationHandler 接口的对象；

要实现动态代理的话，还必须需要实现InvocationHandler 来自定义处理逻辑。当我们的动态代理对象调用一个方法时候，这个方法的调用就会被转发到实现InvocationHandler 接口类的 invoke 方法来调用。

public interface InvocationHandler {
    /**
     * 当你使用代理对象调用方法的时候实际会调用到这个方法
     */
    public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable;
}

invoke() 方法有下面三个参数：

proxy :动态生成的代理类
method : 与代理类对象调用的方法相对应
args : 当前 method 方法的参数

也就是说：你通过Proxy 类的 newProxyInstance() 创建的代理对象在调用方法的时候，实际会调用到实现InvocationHandler 接口的类的 invoke()方法。你可以在 invoke() 方法中自定义处理逻辑，比如在方法执行前后做什么事情。

JDK 动态代理类使用步骤
1.定义一个接口及其实现类；
2.自定义 InvocationHandler 并重写invoke方法，在 invoke 方法中我们会调用原生方法（）并自定义一些处理逻辑；
3.通过 Proxy.newProxyInstance(ClassLoader loader,Class[] interfaces,InvocationHandler h) 方法创建代理对象；

具体代码
1.定义InvocationHandler

public class BuyHouseHander implements InvocationHandler {
    /**
     * 代理类中的真实对象,这里传入Object更加通用
     */
    private final Object target;

    public BuyHouseHander(Object target) {
        this.target = target;
    }


    public Object invoke(Object proxy, Method method, Object[] args) throws InvocationTargetException, IllegalAccessException {
        //调用方法之前，我们可以添加自己的操作
        System.out.println("before method " + method.getName());
        Object result = method.invoke(target, args);
        //调用方法之后，我们同样可以添加自己的操作
        System.out.println("after method " + method.getName());
        return result;
    }
}

2.创建代理对象

public class JdkProxyFactory {
    public static Object getProxy(Object target) {
        return Proxy.newProxyInstance(
                target.getClass().getClassLoader(), // 目标类的类加载
                target.getClass().getInterfaces(),  // 代理需要实现的接口，可指定多个
                new BuyHouseHander(target)   // 代理对象对应的自定义 InvocationHandler
        );
    }
}

3.主方法

public class Main {
    public static void main(String[] args) {
        BuyHouse buyHouseProxy = (BuyHouse) JdkProxyFactory.getProxy(new BuyHouseImpl());
        buyHouseProxy.buyHouse();
    }
}

运行结果：

CJLIB动态代理

我们看到，JDK 动态代理有一个最致命的问题是其只能代理实现了接口的类。（因为在创建代理类的时候需要传入接口）

为了解决这个问题，我们可以用 CGLIB 动态代理机制来避免。

CGLIB(Code Generation Library)是一个基于ASM的字节码生成库，它允许我们在运行时对字节码进行修改和动态生成。CGLIB 通过继承方式实现代理。很多知名的开源框架都使用到了CGLIB，例如 Spring 中的 AOP 模块中：如果目标对象实现了接口，则默认采用 JDK 动态代理，否则采用 CGLIB 动态代理。

在 CGLIB 动态代理机制中 MethodInterceptor 接口和 Enhancer 类是核心。

你需要自定义 MethodInterceptor 并重写 intercept 方法，intercept 用于拦截增强被代理类的方法。

public interface MethodInterceptor
extends Callback{
    // 拦截被代理类中的方法
    public Object intercept(Object obj, java.lang.reflect.Method method, Object[] args,
                               MethodProxy methodProxy ) throws Throwable;
}

obj :被代理的对象（需要增强的对象）
method :被拦截的方法（需要增强的方法）
args :方法入参
methodProxy :用于调用原始方法
你可以通过 Enhancer类来动态获取被代理类，当代理类调用方法的时候，实际调用的是 MethodInterceptor 中的 intercept 方法。
CGLIB 动态代理类使用步骤
定义一个类；
1.自定义 MethodInterceptor 并重写 intercept 方法，intercept 用于拦截增强被代理类的方法，和 JDK 动态代理中的 invoke 方法类似；
2.通过 Enhancer 类的 create()创建代理类；

需要导入额外的jar

    <dependency>
      <groupId>cglib</groupId>
      <artifactId>cglib</artifactId>
      <version>3.3.0</version>
    </dependency>

1.自定义MethodInterceptor

    public class BuyHouseMethodInterceptor implements MethodInterceptor {
    /**
     * @param o           被代理的对象（需要增强的对象）
     * @param method      被拦截的方法（需要增强的方法）
     * @param args        方法入参
     * @param methodProxy 用于调用原始方法
     */
    @Override
    public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        //调用方法之前，我们可以添加自己的操作
        System.out.println("before method " + method.getName());
        Object object = methodProxy.invokeSuper(o, args);
        //调用方法之后，我们同样可以添加自己的操作
        System.out.println("after method " + method.getName());
        return object;
    }
}

2.生成代理类CglibProxyFactory

public class CglibProxyFactory {
    public static Object getProxy(Class<?> clazz) {
        // 创建动态代理增强类
        Enhancer enhancer = new Enhancer();
        // 设置类加载器
        enhancer.setClassLoader(clazz.getClassLoader());
        // 设置被代理类
        enhancer.setSuperclass(clazz);
        // 设置方法拦截器
        enhancer.setCallback(new BuyHouseMethodInterceptor());
        // 创建代理类
        return enhancer.create();
    }
}

3.主方法

public class Main {
    public static void main(String[] args) {
        BuyHouse buyHouseProxy =(BuyHouse) CglibProxyFactory.getProxy(BuyHouseImpl.class);
        buyHouseProxy.buyHouse();
    }
}

运行结果

JDK 动态代理和 CGLIB 动态代理对比

区别：
JDK：基于接口方式实现的动态代理，目标类和代理类拥有相同的接口，也就是说目标类必须有相同的接口才能使用JDK代理方式。
JDK 原生，在jvm里运行较为可靠
平滑支持JDK版本的升级
CGLib:基于继承的方式实现的动态代理，（目标类是父类，代理类是子类，代理类的方法会覆盖父类的方法），基于ASM机制实现
被代理对象无需实现接口，能实现代理类的无侵入。 CGLIB 动态代理是通过生成一个被代理类的子类来拦截被代理类的方法调用，因此不能代理声明为 final 类型的类和方法。
性能方面：
1.8之前是cglib比JDK性能好
1.8之后（包括1.8），jdk已经比cglib快，cglib动态生成字节码代理类比较耗时间
spring aop两种方式都使用了，默认使用的是JDK，如果想使用CGLib，需要设置aop:aspectj-autoproxy标签的proxy-target-class属性才可以

springAop使用的是JDK动态代理还是CGlib?
如果没有接口就使用的是CGlib（proxyTargetClass=true永远使用CGlib,不管有没有接口），如果有接口且proxyTargetClass=false使用的是JDK，
默认策略：Bean实现了接口则用JDK

代理模式优劣

静态代理和动态代理的对比
1.灵活性：动态代理更加灵活，不需要必须实现接口，可以直接代理实现类，并且可以不需要针对每个目标类都创建一个代理类。另外，静态代理中，接口一旦新增加方法，目标对象和代理对象都要进行修改，这是非常麻烦的！
2.JVM 层面：静态代理在编译时就将接口、实现类、代理类这些都变成了一个个实际的 class 文件。而动态代理是在运行时动态生成类字节码，并加载到 JVM 中的。

知识串联
在解析Spring中Configuration和Component区别中曾提到过CGLIB动态代理

正文到此结束(点击广告是对作者最大的支持)