java 项目动态代理模式怎么实现

Java项目中的动态代理模式主要是通过反射机制来实现的，它能在运行时创建代理实例，并确定如何将方法调用委托给目标对象。这种模式通常用于任务如方法调用的拦截和预处理、后处理等。在Java中，动态代理的实现方式主要分为两种，一种是基于接口的动态代理使用java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口，另一种是基于类的动态代理，比如使用CGlib库或Spring的AOP功能。

在Java的动态代理机制中，InvocationHandler接口扮演了核心角色，代理对象的每一个方法调用都会被转发到这个接口的invoke方法。具体来说，当通过代理对象调用任何方法时，都会转换为对InvocationHandler中invoke方法的调用，然后在这个方法中确定如何处理和转发这个调用到实际的目标对象。

一、动态代理概念与用途

动态代理模式是设计模式之一，它在程序运行时，通过反射机制动态创建代理类并实例化。这种代理可以在不修改原有代码的情况下，增强或者控制对象的行为。在Java中，动态代理可以用于多种场景，例如日志记录、权限控制、事务处理、延迟加载等。

代理模式的好处

使用代理模式可以将原对象与行为的增强分离，提高系统的灵活性和可维护性。动态代理使得这些增强可以不接触具体实现，在运行时动态地添加。

二、基于接口的动态代理

Java提供了一种简便的方式来创建动态代理，就是通过java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口。

创建InvocationHandler

InvocationHandler是代理实例的调用处理程序实现的接口。用户定义的每一个代理实例都有一个关联的InvocationHandler实现，当在代理实例上调用方法时，方法调用将被转发到InvocationHandler的invoke方法。

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class DynamicProxyHandler implements InvocationHandler {
    private final Object target; // 目标对象，被代理对象
    public DynamicProxyHandler(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;
    }
}

生成代理实例

使用Proxy类的静态方法newProxyInstance创建代理实例。

import java.lang.reflect.Proxy;
public class ProxyFactory {
    @SuppressWarnings("unchecked")
    public static <T> T getProxyInstance(T target) {
        // 创建动态代理实例
        return (T) Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            new DynamicProxyHandler(target)
        );
    }
}

三、基于类的动态代理（使用CGlib）

CGlib是一个强大的、高性能、高质量的Code生成库，可在运行时扩展Java类与实现Java接口。它被许多流行的Java框架用作动态代理工具，比如Spring。

创建方法拦截器

在CGlib中，MethodInterceptor是方法拦截器，类似于InvocationHandler的角色。

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
public class CglibProxyInterceptor implements MethodInterceptor {
    private Object target; // 目标对象，被代理对象
    public CglibProxyInterceptor(Object target) {
        this.target = target;
    }
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        // 前置处理
        System.out.println("Before method: " + method.getName());
        Object result = proxy.invokeSuper(obj, args); // 通过代理类调用父类中的方法
        // 后置处理
        System.out.println("After method: " + method.getName());
        return result;
    }
}

创建代理对象

使用Enhancer类的create方法创建代理对象。

public class CglibProxyFactory {
    @SuppressWarnings("unchecked")
    public static <T> T getProxyInstance(T target) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(target.getClass()); // 设置需要代理的类
        enhancer.setCallback(new CglibProxyInterceptor(target)); // 设置回调
        // 创建代理实例
        return (T) enhancer.create();
    }
}