【Java基础】动态代理与代理模式哪些事儿

文章目录

代理
- 静态代理
- 动态代理
- - 基于接口的jdk动态的demo
  - 源码解析
  - - Proxy.newProxyInstance
    - - jdk 动态的生成的字节码
  - 基于父类的cglib动态代理
  - 源码解析
- 代理设计模式
- - 应用场景
- Spring AOP
- 小结

代理

代理其实就是扩展目标对象的功能，比如普通人不具备超人能力，超人就是在普通人基础上进行拓展的超人功能。对比程序来说，比如对于一些基础功能，可以添加日志、耗时等统计处理。

静态代理

静态代理其实在程序编译前就决定了代理类。
比如我们有一个用户API，其中提供了用户注册和登录功能。

// 接口类
public interface IUserController {void register(Long uid);void login(Long uid);
}
// 实现类
public class UserController implements IUserController{@Overridepublic void register(Long uid) {try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}}@Overridepublic void login(Long uid) {try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}}
}
// 静态代理类，其实就是内部包含一个真实对象，然后加了一层过滤操作
public class UserControllerProxy implements IUserController{private IUserController userController;public UserControllerProxy(IUserController userController) {this.userController = userController;}@Overridepublic void register(Long uid) {final long startTime = System.currentTimeMillis();userController.register(uid);final long endTime = System.currentTimeMillis();System.out.println(endTime - startTime);}@Overridepublic void login(Long uid) {final long startTime = System.currentTimeMillis();userController.register(uid);final long endTime = System.currentTimeMillis();System.out.println(endTime - startTime);}
}

    private static void extracted2() {IUserController userController = new UserController();IUserController iUserControllerProxy = new UserControllerProxy(userController);iUserControllerProxy.register(1L);iUserControllerProxy.login(1L);}

通过这样的方式，就可以添加耗时统计，但是对于一个类来说可以使用这种方式，对于有很多这种类，需要频繁创建很多代理类。是一个繁琐的过程，有没有一种功能可以根据代理方式动态生成，不需要在编译的时候指定。其实就是动态代理。

动态代理

动态代理其实就是在运行时进行生成代理类的过程，一般来说一种是jdk基于接口的方式，另一种就是字节码工具类，比如cglib,java assist等。生成的字节码，仅仅存在内存中，不会生成对应的class文件。

基于接口的jdk动态的demo

public class CtrlProxyHandler implements InvocationHandler {private Object origBean;public CtrlProxyHandler(Object origBean) {this.origBean = origBean;}// proxy 代理类,method 代理类方法，args 方法参数@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {long startTime = System.currentTimeMillis();Object res = method.invoke(origBean, args);long costTime = System.currentTimeMillis() - startTime;System.out.println(origBean.getClass().getSimpleName()+"#"+method.getName() + "cost time:"+ costTime);return res;}
}// 可以保存生成的代理类System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");IUserController iUserController = new UserController();CtrlProxyHandler handler = new CtrlProxyHandler(iUserController);// 主要通过newProxyInstance进行动态生成代理类IUserController userControllerProxy = (IUserController) Proxy.newProxyInstance(handler.getClass().getClassLoader(), UserController.class.getInterfaces(),handler);userControllerProxy.login(1L);

源码解析

public interface InvocationHandler {// proxy: 代理类// method: 代理类要执行的方法// args : 方法参数public Object invoke(Object proxy, Method method, Object[] args)throws Throwable;
}

Proxy.newProxyInstance

整体就是三步：1.生成代理类 2.加载到jvm中 3.生成动态代理类对象

