五、代理模式详解
2020/3/5 8:01:24
本文主要是介绍五、代理模式详解,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!
7.代理模式
7.1.课程目标
1、掌握代理模式的应用场景和实现原理。
2、了解静态代理和动态代理的区别。
3、了解CGLib和JDK Proxy的根本区别。
4、手写实现定义的动态代理。
7.2.内容定位
都知道 SpringAOP 是用代理模式实现,到底是怎么实现的?我们来一探究竟,并且自己仿真手写
还原部分细节。
7.3.代理模式定义
代理模式(ProxyPattern)是指为其他对象提供一种代理,以控制对这个对象的访问,属于结构型模式。
在某些情况下,一个对象不适合或者不能直接引用另一个对象,而代理对象可以在客户端和目标
对象之间起到中介的作用。
官方原文:Provide a surrogate or placeholder for another object to control access to it.
首先来看代理模式的通用UML类图:
代理模式一般包含三种角色:
抽象主题角色(Subject):抽象主题类的主要职责是声明真实主题与代理的共同接口方法,该类可以是接口也可以是抽象类;
真实主题角色(RealSubject):该类也被称为被代理类,该类定义了代理所表示的真实对象,是负责执行系统真正的逻辑业务对象;
代理主题角色(Proxy):也被称为代理类,其内部持有 RealSubject 的引用,因此具备完全的对
RealSubject的代理权。客户端调用代理对象的方法,同时也调用被代理对象的方法,但是会在代理对
象前后增加一些处理代码。
在代码中,一般代理会被理解为代码增强,实际上就是在原代码逻辑前后增加一些代码逻辑,而使调用者无感知。代理模式属于结构型模式,分为静态代理和动态代理。
7.4.代理模式的应用场景
生活中的租房中介、售票黄牛、婚介、经纪人、快递、事务代理、非侵入式日志监听等,都是代理
模式的实际体现。当无法或不想直接引用某个对象或访问某个对象存在困难时,可以通过也给代理对象
来间接访问。使用代理模式主要有两个目的:一是保护目标对象,二是增强目标对象。
7.5.代理模式的通用写法
下面是代理模式的通用代码展示。
首先创建代理主题角色ISubject类:
public interface ISubject { void request(); }
创建真实主题角色RealSubject类:
public class RealSubject implements ISubject { public void request() { System.out.println("real service is called."); } }
创建代理主题角色Proxy类:
public class Proxy implements ISubject { private ISubject subject; public Proxy(ISubject subject){ this.subject = subject; } public void request() { before(); subject.request(); after(); } public void before(){ System.out.println("called before request()."); } public void after(){ System.out.println("called after request()."); } }
客户端调用代码:
public class Client { public static void main(String[] args) { Proxy proxy = new Proxy(new RealSubject()); proxy.request(); } }
运行结果
called before request(). real service is called. called after request().
7.6.从静态代理到动态代理
举个例子,有些人到了适婚年龄,其父母总是迫不及待地希望早点抱孙子。而现在在各种压力之下,
很多人都选择晚婚晚育。于是着急的父母就开始到处为自己的子女相亲,比子女自己还着急。下面来看代码实现。
静态代理:
创建顶层接口IPerson的代码如下:
public interface IPerson { void findLove(); }
儿子张三要找对象,实现ZhangSan类:
public class ZhangSan implements IPerson { public void findLove() { System.out.println("儿子要求:肤白貌美大长腿"); } }
父亲张老三要帮儿子张三相亲,实现Father类:
public class ZhangLaosan implements IPerson { private ZhangSan zhangsan; public ZhangLaosan(ZhangSan zhangsan) { this.zhangsan = zhangsan; } public void findLove() { // before System.out.println("张老三开始物色"); zhangsan.findLove(); // after System.out.println("开始交往"); } }
来看测试代码:
public class Test { public static void main(String[] args) { ZhangLaosan zhangLaosan = new ZhangLaosan(new ZhangSan()); zhangLaosan.findLove(); } }
运行结果:
张老三开始物色 儿子要求:肤白貌美大长腿 开始交往
但上面的场景有个弊端,就是自己父亲只会给自己的子女去物色对象,别人家的孩子是不会管的。
但社会上这项业务发展成了一个产业,出现了媒婆、婚介所等,还有各种各样的定制套餐。如果还使用静态代理成本就太高了,需要一个更加通用的解决方案,满足任何单身人士找对象的需求。
这就是由静态代理升级到了动态代理。
采用动态代理基本上只要是人(IPerson)就可以提供相亲服务。
动态代理的底层实现一般不用我们自己亲自去实现,已经有很多现成的API。
在Java生态中,目前最普遍使用的是JDK自带的代理和Cglib提供的类库。
下面我们首先基于JDK的动态代理支持如来升级一下代码。
首先,创建媒婆(婚介所)类JdkMeipo:
public class JdkMeipo implements InvocationHandler { private IPerson target; // 反射获取 public IPerson getInstance(IPerson target){ this.target = target; Class<?> clazz = target.getClass(); return (IPerson) Proxy.newProxyInstance(clazz.getClassLoader(),clazz.getInterfaces(),this); } public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { before(); Object result = method.invoke(this.target,args); after(); return result; } private void after() { System.out.println("双方同意,开始交往"); } private void before() { System.out.println("我是媒婆,已经收集到你的需求,开始物色"); } }
再创建一个类ZhaoLiu:
public class ZhaoLiu implements IPerson { public void findLove() { System.out.println("赵六要求:有车有房学历高"); } public void buyInsure() { } }
测试代码如下:
public class Test { public static void main(String[] args) { JdkMeipo jdkMeipo = new JdkMeipo(); IPerson zhangsan = jdkMeipo.getInstance(new Zhangsan()); zhangsan.findLove(); IPerson zhaoliu = jdkMeipo.getInstance(new ZhaoLiu()); zhaoliu.findLove(); } }
运行效果如下:
我是媒婆,已经收集到你的需求,开始物色 张三要求:肤白貌美大长腿 双方同意,开始交往 我是媒婆,已经收集到你的需求,开始物色 赵六要求:有车有房学历高 双方同意,开始交往
7.7.静态模式在业务中的应用
这里“小伙伴们”可能会觉得还是不知道如何将代理模式应用到业务场景中,我们来看一个实际的业务场景。
在分布式业务场景中,通常会对数据库进行分库分表,分库分表之后使用 Java操作时就可能需要配置多个数据源,我们通过设置数据源路由来动态切换数据源。
先创建Order订单类:
@Data public class Order { private Object orderInfo; //订单创建时间进行按年分库 private Long createTime; private String id; }
创建OrderDao持久层操作类:
public class OrderDao { public int insert(Order order){ System.out.println("OrderDao创建Order成功!"); return 1; } }
创建IOrderService接口:
public interface IOrderService { int createOrder(Order order); }
创建OrderService实现类:
public class OrderService implements IOrderService { private OrderDao orderDao; public OrderService(){ //如果使用Spring应该是自动注入的 //我们为了使用方便,在构造方法中将orderDao直接初始化了 orderDao = new OrderDao(); } public int createOrder(Order order) { System.out.println("OrderService调用orderDao创建订单"); return orderDao.insert(order); } }
接下来使用静态代理,主要完成的功能是:根据订单创建时间自动按年进行分库。
根据开闭原则,我们修改原来写好的代码逻辑,通过代理对象来完成。
先创建数据源路由对象,使用ThreadLocal的单例实现DynamicDataSourceEntity类:
public class DynamicDataSourceEntity { public final static String DEFAULE_SOURCE = null; private final static ThreadLocal<String> local = new ThreadLocal<String>(); private DynamicDataSourceEntity(){} public static String get(){return local.get();} public static void restore(){ local.set(DEFAULE_SOURCE); } //DB_2018 //DB_2019 public static void set(String source){local.set(source);} public static void set(int year){local.set("DB_" + year);} }
创建切换数据源的代理类OrderServiceSaticProxy:
public class OrderServiceStaticProxy implements IOrderService { private SimpleDateFormat yearFormat = new SimpleDateFormat("yyyy"); private IOrderService orderService; public OrderServiceStaticProxy(IOrderService orderService) { this.orderService = orderService; } public int createOrder(Order order) { before(); Long time = order.getCreateTime(); Integer dbRouter = Integer.valueOf(yearFormat.format(new Date(time))); System.out.println("静态代理类自动分配到【DB_" + dbRouter + "】数据源处理数据" ); DynamicDataSourceEntity.set(dbRouter); this.orderService.createOrder(order); DynamicDataSourceEntity.restore(); after(); return 0; } private void before(){ System.out.println("Proxy before method."); } private void after(){ System.out.println("Proxy after method."); } }
来看测试代码:
public class DbRouteProxyTest { public static void main(String[] args) { try { Order order = new Order(); SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd"); Date date = sdf.parse("2020/03/01"); order.setCreateTime(date.getTime()); IOrderService orderService = new OrderServiceStaticProxy(new OrderService()); orderService.createOrder(order); } catch (Exception e) { e.printStackTrace(); } } }
运行结果如下:
Proxy before method. 静态代理类自动分配到【DB_2020】数据源处理数据 OrderService调用orderDao创建订单 OrderDao创建Order成功! Proxy after method.
结果符合我们的预期。现在再来回顾一下类图,看是不是和我们最先画的一致,如下图所示。
动态代理和静态代理的基本思路是一致的,只不过动态代理功能更加强大,随着业务的扩展适应性更强。
7.8.动态代理在业务中的应用
上面的案例理解了,我们再来看数据源动态路由业务,帮助“小伙伴们”加深对动态代理的印象。
创建动态代理的类OrderServiceDynamicProxy:
package com.gupaoedu.vip.pattern.proxy.dbroute.proxy; import com.gupaoedu.vip.pattern.proxy.dbroute.db.DynamicDataSourceEntity; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; import java.text.SimpleDateFormat; import java.util.Date; public class OrderServiceDynamicProxy implements InvocationHandler { private SimpleDateFormat yearFormat = new SimpleDateFormat("yyyy"); private Object target; public Object getInstance(Object target) { this.target = target; Class<?> clazz = target.getClass(); return Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), this); } public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { before(args[0]); Object object = method.invoke(target, args); after(); return object; } private void before(Object target) { try { System.out.println("Proxy before method."); Long time = (Long) target.getClass().getMethod("getCreateTime").invoke(target); Integer dbRouter = Integer.valueOf(yearFormat.format(new Date(time))); System.out.println("动态代理类自动分配到【DB_" + dbRouter + "】数据源处理数据"); DynamicDataSourceEntity.set(dbRouter); } catch (Exception e) { e.printStackTrace(); } } private void after() { System.out.println("Proxy after method."); } }
测试代码如下:
public class DbRouteProxyTest { public static void main(String[] args) { try { Order order = new Order(); SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd"); Date date = sdf.parse("2020/03/01"); order.setCreateTime(date.getTime()); IOrderService orderService = (IOrderService) new OrderServiceDynamicProxy().getInstance(new OrderService()); orderService.createOrder(order); } catch (Exception e) { e.printStackTrace(); } } }
运行效果如下:
Proxy before method. 静态代理类自动分配到【DB_2020】数据源处理数据 OrderService调用orderDao创建订单 OrderDao创建Order成功! Proxy after method.
依然能够达到相同运行效果。但是,使用动态代理实现之后,我们不仅能实现 Order的数据源动态
路由,还可以实现其他任何类的数据源路由。当然,有个比较重要的约定,必须实现getCreateTime()
方法,因为路由规则是根据时间来运算的。我们可以通过接口规范来达到约束的目的,在此就不再举例。
7.9.手写JDK动态代理实现原理
不仅知其然,还得知其所以然。既然JDK动态代理功能如此强大,那么它是如何实现的呢?我们现
在来探究一下原理,并模仿JDK动态代理动手写一个属于自己的动态代理。
我们都知道JDK动态代理采用字节重组,重新生成对象来替代原始对象,以达到动态代理的目的。
JDK动态代理的实现原理
-
获取被代理对象的引用,并且获取它的所有接口(反射获取)。
-
JDK Proxy类重新生成一个新的类,实现了被代理类所有接口的方法。
-
动态生成Java代码,把增强逻辑加入到新生成代码中。
-
编译生成新的Java代码的class文件。
-
加载并重新运行新的class,得到类就是全新类。
CGLib动态代理容易踩的坑
- 无法代理final修饰的方法。
以上过程就叫字节码重组。JDK中有一个规范,在ClassPath下只要是$开头的.class文件,一般都是自动生成的。那么我们有没有办法看到代替后的对象的“真容”呢?做一个这样测试,我们将内存中
的对象字节码通过文件流输出到一个新的.class文件,然后利用反编译工具查看其源代码。
public class Test { public static void main(String[] args) { JdkMeipo jdkMeipo = new JdkMeipo(); IPerson zhangsan = jdkMeipo.getInstance(new Zhangsan()); zhangsan.findLove(); // 通过反编译工具可以查看源代码 try { byte[] bytes = ProxyGenerator.generateProxyClass("$Proxy0", new Class[]{IPerson.class}); FileOutputStream os = new FileOutputStream("F://$Proxy0.class"); os.write(bytes); os.close(); } catch (IOException e) { e.printStackTrace(); } } }
运行以上代码,我们能在E盘下找到一个$Proxy0.class 文件。使用Jad反编译,得到$Proxy0.jad
文件,打开它可以看到如下内容:
import com.gupaoedu.vip.pattern.proxy.dynamicproxy.jdkproxy.IPerson; 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 IPerson { 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 findLove() 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 void buyInsure() throws { try { super.h.invoke(this, m4, (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("com.gupaoedu.vip.pattern.proxy.dynamicproxy.jdkproxy.IPerson").getMethod("findLove"); m2 = Class.forName("java.lang.Object").getMethod("toString"); m4 = Class.forName("com.gupaoedu.vip.pattern.proxy.dynamicproxy.jdkproxy.IPerson").getMethod("buyInsure"); m0 = Class.forName("java.lang.Object").getMethod("hashCode"); } catch (NoSuchMethodException var2) { throw new NoSuchMethodError(var2.getMessage()); } catch (ClassNotFoundException var3) { throw new NoClassDefFoundError(var3.getMessage()); } } }
我们发现,$Proxy0继承了Proxy类,同时还实现了Person接口,而且重写了findLove()等方法。
在静态块中用反射查找到了目标对象的所有方法,而且保存了所有方法的引用,重写的方法用反射调用
目标对象的方法。“小伙伴们”此时一定会好奇:这些代码是哪里来的呢?其实是JDK帮我们自动生成
的。现在我们不依赖JDK,自己来动态生成源代码、动态完成编译,然后替代目标对象并执行。
创建GPInvocationHandler接口:
public interface GPInvocationHandler { Object invoke(Object proxy, Method method, Object[] args) throws Throwable; }
创建GPProxy类:
/** * 用来生成源代码的工具类 */ public class GPProxy { public static final String ln = "\r\n"; public static Object newProxyInstance(GPClassLoader classLoader, Class<?> [] interfaces, GPInvocationHandler h){ try { //1、动态生成源代码.java文件 String src = generateSrc(interfaces); //System.out.println(src); //2、Java文件输出磁盘 String filePath = GPProxy.class.getResource("").getPath(); //System.out.println(filePath); File f = new File(filePath + "$Proxy0.java"); FileWriter fw = new FileWriter(f); fw.write(src); fw.flush(); fw.close(); //3、把生成的.java文件编译成.class文件 JavaCompiler compiler = ToolProvider.getSystemJavaCompiler(); StandardJavaFileManager manage = compiler.getStandardFileManager(null,null,null); Iterable iterable = manage.getJavaFileObjects(f); JavaCompiler.CompilationTask task = compiler.getTask(null,manage,null,null,null,iterable); task.call(); manage.close(); //4、编译生成的.class文件加载到JVM中来 Class proxyClass = classLoader.findClass("$Proxy0"); Constructor c = proxyClass.getConstructor(GPInvocationHandler.class); f.delete(); //5、返回字节码重组以后的新的代理对象 return c.newInstance(h); }catch (Exception e){ e.printStackTrace(); } return null; } private static String generateSrc(Class<?>[] interfaces){ StringBuffer sb = new StringBuffer(); sb.append(GPProxy.class.getPackage() + ";" + ln); sb.append("import " + interfaces[0].getName() + ";" + ln); sb.append("import java.lang.reflect.*;" + ln); sb.append("public class $Proxy0 implements " + interfaces[0].getName() + "{" + ln); sb.append("GPInvocationHandler h;" + ln); sb.append("public $Proxy0(GPInvocationHandler h) { " + ln); sb.append("this.h = h;"); sb.append("}" + ln); for (Method m : interfaces[0].getMethods()){ Class<?>[] params = m.getParameterTypes(); StringBuffer paramNames = new StringBuffer(); StringBuffer paramValues = new StringBuffer(); StringBuffer paramClasses = new StringBuffer(); for (int i = 0; i < params.length; i++) { Class clazz = params[i]; String type = clazz.getName(); String paramName = toLowerFirstCase(clazz.getSimpleName()); paramNames.append(type + " " + paramName); paramValues.append(paramName); paramClasses.append(clazz.getName() + ".class"); if(i > 0 && i < params.length-1){ paramNames.append(","); paramClasses.append(","); paramValues.append(","); } } sb.append("public " + m.getReturnType().getName() + " " + m.getName() + "(" + paramNames.toString() + ") {" + ln); sb.append("try{" + ln); sb.append("Method m = " + interfaces[0].getName() + ".class.getMethod(\"" + m.getName() + "\",new Class[]{" + paramClasses.toString() + "});" + ln); sb.append((hasReturnValue(m.getReturnType()) ? "return " : "") + getCaseCode("this.h.invoke(this,m,new Object[]{" + paramValues + "})",m.getReturnType()) + ";" + ln); sb.append("}catch(Error _ex) { }"); sb.append("catch(Throwable e){" + ln); sb.append("throw new UndeclaredThrowableException(e);" + ln); sb.append("}"); sb.append(getReturnEmptyCode(m.getReturnType())); sb.append("}"); } sb.append("}" + ln); return sb.toString(); } private static Map<Class,Class> mappings = new HashMap<Class, Class>(); static { mappings.put(int.class,Integer.class); } private static String getReturnEmptyCode(Class<?> returnClass){ if(mappings.containsKey(returnClass)){ return "return 0;"; }else if(returnClass == void.class){ return ""; }else { return "return null;"; } } private static String getCaseCode(String code,Class<?> returnClass){ if(mappings.containsKey(returnClass)){ return "((" + mappings.get(returnClass).getName() + ")" + code + ")." + returnClass.getSimpleName() + "Value()"; } return code; } private static boolean hasReturnValue(Class<?> clazz){ return clazz != void.class; } private static String toLowerFirstCase(String src){ char [] chars = src.toCharArray(); chars[0] += 32; return String.valueOf(chars); } }
创建GPClassLoader类:
public class GPClassLoader extends ClassLoader { private File classPathFile; public GPClassLoader(){ String classPath = GPClassLoader.class.getResource("").getPath(); this.classPathFile = new File(classPath); } @Override protected Class<?> findClass(String name) throws ClassNotFoundException { String className = GPClassLoader.class.getPackage().getName() + "." + name; if(classPathFile != null){ File classFile = new File(classPathFile,name.replaceAll("\\.","/") + ".class"); if(classFile.exists()){ FileInputStream in = null; ByteArrayOutputStream out = null; try{ in = new FileInputStream(classFile); out = new ByteArrayOutputStream(); byte [] buff = new byte[1024]; int len; while ((len = in.read(buff)) != -1){ out.write(buff,0,len); } return defineClass(className,out.toByteArray(),0,out.size()); }catch (Exception e){ e.printStackTrace(); } } } return null; } }
创建GPMeipo类:
public class GpMeipo implements GPInvocationHandler { private IPerson target; public IPerson getInstance(IPerson target){ this.target = target; Class<?> clazz = target.getClass(); return (IPerson) GPProxy.newProxyInstance(new GPClassLoader(),clazz.getInterfaces(),this); } public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { before(); Object result = method.invoke(this.target,args); after(); return result; } private void after() { System.out.println("双方同意,开始交往"); } private void before() { System.out.println("我是媒婆,已经收集到你的需求,开始物色"); } }
客户端测试代码如下:
public class Test { public static void main(String[] args) { GpMeipo gpMeipo = new GpMeipo(); IPerson zhangsan = gpMeipo.getInstance(new Zhangsan()); zhangsan.findLove(); } }
运行效果如下:
我是媒婆,已经收集到你的需求,开始物色 张三要求:肤白貌美大长腿 双方同意,开始交往
到此,手写JDK动态代理就完成了。“小伙伴们”是不是又多了一个面试用的“撒手锏”呢?
7.10.CGLib代理调用API及原理分析
简单看一下CGLib代理的使用,还是以媒婆为例,创建CglibMeipo类:
public class CGlibMeipo implements MethodInterceptor { public Object getInstance(Class<?> clazz) throws Exception{ //相当于Proxy,代理的工具类 Enhancer enhancer = new Enhancer(); enhancer.setSuperclass(clazz); enhancer.setCallback(this); return enhancer.create(); } public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable { before(); Object obj = methodProxy.invokeSuper(o,objects); after(); return obj; } private void before(){ System.out.println("我是媒婆,我要给你找对象,现在已经确认你的需求"); System.out.println("开始物色"); } private void after(){ System.out.println("OK的话,准备办事"); } }
创建单身客户类Customer:
public class Customer { public void findLove(){ System.out.println("儿子要求:肤白貌美大长腿"); } }
有个小细节,CGLib代理的目标对象不需要实现任何接口,它是通过动态继承目标对象实现动态代
理的。来看测试代码:
public class CglibTest { public static void main(String[] args) { try { Customer obj = (Customer)new CGlibMeipo().getInstance(Customer.class); obj.findLove(); } catch (Exception e) { e.printStackTrace(); } } }
CGLib 代理的实现原理又是怎样的呢?我们可以在测试代码中加上一句代码,将 CGLib 代理后
的.class文件写入磁盘,然后反编译来一探究竟,代码如下:
public class CglibTest { public static void main(String[] args) { try { //JDK是采用读取接口的信息 //CGLib覆盖父类方法 //目的:都是生成一个新的类,去实现增强代码逻辑的功能 //JDK Proxy 对于用户而言,必须要有一个接口实现,目标类相对来说复杂 //CGLib 可以代理任意一个普通的类,没有任何要求 //CGLib 生成代理逻辑更复杂,效率,调用效率更高,生成一个包含了所有的逻辑的FastClass,不再需要反射调用 //JDK Proxy生成代理的逻辑简单,执行效率相对要低,每次都要反射动态调用 //CGLib 有个坑,CGLib不能代理final的方法 System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY,"E://cglib_proxy_classes"); Customer obj = (Customer) new CGlibMeipo().getInstance(Customer.class); System.out.println(obj); obj.findLove(); } catch (Exception e) { e.printStackTrace(); } } }
重新执行代码,我们会发现在E://cglib_proxy_class目录下多了三个.class文件,如下图所示。
通过调试跟踪发现,Customer$$EnhancerByCGLIB$$3feeb52a.class
就是 CGLib 代理生成的代
理类,继承了Customer类。
package com.gupaoedu.vip.pattern.proxy.dynamicproxy.cglibproxy; import java.lang.reflect.Method; import net.sf.cglib.core.ReflectUtils; import net.sf.cglib.core.Signature; import net.sf.cglib.proxy.Callback; import net.sf.cglib.proxy.Factory; import net.sf.cglib.proxy.MethodInterceptor; import net.sf.cglib.proxy.MethodProxy; public class Customer$$EnhancerByCGLIB$$6d99cfc2 extends Customer implements Factory { ... final void CGLIB$findLove$0() { super.findLove(); } public final void findLove() { 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$findLove$0$Method, CGLIB$emptyArgs, CGLIB$findLove$0$Proxy); } else { super.findLove(); } } ... }
我们重写了Customer类的所有方法,通过代理类的源码可以看到,代理类会获得所有从父类继承
来的方法,并且会有 MethodProxy 与之对应,比如 Method CGLIB$findLove$0$Method
、MethodProxy CGLIB$findLove$0$Proxy
这些方法在代理类的findLove()方法中都有调用。
//代理方法(methodProxy.invokeSuper()方法会调用) final void CGLIB$findLove$0() { super.findLove(); } //被代理方法(methodProxy.invoke()方法会调用,这就是为什么在拦截器中调用 methodProxy.invoke 会发生死循环,一直在调用拦截器) public final void findLove() { 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$findLove$0$Method, CGLIB$emptyArgs, CGLIB$findLove$0$Proxy); } else { super.findLove(); } }
调用过程为:代理对象调用 this.findLove()方法→调用拦截器→methodProxy.invokeSuper→CGLIB$findLove$0
→被代理对象findLove()方法。
此时,我们发现拦截器 MethodInterceptor中就是由 MethodProxy的invokeSuper()方法调用代
理方法的,MethodProxy非常关键,我们分析一下它具体做了什么。
package net.sf.cglib.proxy; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import net.sf.cglib.core.AbstractClassGenerator; import net.sf.cglib.core.CodeGenerationException; import net.sf.cglib.core.GeneratorStrategy; import net.sf.cglib.core.NamingPolicy; import net.sf.cglib.core.Signature; import net.sf.cglib.reflect.FastClass; import net.sf.cglib.reflect.FastClass.Generator; public class MethodProxy { private Signature sig1; private Signature sig2; private MethodProxy.CreateInfo createInfo; private final Object initLock = new Object(); private volatile MethodProxy.FastClassInfo fastClassInfo; public static MethodProxy create(Class c1, Class c2, String desc, String name1, String name2) { MethodProxy proxy = new MethodProxy(); proxy.sig1 = new Signature(name1, desc); proxy.sig2 = new Signature(name2, desc); proxy.createInfo = new MethodProxy.CreateInfo(c1, c2); return proxy; } ... private static class CreateInfo { Class c1; Class c2; NamingPolicy namingPolicy; GeneratorStrategy strategy; boolean attemptLoad; public CreateInfo(Class c1, Class c2) { this.c1 = c1; this.c2 = c2; AbstractClassGenerator fromEnhancer = AbstractClassGenerator.getCurrent(); if (fromEnhancer != null) { this.namingPolicy = fromEnhancer.getNamingPolicy(); this.strategy = fromEnhancer.getStrategy(); this.attemptLoad = fromEnhancer.getAttemptLoad(); } } } ... }
继续看invokeSuper()方法:
public Object invokeSuper(Object obj, Object[] args) throws Throwable { try { init(); FastClassInfo fci = fastClassInfo; return fci.f2.invoke(fci.i2, obj, args); } catch (InvocationTargetException e) { throw e.getTargetException(); } } private static class FastClassInfo { FastClass f1; FastClass f2; int i1; int i2; }
上面的代码调用就是获取代理类对应的FastClass,并执行代理方法。还记得之前生成的三个.class
文件吗?Customer$$EnhancerByCGLIB$$3feeb52a$$FastClassByCGLIB$$6aad62f1.class 就是代理类的FastClass,Customer$$FastClassByCGLIB$$2669574a.class 就是被代理类的FastClass。
CGLib代理执行代理方法的效率之所以比JDK的高,是因为CGlib采用了FastClass机制,它的原
理简单来说就是:为代理类和被代理类各生成一个类,这个类会为代理类或被代理类的方法分配一个
index(int类型);这个index当作一个入参,FastClass就可以直接定位要调用的方法并直接进行调
用,省去了反射调用,所以调用效率比JDK代理通过反射调用高。下面我们反编译一个FastClass看看:
public Object invokeSuper(Object obj, Object[] args) throws Throwable { try { init(); FastClassInfo fci = fastClassInfo; return fci.f2.invoke(fci.i2, obj, args); } catch (InvocationTargetException e) { throw e.getTargetException(); } } private static class FastClassInfo { FastClass f1; FastClass f2; int i1; int i2; }
CGLib代理执行代理方法的效率之所以比JDK的高,是因为CGlib采用了FastClass机制,它的原理简单来说就是:为代理类和被代理类各生成一个类,这个类会为代理类或被代理类的方法分配一个
index(int类型);这个index当作一个入参,FastClass就可以直接定位要调用的方法并直接进行调
用,省去了反射调用,所以调用效率比JDK代理通过反射调用高。下面我们反编译一个FastClass看看:
public class test { public int getIndex(Signature signature) { String s = signature.toString(); s; s.hashCode(); JVM INSTR lookupswitch 11:default 223 … JVM INSTR pop; return -1; } //部分代码省略 //根据 index 直接定位执行方法 public Object invoke(int i, Object obj, Object[] aobj) throws InvocationTargetException { (Customer) obj; i; JVM INSTR tableswitch 0 10:default 161 goto _L1 _L2 _L3 _L4 _L5 _L6 _L7 _L8 _L9 _L10 _L11 _L12 _L2: eat(); return null; _L3: findLove(); return null; …throw new IllegalArgumentException("Cannot find matching method/constructor"); } }
FastClass 并不是跟代理类一起生成的,而是在第一次执行 MethodProxy 的 invoke()或
invokeSuper()方法时生成的,并放在了缓存中。
//MethodProxy 的 invoke()或 invokeSuper()方法都调用了 init()方法 private void init() { /* * Using a volatile invariant allows us to initialize the FastClass and * method index pairs atomically. * * Double-checked locking is safe with volatile in Java 5. Before 1.5 this * code could allow fastClassInfo to be instantiated more than once, which * appears to be benign. */ if (fastClassInfo == null) { synchronized (initLock) { if (fastClassInfo == null) { CreateInfo ci = createInfo; FastClassInfo fci = new FastClassInfo(); fci.f1 = helper(ci, ci.c1); fci.f2 = helper(ci, ci.c2); fci.i1 = fci.f1.getIndex(sig1); fci.i2 = fci.f2.getIndex(sig2); fastClassInfo = fci; } } } }
至此,CGLib代理的原理我们就基本搞清楚了,对代码细节有兴趣的“小伙伴”可以自行深入研究。
7.11.CGLib和JDK动态代理对比
(1)JDK动态代理实现了被代理对象的接口,CGLib代理继承了被代理对象。
(2) JDK动态代理和CGLib代理都在运行期生成字节码, JDK动态代理直接写Class字节码, CGLib
代理使用ASM框架写Class字节码,CGlib代理实现更复杂,生成代理类比JDK动态代理效率低。
(3)JDK动态代理调用代理方法是通过反射机制调用的,CGLib代理是通过FastClass机制直接调用方法的,CGLib代理的执行效率更高。
7.12.代理模式与Spring生态
1、代理模式在Spring中的应用
先看ProxyFactoryBean核心方法getObject(),源码如下:
@Nullable public Object getObject() throws BeansException { this.initializeAdvisorChain(); if (this.isSingleton()) { return this.getSingletonInstance(); } else { if (this.targetName == null) { this.logger.info("Using non-singleton proxies with singleton targets is often undesirable. Enable prototype proxies by setting the 'targetName' property."); } return this.newPrototypeInstance(); } }
在getObject()方法中,主要调用 getSingletonInstance()和 newPrototypeInstance()。在 Spring
的配置中如果不做任何设置,那么 Spring 代理生成的 Bean 都是单例对象。如果修改 scope,则每次
创建一个新的原型对象。newPrototypeInstance()里面的逻辑比较复杂,我们后面再做深入研究,这里
先做简单了解。
Spring 利用动态代理实现 AOP 时有两个非常重要的类:JdkDynamicAopProxy 类和CglibAopProxy类,来看一下类图,如下图所示。
7.13.静态代理和动态代理的本质区别
(1)静态代理只能通过手动完成代理操作,如果被代理类增加了新的方法,代理类需要同步增加,
违背开闭原则。
(2)动态代理采用在运行时动态生成代码的方式,取消了对被代理类的扩展限制,遵循开闭原则。
(3)若动态代理要对目标类的增强逻辑进行扩展,结合策略模式,只需要新增策略类便可完成,无须修改代理类的代码。
7.14.代理模式的优缺点
代理模式具有以下优点:
(1)代理模式能将代理对象与真实被调用目标对象分离。
(2)在一定程度上降低了系统的耦合性,扩展性好。
(3)可以起到保护目标对象的作用。
(4)可以增强目标对象的功能。
当然,代理模式也有缺点:
(1)代理模式会造成系统设计中类的数量增加。
(2)在客户端和目标对象中增加一个代理对象,会导致请求处理速度变慢。
(3)增加了系统的复杂度。
7.15.Spring中的代理选择原则
(1)当Bean有实现接口时,Spring就会用JDK动态代理。
(2)当Bean没有实现接口时,Spring会选择CGLib代理。
(3)Spring可以通过配置强制使用CGLib代理,只需在Spring的配置文件中加入如下代码:
<aop:aspectj-autoproxy proxy-target-class="true"/>
7.16.作业
1、请总结静态代理和动态代理的根本区别。
静态代理是硬编码,动态代理是动态生成。
2、继续完成手写Proxy类中带参数方法的代理实现。
Zhangsan添加一个新方法
public void setAge(int age) { System.out.println("年龄要求" + age); }
生成字节码
private static Method m3; public final void setAge(int var1) throws { try { super.h.invoke(this, m3, new Object[]{var1}); } catch (RuntimeException | Error var3) { throw var3; } catch (Throwable var4) { throw new UndeclaredThrowableException(var4); } } static { try { m3 = Class.forName("com.gupaoedu.vip.pattern.proxy.dynamicproxy.jdkproxy.IPerson").getMethod("setAge", Integer.TYPE); } catch (NoSuchMethodException var2) { throw new NoSuchMethodError(var2.getMessage()); } catch (ClassNotFoundException var3) { throw new NoClassDefFoundError(var3.getMessage()); } }
这篇关于五、代理模式详解的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!
- 2024-10-01基于Python+Vue开发的医院门诊预约挂号系统
- 2024-10-01基于Python+Vue开发的旅游景区管理系统
- 2024-10-01RestfulAPI入门指南:打造简单易懂的API接口
- 2024-10-01初学者指南:了解和使用Server Action
- 2024-10-01Server Component入门指南:搭建与配置详解
- 2024-10-01React 中使用 useRequest 实现数据请求
- 2024-10-01使用 golang 将ETH账户的资产平均分散到其他账户
- 2024-10-01JWT用户校验课程:从入门到实践
- 2024-10-01Server Component课程入门指南
- 2024-09-30Dnd-Kit学习:新手快速入门指南