背景

代理模式，很类似与商品买卖中的中间商。客户不需要直接和生产商联系，生产商将产品的销售工作代理给中间商。
在编程中，代理模式和现实生活中类似，调用方通过调用代理，间接的调用了服务提供方。当然，代理不纯粹是一个调用服务提供方的桥梁，它也可以在调用时加入额外的逻辑，这好比是零售商为商品加上包装。
代理分为两种：静态代理和动态代理。静态代理是代码编译的时候将代理逻辑写入字节码。好处是运行效率高，但是如果有大量的类需要代理，需要编写大量重复代码。与静态代理对应的是动态代理。动态代理在运行的时候生成，尽管用起来效果类似，但是动态代理的灵活性是静态代理无法匹敌的。
下面为大家分享两种最常用的动态代理方式：JDK动态代理和CGLib动态代理。

JDK动态代理

JDK动态代理由JDK提供。使用时要求被代理类必须实现一个接口。它的原理是创建一个同样接口的实现类，这个类包含了代理逻辑。

下面举个例子。
我们有一个想要被代理的实现类和它的接口：

interface Controller {
    String doSomething(String str);
}

class ControllerImpl implements Controller {
    @Override
    public String doSomething(String str) {
        return "Call " + str;
    }
}

我们现在需要创建一个动态代理，使得调用doSomething方法之前做一些额外的逻辑。编写main方法如下所示：

public class JDKProxyDemo {
    public static void main(String[] args) {
        // 创建被代理类实例
        Controller controller = new ControllerImpl();
        // 创建代理类
        // newProxyInstance方法共3个参数
        // 分别为被代理类的ClassLoader
        // 被代理类的接口
        // 和代理逻辑InvocationHandler 
        Controller controllerProxied = (Controller) Proxy.newProxyInstance(ControllerImpl.class.getClassLoader(), ControllerImpl.class.getInterfaces(), (proxy, method, args1) -> {
            // 三个参数的含义分别为，proxy对象（不常用），被调用的方法和调用方法的参数列表
            // 调用被代理的方法之前，调用额外的逻辑，这里示例为打印一句话
            System.out.println("Proxy logic");
            // 调用被代理的方法，返回方法的返回值
            return method.invoke(controller, args1);
        });
        // 调用代理类的`doSomething`方法
        System.out.println(controllerProxied.doSomething("Paul"));
    }
}

程序输出如下所示：

Proxy logic
Call Paul

我们发现，在调用被代理类doSomething方法之前，执行了额外的逻辑。

CGLib 动态代理

另一种动态代理方式是使用第三方库CGLib。CGLib和JDK动态代理不同，不需要被代理类实现接口。它的原理是动态创建出被代理类的子类，其中包含代理逻辑。由此可知CGLib是无法代理被final修饰的类的。因为被final修饰的类无法被继承。

一个使用CGLib的例子如下。
首先创建一个maven项目，引入如下依赖：

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

我们举一个较为复杂的例子，仅仅代理目标类被@Intercept注解修饰的方法。
首先我们定义代理拦截注解：

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Intercept {
}

这里是被代理的Calculator类。我们需要代理它的add方法。

public class Calculator {
    @Intercept
    public int add(int a, int b) {
        return a + b;
    }

    public int minus(int a, int b) {
        return a - b;
    }
}

然后，我们编写方法的拦截器，如下所示：

class MethodCallBack implements MethodInterceptor {
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        // 获取方法的注解
        Intercept intercept = method.getAnnotation(Intercept.class);

        Object value;

        // 如果获取到了intercept注解
        if (null != intercept) {
            // 执行额外的代理逻辑，打印一个字符串，再打印出调用该方法的参数列表
            System.out.println("Annotated by intercept");
            System.out.println(Arrays.asList(objects));
            // 然后我们调用真正的被代理方法，获取返回值
            value = methodProxy.invokeSuper(o, objects);
        } else {
            // 如果方法没有被intercept注解修饰，直接调用该方法
            value = methodProxy.invokeSuper(o, objects);
        }
        // 返回调用方法的返回值
        return value;
    }
}

最后我们编写main方法，如下：

public class Demo {
    public static void main(String[] args) throws Exception {
        // 创建一个增强器enhancer
        Enhancer enhancer = new Enhancer();
        // 设置父类，即被代理的类
        enhancer.setSuperclass(Calculator.class);
        // 设置方法拦截器
        enhancer.setCallback(new MethodCallBack());
        
        // 创建被代理的类
        Calculator calculator = (Calculator) enhancer.create();
        // 分别调用add和minus方法
        System.out.println(calculator.add(1, 2));
        System.out.println(calculator.minus(2,1));
    }
}

程序输出为：

Annotated by intercept
[1, 2]
3
1

我们可以看到，add方法在被调用前执行了代理逻辑。minus方法直接返回了调用结果。