【Spring】大白话聊聊代理模式 —— 动态代理
- 为什么要使用代理模式呢？
打个比方，我虽然不会打篮球，但我很喜欢A锥，可是国内我又买不起，
发现海淘的A锥，既经济又实惠（咱也不知道是不是真货，咱也不敢问），
不过我发现我去访问海外电商极度费劲，此时我该怎么办？
我突然想到了代购老黄，我们可以通过老黄啊，来帮我们获取到我们心仪的A锥。
从静态代理的角度我们分析一下老黄代理如何运作：
所以对于老黄，也就代理来说，其实就是一个搬运工。
也比如我们的博客系统，我们查看一个文章，如果文章中有个特别大的图片需要加载，
此时如果等在加载完图片再进行展示图片以后的文章内容，是非常耗时的操作，
那么此时我们就可以使用Proxy来先代替那个图片。
- 我们先看看静态代理是如何实现上述鞋工厂的：
1》先创建一个鞋工厂接口：
public interface ShoeFactory { void saleShoe(int size); }
2》创建一个AJ鞋厂来实现这个接口：
public class AJFactory implements ShoeFactory { @Override public void saleShoe(int size) { System.out.println("根据您的需求，为您定制了一个size为：" + size + "的AJ"); } }
3》看看老黄是如何代理的：
/** * 代理类 */ public class LaohuangProxy implements ShoeFactory { private ShoeFactory factory; public LaohuangProxy(ShoeFactory factory) { super(); this.factory = factory; } @Override public void saleShoe(int size) { doSomethingBefore();//前置增强 factory.saleShoe(size); doSomethingAfter();//后置增强 } private void doSomethingAfter() { System.out.println("提供快递服务一条龙"); } private void doSomethingBefore() { System.out.println("根据您的需求进行市场调研"); } public static void main(String[] args) { AJFactory factory = new AJFactory();//1.有一个AJ鞋工厂 LaohuangProxy laohuangProxy = new LaohuangProxy(factory);//2.老黄代理 laohuangProxy.saleShoe(43);//3.帮我订购一双43码鞋 } }
但此时，快过情人节了，这空手确实不太行啊，我准备给我的女神小娜个迪奥999口红（就是这么大气），
但是专柜已经被抢空了，所以我又想到了无所不能的老黄，找他帮我代购一波：
如果继续使用静态代理，我们需要再创建一个口红制造厂接口和迪奥口红工厂类，话不多说，撸码就完了：
1》声明一个口红工厂接口
public interface LipstickFactory { void saleLipstick(String color); }
2》创建一个迪奥工厂类：
public class DiorFactory implements LipstickFactory { @Override public void saleLipstick(String color) { System.out.println("根据您的需求，为您包装了一个颜色为：" + color + "的迪奥口红"); } }
3》看看老黄代理的改动：
public class LaohuangProxy implements ShoeFactory, LipstickFactory { //改动1：需要多继承一个接口 private ShoeFactory factory; private LipstickFactory lipstickFactory;//改动2：由于代理类只是一个搬运工，所以需要多包含一个口红工厂 public LaohuangProxy(ShoeFactory factory) { super(); this.factory = factory; } //改动3：需要实现一个新的构造函数 public LaohuangProxy(LipstickFactory lipstickFactory) { super(); this.lipstickFactory = lipstickFactory; } @Override public void saleShoe(int size) { doSomethingBefore();//前置增强 factory.saleShoe(size); doSomethingAfter();//后置增强 } //改动4：需要新增一个口红售卖类 @Override public void saleLipstick(String color) { doSomethingBefore();//前置增强 lipstickFactory.saleLipstick(color); doSomethingAfter();//后置增强 } private void doSomethingAfter() { System.out.println("提供快递服务一条龙"); } private void doSomethingBefore() { System.out.println("根据您的需求进行市场调研"); } main{....} }
可以看出一共有四处改动，所以静态代理的弊端就是，我么如果每增加一个代理对象，代理类就需要在原有基础上有很大的改动。
- 所以此时我们必须要引入动态代理，那动态代理是如何实现的呢？
动态代理的话，老黄就不是一个人代购了，老黄开了一家代购公司，
话不多BB，撸代码：
（口红工厂和鞋工厂对象同上）
动态代理的总代理对象如下：
public class LaohuangCompanyProxy implements InvocationHandler { private Object factory; public Object getFactory() { return factory; } public void setFactory(Object factory) { this.factory = factory; } public Object getProxyInstance() { //传入this说明调度的所有员工必须遵循当前类的业务增强 return Proxy.newProxyInstance(factory.getClass().getClassLoader(), factory.getClass().getInterfaces(), this); } /** * 通过动态代理对象方法进行增强(动态代理对象调用方法时调用本方法) * * @param proxy * @param method 方法名 * @param args 方法参数 * @return */ @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { doSomethingBefore(); Object res = method.invoke(factory, args); doSomethingAfter(); return res; } private void doSomethingAfter() { System.out.println("提供快递服务一条龙"); } private void doSomethingBefore() { System.out.println("根据您的需求进行市场调研"); } public static void main(String[] args) { ShoeFactory shoeFactory = new AJFactory(); LipstickFactory lipstickFactory = new DiorFactory(); LaohuangCompanyProxy laohuangCompanyProxy = new LaohuangCompanyProxy();//声明总代理对象 laohuangCompanyProxy.setFactory(shoeFactory); ShoeFactory shoeFactory1 = (ShoeFactory) laohuangCompanyProxy.getProxyInstance();//通过总代理对象分配出一个代理运行对象 shoeFactory1.saleShoe(43); laohuangCompanyProxy.setFactory(lipstickFactory); LipstickFactory lipstickFactory1 = (LipstickFactory) laohuangCompanyProxy.getProxyInstance(); lipstickFactory1.saleLipstick("斩男色"); } }
关键代码:
1》【Proxy.newProxyInstance(factory.getClass().getClassLoader(), factory.getClass().getInterfaces(), this);】
生成一个代理对象，通过总代理对象，创建一个动态代理对象：
Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
ClassLoader loader: 定义了由哪个类加载器来对生成的代理对象进行加载
Class<?>[] interfaces: 表示给代理对象提供一组什么接口，相当于用代理对象去实现这些接口中的方法，这样就可以直接调用了
InvocationHandler h：表示我这个动态代理对象在调用方法时，会关联到哪一个InvocationHandler上
2》【Object invoke(Object proxy, Method method, Object[] args)】
Object invoke(Object proxy, Method method, Object[] args)
Object proxy： 所代理的真实对象
Method method：所要调用的某个方法
Object[] args： 调用方法中的参数
我们Debug看一下【shoeFactory1】的真正类型，是一个JDK帮我们生成的动态代理类型。
- 我们分析下AOP的是如何使用JDK动态代理的呢？
在Spring-Aop源文件中类【JdkDynamicAopProxy】实现了【InvocationHandler】：
所以同样也实现了invoke方法，那么【@Transactional】注解实现是如何的呢？
调用了【invoke】方法后，通过责任链的方式，交给对应的拦截器【TransactionInterceptor】去进行aop拦截
@Override @Nullable public Object invoke(MethodInvocation invocation) throws Throwable { // Work out the target class: may be {@code null}. // The TransactionAttributeSource should be passed the target class // as well as the method, which may be from an interface. Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null); // Adapt to TransactionAspectSupport's invokeWithinTransaction... return invokeWithinTransaction(invocation.getMethod(), targetClass, invocation::proceed); }
然后进入到【invokeWithinTransaction】，我们可以看下源码：
@Nullable protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass, final InvocationCallback invocation) throws Throwable { // If the transaction attribute is null, the method is non-transactional. TransactionAttributeSource tas = getTransactionAttributeSource(); final TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClass) : null); final PlatformTransactionManager tm = determineTransactionManager(txAttr); final String joinpointIdentification = methodIdentification(method, targetClass, txAttr); if (txAttr == null || !(tm instanceof CallbackPreferringPlatformTransactionManager)) { //开启事务，关闭自动提交 TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification); Object retVal = null; try { // This is an around advice: Invoke the next interceptor in the chain. // This will normally result in a target object being invoked. retVal = invocation.proceedWithInvocation();//执行方法本身 } catch (Throwable ex) { // target invocation exception completeTransactionAfterThrowing(txInfo, ex);//异常提交回滚 throw ex; } finally { cleanupTransactionInfo(txInfo); } commitTransactionAfterReturning(txInfo);//未出现异常则直接进行提交 return retVal; } else { final ThrowableHolder throwableHolder = new ThrowableHolder(); // It's a CallbackPreferringPlatformTransactionManager: pass a TransactionCallback in. try { Object result = ((CallbackPreferringPlatformTransactionManager) tm).execute(txAttr, status -> { TransactionInfo txInfo = prepareTransactionInfo(tm, txAttr, joinpointIdentification, status); try { return invocation.proceedWithInvocation(); } catch (Throwable ex) { if (txAttr.rollbackOn(ex)) { // A RuntimeException: will lead to a rollback. if (ex instanceof RuntimeException) { throw (RuntimeException) ex; } else { throw new ThrowableHolderException(ex); } } else { // A normal return value: will lead to a commit. throwableHolder.throwable = ex; return null; } } finally { cleanupTransactionInfo(txInfo); } }); // Check result state: It might indicate a Throwable to rethrow. if (throwableHolder.throwable != null) { throw throwableHolder.throwable; } return result; } catch (ThrowableHolderException ex) { throw ex.getCause(); } catch (TransactionSystemException ex2) { if (throwableHolder.throwable != null) { logger.error("Application exception overridden by commit exception", throwableHolder.throwable); ex2.initApplicationException(throwableHolder.throwable); } throw ex2; } catch (Throwable ex2) { if (throwableHolder.throwable != null) { logger.error("Application exception overridden by commit exception", throwableHolder.throwable); } throw ex2; } } }
总结，所有的AOP都是基于动态代理增强，并且如果面试官问@Transactional的实现原理是什么，不要只说动态代理，要别责任链、连接器以及实现流程大致说详细。
学而不思则罔 思而不学则殆 ！
