深入理解Java的JDK动态代理

一、什么是JDK动态代理

1. 什么是代理模式**（Proxy Pattern）**

代理模式是一种设计模式，它通过为其他对象提供一个代理或占位符来控制对原始对象的访问。即通过代理对象访问目标对象。

代理模式可以在不修改原始类代码的情况下，通过代理类，添加一些功能操作，比如添加方法调用的预处理、后处理等。

代理模式的基本概念包括以下几个部分：

• 抽象对象（Subject）： 这是一个接口，定义了代理对象和具体对象的公共接口，这样在任何使用具体对象的地方都可以使用代理对象。
• 具体对象（RealSubject）： 被代理的对象。
• 代理对象（Proxy）： 包含了对具体对象的引用，从而可以在任何时候操作具体对象；代理对象提供了一个与具体对象相同的接口，所以它可以被当作具体对象使用。代理对象通常在客户端调用传递给实际对象之前或之后，执行某个操作，而不是只处理调用并将调用传递给实际对象。

在Java中，代理模式的实现通常可以通过接口实现，但是也可以通过类或者抽象类实现。

2. 静态代理与动态代理

• 静态代理 静态代理在编译时就已经实现，代码在编译时就已经确定，并已经被转换为字节码文件。
• 动态代理 动态代理是在运行时动态生成的，即编译完成后还没有实际的代理对象，只有在运行时才会创建。

3. JDK动态代理

JDK动态代理是Java原生支持的代理方式，它允许开发者在运行时动态地创建和使用代理对象。这种方式主要依赖于Java的反射技术。

二、JDK动态代理的基本原理

1. JDK动态代理的工作原理

JDK动态代理的工作原理是在运行时在内存中动态地创建一个接口的实现类。

当我们通过代理类的对象调用方法时，它实际上会调用定义的InvocationHandler接口的实现类对象的invoke方法。然后在invoke方法中我们可以定义预处理、调用目标方法、后处理等，我们也可以选择不调用目标对象的方法。这样，我们就可以在不修改源码的情况下，实现对目标对象的功能增强。

2. JDK动态代理的关键组件：InvocationHandler和Proxy

JDK动态代理主要涉及到java.lang.reflect包中的两个类：Proxy和InvocationHandler。Proxy类是所有动态代理类的父类，它有一个名为newProxyInstance的方法，这个方法生成动态代理对象。InvocationHandler是一个接口，通过实现该接口定义横切逻辑，并通过反射机制调用目标类的代码，动态的将横切逻辑和业务逻辑编织在一起。

• InvocationHandler：它是一个接口，我们必须实现该接口。我们可以通过实现该接口的invoke方法，定义横切逻辑，然后通过反射机制调用目标类的代码。动态的将横切逻辑和业务逻辑编织在一起。
• Proxy：Proxy类是所有动态代理类的父类，它有一个名为newProxyInstance的方法，这个方法生成动态代理对象；newProxyInstance方法接收三个参数：
  • ClassLoader loader（类加载器）、
  • Class<?>[] interfaces（给代理对象提供的接口）、
  • InvocationHandler h（调用处理器），

  并返回一个新的代理对象（对象实现了指定的接口）。

三、JDK动态代理的实现步骤

1. 定义一个接口和它的实现类

public interface MyInterface {
    void doSomething();
}

public class MyInterfaceImpl implements MyInterface {
    @Override
    public void doSomething() {
        System.out.println("Doing something...");
    }
}

2. 创建InvocationHandler对象，自定义invoke 方法

public class MyInvocationHandler implements InvocationHandler {
    private Object target;

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before method...");
        Object result = method.invoke(target, args);
        System.out.println("After method...");
        return result;
    }
}

3. 使用Proxy 类生成代理对象，并调用

public class Main {
    public static void main(String[] args) {
        MyInterface myInterface = new MyInterfaceImpl();
        InvocationHandler handler = new MyInvocationHandler(myInterface);
        MyInterface proxy = (MyInterface) Proxy.newProxyInstance(
                myInterface.getClass().getClassLoader(),
                myInterface.getClass().getInterfaces(),
                handler);
        proxy.doSomething();
    }
}

运行以上代码，得到输出：

Before method...
Doing something...
After method...

四、JDK动态代理的实际应用

1. AOP（面向切面编程）中的应用

AOP是一种编程范式，其目标是提高程序模块化的程度。

在AOP中，切面（Aspect）是包含横切关注点实现的模块。切点（Pointcut）定义了在何处应用切面的代码逻辑。连接点（Joinpoint）是程序执行过程中的某个特定点，如方法调用或异常抛出。通知（Advice）是切面在特定连接点执行的动作。

JDK动态代理可以用于实现AOP中的通知。通过创建目标类的代理对象，我们可以在调用目标方法之前、之后或在抛出异常时插入自定义的逻辑。以下是一个简单的示例：

public class LoggingAspect implements InvocationHandler {
    private Object target;

