谈谈JDK动态代理和CGlib动态代理的一点思考

﹏ヽ暗。殇╰゛Y 2021-05-18 20:36 373阅读 0赞

既然说到了代理，我们就来聊聊代理是什么？

### 什么叫代理： ###

代理，英文：Proxy，本来是一个网络的概念，如代理服务器，正向代理，反向代理等。

利用了这一思想，就有了设计模式中的代理模式：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zNzk2ODYxMw_size_16_color_FFFFFF_t_70][]

这是代理模式的结构图，可以看出Proxy对RealSubject对实现了Subject接口，实现了相同的Request方法，它直接包含了RealSubject的实例，保留了原来的所有事情，同时还增加了请求前后的事务preRequest和postRequest，对原有类进行了增强。同时，因为实现了相同的接口，在代码改造的时候，只要将RealSubject的调用改为对Proxy的调用就可以了。

至于代理模式有哪些用途呢？

比如有一个远程调用逻辑，核心的调用逻辑已经写好了，但这个远程调用使用的协议会不稳定，会变化。此时我们为其创建一个代理proxy，这个协议选择的逻辑写到代理中，由代理去选择调用采用什么协议。这时采用代理模式是比较合适的。

### 代理的分类： ###

我们在程序里面，代理的类别有：静态代理和动态代理。

静态代理：就是已经写好的代码，一个代理只能为固定的类服务。上文提到的远程调用的代理就是静态代理。缺点：顾名思义，静态的，不灵活。同时因为代理和原类都实现了相同接口，接口类变化时需要同时修改两个类。

动态代理：会根据接口或类的变化，动态生成代理。代理还是那个代理，只是动态生成的，方便。

### 接下来主要讲动态代理如何生成： ###

常见的动态代理生成方式有：1、JDK动态代理 2、CGlib动态代理  3、asm

Cglib和asm类似，所以暂说前两种（其实我也没仔细学习过asm，不清楚）

面试官问你：“JDK动态代理 、CGlib动态代理的区别是什么？”

你：JDK动态代理是基于反射生成的，只能代理实现接口的类，CGlib动态代理是基于字节码生成的，对实现接口的类和无接口的类型都可以代理。

先说说JDK动态代理的原理：

JDK动态代理主要借助InvocationHandler这一个接口

/**
     * {@code InvocationHandler} is the interface implemented by
     * the <i>invocation handler</i> of a proxy instance.
     *
     * <p>Each proxy instance has an associated invocation handler.
     * When a method is invoked on a proxy instance, the method
     * invocation is encoded and dispatched to the {@code invoke}
     * method of its invocation handler.
     */
    public interface InvocationHandler {
        public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable;
    }

它的大概作用就是 每个代理实例都有一个关联的调用处理程序。当在代理实例上调用方法时，方法调用被编码并发送到关联处理程序的invoke方法。

举个例子，假如有一个接口和实现类，

public interface UserService {
    	void doOption();
    }

public class UserServiceImpl implements UserService{
    	@Override
    	public void doOption() {
    		System.out.println("执行操作！！！");
    	}
    }

执行的时候是这样的：

//执行的时候
    UserService userService = new UserServiceImpl();
    userService.doOption();

现在动态生成的代理类形如：jdk通过反射只要能获取到接口名，接口中的方法即可构造出这个代理。

public class $Proxy0 implements UserService{
        InvocationHandler h; //这个属性其实是在Proxy类中  真实情况是extends Proxy，下文会说到
        public $Proxy0(InvocationHandler h) {
            this.h = h;
        }
        public String doOption() {
            Method md = UserService.class.getMethod("doOption",new Class[]{});
            return (String)this.h.invoke(this, md, null);
        }
    }

那么，具体的实现类只要实现InvocationHandler 接口，便可以在invoke方法中增加其他业务。如下：

public class InvocationHandlerImpl implements InvocationHandler{
    	private UserService userService;
    	public InvocationHandlerImpl(UserService userService) {
    		this.userService = userService;
    	}
    	@Override
    	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    		before();
    		method.invoke(userService, args);
    		after();
    		return "success";
    	}
    	private void before() {
    		System.out.println("事务开始---");
    	}
    	private void after() {
    		System.out.println("事务结束---");
    	}
    }

那么，真正要实现userService的时候就可以用代理类代替了：

public class Main {
    	public static void main(String[] args) {
    		System.out.println("---------------JDK动态代理----------------");
    		UserService userService = (UserService) Proxy.newProxyInstance(Main.class.getClassLoader(),
    				new Class<?>[]{UserService.class},
    				new InvocationHandlerImpl(new UserServiceImpl()));
    
    		userService.doOption();
    	}
    }

