Java动态代理

1、JDK动态代理

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

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

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

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

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

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

 

public interface SmsgService {

    String send(String msg);
}

public class SmsgServiceImpl implements SmsgService {
    @Override
    public String send(String msg) {
        System.out.println("send message:" + msg);
        return msg;
    }
}

public class MyInvocationHandler implements InvocationHandler {

    // 被代理的真实对象
    private final Object target;

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

    /**
     * @param proxy  代理对象
     * @param method 需要代理的方法
     * @param args   方法参数
     * @return
     * @throws Throwable
     */
    @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;
    }
}

public class ProxyFactory {
	// 返回代理对象 利用反射获取类加载器、
    public static Object getProxy(Object target) {
        return Proxy.newProxyInstance(
                target.getClass().getClassLoader(), // 目标类的类加载器
                target.getClass().getInterfaces(),  // 代理需要实现的接口，可指定多个
                new MyInvocationHandler(target)   // 代理对象对应的自定义 InvocationHandler
        );
    }

}

public class ProxyTest {
    public static void main(String[] args) {

        /*
         * Jdk动态代理实现步骤
         * 1.接口与实现类
         * 2.自定义InvocationHandler实现invoke方法，在invoke方法中实现对需要代理的方法增强
         * 3.实现ProxyFactory来获取代理对象，Proxy.newProxyInstance()
         *
         */
        SmsgService smsgService = (SmsgService) ProxyFactory.getProxy(new SmsgServiceImpl());
        smsgService.send("JDK动态代理实现");

    }
}

2、cglib动态代理

JDK 动态代理有一个最致命的问题是其只能代理实现了接口的类。

为了解决这个问题，我们可以用 CGLIB 动态代理机制来避免。

在 CGLIB 动态代理机制中 MethodInterceptor 接口和 Enhancer 类是核心。

1. 定义一个类；

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

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

引入依赖

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

public class SmsgService {

    public String send(String msg) {
        System.out.println("send msg" + msg);
        return msg;
    }

    public String receive(String msg) {
        System.out.println("receive msg" + msg);
        return msg;
    }
}

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

public class CglibProxyFactory {


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

}

public class ProxyTest {
    public static void main(String[] args) {
        /*
        cglib动态代理实现步骤：
        1.创建实现类
        2.自定义MethodInterceptor
        3.创建CglibProxyFactory
         */
        SmsgService smsgService = (SmsgService) CglibProxyFactory.getProxy(SmsgService.class);
        smsgService.receive("cglib动态代理实现receive()");
        smsgService.send("cglib动态代理实现send()");
    }
}

三、静态代理和动态代理的对比

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

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