文章目录
代理
代理其实就是扩展目标对象的功能，比如普通人不具备超人能力，超人就是在普通人基础上进行拓展的超人功能。对比程序来说，比如对于一些基础功能，可以添加日志、耗时等统计处理。
静态代理
静态代理其实在程序编译前就决定了代理类。
比如我们有一个用户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);
}
}
小结
本篇主要从静态代理聊到存在的弊端，以及动态代理 jdk和cglib的方式，以及具体的应用场景。在学习的时候，我们不能仅仅停留在八股文的阶段，而要结合具体的实际场景进行总结。
1626
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