![20191217100819353.png][]

然后再说CGlib动态代理动态代理：

该种方法直接采用继承的思想，通过Enhancer利用字节码生成代理类。在执行原父类方法时，通过MethodInterceptor进行拦截，在代理类增加其他业务。

这是原方法，（有没有实现接口都可以，因为通过继承实现，但类不能是final，否则无法继承。需要代理的方法也不能是final，否则也不能覆写）

public class UserServiceImpl{
    	public void doOption() {
    		System.out.println("执行操作！！！");
    	}
    }

代理类：

public class CglibProxy implements MethodInterceptor {
    	@Override
    	public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
    		before();
    		methodProxy.invokeSuper(o, objects);
    		after();
    		return "success";
    	}
    	private void before() {
    		System.out.println("事务开始---");
    	}
    	private void after() {
    		System.out.println("事务结束---");
    	}
    }

生成动态代理：

public class Main {
    	public static void main(String[] args) {
    		System.out.println("---------------CGlib动态代理----------------");
    
    		Enhancer enhancer = new Enhancer();
    		enhancer.setSuperclass(UserServiceImpl.class);
    		enhancer.setCallback(new CglibProxy());
    		UserServiceImpl userService1 = (UserServiceImpl) enhancer.create();
    
    		userService1.doOption();
    	}
    }

![20191217105557424.png][]

### 为什么JDK动态代理只能代理接口类 ###

1、java只支持单继承，把JDK生成的代理输出看看，可见已经继承了Proxy类，Proxy类中有InvocationHandler接口，所以只能实现接口了

byte[] generateProxyClass = ProxyGenerator.generateProxyClass("$Proxy0", new Class<?>[]{UserService.class});
    FileOutputStream outputStream = new FileOutputStream("D:\\version\\github\\SimpleProxy\\SimpleProxy\\src\\main\\proxy\\temp\\11.class");
    outputStream.write(generateProxyClass);
    outputStream.close();

//
    // Source code recreated from a .class file by IntelliJ IDEA
    // (powered by Fernflower decompiler)
    //
    
    import cn.com.common.proxy.service.UserService;
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    import java.lang.reflect.UndeclaredThrowableException;
    
    public final class $Proxy0 extends Proxy implements UserService {
        private static Method m1;
        private static Method m3;
        private static Method m2;
        private static Method m0;
    
        public $Proxy0(InvocationHandler var1) throws  {
            super(var1);
        }
    
        public final boolean equals(Object var1) throws  {
            try {
                return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
            } catch (RuntimeException | Error var3) {
                throw var3;
            } catch (Throwable var4) {
                throw new UndeclaredThrowableException(var4);
            }
        }
    
        public final void doOption() throws  {
            try {
                super.h.invoke(this, m3, (Object[])null);
            } catch (RuntimeException | Error var2) {
                throw var2;
            } catch (Throwable var3) {
                throw new UndeclaredThrowableException(var3);
            }
        }
    
        public final String toString() throws  {
            try {
                return (String)super.h.invoke(this, m2, (Object[])null);
            } catch (RuntimeException | Error var2) {
                throw var2;
            } catch (Throwable var3) {
                throw new UndeclaredThrowableException(var3);
            }
        }
    
        public final int hashCode() throws  {
            try {
                return (Integer)super.h.invoke(this, m0, (Object[])null);
            } catch (RuntimeException | Error var2) {
                throw var2;
            } catch (Throwable var3) {
                throw new UndeclaredThrowableException(var3);
            }
        }
    
        static {
            try {
                m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
                m3 = Class.forName("cn.com.common.proxy.service.UserService").getMethod("doOption");
                m2 = Class.forName("java.lang.Object").getMethod("toString");
                m0 = Class.forName("java.lang.Object").getMethod("hashCode");
            } catch (NoSuchMethodException var2) {
                throw new NoSuchMethodError(var2.getMessage());
            } catch (ClassNotFoundException var3) {
                throw new NoClassDefFoundError(var3.getMessage());
            }
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zNzk2ODYxMw_size_16_color_FFFFFF_t_70]: /images/20210518/6cef4028436946f2a8fa198cefdf1888.png
[20191217100819353.png]: /images/20210518/e8cf908ab7f244b3b491d247ce6a4baa.png
[20191217105557424.png]: /images/20210518/59abb742d2ec4aa78127e744b394eb0d.png