public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h) {// 判断InvocationHandler是否等于空                                          Objects.requireNonNull(h);/** Look up or generate the designated proxy class.*/// 生成字节码文件Class<?> cl = getProxyClass0(loader, intfs);/** Invoke its constructor with the designated invocation handler.*/final Constructor<?> cons = cl.getConstructor(constructorParams);// 构建动态代理实例对象return cons.newInstance(new Object[]{h});
}

    private static Class<?> getProxyClass0(ClassLoader loader,Class<?>... interfaces) {// 判断接口是否超过阈值                                           if (interfaces.length > 65535) {throw new IllegalArgumentException("interface limit exceeded");}// 生成动态代理类return proxyClassCache.get(loader, interfaces);}private static final WeakCache<ClassLoader, Class<?>[], Class<?>>proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());

其实最终会执行到 ProxyClassFactory中

    private static final class ProxyClassFactoryimplements BiFunction<ClassLoader, Class<?>[], Class<?>>{// 代理名前缀private static final String proxyClassNamePrefix = "$Proxy";// 代理名自动递增private static final AtomicLong nextUniqueNumber = new AtomicLong();@Overridepublic Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {if (proxyPkg == null) {// 基础包名 com.sun.proxyproxyPkg = ReflectUtil.PROXY_PACKAGE + ".";}// 每次新增一个代理类 +1 操作long num = nextUniqueNumber.getAndIncrement();// 基础包名+$Proxy+0 -> com.sun.proxy.$Proxy0String proxyName = proxyPkg + proxyClassNamePrefix + num;// 生成字节码文件byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces, accessFlags);// 加载到JVM内存中    return defineClass0(loader, proxyName,proxyClassFile, 0, proxyClassFile.length);}}

在这里插入图片描述

jdk 动态的生成的字节码

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//package com.sun.proxy;import com.proxy.IUserController;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
// 生成的代理类 实现了接口 继承proxy 
public final class $Proxy0 extends Proxy implements IUserController {private static Method m1;private static Method m3;private static Method m2;private static Method m4;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 login(Long var1) throws  {try {// h : // m3 :  其实就是login方法 // var1 super.h.invoke(this, m3, new Object[]{var1});} catch (RuntimeException | Error var3) {throw var3;} catch (Throwable var4) {throw new UndeclaredThrowableException(var4);}}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 void register(Long var1) throws  {try {super.h.invoke(this, m4, new Object[]{var1});} catch (RuntimeException | Error var3) {throw var3;} catch (Throwable var4) {throw new UndeclaredThrowableException(var4);}}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("com.proxy.IUserController").getMethod("login", Class.forName("java.lang.Long"));m2 = Class.forName("java.lang.Object").getMethod("toString");m4 = Class.forName("com.proxy.IUserController").getMethod("register", Class.forName("java.lang.Long"));m0 = Class.forName("java.lang.Object").getMethod("hashCode");} catch (NoSuchMethodException var2) {throw new NoSuchMethodError(var2.getMessage());} catch (ClassNotFoundException var3) {throw new NoClassDefFoundError(var3.getMessage());}}
}

来分析下，不管使用什么方式默认顶级父类都是Object，在字节码中可以看到生成了对应toString(),hashCode()等方法。
这里很有意思的是h变量并没有在字节码文件中，发现其实proxy0代理类继承了proxy代理类，而父类中包含了h属性 protected InvocationHandler h; 其实就是我们自定义的接口类 CtrlProxyHandler

			// h :  其实就是自定义的实现类// m3 :  其实就是login方法 // var1  这里其实就是调用了 我们实现 CtrlProxyHandler的invoke()方法super.h.invoke(this, m3, new Object[]{var1});

在这里插入图片描述

基于父类的cglib动态代理

导入依赖的类

    <dependencies><!-- https://mvnrepository.com/artifact/cglib/cglib --><dependency><groupId>cglib</groupId><artifactId>cglib</artifactId><version>3.3.0</version></dependency></dependencies>

创建一个拦截器

public class ProxyFactory implements MethodInterceptor {private Object orinBean;public ProxyFactory(Object orinBean) {this.orinBean = orinBean;}@Overridepublic Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {Long startTime = System.currentTimeMillis();Object res = method.invoke(orinBean, args);Long costTime = System.currentTimeMillis() - startTime;System.out.println(orinBean.getClass().getSimpleName() +"#" + method.getName() + "cost time:"+costTime);return res;}
}

        //动态代理创建的class文件存储到本地System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY,"/Users/qxlx/work/qxlx/qxlx/jdk-learn/src/main/java/com/proxy");//通过cglib动态代理获取代理对象的过程 创建调用的对象Enhancer enhancer = new Enhancer();//设置enhancer对象的父类enhancer.setSuperclass(UserController.class);//设置enhancer的回调对象enhancer.setCallback(new ProxyFactory(new UserController()));//创建代理对象UserController userControllerProxy = (UserController)enhancer.create();userControllerProxy.login(1L);

源码解析

cglib的整体源码还是比较多的，整理了一个大概的整体轮廓图，可以查看。在这里插入图片描述
可以发现从生成的字节码文件中，最终调用login的方法的时候，其实是先调用var10000.intercept方法。

    public final void login(Long var1) {MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;if (var10000 == null) {CGLIB$BIND_CALLBACKS(this);var10000 = this.CGLIB$CALLBACK_0;}if (var10000 != null) {var10000.intercept(this, CGLIB$login$0$Method, new Object[]{var1}, CGLIB$login$0$Proxy);} else {super.login(var1);}}

实际，就是通过在生成的拦截器中，利用反射调用具体的方法，执行公共的逻辑，然后调用具体的业务方法，在返回具体的公共逻辑。实现统计耗时的计算。
在这里插入图片描述
所以到这里，其实动态代理的底层 1.生成字节码的技术 + 反射(动态生成类实例，获取方法信息、方法调用等)。

代理设计模式

代理设计模式，其实就是根据静态代理和动态代理进行使用，本质上就是在不修改原始对象的基础上，提供一些额外的功能。

应用场景

1.业务系统的非功能性需求开发
对于一个系统来说，有一些通用的非业务需求，可以进行使用代理类方式，监控、统计、鉴权、限流、事务、幂等，日志。其实单一职责，将业务功能与附加功能进行解除耦合。

2.代理模式在RPC、缓冲中的应用
对于RPC来说，客户端需要调用服务端进行网络通信、数据编解码操作，而这种细节，其实可以通过使用代理模式进行交互。

Spring AOP

那么我们来源码解析下 springAOP中是如何选择代理模式的，接口使用JDK 否则就是CGLIB方法。

	public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {// 判断选择使用那种代理方式// 策略优化// config.isProxyTargetClass() 是否使用cglib动态代理方式if (!NativeDetector.inNativeImage() &&(config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config))) {Class<?> targetClass = config.getTargetClass();if (targetClass == null) {throw new AopConfigException("TargetSource cannot determine target class: " +"Either an interface or a target is required for proxy creation.");}// 接口 被代理的类 jdkif (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {return new JdkDynamicAopProxy(config);}// cglib方式return new ObjenesisCglibAopProxy(config);}else {return new JdkDynamicAopProxy(config);}}