java 代理模式（静态代理、动态代理、JDK动态代理、CGLIB动态代理）详解

代理模式

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

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

常用的例子：

1.VPN：当我们访问国外网站的时候，往往需要VPN， 他可以帮助我们去访问一些国内不能访问的网站，也就是说他代理了这个访问过程，把结果返回给了我们。这就是代理模式。

2.SpringAOP功能的实现

代理模式有静态代理和动态代理两种实现方式。

优缺点、适用场景

优点

代理模式是最常用的设计模式之一，因为他包含以下优点：

1. 可以使真实业务角色责任更纯粹，不用包含一些公共业务。
2. 公共业务交给了代理类，实现了解耦。
3. 提供了面向切面编程的基础，使一个横向业务更容易编写
4. 动态代理可以代理多个实现了同一个接口的类。

缺点

增加代理类可能会导致业务处理速度变慢。

适用场景

以下场景适合适用代理模式

1. 当业务无法直接访问某个类时，需要一个代理类去代理访问。
2. 当需要横向添加一些功能，比如日志功能时，可以使用代理模式。

静态代理

从实现和应用角度来说：

静态代理中,我们对目标对象的每个方法的增强都是手动完成的，非常不灵活且麻烦。实际应用场景非常非常少，日常开发几乎看不到使用静态代理的场景。

不灵活：比如接口一旦新增加方法，目标对象和代理对象都要进行修改

麻烦：需要对每个目标类都单独写一个代理类

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

静态代理实现步骤:

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

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

代码示例

1.定义发送短信的接口

public interface SmsService {
    String send(String message);
}

2.实现发送短信的接口

public class SmsServiceImpl implements SmsService {
    public String send(String message) {
        System.out.println("send message:" + message);
        return message;
    }
}

3.创建代理类并同样实现发送短信的接口

public class SmsProxy implements SmsService {

    private final SmsService smsService;
	//将 接口实现类作为参数 注入到 构造器里面
    public SmsProxy(SmsService smsService) {
        this.smsService = smsService;
    }

    @Override
    public String send(String message) {
        //调用方法之前，我们可以添加自己的操作
        System.out.println("before method send()");
        smsService.send(message);
        //调用方法之后，我们同样可以添加自己的操作
        System.out.println("after method send()");
        return null;
    }
}

4.实际使用

public class Main {
    public static void main(String[] args) {
        SmsService smsService = new SmsServiceImpl();
        SmsProxy smsProxy = new SmsProxy(smsService);
        smsProxy.send("java");
    }
}

控制台输出：

before method send()
send message:java
after method send()

可以看到我们对发送短信的前后做了扩展

动态代理

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

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

说到动态代理，Spring AOP、RPC 框架应该是两个不得不提的，它们的实现都依赖了动态代理。

动态代理在我们日常开发中使用的相对较少，但是在框架中的几乎是必用的一门技术。学会了动态代理之后，对于我们理解和学习各种框架的原理也非常有帮助。

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

JDK动态代理

JDK 动态代理是 Java 标准库提供的一种动态代理实现方式，它基于接口代理实现。在 JDK 动态代理中，我们需要通过 java.lang.reflect.Proxy 类来生成代理对象。

JDK 动态代理代理的目标得是 实现接口的一个类

步骤

1.定义一个接口及其实现类；

2.自定义 InvocationHandler 并重写invoke方法，在 invoke 方法中我们会调用原生方法（被代理类的方法）并自定义一些处理逻辑；

3.通过 Proxy.newProxyInstance(ClassLoader loader,Class[] interfaces,InvocationHandler h) 方法创建代理对象；

例子

假设我们还是需要一个计算器程序，我们可以重新定义一个计算器接口：

public interface Calculator {
    int add(int a, int b);
    int sub(int a, int b);
    int mul(int a, int b);
    int div(int a, int b);
}

然后，我们可以使用 JDK 动态代理来生成代理对象：

public class CalculatorInvocationHandler implements InvocationHandler {
    private final Object target;

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("执行方法前");
        Object result = method.invoke(target, args);
        System.out.println("执行方法后");
        return result;
    }
}

public class Main {
    public static void main(String[] args) {
        Calculator calculator = new RealCalculator();
        CalculatorInvocationHandler handler = new CalculatorInvocationHandler(calculator);
        Calculator proxy = (Calculator) Proxy.newProxyInstance(
            calculator.getClass().getClassLoader(),
            calculator.getClass().getInterfaces(),
            handler);

        int a = 1, b = 2;
        System.out.println("add: " + proxy.add(a, b));
        System.out.println("sub: " + proxy.sub(a, b));
        System.out.println("mul: " + proxy.mul(a, b));
        System.out.println("div: " + proxy.div(a, b));
    }
}

在上面的代码中，我们定义了一个 CalculatorInvocationHandler 类来实现 java.lang.reflect.InvocationHandler 接口。当客户端调用代理对象的方法时，JDK 动态代理会自动调用 invoke 方法，并将原始方法的调用转发给 RealCalculator 对象。在 invoke 方法前或方法后，我们可以添加一些额外的操作，例如日志记录、性能监控等。

CGLIB动态代理

CGLIB 动态代理是一种不基于接口的动态代理实现方式，它可以代理没有实现接口的类。在 CGLIB 动态代理中，我们需要通过 net.sf.cglib.proxy.Enhancer 类来生成代理对象。

**JDK 动态代理有一个最致命的问题是其只能代理实现了接口的类。**为了解决这个问题，我们可以用 CGLIB 动态代理机制来避免。CGLIB动态代理的目标 可以是没有实现任何接口的类。

使用步骤

1.定义一个类；

2.自定义 MethodInterceptor 并重写 intercept 方法，intercept 用于拦截增强被代理类的方法，和 JDK 动态代理中的 invoke 方法类似；

3.通过 Enhancer 类的 create()创建代理类

例子：

假设我们有一个没有实现任何接口的类：

public class UserService {
    public void addUser(String username, String password) {
        System.out.println("add user: " + username + ", " + password);
    }

    public void updateUser(String username, String password) {
        System.out.println("update user: " + username + ", " + password);
    }

    public void deleteUser(String username) {
        System.out.println("delete user: " + username);
    }
}

然后，我们可以使用 CGLIB 动态代理来生成代理对象：

public class UserServiceInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("执行方法前");
        Object result = proxy.invokeSuper(obj, args);
        System.out.println("执行方法后");
        return result;
    }
}

public class Main {
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(UserService.class);
        enhancer.setCallback(new UserServiceInterceptor());
        UserService proxy = (UserService) enhancer.create();

        proxy.addUser("Tom", "123456");
        proxy.updateUser("Tom", "654321");
        proxy.deleteUser("Tom");
    }
}

在上面的代码中，我们定义了一个 UserServiceInterceptor 类来实现 net.sf.cglib.proxy.MethodInterceptor 接口。当客户端调用代理对象的方法时，CGLIB 动态代理会自动调用 intercept 方法，并将原始方法的调用转发给 UserService 类。在 intercept 方法前或方法后，我们可以添加一些额外的操作，例如日志记录、性能监控等。

JDK 和 CGLIB 区别

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

静态代理和动态代理的区别

灵活性：动态代理更加灵活，不需要必须实现接口，可以直接代理实现类，并且可以不需要针对每个目标类都创建一个代理类。另外，静态代理中，接口一旦新增加方法，目标对象和代理对象都要进行修改，这是非常麻烦的！

JVM 层面：静态代理在编译时就将接口、实现类、代理类这些都变成了一个个实际的 class 文件。而动态代理是在运行时动态生成类字节码，并加载到 JVM 中的。