手写Spring AOP，快来瞧一瞧看一看撒！
上面两篇内容说到了手写IOC和DI，本篇内容就是手写AOP，由于内容中使用到了上面两篇内容写的代码，所以此处贴下链接：
手写Spring IOC容器：点击进入
手写Spring DI依赖注入：点击进入
AOP分析
AOP是什么
Aspect Oriented Programming 面向切面编程，在不改变类的代码的情况下，对类的方法进行功能增强
那么如果要实现一个AOP，需要做的事情就是要向使用的用户提供AOP功能，能够通过AOP技术实现对类的方法进行功能增强
AOP中的元素
- Advice 通知，即增强的功能
- Join points 连接点，可以选择的方法点，即有哪些可以增强的方法供选择
- Pointcut 切入点，选择切入的方法点，即对哪些方法进行增强
- Aspact 切面，选择的多个方法点 + 增强的功能，即Advice和Pointcut的组合
- Introduction 引入，添加新的方法、属性到已经存在的类中，叫做引入
- Weaving 织入，即不改变原来的代码，加入增强的功能
手写AOP的话，上面几个元素有的是需要用户提供的：Advice、Pointcut、Aspact，用户需要提供增强的功能和切入点、切面信息；AOP框架需要提供Join points、Weaving
AOP提供的功能
- 需要功能的增强，即Advice通知
- 对类的方法进行增强，那需要可以选择的要增强的方法点，即Pointcut切入点
- 需要在不改变原类代码的情况下，进行功能的增强，即Weaving织入
图解AOP
假设我们现在玩一局王者荣耀，选择了一个英雄鲁班，这个鲁班需要参与整个游戏直到结束，不管是否挂机；刚刚开始的时候，没有任何装备，假设鲁班身上的各个部位是Join points，即这些部位需要装备去增强它，那每一个装备就是Advice增强的功能，比如增加攻速、生命等，现在买了一个鞋子，那么就是选择在速度上进行增强，即穿在脚上，那么就是Pointcut，那么这个鞋子加上脚就是Aspact切面，上面说的例子可能不够好，见谅啊！
特点分析
- Advice
实现一个Advice，就需要知道Advice有哪些特点，从上面可以知道Advice是用户来提供的，所以有很多不可控的因素
- 用户性：由用户来提供增强的功能，即增强功能的代码是用户来进行编写的
- 多变性：既然用户来提供，那么对于不同的需求，增强的逻辑都是不一样的
- 可选时机：用户可以选择在方法的前面、后面、异常时进行功能增强
- 多重性：同一个切入点，即同一个方法，可以有多重的增强，不止增强一次
- Pointcut
切入点，通过上面知道它也是用户提供的，所以它的特点和Advice基本上差不多
- 用户性：由用户来指定，对哪些方法进行功能增强
- 多变性：用户可以灵活的来指定
- 多点性：用户可以选择在多个方法点上进行功能增强
- Weaving
织入，这部分代码，是需要框架提供的，即是需要我们自己去实现的逻辑，通过这个可以把增强的功能加入到用户指定的方法上面
- 无侵入性：不改变原来类的代码，去实现功能的增强
- 需要我们在AOP框架中自己实现逻辑
通过上面的内容，可以知道，需要做的事情就是Advice、Pointcut、Weaving三个部分，Join points为什么不需要去实现呢，这部分内容在编写代码的过程中就可以知道了
Advice实现
Advice是由用户来实现的，这部分逻辑需要用户写好然后我们实现AOP的时候来进行使用；我们需要认识用户的东西，用户需要使用我们写的框架，而且还需要隔绝用户的多变性
那么需要做的事情是啥呢，可以定义一个标准的接口，用户通过实现接口来提供不同的增强逻辑，这就是应对变化的方式，面向接口编程
定义Advice接口
定义的Advice是一个顶级接口，不需要写任何的方法，然后根据前置、后置、环绕、异常增强，来去实现Advice接口，那么这些增强需要的参数是一样的吗，请往下看
Advice接口：
/**
* @className: Advice
* @description: 通知的标准接口
* @author TR
*/
public interface Advice {
}
首先，我们知道，增强是对方法进行增强，那么使用Advice的时候，需要给的就是方法的一些信息
- 前置增强
在方法执行前进行增强，那么可以知道前置增强是不需要返回值的，需要的参数如下：
- 方法自身 Method
- 方法的参数 Object[]
- 方法所在的类（对象） Object
- 后置增强
在方法执行后进行增强，那需要的参数是不是需要增加一个啊，即需要方法的返回值，因为我如果需要对返回值做一下处理，就需要用到它，而且后置增强也是不需要返回值的，需要的参数如下：
- 方法自身 Method
- 方法的参数 Object[]
- 方法所在的类（对象） Object
- 方法的返回值 Object
- 环绕增强
包裹方法进行增强，它是需要包裹整个方法，即方法由它来执行，那么环绕增强是需要返回值的，这个返回值是需要增强方法的返回值，需要的参数如下：
- 方法自身 Method
- 方法的参数 Object[]
- 方法所在的类（对象） Object
- 异常增强
捕获方法执行时的异常信息，然后进行增强，而且它也是需要包裹方法进行增强的，即它可以在环绕增强中来实现
通过上面知道，需要定义三个方法：前置增强的方法、后置增强的方法、环绕和异常增强的方法，那这三个方法是定义在一个接口里面，还是分三个接口呢，根据单一职责原则，还是分三个接口来实现比较好，而且还可以根据不同的接口类型来区分是哪个Advice
定义前置、后置、环绕和异常增强接口
定义前置增强接口MethodBeforeAdvice：
/**
* @className: MethodBeforeAdvice
* @description: 前置增强接口
* @author TR
*/
public interface MethodBeforeAdvice extends Advice {
/**
* 前置增强方法
* @param method: 将要被执行的方法
* @param target: 执行方法的目标对象
* @param args: 执行方法的参数
* @return: void
**/
void before(Method method, Object target, Object[] args);
}
定义后置增强接口AfterReturningAdvice：
/**
* @className: AfterReturningAdvice
* @description: 后置增强接口
* @author TR
*/
public interface AfterReturningAdvice extends Advice {
/**
* 后置增强方法
* @param method: 将要被执行的方法
* @param target: 执行方法的目标对象
* @param args: 执行方法的参数
* @param returnValue: 执行方法的返回值
* @return: void
**/
void after(Method method, Object target, Object[] args, Object returnValue);
}
定义环绕、异常增强接口MethodInterceptor：
/**
* @className: MethodInterceptor
* @description: 环绕、异常增强接口
* @author TR
*/
public interface MethodInterceptor extends Advice {
/**
* 环绕、异常增强方法，在方法实现中需要调用目标方法
* @param method: 将要被执行的方法
* @param target: 执行方法的目标对象
* @param args: 执行方法的参数
* @return: java.lang.Object 执行方法的返回值
* @throws Throwable
**/
Object invoke(Method method, Object target, Object[] args) throws Throwable;
}
类图如下：
Pointcut实现
Pointcut的特点：
- 用户性：由用户来指定，对哪些方法进行功能增强
- 多变性：用户可以灵活的来指定
- 多点性：用户可以选择在多个方法点上进行功能增强
我们需要给用户提供一个东西，让用户可以灵活的来指定方法点，而且我们获取到的时候又能够知道，用户对哪些方法点进行了指定
指定对哪些方法进行增强，指定的信息是什么，其实就是一个或者多个方法，而且如果有重载存在呢，所以这个指定的东西，就是一个完整的方法签名
那该怎么做到灵活性、多点性呢，这个指定的信息是可以描述一类方法的，比如：
- 某个包下某个类的某个方法
- 某个包下某个类的所有方法
- 某个包下所有类中以get开头的方法
- 某个包下所有类中以get开头以sevice结尾的方法
- 某个包下及其子包下所有类中以get开头以sevice结尾的方法
那么可以定义一个表达式，来去描述上面的信息，这个描述的信息是包名.类名.方法名(参数类型)
每一部分是如何要求的呢？
- 包名：需要有父子特点，可以模糊匹配
- 类名：可以模糊匹配
- 方法名：可以模糊匹配
- 参数类型：可以有多个
定义的表达式是需要来判断：是否需要对某个类的某个方法进行增强，那么需要去匹配类和匹配方法
匹配的表达式：
- 正则表达式
- AspactJ表达式
AspactJ表达式学习
/**
* @className: AspectJTest
* @description: AspectJ测试类
*/
public class AspectJTest {
public static void main(String[] args) throws NoSuchMethodException {
//获得切点解析器
PointcutParser pp = PointcutParser
.getPointcutParserSupportingAllPrimitivesAndUsingContextClassloaderForResolution();
//切点解析器根据规则，解析出一个类型匹配器
TypePatternMatcher tp = pp.parseTypePattern("di.*");
//根据表达式生成一个切点表达式
PointcutExpression pe = pp.parsePointcutExpression("execution(* demo.beans.BeanFactory.get*(..))");
//匹配MagicGril的getName方法
Class<?> cl = MagicGril.class;
Method method = cl.getMethod("getName", null);
//匹配方法执行
ShadowMatch sm = pe.matchesMethodExecution(method);
System.out.println("是否匹配到方法：" + sm.alwaysMatches());
System.out.println(cl.getName() + "，是否匹配表达式：" + pe.couldMatchJoinPointsInType(cl));
System.out.println(DefaultBeanFactory.class + "，是否匹配表达式：" + pe.couldMatchJoinPointsInType(DefaultBeanFactory.class));
System.out.println(cl.getName() +"类下的所有方法：");
for (Method method1 : cl.getMethods()) {
System.out.println(method1.getName());
}
}
}
输出结果：
通过上面的描述，可以知道，切点该怎么去设计了
切点需要有的属性就是切点表达式，需要提供的功能就是匹配类和匹配方法
而且这里也可以像Advice一样定义一个顶级接口，因为如果以后有其他的表达式更加好用的话，需要扩展，那么只需要继承定义的这个顶级接口就行了，不管它内部如何实现，都要去实现我们定义的匹配类和匹配方法的行为
定义PointCut接口
/**
* @className: PointCut
* @description: 切点匹配接口
* @author: TR
*/
public interface PointCut {
/**
* 匹配类
* @author: jinpeng.sun
* @date: 2021/4/19 13:46
* @param targetClass: 匹配的目标类
* @return: boolean
**/
boolean matchClass(Class<?> targetClass);
/**
* 匹配方法
* @author: jinpeng.sun
* @date: 2021/4/19 13:46
* @param method: 匹配的目标方法
* @param targetClass: 匹配的目标类
* @return: boolean
**/
boolean matchMethod(Method method, Class<?> targetClass);
}
定义正则表达式的实现类：RegExpressionPointcut
此处不实现，主要使用AspactJ的方式
/**
* @className: RegExpressionPointcut
* @description: 正则表达式实现类
* @author: TR
*/
public class RegExpressionPointcut implements PointCut {
@Override
public boolean matchClass(Class<?> targetClass) {
return false;
}
@Override
public boolean matchMethod(Method method, Class<?> targetClass) {
return false;
}
}
定义AspectJ切点表达式的实现类：AspectJExpressionPointcut
/**
* @className: AspectJExpressionPointcut
* @description: AspectJ切点表达式实现类
* @author: TR
*/
public class AspectJExpressionPointcut implements PointCut {
/** 获得切点解析器 */
PointcutParser pp = PointcutParser
.getPointcutParserSupportingAllPrimitivesAndUsingContextClassloaderForResolution();
/** 切点表达式的字符串形式 */
private String expression;
/** AspectJ中的切点表达式 */
private PointcutExpression pe;
public AspectJExpressionPointcut(String expression) {
super();
this.expression = expression;
pe = pp.parsePointcutExpression(expression);
}
@Override
public boolean matchClass(Class<?> targetClass) {
return pe.couldMatchJoinPointsInType(targetClass);
}
@Override
public boolean matchMethod(Method method, Class<?> targetClass) {
ShadowMatch sm = pe.matchesMethodExecution(method);
return sm.alwaysMatches();
}
public String getExpression() {
return expression;
}
}
实现步骤：
- maven引入Aspectj的jar
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.6</version>
</dependency>
- 获得切点解析器
PointcutParser pp = PointcutParser
.getPointcutParserSupportingAllPrimitivesAndUsingContextClassloaderForResolution();
- 解析切点表达式，获得PointcutExpression
PointcutExpression pe = pp.parsePointcutExpression(
"execution(* edu.dongnao.courseware.beans.BeanFactory.get*(..))");
- 使用PointcutExpression匹配类，不可靠
pe.couldMatchJoinPointsInType(targetClass)
- 使用PointcutExpression匹配方法，可靠
ShadowMatch sm = pe.matchesMethodExecution(method);
return sm.alwaysMatches();
类图如下：
Aspact实现
上面实现了Advice和Pointcut，那么用户该如何使用呢？
Advice是用户提供的功能增强实现，是需要继承接口的，那么可以把Advice配置成一个bean，Pointcut是切点表达式，是用来匹配类和方法的，是不需要配置成bean的，只需要提供一个字符串形式的表达式就行了，那么adviceBeanName+expression就组成了切面
下面通过外观模式来实现切面，把Advice和Pointcut组合起来
定义Advisor接口
/**
* @className: Advisor
* @description: 构建切面的接口，组合advice和pointcut
* @author: TR
*/
public interface Advisor {
/**
* 获取通知bean的名称
* @return: java.lang.String
**/
String getAdviceBeanName();
/**
* 获取切点表达式
* @return: java.lang.String
**/
String getExpression();
}
定义PointcutAdvisor接口
/**
* @className: PointcutAdvisor
* @description: 切点通知者，继承自Advisor，扩展了pointcut
* @author: TR
*/
public interface PointcutAdvisor extends Advisor {
/**
* 获取切点
* @return: PointCut
**/
PointCut getPointCut();
}
定义AspectJPointcutAdvisor实现类
/**
* @className: AspectJPointcutAdvisor
* @description: AspectJ切点表达式的通知者实现类
* @author: TR
*/
public class AspectJPointcutAdvisor implements PointcutAdvisor {
/** 通知bean的名称 */
private String adviceBeanName;
/** 表达式 */
private String expression;
/** 切点 */
private PointCut pointCut;
public AspectJPointcutAdvisor(String adviceBeanName, String expression) {
this.adviceBeanName = adviceBeanName;
this.expression = expression;
this.pointCut = new AspectJExpressionPointcut(expression);
}
@Override
public PointCut getPointCut() {
return pointCut;
}
@Override
public String getAdviceBeanName() {
return adviceBeanName;
}
@Override
public String getExpression() {
return expression;
}
}
下面的类不予实现，主要使用AspactJ的形式
/**
* @className: RegPointcutAdvisor
* @description: 正则切点表达式的通知者实现类
* @author: TR
*/
public class RegPointcutAdvisor implements PointcutAdvisor {
/** 通知bean的名称 */
private String adviceBeanName;
/** 表达式 */
private String expression;
/** 切点 */
private PointCut pointCut;
public RegPointcutAdvisor(String adviceBeanName, String expression) {
this.adviceBeanName = adviceBeanName;
this.expression = expression;
this.pointCut = new RegExpressionPointcut();
}
@Override
public PointCut getPointCut() {
return null;
}
@Override
public String getAdviceBeanName() {
return null;
}
@Override
public String getExpression() {
return null;
}
}
类图如下：
从上面的图中看到了，如果再扩展其他的切点表达式，那么在实现类中，可以看到，有很多的重复代码，那么是不是还可以优化一下呢，可以在实现类的上层再加一个抽象类，来继承PointcutAdvisor，然后主要的切点实现继承这个抽象类就行了
Weaving实现
要完成的事情
将用户提供的增强功能加入到指定的方法上，需要我们来实现
什么时候做织入
在创建Bean实例的时候，在Bean初始化完成后，再进行织入
怎么知道Bean要进行增强
需要遍历Bean类及其所有的方法，然后依次的去匹配用户指定的切面，如果存在匹配的切面，就是需要增强了
怎么织入呢，就是需要用到代理了！
用户需要去注册切面，我们还需要实现判断匹配、织入的的逻辑，这部分代码改如何写，需要写到哪里呢
现在要做的事情，就是在Bean创建的过程中加一项处理，后面可能会在Bean的创建过程中加入更多的处理，如果这部分代码都写在BeanFactory中，那么这个类是不是就会有特别多的代码，而且后面不方便扩展
看下Bean的创建过程：
上面图中，每个箭头都是加的扩展点，后面可能存在的是，需要在这些点上加入更多的处理逻辑，那么就需要设计一种方式，在不改变BeanFactory的情况下，能灵活的扩展，那么可以使用观察者模式，有几个扩展点，就是有几个主题，六个观察者
定义观察者接口BeanPostProcessor
/**
* @className: BeanPostProcessor
* @description: 后置处理器，Bean实例化完成后及依赖注入完成后触发
* @author: TR
*/
public interface BeanPostProcessor {
/**
* bean初始化前的处理
* @author: TR
* @param bean: bean实例
* @param beanName: bean名称
* @return: java.lang.Object
**/
default Object postProcessBeforeInitialization(Object bean, String beanName) throws Exception {
return bean;
}
/**
* bean初始化后的处理
* @author: TR
* @param bean: bean实例
* @param beanName: bean名称
* @return: java.lang.Object
**/
default Object postProcessAfterInitialization(Object bean, String beanName) throws Exception {
return bean;
}
}
定义通知接口Aware
/**
* @className: Aware
* @description: 构建通知接口
* @date: 2021/4/19 16:38
* @author: jinpeng.sun
*/
public interface Aware {
}
/**
* @className: BeanFactoryAware
* @description: bean工厂构建通知接口
* @author: TR
*/
public interface BeanFactoryAware extends Aware {
/**
* 接口实现者获得bean工厂方法
* @author: TR
* @param bf:
* @return: void
**/
void setBeanFactory(BeanFactory bf);
}
上面的接口主要用来获得Bean工厂信息
定义通知者注册接口AdvisorRegistry
这个接口主要用来把Advisor注册到增强功能的实现类里面
/**
* @className: AdvisorRegistry
* @description: 通知者注册接口
* @author: TR
*/
public interface AdvisorRegistry {
/**
* 注册通知者
* @author: TR
* @param advisor:
* @return: void
**/
public void registerAdvisor(Advisor advisor);
/**
* 获得通知者列表
* @author: TR
* @date: 2021/4/19 16:45
*
* @return: java.util.List<demo.aop.advisor.Advisor>
**/
public List<Advisor> getAdvisors();
}
定义增强处理的观察者实现类AdvisorAutoProxyCreator
/**
* @className: AdvisorAutoProxyCreator
* @description: 功能增强的实现类，用户和框架交互的核心类
* 用户通过Advisor提供切面，向DefaultBeanFactory注入该实现
* 框架内部：DefaultBeanFactory注入ioc容器
* DefaultBeanFactory调用BeanPostProcessor接口相关方法，进行功能增强
* @author: TR
*/
public class AdvisorAutoProxyCreator implements BeanPostProcessor, BeanFactoryAware, AdvisorRegistry {
/** 通知者列表 */
private List<Advisor> advisors;
/** 当前的bean */
private BeanFactory beanFactory;
public AdvisorAutoProxyCreator() {
this.advisors = new ArrayList<>();
}
@Override
public void registerAdvisor(Advisor advisor) {
this.advisors.add(advisor);
}
@Override
public List<Advisor> getAdvisors() {
return this.advisors;
}
@Override
public void setBeanFactory(BeanFactory bf) {
this.beanFactory = bf;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws Exception {
return null;
}
}
注册BeanPostProcessor
BeanFactory接口中增加注册BeanPostProcessor的方法
/** 注册BeanPostProcessor */
void registerBeanPostProcessor(BeanPostProcessor beanPostProcessor);
DefaultBeanFactory实现类中增加如下方法：
private List<BeanPostProcessor> postProcessors = Collections.synchronizedList(new ArrayList<>());
@Override
public void registerBeanPostProcessor(BeanPostProcessor beanPostProcessor) {
postProcessors.add(beanPostProcessor);
if (beanPostProcessor instanceof BeanFactoryAware) {
((BeanFactoryAware) beanPostProcessor).setBeanFactory(this);
}
}
getBean方法中增加bean初始化前后的处理：
@Override
public Object getBean(String beanName) throws Exception {
//获取bean定义
BeanDefinition bd = beanDefinitionMap.get(beanName);
Object bean = doGetBean(beanName);
//属性注入
setPropertyDIValues(bd, bean);
//bean初始化前的处理
bean = this.applyPostProcessBeforeInitialization(bean, beanName);
//bean的生命周期
if (StringUtils.isNotBlank(bd.getInitMethodName())) {
doInitMethod(bean,bd);
}
//bean初始化后的处理
bean = this.applyPostProcessAfterInitialization(bean, beanName);
return bean;
}
/**
* bean初始化后的处理
* @author: TR
* @param bean:
* @param beanName:
* @return: java.lang.Object
**/
private Object applyPostProcessAfterInitialization(Object bean, String beanName) throws Exception {
for (BeanPostProcessor bp : this.postProcessors) {
bean = bp.postProcessBeforeInitialization(bean, beanName);
}
return bean;
}
/**
* bean初始化前的处理
* @author: TR
* @param bean:
* @param beanName:
* @return: java.lang.Object
**/
private Object applyPostProcessBeforeInitialization(Object bean, String beanName) throws Exception {
for (BeanPostProcessor bp : this.postProcessors) {
bean = bp.postProcessAfterInitialization(bean, beanName);
}
return bean;
}
下面需要实现的就是判断bean是否需要增强了，那么需要获取到bean的所有方法，然后根据注册进来的advisors去遍历它，然后得到切点去匹配类和方法
修改AdvisorAutoProxyCreator类中的postProcessAfterInitialization方法：
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws Exception {
//判断是否需要进行切面增强，及获得增强的通知实现
List<Advisor> advisors = getMatchedAdvisors(bean, beanName);
//如果需要增强，返回增强后的对象
if (CollectionUtils.isNotEmpty(advisors)) {
//使用代理模式进行功能增强
}
return bean;
}
下面是获取匹配的方法代码：
/**
* 获取匹配的方法
* @author: TR
* @param bean: bean实例
* @param beanName: bean名称
* @return: void
**/
private List<Advisor> getMatchedAdvisors(Object bean, String beanName) {
if (CollectionUtils.isEmpty(advisors)) {
return null;
}
//得到类
Class<?> beanClass = bean.getClass();
//得到所有的方法
List<Method> allMethods = getAllMethodForClass(beanClass);
//存放匹配的Advisor
List<Advisor> advisors = new ArrayList<>();
for (Advisor ad : this.advisors) {
if (ad instanceof PointcutAdvisor) {
//判断是否匹配
if (isPointcutMatchBean((PointcutAdvisor) ad, beanClass, allMethods)) {
advisors.add(ad);
}
}
}
return advisors;
}
获取所有的方法，使用的是Spring framework提供的工具类，来找到类下面所有的方法：
/**
* 获取所有的方法
* @author: TR
* @param beanClass:
* @return: void
**/
private List<Method> getAllMethodForClass(Class<?> beanClass) {
List<Method> allMethods = new LinkedList<>();
Set<Class<?>> classes = new LinkedHashSet<>(ClassUtils.getAllInterfacesForClassAsSet(beanClass));
classes.add(beanClass);
for (Class<?> cc : classes) {
//根据工具类获取所有的方法
Method[] methods = ReflectionUtils.getAllDeclaredMethods(cc);
for (Method m : methods) {
allMethods.add(m);
}
}
return allMethods;
}
下面是判断是否有匹配切点规则的方法，使用PointCut中定义的方法来实现：
/**
* 判断是否有匹配切点规则的方法
* @author: TR
* @param ad: 切面
* @param beanClass: 指定的类
* @param allMethods: 指定的类下面所有的方法
* @return: void
**/
private boolean isPointcutMatchBean(PointcutAdvisor ad, Class<?> beanClass, List<Method> allMethods) {
PointCut p = ad.getPointCut();
//匹配类
if (!p.matchClass(beanClass)) {
return false;
}
for (Method m : allMethods) {
//匹配方法
if (p.matchMethod(m, beanClass)) {
return true;
}
}
return false;
}
判断是否增强之后，就是需要进行代理增强了，那么这里的实现逻辑又是啥样的呢
通过上图可以看到，需要判断代理的方式，即使用JDK动态代理还是CGLIB动态代码，那么这里也可以抽象出一个接口。然后不同的代理方式分别去实现
定义AopProxy代理接口
/**
* @className: AopProxy
* @description: AOP代理接口，用来创建和获取代理对象
* @author: TR
*/
public interface AopProxy {
Object getProxy();
Object getProxy(ClassLoader classLoader);
}
JDK动态代理实现
我们知道JDK动态代理是对接口进行的，那么在实现中需要哪些数据呢？
- 要实现的接口
- 目标对象
- 匹配的Advisors
- BeanFactory
需要的参数：
- 需要实现的接口
- InvocationHandler
/**
* @className: JdkDynamicAopProxy
* @description: JDK动态代理实现
* @author: TR
*/
public class JdkDynamicAopProxy implements AopProxy, InvocationHandler {
private static final Logger logger = LoggerFactory.getLogger(JdkDynamicAopProxy.class);
//bean名称
private String beanName;
//bean对象，需要被代理的对象
private Object target;
//通知列表，需要被增强的功能
private List<Advisor> advisors;
//当前的bean
private BeanFactory beanFactory;
public JdkDynamicAopProxy(String beanName, Object target, List<Advisor> advisors, BeanFactory beanFactory) {
this.beanName = beanName;
this.target = target;
this.advisors = advisors;
this.beanFactory = beanFactory;
}
@Override
public Object getProxy() {
return this.getProxy(target.getClass().getClassLoader());
}
@Override
public Object getProxy(ClassLoader classLoader) {
if (logger.isDebugEnabled()) {
logger.debug("为" + target + "创建JDK代理。");
}
return Proxy.newProxyInstance(classLoader, target.getClass().getInterfaces(), this);
}
/**
* InvocationHandler接口的实现
* 用来进行代理增强后返回实际的结果
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
return AopProxyUtils.applyAdvices(target, method, args, advisors, proxy, beanFactory);
}
}
CGLIB动态代理实现
CGLIB动态代理可以对接口和类进行，那么它需要下面的数据：
- 要继承的类
- 要实现的接口
- 目标对象
- 匹配的Advisors
- BeanFactory
- 构造参数类
- 构造参数
需要的参数：
- 继承的类
- 需要实现的接口
- Callback
- 构造参数类型
- 构造参数
构造参数类型和构造参数在创建实例的时候会有的
/**
* @className: CglibDynamicAopProxy
* @description: Cglib动态代理
* @author: TR
*/
public class CglibDynamicAopProxy implements AopProxy, MethodInterceptor {
private static final Logger logger = LoggerFactory.getLogger(CglibDynamicAopProxy.class);
private static Enhancer enhancer = new Enhancer();
//bean名称
private String beanName;
//bean对象，需要被代理的对象
private Object target;
//通知列表，需要被增强的功能
private List<Advisor> advisors;
//当前的bean
private BeanFactory beanFactory;
public CglibDynamicAopProxy(String beanName, Object target, List<Advisor> advisors, BeanFactory beanFactory) {
this.beanName = beanName;
this.target = target;
this.advisors = advisors;
this.beanFactory = beanFactory;
}
@Override
public Object getProxy() {
return this.getProxy(target.getClass().getClassLoader());
}
@Override
public Object getProxy(ClassLoader classLoader) {
if (logger.isDebugEnabled()) {
logger.debug("为" + target + "创建cglib代理。");
}
Class<?> superClass = this.target.getClass();
enhancer.setSuperclass(superClass);
enhancer.setInterfaces(this.getClass().getInterfaces());
enhancer.setCallback(this);
Constructor<?> constructor = null;
try {
constructor = superClass.getConstructor(new Class<?>[] {});
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
if (constructor != null) {
return enhancer.create();
} else {
BeanDefinition bd = ((DefaultBeanFactory)beanFactory).getBeanDefinition(beanName);
return enhancer.create(bd.getConstructor().getParameterTypes(), bd.getConstructorArgumentRealValues());
}
}
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
return AopProxyUtils.applyAdvices(target, method, objects, advisors, o, beanFactory);
}
}
AopProxyUtils它是用来干什么的呢，从上面可以看到，这部分的处理，主要是用来实现增强的，都是使用Advice来增强的，所以增强的逻辑是一样的
/**
* @className: AopProxyUtils
* @description: aop代理工具类
* @author: TR
*/
public class AopProxyUtils {
/**
* 对方法应用advice增强，获得最终返回结果
* @author: TR
* @param target: 需要被增强的对象
* @param method: 需要被增强的方法
* @param args: 增强方法的参数
* @param advisors: 匹配到的切面
* @param proxy: bean对象功能增强后的代理对象
* @param beanFactory: bean工厂
* @return: java.lang.Object
**/
public static Object applyAdvices(Object target, Method method, Object[] args, List<Advisor> advisors,
Object proxy, BeanFactory beanFactory) throws Throwable {
//获取对当前方法进行增强的advices
List<Object> advices = AopProxyUtils.getShouldApplyAdvices(target.getClass(), method, advisors, beanFactory);
if (CollectionUtils.isEmpty(advices)) {
return method.invoke(target, args);
} else {
//使用责任链进行增强
AopAdviceChainInvocation ac = new AopAdviceChainInvocation(proxy, target, method, args, advices);
return ac.invoke();
}
}
/**
* 获得与方法匹配的Advice切面列表
* @author: TR
* @param aClass:
* @param method:
* @param advisors:
* @param beanFactory:
* @return: java.util.List<demo.aop.advice.Advice>
**/
private static List<Object> getShouldApplyAdvices(Class<?> aClass, Method method,
List<Advisor> advisors, BeanFactory beanFactory) throws Exception {
if (CollectionUtils.isEmpty(advisors)) {
return null;
}
List<Object> advices = new ArrayList<>();
for (Advisor advisor : advisors) {
if (advisor instanceof PointcutAdvisor) {
if (((PointcutAdvisor)advisor).getPointCut().matchMethod(method, aClass)) {
advices.add(beanFactory.getBean(advisor.getAdviceBeanName()));
}
}
}
return advices;
}
}
如何来传递创建bean实例时获得的数据到初始化后的Aop中，就是要在BeanDefinition中使用ThreadLocal持有参数值
BeanDefinition增加如下方法：
/** 获取构造参数值 */
public Object[] getConstructorArgumentRealValues();
/** 设置构造参数值 */
public void setConstructorArgumentRealValues(Object[] values);
GeneralBeanDefinition类中相应的实现：
private ThreadLocal<Object[]> realConstructorArgumentValues = new ThreadLocal<>();
@Override
public Object[] getConstructorArgumentRealValues() {
return realConstructorArgumentValues.get();
}
@Override
public void setConstructorArgumentRealValues(Object[] values) {
this.realConstructorArgumentValues.set(values);
}
责任链AopAdviceChainInvocation类
/**
* @className: AopAdviceChainInvocation
* @description: AOP责任链调用类
* @author: TR
*/
public class AopAdviceChainInvocation {
/** AOP责任链执行的方法 */
private static Method invokeMethod;
static {
try {
invokeMethod = AopAdviceChainInvocation.class.getMethod("invoke", null);
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
}
//代理类对象
private Object proxy;
//目标类对象
private Object target;
//调用执行的对象方法
private Method method;
//执行方法的参数
private Object[] args;
//方法被增强的功能：通知列表
private List<Object> advices;
public AopAdviceChainInvocation(Object proxy, Object target, Method method, Object[] args, List<Object> advices) {
this.proxy = proxy;
this.target = target;
this.method = method;
this.args = args;
this.advices = advices;
}
//责任链执行记录的索引号
private int i = 0;
public Object invoke() throws Throwable {
if (i < this.advices.size()) {
Object advice = this.advices.get(i++);
if (advice instanceof MethodBeforeAdvice) {
//执行前增强
((MethodBeforeAdvice)advice).before(method, target, args);
} else if (advice instanceof MethodInterceptor) {
//执行环绕增强和异常增强，这里给的method和对象是invoke方法和链对象
((MethodInterceptor)advice).invoke(invokeMethod,this, null);
} else if (advice instanceof AfterReturningAdvice) {
//后置增强，先获得结果，在增强
Object returnValue = this.invoke();
((AfterReturningAdvice)advice).after(method, target, args, returnValue);
return returnValue;
}
//回调
return this.invoke();
} else {
return method.invoke(target, args);
}
}
}
定义AopProxyFactory接口
代理的方式实现完了之后，就需要使用它了，这里使用工厂模式实现：
/**
* @className: AopProxyFactory
* @description: AOP代理的工厂接口
* @author: TR
*/
public interface AopProxyFactory {
/**
* 根据参数获取AOP代理接口的实现
* @param bean: 实例
* @param beanName: bean名称
* @param advisors: advisors列表
* @param beanFactory: bean工厂
* @return: AopProxyFactory
**/
AopProxy createAopProxy(Object bean, String beanName, List<Advisor> advisors, BeanFactory beanFactory);
/**
* 获取默认的AopProxyFactory
* @return: AopProxyFactory
**/
static AopProxyFactory getDefaultAopProxyFactory() {
return new DefaultAopProxyFactory();
}
}
实现类：
/**
* @className: DefaultAopProxyFactory
* @description: 代理工厂实现类
* @author: TR
*/
public class DefaultAopProxyFactory implements AopProxyFactory {
@Override
public AopProxy createAopProxy(Object bean, String beanName, List<Advisor> advisors, BeanFactory beanFactory) {
//是用JDK动态代理还是CGLIB动态代理
if (shouldUseJDKDynamicProxy(bean, beanName)) {
return new JdkDynamicAopProxy(beanName, bean, advisors, beanFactory);
} else {
return new CglibDynamicAopProxy(beanName, bean, advisors, beanFactory);
}
}
private boolean shouldUseJDKDynamicProxy(Object bean, String beanName) {
return false;
}
}
下面需要修改下AdvisorAutoProxyCreator类中的postProcessAfterInitialization方法：
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws Exception {
//判断是否需要进行切面增强，及获得增强的通知实现
List<Advisor> advisors = getMatchedAdvisors(bean, beanName);
//如果需要增强，返回增强后的对象
if (CollectionUtils.isNotEmpty(advisors)) {
//使用代理模式进行功能增强
bean = this.createProxy(bean, beanName, advisors);
}
return bean;
}
private Object createProxy(Object bean, String beanName, List<Advisor> advisors) {
return AopProxyFactory.getDefaultAopProxyFactory()
.createAopProxy(bean, beanName, advisors, beanFactory)
.getProxy();
}
DefaultBeanFactory类中缓存构造函数的方式需要改变一下
determineConstructor方法中缓存的代码注释掉：
if (ct != null) {
// //对于原型bean，缓存起来
// if (bd.isProtoType()) {
// bd.setConstructor(ct);
// }
return ct;
} else {
throw new Exception("找不到对应的构造方法：" + bd);
}
在createBeanByConstructor中增加代码
/** 通过构造函数构建bean */
private Object createBeanByConstructor(BeanDefinition bd) throws Exception {
Object object = null;
if (CollectionUtils.isEmpty(bd.getConstructorArgumentValues())) {
//获得的构造参数值是空的，就不传参
object = bd.getBeanClass().newInstance();
} else {
//获得的参数值是空的，就不传参
Object[] args = getConstructorArgumentValues(bd);
if (args == null) {
object = bd.getBeanClass().newInstance();
} else {
// 根据参数匹配决定构造方法，然后进行实例化调用
bd.setConstructorArgumentRealValues(args);
Constructor<?> ct = this.determineConstructor(bd, args);
// 缓存构造函数由determineConstructor 中移到了这里，无论原型否都缓存，因为后面AOP需要用
bd.setConstructor(ct);
return ct.newInstance(args);
}
}
return object;
}
测试一下
前置增强实现：
public class MyBeforeAdvice implements MethodBeforeAdvice {
@Override
public void before(Method method, Object target, Object[] args) {
System.out.println(this + " 对 " + target + " 进行了前置增强！");
}
}
后置增强实现：
public class MyAfterReturningAdvice implements AfterReturningAdvice {
@Override
public void after(Method method, Object target, Object[] args, Object returnValue) {
System.out.println(this + " 对 " + target + " 做了后置增强，得到的返回值=" + returnValue);
}
}
环绕增强实现：
public class MyMethodInterceptor implements MethodInterceptor {
@Override
public Object invoke(Method method, Object target, Object[] args) throws Throwable {
System.out.println(this + "对 " + target + "进行了环绕--前增强");
Object ret = method.invoke(target, args);
System.out.println(this + "对 " + target + "进行了环绕 --后增强。方法的返回值为：" + ret);
return ret;
}
}
测试类：
public class AopTest {
static PreBuildBeanFactory bf = new PreBuildBeanFactory();
@Test
public void testCirculationDI() throws Throwable {
GeneralBeanDefinition bd = new GeneralBeanDefinition();
bd.setBeanClass(Lad.class);
List<Object> args = new ArrayList<>();
args.add("孙悟空");
args.add(new BeanReference("baigujing"));
bd.setConstructorArgumentValues(args);
bf.registerBeanDefinition("swk", bd);
bd = new GeneralBeanDefinition();
bd.setBeanClass(MagicGirl.class);
args = new ArrayList<>();
args.add("白骨精");
bd.setConstructorArgumentValues(args);
bf.registerBeanDefinition("baigujing", bd);
bd = new GeneralBeanDefinition();
bd.setBeanClass(Renminbi.class);
bf.registerBeanDefinition("renminbi", bd);
// 前置增强advice bean注册
bd = new GeneralBeanDefinition();
bd.setBeanClass(MyBeforeAdvice.class);
bf.registerBeanDefinition("myBeforeAdvice", bd);
// 环绕增强advice bean注册
bd = new GeneralBeanDefinition();
bd.setBeanClass(MyMethodInterceptor.class);
bf.registerBeanDefinition("myMethodInterceptor", bd);
// 后置增强advice bean注册
bd = new GeneralBeanDefinition();
bd.setBeanClass(MyAfterReturningAdvice.class);
bf.registerBeanDefinition("myAfterReturningAdvice", bd);
// 往BeanFactory中注册AOP的BeanPostProcessor
AdvisorAutoProxyCreator aapc = new AdvisorAutoProxyCreator();
bf.registerBeanPostProcessor(aapc);
// 向AdvisorAutoProxyCreator注册Advisor
aapc.registerAdvisor(
new AspectJPointcutAdvisor("myBeforeAdvice", "execution(* demo.di.MagicGirl.*(..))"));
// 向AdvisorAutoProxyCreator注册Advisor
aapc.registerAdvisor(
new AspectJPointcutAdvisor("myMethodInterceptor", "execution(* demo.di.Lad.say*(..))"));
// 向AdvisorAutoProxyCreator注册Advisor
aapc.registerAdvisor(new AspectJPointcutAdvisor("myAfterReturningAdvice",
"execution(* demo.di.Renminbi.*(..))"));
bf.preInstantiateSingletons();
System.out.println("-----------------myBeforeAdvice---------------");
MagicGirl gril = (MagicGirl) bf.getBean("baigujing");
gril.getFriend();
gril.getName();
System.out.println("----------------myMethodInterceptor----------------");
Boy boy = (Boy) bf.getBean("swk");
boy.sayLove();
System.out.println("-----------------myAfterReturningAdvice---------------");
Renminbi rmb = (Renminbi) bf.getBean("renminbi");
rmb.pay();
}
}
运行结果：
本文其他知识点：
