上一篇 <<<Java基础-反射机制
下一篇 >>>Java基础-字节码技术
代理模式：使用代理对象完成用户请求，屏蔽用户对真实对象的访问。
- 优点：减少代码冗余、提高代码复用性、安全性、隐藏真实角色、非入侵
应用场景
- Spring AOP
- 过滤器
- 自定义注解
- 全局捕获异常
- 事务原理
- 日志收集打印
- 权限控制
- RPC远程调用
- 安全代理可以隐蔽真实角色
- Mybatis的Mapper
- 全局ID（LCN/Seata中）
分类
静态代理：实现接口和实现集成两种方式
动态代理：JDK代理(接口实现)和CGLIB代理(继承方式)
区别：静态代理需要自己写代理类，而动态代理不需要写代理类。
静态代理
- 接口实现
/**静态代理：接口实现*/
OrderService orderService = new OrderServiceProxy1(new OrderServiceImpl());
orderService.order();
/**
* 接口实现方式
*/
public class OrderServiceProxy1 implements OrderService {
/**
* 代理对象
*/
private OrderService proxiedOrderService;
public OrderServiceProxy1(OrderService orderService) {
this.proxiedOrderService=orderService;
}
public void order() {
System.out.println("日志收集开始..");
proxiedOrderService.order();
System.out.println("日志收集结束..");
}
}
- 继承实现
/**静态代理：继承实现*/
OrderService orderService = new OrderServiceProxy();
orderService.order();
/**
* 继承方式
*/
public class OrderServiceProxy extends OrderServiceImpl {
@Override
public void order() {
System.out.println("日志收集开始..");
super.order();
System.out.println("日志收集结束..");
}
}
动态代理
1.JDK动态代理
执行步骤
1.创建被代理的接口和类；
2.实现InvocationHandler接口，对目标接口中声明的所有方法进行统一处理；
3.调用Proxy的静态方法，创建代理类并生成相应的代理对象；
1).核心原理 (代理类的生成、编译及加载到jvm中)
a、生成代理类---该类实现了接口，并集成Proxy类【通过编译之后可查看】
Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
b、执行代理类的order等目标方法，实际上是调用MyInvocationHandel h的invoke方法
缺点：jdk动态代理，必须是面向接口，目标业务类必须实现接口
2).调试源码
JdkInvocationHandler jdkInvocationHandler = new JdkInvocationHandler(new OrderServiceImpl());
OrderService proxy = jdkInvocationHandler.getProxy();
proxy.order();
/**
* JDK动态代理
*/
public class JdkInvocationHandler implements InvocationHandler {
/**
* 目标代理对象
*/
public Object target;
public JdkInvocationHandler(Object target) {
this.target = target;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println(">>>日志收集开始>>>>");
// 执行代理对象方法
Object reuslt = method.invoke(target, args);
System.out.println(">>>日志收集结束>>>>");
return reuslt;
}
/**
* 获取代理对象接口
*
*/
public <T> T getProxy() {
return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
}
}
3).自动生成的代理类源码
public final class $Proxy0 extends Proxy implements OrderService
{
private static Method m1;
private static Method m3;
private static Method m2;
private static Method m0;
public $Proxy0(final InvocationHandler invocationHandler) {
super(invocationHandler);
}
public final void order() {
try {
super.h.invoke(this, $Proxy0.m3, null);
}
catch (Error | RuntimeException error) {
throw;
}
catch (Throwable t) {
throw new UndeclaredThrowableException(t);
}
}
static {
try {
$Proxy0.m3 = Class.forName("cn.jarye.service.OrderService").getMethod("order", (Class<?>[])new Class[0]);
}
catch (NoSuchMethodException ex) {
throw new NoSuchMethodError(ex.getMessage());
}
catch (ClassNotFoundException ex2) {
throw new NoClassDefFoundError(ex2.getMessage());
}
}
}
4).手写JDK动态代理思路
a.使用java反射机制拼接$Proxy.java类的源代码---参考Proxy.newProxyInstance方法
b.需要将$Proxy.java编译成$Proxy.class
c.程序中直接读取该class文件到内存中
2.CGLIB动态代理
1).核心原理
利用asm字节码开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。
2).调试源码
CglibMethodInterceptor cglibMethodInterceptor = new CglibMethodInterceptor();
//相当于生成代理类
Enhancer enhancer = new Enhancer();
// 设置代理类的付类
enhancer.setSuperclass(OrderServiceImpl.class);
// 设置回调对象
enhancer.setCallback(cglibMethodInterceptor);
// 创建代理对象
OrderServiceImpl orderServiceImpl = (OrderServiceImpl) enhancer.create();
orderServiceImpl.order();
public class CglibMethodInterceptor implements MethodInterceptor {
@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
System.out.println("<<<<<日志收集开始...>>>>>>>");
Object reuslt = proxy.invokeSuper(obj, args);
System.out.println("<<<<<日志收集结束...>>>>>>>");
return reuslt;
}
}
3).自动生成的代理类源码
-
索引机制
使用字节码技术获取当前所有的方法，对每个方法加上一个索引，直接根据索引调用到目标方法效率是比反射机制要高。
MethodProxy类的源码：
public Object invokeSuper(Object obj, Object[] args) throws Throwable {
try {
this.init();
MethodProxy.FastClassInfo fci = this.fastClassInfo;
return fci.f2.invoke(fci.i2, obj, args);
} catch (InvocationTargetException var4) {
throw var4.getTargetException();
}
}
-
索引计算方法
使用方法名称+参数类型计算hash值，在根据hash值得出索引 - 代理类 (使用继承方法)
public class OrderServiceImpl$$EnhancerByCGLIB$$279607fc extends OrderServiceImpl implements Factory
{
private static Object CGLIB$CALLBACK_FILTER;
private static final Method CGLIB$order$0$Method;
private static final MethodProxy CGLIB$order$0$Proxy;
static void CGLIB$STATICHOOK1() {
final Class<?> forName3;
CGLIB$order$0$Method = ReflectUtils.findMethods(new String[] { "order", "()V" }, (forName3 = Class.forName("com.jarye.service.impl.OrderServiceImpl")).getDeclaredMethods())[0];
CGLIB$order$0$Proxy = MethodProxy.create((Class)forName3, (Class)forName, "()V", "order", "CGLIB$order$0");
}
final void CGLIB$order$0() {
super.order();
}
public final void order() {
MethodInterceptor cglib$CALLBACK_2;
MethodInterceptor cglib$CALLBACK_0;
if ((cglib$CALLBACK_0 = (cglib$CALLBACK_2 = this.CGLIB$CALLBACK_0)) == null) {
CGLIB$BIND_CALLBACKS(this);
cglib$CALLBACK_2 = (cglib$CALLBACK_0 = this.CGLIB$CALLBACK_0);
}
if (cglib$CALLBACK_0 != null) {
cglib$CALLBACK_2.intercept((Object)this, OrderServiceImpl$$EnhancerByCGLIB$$279607fc.CGLIB$order$0$Method, OrderServiceImpl$$EnhancerByCGLIB$$279607fc.CGLIB$emptyArgs, OrderServiceImpl$$EnhancerByCGLIB$$279607fc.CGLIB$order$0$Proxy);
return;
}
super.order();
}
// 设置回调
public void setCallbacks(final Callback[] array) {
this.CGLIB$CALLBACK_0 = (MethodInterceptor)array[0];
}
static {
CGLIB$STATICHOOK1();
}
}
- 方法索引
public int getIndex(final String s, final Class[] array) {
Label_1079: {
switch (s.hashCode()) {
case 106006350: {
if (!s.equals("order")) {
break;
}
switch (array.length) {
case 0: {
return 7;
}
default: {
break Label_1079;
}
}
break;
}
}
}
return -1;
}
public Object invoke(final int n, final Object o, final Object[] array) throws InvocationTargetException {
final OrderServiceImpl$$EnhancerByCGLIB$$279607fc orderServiceImpl$$EnhancerByCGLIB$$279607fc = (OrderServiceImpl$$EnhancerByCGLIB$$279607fc)o;
try {
switch (n) {
case 7: {
orderServiceImpl$$EnhancerByCGLIB$$279607fc.order();
return null;
}
}
}
catch (Throwable t) {
throw new InvocationTargetException(t);
}
throw new IllegalArgumentException("Cannot find matching method/constructor");
}
4).手写CGLIB动态代理思路
/**
* 直接生成代理类，然后设置callback方法
*/
MemberServiceImpl$$EnhancerByCGLIB$$600aa7a2 memberServiceImpl=
new MemberServiceImpl$$EnhancerByCGLIB$$600aa7a2();
// 设置回调
memberServiceImpl.setCallbacks(new CglibMethodInterceptor());
memberServiceImpl.addMember("jarye");
3.JDK和CGLIB动态代理
1).差异对比
| 对比点 | JDK动态代理 | CGLIB动态代理 |
|---|---|---|
| 代码上 | 实现InvocationHandler接口，对目标接口中声明的所有方法进行统一处理 | 实现MethodInterceptor接口的intercept方法 |
| 原理上 | 使用Java的反射技术生成继承了Proxy类的动态匿名类，只能代理实现了接口的类， 没有实现接口的类不能实现动态代理。 | 通过ASM字节码处理框架来转换字节码并生成代理类的子类，子类重写了被代理类中所有非final的方法，在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势植入横切逻辑。大部分功能实际上是ASM所提供的，Cglib只是封装了ASM，简化了ASM操作，实现了运行期生成新的class。 |
| 缺陷 | jdk动态代理，必须是面向接口，目标业务类必须实现接口 | 对于被代理类中的final方法，无法进行代理，因为子类中无法重写final函数 |
| 总结 | jdk动态代理最终使用反射机制执行目标方法 | cglib根据索引找到目标方法，然后通过super.目标方法执行 |
2).Cglib的效率比Jdk动态代理效率要高原因【jdk7开始JDK动态代理更加高效】
-
Jdk动态动态代理 走回调拦截 实现接口接口生成带了类 使用反射技术执行我们的目标方法
a.拼接java源代码
b.编译为class文件
c.读取去class文件到内存中 -
Cglib动态代理 采用继承的模式生成代理类 底层基于Asm字节码技术实现生成代理类
a.生成class文件
b.读取去class文件到内存中
c、采用fastClass索引的机制执行我们的目标方法
2).代理模式在Spring中的应用
- 如果目标对象实现了接口，默认情况下会采用JDK的动态代理实现AOP，但可以强制使用CGLIB实现
- 如果目标对象没有实现了接口，必须采用CGLIB库，spring会自动在JDK动态代理和CGLIB之间转换
Spring中的@Async注解使用不当会导致失效，请参考：@Async失效之谜
相关文章链接：
<<<23种常用设计模式总览
<<<装饰模式（Decorator Pattern）
<<<观察者模式（Observer Pattern）
<<<单例模式（Singleton Pattern）
<<<责任链模式（Chain of Responsibility Pattern）
<<<策略模式（Strategy Pattern）
<<<模板方法模式（Template Pattern）
<<<外观/门面模式（Facade Pattern）
<<<建造者模式（Builder Pattern）
<<<适配器模式（Adapter Pattern）
<<<原型模式（Prototype Pattern）
<<<工厂相关模式（Factory Pattern）
