动态代理之JDK动态代理&CGLib动态代理

Love The Way You Lie 2022-05-26 06:53 321阅读 0赞

### JDK动态代理 ###

核心思想：通过实现被代理类的所有接口，生成一个字节码文件后构造一个代理对象，通过持有反射构造被代理类的一个实例，再通过invoke反射调用被代理类实例的方法，来实现代理。

缺点：JDK动态代理的对象必须实现一个或多个接口  
![这里写图片描述][70]

### 流程图 ###

![这里写图片描述][70 1]

### 知识点 ###

*  JDK实现动态代理需要实现类通过接口定义业务方法
 *  JDK生成的代理类以”$Proxy”为开头进行命名
 *  JDK代理生成的代理类的Method在static静态代码块中进行初始化；
 *  public接口生成的代理类package为”com.sun.proxy”；
 *  JDK动态代理需要实现InvocationHandler接口；

代码：

package com.quancheng;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    public class DynamicProxy { 
        public static void main(String[] args) {
            Student stu = new Student();
            CusInvocationHandler handler = new CusInvocationHandler(stu);
            Play instance = (Play) Proxy.newProxyInstance(stu.getClass().getClassLoader(), stu.getClass().getInterfaces(), handler);
            instance.play();
        }
    }
    
    class CusInvocationHandler implements InvocationHandler { 
        private Object target;
    
        public CusInvocationHandler(Object object) {
            this.target = object;
        }
    
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.err.println("代理方法处理");
            return method.invoke(target, args);
        }
    }
    
    interface Play { 
        void play();
    }
    
    class Student implements Play { 
    
        @Override
        public void play() {
            System.err.println("student ====>");
        }
    }

生成的代理类示例：

import dynamic.proxy.UserService;  
    import java.lang.reflect.*;  
    
    public final class $Proxy11 extends Proxy implements UserService {   
    
        // 构造方法，参数就是刚才传过来的MyInvocationHandler类的实例 
        public $Proxy11(InvocationHandler invocationhandler)  
        {  
            super(invocationhandler);  
        }  
    
        public final boolean equals(Object obj)  
        {  
            // 省略
        }  
    
        /** * 被代理的方法 */  
        public final void add()  
        {  
            try  
            {  
                // 实际上就是调用MyInvocationHandler的public Object invoke(Object proxy, Method method, Object[] args)方法，第二个问题就解决了 
                super.h.invoke(this, m3, null);  
                return;  
            }  
            catch(Error _ex) { }  
            catch(Throwable throwable)  
            {  
                throw new UndeclaredThrowableException(throwable);  
            }  
        }  
    
        public final int hashCode()  
        {  
            // 省略
        }  
    
        public final String toString()  
        {  
            // 省略
        }  
    
        private static Method m1;  
        private static Method m3;  
        private static Method m0;  
        private static Method m2;  
    
        // 在静态代码块中获取了4个方法：Object中的equals方法、UserService中的add方法、Object中的hashCode方法、Object中toString方法 
        static   
        {  
            try  
            {  
                m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] {  
                    Class.forName("java.lang.Object")  
                });  
                m3 = Class.forName("dynamic.proxy.UserService").getMethod("add", new Class[0]);  
                m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);  
                m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);  
            }  
            catch(NoSuchMethodException nosuchmethodexception)  
            {  
                throw new NoSuchMethodError(nosuchmethodexception.getMessage());  
            }  
            catch(ClassNotFoundException classnotfoundexception)  
            {  
                throw new NoClassDefFoundError(classnotfoundexception.getMessage());  
            }  
        }  
    }

###  ###

### cglib动态代理 ###

核心思想：CGLib采用了非常底层的字节码技术，其原理是通过字节码技术为一个类创建子类(CGLib底层是通过继承实现的动态代理)，并在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑。JDK动态代理与CGLib动态代理均是实现Spring AOP的基础；底层：使用一个小而快的字节码处理框架ASM(Java字节码操控框架)，来转换字节码并生成新的类

缺点：不能代理final修饰的类

示例代码：

//被代理的类即目标对象
    public class A { 
        public void execute(){
            System.out.println("执行A的execute方法...");
        }
    }
    
    //代理类
    public class CGLibProxy implements MethodInterceptor { 
    
        /** * 被代理的目标类 */
        private A target;
    
        public CGLibProxy(A target) {
            super();
            this.target = target;
        }
    
        /** * 创建代理对象 * @return */
        public A createProxy(){
            // 使用CGLIB生成代理:
            // 1.声明增强类实例,用于生产代理类
            Enhancer enhancer = new Enhancer();
            // 2.设置被代理类字节码，CGLIB根据字节码生成被代理类的子类
            enhancer.setSuperclass(target.getClass());
            // 3.//设置回调函数，即一个方法拦截
            enhancer.setCallback(this);
            // 4.创建代理:
            return (A) enhancer.create();
        }
    
        /** * 回调函数 * @param proxy 代理对象 * @param method 委托类方法 * @param args 方法参数 * @param methodProxy 每个被代理的方法都对应一个MethodProxy对象， * methodProxy.invokeSuper方法最终调用委托类(目标类)的原始方法 * @return * @throws Throwable */
        @Override
        public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
       //过滤不需要该业务的方法
          if("execute".equals(method.getName())) {
              //调用前验证权限(动态添加其他要执行业务)
              AuthCheck.authCheck();
    
              //调用目标对象的方法(执行A对象即被代理对象的execute方法)
              Object result = methodProxy.invokeSuper(proxy, args);
    
              //记录日志数据(动态添加其他要执行业务)
              Report.recordLog();
    
              return result;
          }else if("delete".equals(method.getName())){
              //.....
              return methodProxy.invokeSuper(proxy, args);
          }
          //如果不需要增强直接执行原方法
          return methodProxy.invokeSuper(proxy, args);
    
        }
    }

[70]: /images/20220526/40bb71567afe40ea97be2995cc4c1eec.png
[70 1]: /images/20220526/c0f5808050fd4bb483daa23f20de2b4d.png