设计模式之代理模式-简单、清晰、易懂

1. 代理模式理解

简单来说，代理模式就是 我们使用代理对象来代替访问真实对象的访问，这样就可以在不修改原目标对象的前提下，提供额外的功能操作，扩展目标对象的额功能 。

代理模式的主要作用： 扩展目标对象的功能，比如说在目标对象的某个方法执行前后增加一些自定义的操作。

代理模式有 静态代理 和 动态代理 两种实现方式，我们分别来看下对应的实现。

2. 静态代理

静态代理中，我们对目标对象的每个方法的增强都是手动完成的，非常的不灵活（比如接口一旦新增方法，目标对象和代理对象都要进行修改）且麻烦（需要对每个目标类都单独写一个代理类）。实际应用场景非常非常少，日常开发几乎看不到使用静态代理的场景。

上面是从实现和应用角度来说的静态代理，从JVM层面来说，静态代理在编译时就将接口、实现类、代理类这些都变成了一个个实际的class文件。

静态代理实现的步骤：

1. 定义一个接口及其实现类。
2. 创建一个代理类，并且代理类实现这个接口。
3. 将目标对象注入代理类，然后在代理类的对应方法调用目标类中的对应方法。

这样的话，我们就可以通过代理类屏蔽对目标对象的访问，并且可以在目标方法执行前后做一些想要做的事情。

下面通过代码来说明代理模式：

1.定义一个测试接口

public interface TestService {
    String test(String str);
}

2.定义接口实现类

public class TestServiceImpl implements TestService {
    @Override
    public String test(String str) {
        System.out.println("test method : "+ str);
        return str;
    }
}

3.定义代理类，并同样实现测试接口

public class TestPolicy implements TestService {

    private final TestService testService;

    public TestPolicy(TestService testService) {
        this.testService = testService;
    }

    @Override
    public String test(String str) {
        System.out.println("before method test()");
        smsService.send(str);
        System.out.println("after method test()");
        return null;
    }
}

4.实际测试

public class Test {
    public static void main(String[] args) {
        TestService testService = new TestServiceImpl();
        TestPolicy testPolicy = new TestPolicy(testService);
        testPolicy.test("Java测试");
    }
}

运行上面代码后，通知台打印：

before method test()
Java测试
after method test()

从输出结果可以看出，我们已经增强了 TestServiceImpl 的 test() 方法。

3. 动态代理

相比静态代理，动态代理更加灵活，不需要针对每个目标类都单独创建一个代理类，并且也不需要必须实现接口。

从 JVM 的角度来说，动态代理是在运行时动态生成类字节码，并加载到 JVM 中的。

就 Java 来说，动态代理实现方式有很多中，比如 JDK动态代理 、 CGLIB 动态代理 等等。

3.1. JDK动态代理

3.1.1. 介绍

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

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

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

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

1. loader ：类加载器，用于加载代理对象。
2. interfaces ：被代理实现的一些接口。
3. h ：实现了 InvocationHandler 接口的对象。

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

public interface InvocationHandler {

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

Invoke() 方法有三个参数：

1. proxy ：动态生成的类。
2. method ：与代理类对象调用的方法相对应。
3. args ：当前method方法的参数。

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

3.1.2. JDK动态代理类实现

步骤：

1. 定义一个接口及其实现类。
2. 自定义 InvocationHandler 并重写 invoke 方法，在 invoke方法中我们会调用被代理的方法并自定义一些处理逻辑。
3. 通过 Proxy.newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)方法创建代理对象。

3.1.3. 示例代码

为了让小伙伴更好的理解 JDK动态代理机制 ，我们用代码来实现哦。

1.定义测试接口

public interface TestService {
    String test(String str);
}

2.定义测试接口实现类

public class TestServiceImpl implements TestService {
    @Override
    public String test(String str) {
        System.out.println("test method : "+ str);
        return str;
    }
}

3.定义一个 JDK动态代理类

public class TestInvocationHandler implements InvocationHandler {

    /**
     * 代理类中的真实对象
     */
    private final Object target;

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

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

invoke() 方法：当我们的动态代理对象调用原生方法的时候，实际上调用到的是 invoke()方法，然后 invoke() 里面再调用被代理对象的原生方法。

4.获取代理对象的工厂类

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

getProxy() ：主要通过Proxy.newProxyInstance（）方法获取某个类的代理对象。

5.测试调用

public class Test {
    public static void main(String[] args) {
        TestService testService = (TestService)JdkTestProxyFactory.getProxy(new TestServiceImpl());
        testService.test("Java 测试");
    }
}

运行上述代码之后，控制台打印输出：

before method : test
test method : Java 测试
after method : test

3.2. CGLIB 动态代理

3.2.1. 介绍

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 proxy) throws Throwable;
}

intercept 方法有以下几个参数：

1. obj ：被代理的对象（需要增强的对象）
2. method ：被拦截的方法 （需要增强的方法）
3. args ： 方法入参
4. methodProxy ： 用于调用原生方法

你可以通过 Enhancer类来动态获取被代理类，当代理类调用方法的时候，实际调用的是 MethodInterceptor 中的 intercept 方法。

3.2.2. CGLIB动态代理类实现

步骤：

1. 定义一个类；
2. 自定义 MethodInterceptor 接口，并重写 intercept() 方法，intercept() 方法用于拦截增强被代理类的方法，和 JDK动态代理中的invoke() 方法类似。
3. 通过 Enhancer 类的 create() 创建代理类。

3.2.3.示例代码

JDK 动态代理不需要依赖额外的依赖，CGLIB 实际是属于一个开源项目，如果想要使用它的话，需要手动添加相关依赖。

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

1.实现一个测试类

public class TestService{
    public String test(String str) {
        System.out.println("test method : "+ str);
        return str;
    }
}

2.自定义 MethodInterceptor 类（方法拦截器）

public class TestMethodInterceptor 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;
    }
}

3.获取代理类

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

4.测试调用

public class Test {
    public static void main(String[] args) {
        TestService proxy = (TestService)CglibProxyFactory.getProxy(TestService.class);
        proxy.test("Java 测试");
    }
}

运行上述代码之后，控制台打印：

before method test
test method : Java 测试
after method test

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

1. JDK动态代理只能代理实现了接口的类 或者 直接代理接口，而CGLIB可以代理未实现任何接口的类。 另外，CGLIB 动态代理是通过生成一个呗代理类的子类来拦截被代理类的方法调用，因此不用声明为final类型的类和方法。
2. 就二者效率来说，大部分情况都是 JDK动态代理更加优秀，随着JDK版本的升级，这个优势更加明显。

4. 静态代理和动态代理的对比

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

5. 总结

本篇文章讲解了代理模式的两种实现：静态代理和动态代理。代码和笔记由于纯手打，难免会有纰漏，如果发现错误的地方，请第一时间告诉我，这将是我进步的一个很重要的环节。以后会定期更新算法题目以及各种开发知识点，如果您觉得写得不错，不妨点个关注，谢谢。