1.5.深入分析代理模式
1.5.1.深度分析代理模式【上】
时长：46min
学习目标：
》代理模式的应用场景及实现原理
》区分静态代理与动态代理
》cglib和jdk Proxy实现动态代理的区别
》手写实现定义的动态代理
》spring Aop基于动态代理，打下基础
5.1.代理模式定义
5.1.1.什么是代理模式？
Proxy Pattern,是指为其他对象提供一种代理，以控制对这个对象的访问。
代理对象，在客户端与目标对象之间起到中介作用，起到功能增强的作用。
属于结构型设计模式。
代理之生活理解：
可以参照中介来理解。如：租房中介，用户需要租房子，但是找不到或没时间找房子【用户功能不够强大】，那么，
就找到一个代理【中介】，中介是专门找到房子的【他的功能比用户强大】，最后中介帮用户找到了房子。
所以，代理是对目标对象【用户】功能的增强。
生活中代理场景：
房产中介，快递小哥，黄牛党。
5.1.2.代理模式的适用场景
》保护目标对象
》增强目标对象
三层架构：典型的静态代理模式
5.1.3.代理模式的优点与缺点
优点：
代理模式，能够将代理对象与真实的目标对象分离
一定程度上，降低了系统的耦合程度，易于扩展。
代理可以起到保护目标对象的作用。
可以增强目标对象的职责，功能。
缺点：
会造成系统设计中类数量的增加。
在客户端与目标对象之间增加了一个代理对象，请求速度变慢。
增加系统复杂性。
5.1.4.spring中的代理选择原则
1.当Bean有实现接口时，默认使用Jdk的动态代理
2.当Bean没有实现接口时，Spring会选择cglib实现。
3.spring可以通过配置强制使用cglib,只需在spring配置文件中，使用如下配置：
<aop:aspectj-autoproxy proxy-target-class="true"/> //强制设置cglib实现
5.2.代理模式的实现示例代码
5.2.1.通用写法
5.2.1.1.目标对象定义
由于面向接口编程，定义顶层接口：
package com.wf.proxy.general; /** * @ClassName ISubject * @Description 目标对象的抽象接口 * @Author wf * @Date 2020/5/15 17:00 * @Version 1.0 */ public interface ISubject { void request(); }
目标对象实现：
package com.wf.proxy.general; /** * @ClassName RealSubject * @Description 目标对象 * @Author wf * @Date 2020/5/15 17:02 * @Version 1.0 */ public class RealSubject implements ISubject { @Override public void request() { System.out.println("目标对象真实的服务实现"); } }
5.2.1.2.代理类定义
package com.wf.proxy.general; /** * @ClassName Proxy * @Description 代理对象 * @Author wf * @Date 2020/5/15 17:05 * @Version 1.0 */ public class Proxy implements ISubject { //代理对象 需要对目标对象的功能进行增强 //即增强目标对象的方法，所以实现同一接口 //增强目标对象，所以个课程目标对象【基于多态，可以引入顶层接口bean】 private ISubject subject; //客户端要传参目标对象，这里定义构建器传参 public Proxy(ISubject subject) { this.subject = subject; } //程序中，什么叫功能增强，就是多加一段代码，提供更多功能 @Override public void request() { doBefore(); //方法前增强 subject.request(); //方法后增强 doAfter(); } private void doAfter() { System.out.println("方法后面进行增强"); } private void doBefore() { System.out.println("方法前面进行增强"); } }
5.2.1.3.客户端调用
package com.wf.proxy.general; /** * @ClassName Client * @Description 客户端调用 * @Author wf * @Date 2020/5/15 17:15 * @Version 1.0 */ public class Client { public static void main(String[] args) { RealSubject subject = new RealSubject(); Proxy proxy = new Proxy(subject); proxy.request(); } }
测试结果如下：
说明：
显然，request方法的功能得到了增强。
5.2.1.4.系统类图
5.3.静态代理与动态代理
5.3.1.什么是静态代理？
先以一个生活场景，通过代码来说明。
程序员平时加班较多，没时间找对象-----------父母着急，帮忙物色对象【充当代理】，安排相亲-------最后找到女朋友。
抽象出业务模型
Person----Parent-----------findLove
5.3.1.1.代码示例
1.定义顶层接口
package com.wf.proxy.staticproxy; /** * @ClassName IPerson * @Description 程序员顶层抽象接口 * @Author wf * @Date 2020/5/15 17:31 * @Version 1.0 */ public interface IPerson { void findLove(); }
2.目标对象
package com.wf.proxy.staticproxy; /** * @ClassName Person * @Description 程序员 目标对象 * @Author wf * @Date 2020/5/15 17:33 * @Version 1.0 */ public class Person implements IPerson { @Override public void findLove() { System.out.println("程序员，自己没有找到女朋友"); } }
3.代理类---父母
package com.wf.proxy.staticproxy; /** * @ClassName ParentProxy * @Description 父母 代理类 * @Author wf * @Date 2020/5/15 17:36 * @Version 1.0 */ public class ParentProxy implements IPerson { private IPerson person; public ParentProxy(IPerson person) { this.person = person; } @Override public void findLove() { // System.out.println("开始帮儿子，物色对象"); person.findLove(); System.out.println("儿子说，ok,开始交往"); } }
4.客户端代码
package com.wf.proxy.staticproxy; /** * @ClassName Client * @Description 客户端调用类 * @Author wf * @Date 2020/5/15 17:41 * @Version 1.0 */ public class Client { public static void main(String[] args) { Person person = new Person(); ParentProxy proxy = new ParentProxy(person); proxy.findLove(); } }
测试结果如下：
说明：
因为有大量人可能也没有找到对象，针对这种需求，社会上形成一个产业链，叫婚介所，婚恋网。
因此，系统需要扩展。
但是，张三的父母，力量有限，只能给儿子一个人物色对象。
如果李四也想找到张三的父母物色对象，就没办法完成。也就是父母这个代理只能代理儿子的事情。
这就是静态代理。
如果想要为更多人做代理，代理需要更为强大，于是，产生动态代理。
静态代理：
只能代理某特定的目标对象。如：房产中介，只能代理租客。
动态代理：
代理对象可以代理任意的目标对象。
5.3.2.动态代理的实现
在java中，动态代理有两种实现方案：
》jdk Proxy代理类实现
》cglib库实现
5.3.2.1.jdk实现动态代理
1.婚介所代理类创建
package com.wf.proxy.dynamicproxy.jdkproxy; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; /** * @ClassName MarriageAgency * @Description 婚介所 代理类 * @Author wf * @Date 2020/5/15 18:23 * @Version 1.0 */ public class MarriageAgency implements InvocationHandler { //jdk动态代理 实现一个抽象的接口【接口可以定义任意功能】 //加强目标对象功能，需要引入目标对象 private IPerson person; public IPerson getProxy(IPerson person) { this.person = person; //根据目标对象，得到代理对象 //jdk底层是基于字节码，需要传参代理类的类加载器，并且代理对象需要实现接口功能【传参接口，实例this】 Class<? extends IPerson> personClass = person.getClass(); return (IPerson)Proxy.newProxyInstance(personClass.getClassLoader(), personClass.getInterfaces(),this); } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { //加强目标对象的方法 doBefore(); Object result = method.invoke(this.person, args); doAfter(); return result; } private void doAfter() { System.out.println("是不是确认关系，开始交往"); } private void doBefore() { System.out.println("开始物色对象"); } }
2.顶层接口类
package com.wf.proxy.dynamicproxy.jdkproxy; /** * @ClassName IPerson * @Description 程序员顶层抽象接口 * @Author wf * @Date 2020/5/15 17:31 * @Version 1.0 */ public interface IPerson { void findLove(); }
然后，就可以定义不同的人实现IPerson接口。测试类【略】
5.3.2.2.基于cglib实现动态代理
1.添加cglib pom依赖
<!-- https://mvnrepository.com/artifact/cglib/cglib-nodep -->
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib-nodep</artifactId>
<version>2.2</version>
<!-- <scope>test</scope>-->
</dependency>
2.定义代理类
package com.wf.proxy.dynamicproxy.cglibproxy; import com.wf.proxy.dynamicproxy.jdkproxy.IPerson; import net.sf.cglib.proxy.Enhancer; import net.sf.cglib.proxy.MethodInterceptor; import net.sf.cglib.proxy.MethodProxy; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; /** * @ClassName CglibMarriageAgency * @Description 婚介所 代理类 * @Author wf * @Date 2020/5/15 18:23 * @Version 1.0 */ public class CglibMarriageAgency implements MethodInterceptor { //jdk动态代理 实现一个抽象的接口【接口可以定义任意功能】 //加强目标对象功能，需要引入目标对象 private IPerson person; public Object getProxy(Class<?> clazz) { //根据目标对象，得到代理对象 Enhancer enhancer = new Enhancer(); enhancer.setSuperclass(clazz); enhancer.setCallback(this); return enhancer.create(); } private void doAfter() { System.out.println("是不是确认关系，开始交往"); } private void doBefore() { System.out.println("开始物色对象"); } @Override public Object intercept(Object obj, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable { doBefore(); Object result = methodProxy.invokeSuper(obj, objects); doAfter(); return result; } }
测试类：
package com.wf.proxy.dynamicproxy.cglibproxy; /** * @ClassName Test * @Description 测试类 * @Author wf * @Date 2020/5/18 14:15 * @Version 1.0 */ public class Test { public static void main(String[] args) { PersonZhang person = (PersonZhang) new CglibMarriageAgency().getProxy(PersonZhang.class); person.findLove(); } }
测试结果如下：
1.5.2.深度分析代理模式【下】
时长：1h22min
5.2.动态代理实现原理分析
5.2.1.Jdk实现原理
5.2.1.1.示例代码
1.测试代码
package com.wf.proxy.dynamicproxy.jdkproxy; /** * @ClassName Test * @Description * @Author wf * @Date 2020/5/18 16:06 * @Version 1.0 */ public class Test { public static void main(String[] args) { MarriageAgency proxy = new MarriageAgency(); IPerson personLi = proxy.getProxy(new PersonLi()); personLi.findLove(); } }
2.断点调试程序
可以发现，personLi是一个特殊的类型声明。$Proxy0@521【以$开头的实例，都是动态代理生成的，只在内存可见】
3.工具类查看代理实现
package com.wf.proxy.dynamicproxy.jdkproxy; import sun.misc.ProxyGenerator; import java.io.FileNotFoundException; import java.io.FileOutputStream; /** * @ClassName Test * @Description * @Author wf * @Date 2020/5/18 16:06 * @Version 1.0 */ public class Test { public static void main(String[] args) { MarriageAgency proxy = new MarriageAgency(); IPerson personLi = proxy.getProxy(new PersonLi()); personLi.findLove(); //使用工具，获取代理类的代理对象内部实现 byte[] bytes = ProxyGenerator.generateProxyClass("$Proxy0", new Class[]{IPerson.class}); try { FileOutputStream fos = new FileOutputStream("proxy0.class"); fos.write(bytes); fos.close(); } catch (Exception e) { e.printStackTrace(); } } }
在文件目录下生成类：
打开内容如下：
// // Source code recreated from a .class file by IntelliJ IDEA // (powered by Fernflower decompiler) // import com.wf.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 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 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.wf.proxy.dynamicproxy.jdkproxy.IPerson").getMethod("findLove"); m2 = Class.forName("java.lang.Object").getMethod("toString"); m0 = Class.forName("java.lang.Object").getMethod("hashCode"); } catch (NoSuchMethodException var2) { throw new NoSuchMethodError(var2.getMessage()); } catch (ClassNotFoundException var3) { throw new NoClassDefFoundError(var3.getMessage()); } } }
5.2.1.2.模仿jdk自定义动态代理实现
1.定义MyInvocationHandler
package com.wf.proxy.dynamicproxy.defproxy; import java.lang.reflect.Method; /** * @ClassName MyInvocationHandler * @Description 自定义handler * @Author wf * @Date 2020/5/18 16:35 * @Version 1.0 */ public interface MyInvocationHandler { public Object invoke(Object proxy, Method method, Object[] args) throws Throwable; }
2.自定义Proxy工具类
package com.wf.proxy.dynamicproxy.defproxy; import javax.tools.JavaCompiler; import javax.tools.JavaFileObject; import javax.tools.StandardJavaFileManager; import javax.tools.ToolProvider; import java.io.File; import java.io.FileWriter; import java.lang.reflect.Constructor; import java.lang.reflect.Method; /** * @ClassName MyProxy * @Description 自定义Proxy工具类 * @Author wf * @Date 2020/5/18 16:37 * @Version 1.0 */ public class MyProxy { public static final String ln = " "; public static Object newProxyInstance(MyClassLoader loader, Class<?>[] interfaces, MyInvocationHandler h){ //1.动态生成源码.java文件 String srcFile = generateSrc(interfaces); System.out.println(srcFile); //2.输出.java文件到磁盘 String filePath = MyProxy.class.getResource("").getPath(); File file = new File(filePath+"$Proxy0.java"); try { FileWriter fw = new FileWriter(file); fw.write(srcFile); fw.flush(); fw.close(); //3.编译.java文件，成$Proxy0.class文件 JavaCompiler compiler = ToolProvider.getSystemJavaCompiler(); StandardJavaFileManager manager = compiler.getStandardFileManager(null, null, null); Iterable<? extends JavaFileObject> it = manager.getJavaFileObjects(file); JavaCompiler.CompilationTask task = compiler.getTask(null, manager, null, null, null, it); task.call(); manager.close(); //4.把生成的.class文件加载到jvm中 Class<?> proxyClass = loader.findClass("$Proxy0"); Constructor<?> constructor = proxyClass.getConstructor(MyInvocationHandler.class); //5.返回新的代理对象 return constructor.newInstance(h); } catch (Exception e) { e.printStackTrace(); } return null; } private static String generateSrc(Class<?>[] interfaces) { StringBuilder sb = new StringBuilder(); sb.append(MyProxy.class.getPackage()).append(";").append(ln); sb.append("import ").append(interfaces[0].getName()).append(";").append(ln); sb.append("import java.lang.reflect.*;").append(ln); sb.append("public final class $Proxy0 implements ").append(interfaces[0].getSimpleName()).append("{").append(ln); sb.append("MyInvocationHandler h;").append(ln); sb.append("public $Proxy0(MyInvocationHandler h){").append(ln). append(" this.h = h;").append(ln). append(" }").append(ln); for(Method m: interfaces[0].getMethods()){ Class<?>[] params = m.getParameterTypes(); StringBuilder paramNames = new StringBuilder(); StringBuilder paramValues = new StringBuilder(); StringBuilder paramClasses = new StringBuilder(); for(int i=0; i < params.length; i++){ Class clazz = params[i]; String type = clazz.getName(); String paramName = toLowerFirstCase(clazz.getSimpleName()); paramNames.append(type).append(" ").append(paramName); paramValues.append(paramName); paramClasses.append(clazz.getName()).append(".class"); if(i < params.length -1){ paramNames.append(","); paramValues.append(","); paramClasses.append(","); } } sb.append("public ").append(m.getReturnType().getName()).append(" ").append(m.getName()).append("(") .append(paramNames).append("){").append(ln); sb.append(" try {" ).append(ln). append(" Method m = ").append(interfaces[0].getName()).append(".class.getMethod("").append(m.getName()). append("",new Class[]{").append(paramClasses).append("} );").append(ln); sb.append(" ").append(hasReturnValue(m.getReturnType()) ? "return ("+m.getReturnType().getTypeName()+")": ""). append("this.h.invoke(this, m, ").append("new Object[]{").append(paramValues).append("});").append(ln). append(" } catch (RuntimeException | Error var2) { " ). append(" throw var2; " ). append(" } catch (Throwable var3) { " ). append(" throw new UndeclaredThrowableException(var3); " ). append(" } " );//.append(getReturnEmptyCode(m.getReturnType())).append(ln); sb.append(" }"); } return sb.append(ln).append("}").toString(); } private static String getReturnEmptyCode(Class<?> returnType) { if(hasReturnValue(returnType)){ return "return null;"; } return "return;"; } private static boolean hasReturnValue(Class<?> returnType) { if(returnType == Void.class || returnType == void.class){ return false; } return true; } private static String toLowerFirstCase(String paramName) { char first = paramName.charAt(0); //首字母大写判断 if(first >= 'A' && first<= 'Z'){ first += 32; paramName = first + paramName.substring(1); } return paramName; } }
会在项目根目录cglib_proxy_classes生成cglib相关实例信息，如下所示：
5.3.cglib与jdk实现动态代理的总结
cglib采用继承的方式，覆盖父类的方法
jdk采用实现接口的方式，要求代理的目标对象，必须实现一个接口。、
两者的思想：
都是生成字节码，再重组成一个新的类。
缺点及优点：
Jdk Proxy，对于用户而言，依赖性更强，调用也更复杂。生成逻辑较为简单，执行效率较低，每次都要用到反射。
cglib 对目标类没有任何要求。效率更高，性能更好，底层没有用到反射。
cglib有个坑，目标代理对象不能有final修饰的方法，忽略final修饰的方法。
5.4.代理的运用案例
5.4.1.示例代码
5.4.1.1.Service服务
1.接口服务定义
package com.wf.proxy.dbroute; import com.wf.proxy.dbroute.dbsource.DynamicDataSourceEntity; import java.text.ChoiceFormat; import java.text.SimpleDateFormat; import java.util.Date; /** * @ClassName OrderServiceImpl * @Description 订单服务实现，OrderServiceImpl类就相当于代理类，orderDao就是目标对象，这是静态代理 * @Author wf * @Date 2020/5/19 14:24 * @Version 1.0 */ public class OrderServiceImpl implements IOrderService { private OrderDao orderDao; //时间年份格式化 private SimpleDateFormat yearFormat = new SimpleDateFormat("yyyy"); public OrderServiceImpl() { //spring中使用自动注入 //普通maven工程中，使用构造器注入 this.orderDao = new OrderDao(); } /** * 在调用orderDao.insert前后会做一些处理，比如，设置订单创建时间 * 这里的前后处理，需要架构师来统一操作，如果每个都写的话，很乱 * 在当前代理的上层，还需要一个父类代理 * @param order * @return */ @Override public int createOrder(Order order) { System.out.println("OrderService服务调用orderDao创建订单"); Long time = order.getCreateTime(); //根据订单创建年份，进行路由，选择数据源 Integer dbRouter = Integer.valueOf(yearFormat.format(new Date(time))); System.out.println("自动切换数据源到【DB_"+dbRouter+"】"); DynamicDataSourceEntity.set(dbRouter); int rows = this.orderDao.insert(order); //用完后，释放数据源 DynamicDataSourceEntity.restore(); return rows; } }
2.创建订单业务bean
package com.wf.proxy.dbroute; /** * @ClassName Order * @Description 订单业务bean * @Author wf * @Date 2020/5/19 14:23 * @Version 1.0 */ public class Order { private Long createTime; public void setCreateTime(Long createTime) { this.createTime = createTime; } public Long getCreateTime() { return createTime; } }
3.创建dao层服务
这里为示例简洁性，直接定义class服务，而没有面向接口编程。
package com.wf.proxy.dbroute; /** * @ClassName OrderDao * @Description 订单dao实现 * @Author wf * @Date 2020/5/19 15:01 * @Version 1.0 */ public class OrderDao { public int insert(Order order) { System.out.println("创建开始"); return 0; } }
4.数据源处理工具类
这里需要切换数据源，定义数据源处理工具类，内部使用ThreadLocal存储。
package com.wf.proxy.dbroute.dbsource; /** * @ClassName DynamicDataSourceEntity * @Description 动态切换数据源工具类 * @Author wf * @Date 2020/5/19 14:38 * @Version 1.0 */ public class DynamicDataSourceEntity { private static final ThreadLocal<String> local = new ThreadLocal<>(); private static String DEFAULT_SOURCE = null; //单例控制 private DynamicDataSourceEntity(){} public static String get(){ return local.get(); } public static void restore(){ local.set(DEFAULT_SOURCE); } public static void set(String source){ local.set(source); } //DB_2018 //DB_2019 public static void set(int year){ local.set("DB_"+year); } }
5.测试类
package com.wf.proxy.dbroute; import java.text.SimpleDateFormat; import java.util.Date; /** * @ClassName DBRouterProxyTest * @Description 数据源路由测试 * @Author wf * @Date 2020/5/19 14:55 * @Version 1.0 */ public class DBRouterProxyTest { public static void main(String[] args) { try{ Order order = new Order(); // order.setCreateTime(System.currentTimeMillis()); SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd"); Date date = sdf.parse("2021/03/01"); order.setCreateTime(date.getTime()); IOrderService orderService = new OrderServiceImpl(); orderService.createOrder(order); }catch (Exception e){ e.printStackTrace(); } } }
测试结果如下：
说明：
这里主要输出OrderServiceImpl服务实现的逻辑，由于希望把insert逻辑调用与数据源处理的逻辑分离，对该类创建代理类。
5.4.1.2.定义代理类处理数据源切换
1.增加上层代理类
package com.wf.proxy.dbroute.proxy; import com.wf.proxy.dbroute.IOrderService; import com.wf.proxy.dbroute.Order; import com.wf.proxy.dbroute.dbsource.DynamicDataSourceEntity; import java.text.SimpleDateFormat; import java.util.Date; /** * @ClassName OrderServiceStaticProxy * @Description 定义代理类，处理数据源切换 * @Author wf * @Date 2020/5/19 14:49 * @Version 1.0 */ public class OrderServiceStaticProxy implements IOrderService { //时间年份格式化 private SimpleDateFormat yearFormat = new SimpleDateFormat("yyyy"); private IOrderService orderService; public OrderServiceStaticProxy(IOrderService orderService) { this.orderService = orderService; } @Override public int createOrder(Order order) { 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(); return 0; } }
2.修改OrderServiceImpl服务
package com.wf.proxy.dbroute; import com.wf.proxy.dbroute.dbsource.DynamicDataSourceEntity; import java.text.ChoiceFormat; import java.text.SimpleDateFormat; import java.util.Date; /** * @ClassName OrderServiceImpl * @Description 订单服务实现，OrderServiceImpl类就相当于代理类，orderDao就是目标对象，这是静态代理 * @Author wf * @Date 2020/5/19 14:24 * @Version 1.0 */ public class OrderServiceImpl implements IOrderService { private OrderDao orderDao; //时间年份格式化 //private SimpleDateFormat yearFormat = new SimpleDateFormat("yyyy"); public OrderServiceImpl() { //spring中使用自动注入 //普通maven工程中，使用构造器注入 this.orderDao = new OrderDao(); } /** * 在调用orderDao.insert前后会做一些处理，比如，设置订单创建时间 * 这里的前后处理，需要架构师来统一操作，如果每个都写的话，很乱 * 在当前代理的上层，还需要一个父类代理 * @param order * @return */ @Override public int createOrder(Order order) { System.out.println("OrderService服务调用orderDao创建订单"); /*Long time = order.getCreateTime(); //根据订单创建年份，进行路由，选择数据源 Integer dbRouter = Integer.valueOf(yearFormat.format(new Date(time))); System.out.println("自动切换数据源到【DB_"+dbRouter+"】"); DynamicDataSourceEntity.set(dbRouter);*/ int rows = this.orderDao.insert(order); //用完后，释放数据源 // DynamicDataSourceEntity.restore(); return rows; } }
3.修改测试类
package com.wf.proxy.dbroute; import com.sun.org.apache.xpath.internal.operations.Or; import com.wf.proxy.dbroute.proxy.OrderServiceStaticProxy; import java.text.SimpleDateFormat; import java.util.Date; /** * @ClassName DBRouterProxyTest * @Description 数据源路由测试 * @Author wf * @Date 2020/5/19 14:55 * @Version 1.0 */ public class DBRouterProxyTest { /*public static void main(String[] args) { try{ Order order = new Order(); // order.setCreateTime(System.currentTimeMillis()); SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd"); Date date = sdf.parse("2021/03/01"); order.setCreateTime(date.getTime()); IOrderService orderService = new OrderServiceImpl(); orderService.createOrder(order); }catch (Exception e){ e.printStackTrace(); } }*/ public static void main(String[] args) { try{ Order order = new Order(); // order.setCreateTime(System.currentTimeMillis()); SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd"); Date date = sdf.parse("2021/03/01"); order.setCreateTime(date.getTime()); //调用代理类，创建代理对象 IOrderService orderService = new OrderServiceStaticProxy(new OrderServiceImpl()); orderService.createOrder(order); }catch (Exception e){ e.printStackTrace(); } } }
测试结果如下图：
说明：
现在的静态代理，只能代理OrderService不能代理其他Service服务，为了系统扩展性，和复用性。需要使用动态代理。
5.4.1.3.动态代理处理数据源切换
1.创建动态代理类
package com.wf.proxy.dbroute.proxy; import com.wf.proxy.dbroute.dbsource.DynamicDataSourceEntity; import com.wf.proxy.dynamicproxy.defproxy.MyClassLoader; import com.wf.proxy.dynamicproxy.defproxy.MyInvocationHandler; import com.wf.proxy.dynamicproxy.defproxy.MyProxy; import java.lang.reflect.Method; import java.text.SimpleDateFormat; import java.util.Date; /** * @ClassName ServiceDynamicProxy * @Description 动态代理，创建代理类 * @Author wf * @Date 2020/5/19 16:15 * @Version 1.0 */ public class ServiceDynamicProxy implements MyInvocationHandler { //时间年份格式化 private SimpleDateFormat yearFormat = new SimpleDateFormat("yyyy"); private Object targetObj; public Object getInstance(Object targetObj){ this.targetObj = targetObj; Class<?> clazz = targetObj.getClass(); return MyProxy.newProxyInstance(new MyClassLoader(), clazz.getInterfaces(),this); } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { doBefore(args[0]); Object result = method.invoke(targetObj, args); doAfter(); return result; } private void doAfter() { System.out.println("Proxy after method"); //用完后，释放数据源 DynamicDataSourceEntity.restore(); } private void doBefore(Object arg) { System.out.println("Proxy before method"); //约定优于配置 try { Long time = (Long) arg.getClass().getMethod("getCreateTime").invoke(arg); //根据订单创建年份，进行路由，选择数据源 Integer dbRouter = Integer.valueOf(yearFormat.format(new Date(time))); System.out.println("静态代理类自动分配到【DB_"+dbRouter+"】数据源处理数据"); DynamicDataSourceEntity.set(dbRouter); } catch (Exception e) { e.printStackTrace(); } } }
2.修改测试类
5.5.代理模式相关问题思考
5.5.1.总结静态代理与动态代理的根本区别
静态代理：硬编码【只适用于某特定类型的bean的代理】，手动注入。
依赖目标对象的引用，手动调用目标对象的方法。
动态代理：
具有更强的扩展性，自动注入，自动生成一个新的类【和目标类同一继承体系】
特征：
拿到目标对象的引用
拿到目标对象的方法，进行增强
5.5.2.使用java代码实现Proxy类的带参方法实现