    public LoggingAspect(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;
    }
}

// 使用JDK动态代理创建代理对象
MyService myService = (MyService) Proxy.newProxyInstance(
        MyService.class.getClassLoader(),
        new Class<?>[]{MyService.class},
        new LoggingAspect(new MyServiceImpl()));

// 调用代理对象的方法
myService.doSomething();

2. Spring框架中的应用

动态代理在Spring框架中有广泛的应用，

• Spring的AOP功能 就是基于动态代理实现的，当我们在Spring中配置一个bean为代理对象时，Spring会自动为这个bean创建一个代理对象。当我们调用bean的方法时，实际上是调用了代理对象的方法。这样，我们就可以在代理对象的方法中添加一些额外的逻辑，例如事务管理、日志记录等。
• Spring的事务管理 也是通过动态代理实现的。当我们在方法上添加@Transactional注解时，Spring会为这个方法创建一个代理对象，用于在方法执行前后添加事务管理的代码。

在Spring中使用JDK动态代理时，我们需要定义一个切面（Aspect），并在切面中指定切点和通知。以下是一个简单的示例：

@Aspect
public class LoggingAspect {
    @Before("execution(* com.example.MyService.*(..))")
    public void beforeAdvice(JoinPoint joinPoint) {
        System.out.println("Before method: " + joinPoint.getSignature().getName());
    }

    @After("execution(* com.example.MyService.*(..))")
    public void afterAdvice(JoinPoint joinPoint) {
        System.out.println("After method: " + joinPoint.getSignature().getName());
    }
}

// 在Spring配置类中启用AOP自动代理
@Configuration
@EnableAspectJAutoProxy
public class AppConfig {
    @Bean
    public LoggingAspect loggingAspect() {
        return new LoggingAspect();
    }
}

在这个示例中，我们使用了@Aspect注解来标记LoggingAspect类作为一个切面。@Before和@After注解分别定义了前置通知和后置通知。execution表达式指定了切点，表示这些通知将应用于com.example.MyService类的所有方法。通过在Spring配置类中启用AOP自动代理，我们可以确保Spring会为匹配切点的方法创建代理对象，并应用相应的通知。

五、JDK动态代理的优缺点

1. 优点

• 实现简单： JDK动态代理使用Java反射机制生成代理对象，不需要我们手动创建代理类。
• 无嵌入性： 只需要实现InvocationHandler接口和创建代理类即可。对于简单的需求，这种方法是快速且易于实现的。
• 动态性： JDK动态代理能够在运行时根据需要动态地创建代理对象，这为程序的扩展性和灵活性提供了支持。
• **解耦：**通过代理模式，可以将目标对象与横切逻辑分离，降低了代码之间的耦合度，提高了代码的可维护性。
• 跨平台： JDK动态代理是基于Java反射机制实现的，因此具有跨平台的特性。

2. 缺点

• 性能开销： JDK动态代理使用反射机制来调用目标方法，这会导致一定程度的性能损失。尽管JVM对反射进行了优化，但在某些性能敏感的场景下，可能仍然不是最佳选择。
• 仅支持接口代理： JDK动态代理只能为接口创建代理类，无法直接为类创建代理。这意味着如果目标对象没有实现任何接口，JDK动态代理将无法使用。
• 代理类数量： 对于每个需要代理的接口，JDK动态代理都会生成一个新的代理类。如果有大量接口需要代理，这可能导致代理类数量过多，增加了部署和管理的复杂性。
• 横切逻辑限制： JDK动态代理的横切逻辑必须实现为InvocationHandler接口的方法，这限制了横切逻辑的灵活性和多样性，无法处理复杂的情况。

六、CGLIB动态代理（拓展）

1. CGLIB动态代理的基本原理：

CGLIB（Code Generation Library）是一个开源项目，它提供了在运行时动态生成Java类的能力。CGLIB动态代理的基本原理是通过继承的方式进行代理。当我们对一个类进行CGLIB动态代理时，CGLIB会动态生成一个子类来继承这个类，然后在子类中添加我们的代理逻辑。当我们调用目标方法时，实际上是调用了子类的方法。因此，CGLIB动态代理可以代理任何类，不仅仅是接口。

2. JDK动态代理与CGLIB动态代理的比较：

• JDK动态代理只能代理实现了接口的类，而CGLIB动态代理可以代理任何类。
• JDK动态代理是通过反射机制实现的，而CGLIB动态代理是通过生成一个被代理类的子类来实现的。
• 由于CGLIB动态代理生成的是子类，所以在性能上可能会比JDK动态代理稍微好一些，但是生成的类较多，可能会占用更多的内存。
• 在Spring框架中，如果一个类没有实现接口，那么Spring会默认使用CGLIB进行动态代理。如果一个类实现了接口，Spring会优先使用JDK动态代理。如果要强制使用CGLIB，可以在Spring配置中进行设置。