【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{
    @Override
    public void register(Long uid) {
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    @Override
    public 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;
    }

    @Override
    public void register(Long uid) {
        final long startTime = System.currentTimeMillis();
        userController.register(uid);
        final long endTime = System.currentTimeMillis();
        System.out.println(endTime - startTime);
    }

    @Override
    public 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 方法参数
    @Override
    public 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 ProxyClassFactory
        implements BiFunction<ClassLoader, Class<?>[], Class<?>>
    {
    	// 代理名前缀
        private static final String proxyClassNamePrefix = "$Proxy";

        // 代理名自动递增
        private static final AtomicLong nextUniqueNumber = new AtomicLong();

        @Override
        public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
            if (proxyPkg == null) {
                // 基础包名 com.sun.proxy
                proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
            }
            // 每次新增一个代理类 +1 操作
            long num = nextUniqueNumber.getAndIncrement();
            // 基础包名+$Proxy+0 -> com.sun.proxy.$Proxy0
            String 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;
    }

    @Override
    public 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.");
			}
			// 接口 被代理的类 jdk
			if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
				return new JdkDynamicAopProxy(config);
			}
			// cglib方式
			return new ObjenesisCglibAopProxy(config);
		}
		else {
			return new JdkDynamicAopProxy(config);
		}
	}