本文节选自《Spring 5核心原理》

前面我们已经完成了Spring IoC、DI、MVC三大核心模块的功能,并保证了功能可用。接下来要完成Spring的另一个核心模块—AOP,这也是最难的部分。

1 基础配置

首先,在application.properties中增加如下自定义配置,作为Spring AOP的基础配置:


  1. #多切面配置可以在key前面加前缀
  2. #例如 aspect.logAspect.
  3. #切面表达式#
  4. pointCut=public .* com.tom.spring.demo.service..*Service..*(.*)
  5. #切面类#
  6. aspectClass=com.tom.spring.demo.aspect.LogAspect
  7. #切面前置通知#
  8. aspectBefore=before
  9. #切面后置通知#
  10. aspectAfter=after
  11. #切面异常通知#
  12. aspectAfterThrow=afterThrowing
  13. #切面异常类型#
  14. aspectAfterThrowingName=java.lang.Exception

为了加强理解,我们对比一下Spring AOP的原生配置:


  1. <bean id="xmlAspect" class="com.gupaoedu.aop.aspect.XmlAspect"></bean>
  2. <!-- AOP配置 -->
  3. <aop:config>
  4. <!-- 声明一个切面,并注入切面Bean,相当于@Aspect -->
  5. <aop:aspect ref="xmlAspect">
  6. <!-- 配置一个切入点,相当于@Pointcut -->
  7. <aop:pointcut expression="execution(* com.gupaoedu.aop.service..*(..))" id="simplePointcut"/>
  8. <!-- 配置通知,相当于@Before、@After、@AfterReturn、@Around、@AfterThrowing -->
  9. <aop:before pointcut-ref="simplePointcut" method="before"/>
  10. <aop:after pointcut-ref="simplePointcut" method="after"/>
  11. <aop:after-returning pointcut-ref="simplePointcut" method="afterReturn"/>
  12. <aop:after-throwing pointcut-ref="simplePointcut" method="afterThrow" throwing="ex"/>
  13. </aop:aspect>
  14. </aop:config>

为了方便,我们用properties文件来代替XML,以简化操作。

2 AOP核心原理V1.0版本

AOP的基本实现原理是利用动态代理机制,创建一个新的代理类完成代码织入,以达到代码功能增强的目的。如果各位小伙伴对动态代理原理不太了解的话,可以回看一下我前段时间更新的“设计模式就该这样学”系列中的动态代理模式专题文章。那么Spring AOP又是如何利用动态代理工作的呢?其实Spring主要功能就是完成解耦,将我们需要增强的代码逻辑单独拆离出来放到专门的类中,然后,通过声明配置文件来关联这些已经被拆离的逻辑,最后合并到一起运行。Spring容器为了保存这种关系,我们可以简单的理解成Spring是用一个Map保存保存这种关联关系的。Map的key就是我们要调用的目标方法,Map的value就是我们要织入的方法。只不过要织入的方法有前后顺序,因此我们需要标记织入方法的位置。在目标方法前面织入的逻辑叫做前置通知,在目标方法后面织入的逻辑叫后置通知,在目标方法出现异常时需要织入的逻辑叫异常通知。Map的具体设计如下:


  1. private Map<Method,Map<String, Method>> methodAdvices = new HashMap<Method, Map<String, Method>>();

下面我完整的写出一个简易的ApplicationContex,小伙伴可以参考 一下:


  1. import java.lang.reflect.InvocationHandler;
  2. import java.lang.reflect.Method;
  3. import java.lang.reflect.Proxy;
  4. import java.io.IOException;
  5. import java.io.InputStream;
  6. import java.lang.reflect.Method;
  7. import java.util.HashMap;
  8. import java.util.Map;
  9. import java.util.Properties;
  10. import java.util.regex.Matcher;
  11. import java.util.regex.Pattern;
  12. public class GPApplicationContext {
  13. private Properties contextConfig = new Properties();
  14. private Map<String,Object> ioc = new HashMap<String,Object>();
  15. //用来保存配置文件中对应的Method和Advice的对应关系
  16. private Map<Method,Map<String, Method>> methodAdvices = new HashMap<Method, Map<String, Method>>();
  17. public GPApplicationContext(){
  18. //为了演示,手动初始化一个Bean
  19. ioc.put("memberService", new MemberService());
  20. doLoadConfig("application.properties");
  21. doInitAopConfig();
  22. }
  23. public Object getBean(String name){
  24. return createProxy(ioc.get(name));
  25. }
  26. private Object createProxy(Object instance){
  27. return new GPJdkDynamicAopProxy(instance).getProxy();
  28. }
  29. //加载配置文件
  30. private void doLoadConfig(String contextConfigLocation) {
  31. //直接从类路径下找到Spring主配置文件所在的路径
  32. //并且将其读取出来放到Properties对象中
  33. //相对于scanPackage=com.gupaoedu.demo 从文件中保存到了内存中
  34. InputStream is = this.getClass().getClassLoader().getResourceAsStream(contextConfigLocation);
  35. try {
  36. contextConfig.load(is);
  37. } catch (IOException e) {
  38. e.printStackTrace();
  39. }finally {
  40. if(null != is){
  41. try {
  42. is.close();
  43. } catch (IOException e) {
  44. e.printStackTrace();
  45. }
  46. }
  47. }
  48. }
  49. private void doInitAopConfig() {
  50. try {
  51. Class apectClass = Class.forName(contextConfig.getProperty("aspectClass"));
  52. Map<String,Method> aspectMethods = new HashMap<String,Method>();
  53. for (Method method : apectClass.getMethods()) {
  54. aspectMethods.put(method.getName(),method);
  55. }
  56. //PonintCut 表达式解析为正则表达式
  57. String pointCut = contextConfig.getProperty("pointCut")
  58. .replaceAll("\\.","\\\\.")
  59. .replaceAll("\\\\.\\*",".*")
  60. .replaceAll("\\(","\\\\(")
  61. .replaceAll("\\)","\\\\)");
  62. Pattern pointCutPattern = Pattern.compile(pointCut);
  63. for (Map.Entry<String,Object> entry : ioc.entrySet()) {
  64. Class<?> clazz = entry.getValue().getClass();
  65. //循环找到所有的方法
  66. for (Method method : clazz.getMethods()) {
  67. //保存方法名
  68. String methodString = method.toString();
  69. if(methodString.contains("throws")){
  70. methodString = methodString.substring(0,methodString.lastIndexOf("throws")).trim();
  71. }
  72. Matcher matcher = pointCutPattern.matcher(methodString);
  73. if(matcher.matches()){
  74. Map<String,Method> advices = new HashMap<String,Method>();
  75. if(!(null == contextConfig.getProperty("aspectBefore") || "".equals( contextConfig.getProperty("aspectBefore")))){
  76. advices.put("before",aspectMethods.get(contextConfig.getProperty("aspectBefore")));
  77. }
  78. if(!(null == contextConfig.getProperty("aspectAfter") || "".equals( contextConfig.getProperty("aspectAfter")))){
  79. advices.put("after",aspectMethods.get(contextConfig.getProperty("aspectAfter")));
  80. }
  81. if(!(null == contextConfig.getProperty("aspectAfterThrow") || "".equals( contextConfig.getProperty("aspectAfterThrow")))){
  82. advices.put("afterThrow",aspectMethods.get(contextConfig.getProperty("aspectAfterThrow")));
  83. }
  84. methodAdvices.put(method,advices);
  85. }
  86. }
  87. }
  88. }catch (Exception e){
  89. e.printStackTrace();
  90. }
  91. }
  92. class GPJdkDynamicAopProxy implements GPInvocationHandler {
  93. private Object instance;
  94. public GPJdkDynamicAopProxy(Object instance) {
  95. this.instance = instance;
  96. }
  97. public Object getProxy() {
  98. return Proxy.newProxyInstance(instance.getClass().getClassLoader(),instance.getClass().getInterfaces(),this);
  99. }
  100. public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  101. Object aspectObject = Class.forName(contextConfig.getProperty("aspectClass")).newInstance();
  102. Map<String,Method> advices = methodAdvices.get(instance.getClass().getMethod(method.getName(),method.getParameterTypes()));
  103. Object returnValue = null;
  104. advices.get("before").invoke(aspectObject);
  105. try {
  106. returnValue = method.invoke(instance, args);
  107. }catch (Exception e){
  108. advices.get("afterThrow").invoke(aspectObject);
  109. e.printStackTrace();
  110. throw e;
  111. }
  112. advices.get("after").invoke(aspectObject);
  113. return returnValue;
  114. }
  115. }
  116. }

测试代码:


  1. public class MemberServiceTest {
  2. public static void main(String[] args) {
  3. GPApplicationContext applicationContext = new GPApplicationContext();
  4. IMemberService memberService = (IMemberService)applicationContext.getBean("memberService");
  5. try {
  6. memberService.get("1");
  7. memberService.save(new Member());
  8. } catch (Exception e) {
  9. e.printStackTrace();
  10. }
  11. }
  12. }

我们通过简单几百行代码,就可以完整地演示Spring AOP的核心原理,是不是很简单呢?当然,小伙伴们还是要自己动手哈亲自体验一下,这样才会印象深刻。下面,我们继续完善,将Spring AOP 1.0升级到2.0,那么2.0版本我是完全仿真Spring的原始设计来写的,希望能够给大家带来不一样的手写体验,从而更加深刻地理解Spring AOP的原理。

3 完成AOP顶层设计

3.1 GPJoinPoint

定义一个切点的抽象,这是AOP的基础组成单元。我们可以理解为这是某一个业务方法的附加信息。可想而知,切点应该包含业务方法本身、实参列表和方法所属的实例对象,还可以在GPJoinPoint中添加自定义属性,看下面的代码:


  1. package com.tom.spring.formework.aop.aspect;
  2. import java.lang.reflect.Method;
  3. /**
  4. * 回调连接点,通过它可以获得被代理的业务方法的所有信息
  5. */
  6. public interface GPJoinPoint {
  7. Method getMethod(); //业务方法本身
  8. Object[] getArguments(); //该方法的实参列表
  9. Object getThis(); //该方法所属的实例对象
  10. //在JoinPoint中添加自定义属性
  11. void setUserAttribute(String key, Object value);
  12. //从已添加的自定义属性中获取一个属性值
  13. Object getUserAttribute(String key);
  14. }

3.2 GPMethodInterceptor

方法拦截器是AOP代码增强的基本组成单元,其子类主要有GPMethodBeforeAdvice、GPAfterReturningAdvice和GPAfterThrowingAdvice。


  1. package com.tom.spring.formework.aop.intercept;
  2. /**
  3. * 方法拦截器顶层接口
  4. */
  5. public interface GPMethodInterceptor{
  6. Object invoke(GPMethodInvocation mi) throws Throwable;
  7. }

3.3 GPAopConfig

定义AOP的配置信息的封装对象,以方便在之后的代码中相互传递。


  1. package com.tom.spring.formework.aop;
  2. import lombok.Data;
  3. /**
  4. * AOP配置封装
  5. */
  6. @Data
  7. public class GPAopConfig {
  8. //以下配置与properties文件中的属性一一对应
  9. private String pointCut; //切面表达式
  10. private String aspectBefore; //前置通知方法名
  11. private String aspectAfter; //后置通知方法名
  12. private String aspectClass; //要织入的切面类
  13. private String aspectAfterThrow; //异常通知方法名
  14. private String aspectAfterThrowingName; //需要通知的异常类型
  15. }

3.4 GPAdvisedSupport

GPAdvisedSupport主要完成对AOP配置的解析。其中pointCutMatch()方法用来判断目标类是否符合切面规则,从而决定是否需要生成代理类,对目标方法进行增强。而getInterceptorsAndDynamic- InterceptionAdvice()方法主要根据AOP配置,将需要回调的方法封装成一个拦截器链并返回提供给外部获取。


  1. package com.tom.spring.formework.aop.support;
  2. import com.tom.spring.formework.aop.GPAopConfig;
  3. import com.tom.spring.formework.aop.aspect.GPAfterReturningAdvice;
  4. import com.tom.spring.formework.aop.aspect.GPAfterThrowingAdvice;
  5. import com.tom.spring.formework.aop.aspect.GPMethodBeforeAdvice;
  6. import java.lang.reflect.Method;
  7. import java.util.*;
  8. import java.util.regex.Matcher;
  9. import java.util.regex.Pattern;
  10. /**
  11. * 主要用来解析和封装AOP配置
  12. */
  13. public class GPAdvisedSupport {
  14. private Class targetClass;
  15. private Object target;
  16. private Pattern pointCutClassPattern;
  17. private transient Map<Method, List<Object>> methodCache;
  18. private GPAopConfig config;
  19. public GPAdvisedSupport(GPAopConfig config){
  20. this.config = config;
  21. }
  22. public Class getTargetClass() {
  23. return targetClass;
  24. }
  25. public void setTargetClass(Class targetClass) {
  26. this.targetClass = targetClass;
  27. parse();
  28. }
  29. public Object getTarget() {
  30. return target;
  31. }
  32. public void setTarget(Object target) {
  33. this.target = target;
  34. }
  35. public List<Object> getInterceptorsAndDynamicInterceptionAdvice(Method method, Class<?> targetClass) throws Exception {
  36. List<Object> cached = methodCache.get(method);
  37. //缓存未命中,则进行下一步处理
  38. if (cached == null) {
  39. Method m = targetClass.getMethod(method.getName(),method.getParameterTypes());
  40. cached = methodCache.get(m);
  41. //存入缓存
  42. this.methodCache.put(m, cached);
  43. }
  44. return cached;
  45. }
  46. public boolean pointCutMatch(){
  47. return pointCutClassPattern.matcher(this.targetClass.toString()).matches();
  48. }
  49. private void parse(){
  50. //pointCut表达式
  51. String pointCut = config.getPointCut()
  52. .replaceAll("\\.","\\\\.")
  53. .replaceAll("\\\\.\\*",".*")
  54. .replaceAll("\\(","\\\\(")
  55. .replaceAll("\\)","\\\\)");
  56. String pointCutForClass = pointCut.substring(0,pointCut.lastIndexOf("\\(") - 4);
  57. pointCutClassPattern = Pattern.compile("class " + pointCutForClass.substring (pointCutForClass.lastIndexOf(" ")+1));
  58. methodCache = new HashMap<Method, List<Object>>();
  59. Pattern pattern = Pattern.compile(pointCut);
  60. try {
  61. Class aspectClass = Class.forName(config.getAspectClass());
  62. Map<String,Method> aspectMethods = new HashMap<String,Method>();
  63. for (Method m : aspectClass.getMethods()){
  64. aspectMethods.put(m.getName(),m);
  65. }
  66. //在这里得到的方法都是原生方法
  67. for (Method m : targetClass.getMethods()){
  68. String methodString = m.toString();
  69. if(methodString.contains("throws")){
  70. methodString = methodString.substring(0,methodString.lastIndexOf("throws")).trim();
  71. }
  72. Matcher matcher = pattern.matcher(methodString);
  73. if(matcher.matches()){
  74. //能满足切面规则的类,添加到AOP配置中
  75. List<Object> advices = new LinkedList<Object>();
  76. //前置通知
  77. if(!(null == config.getAspectBefore() || "".equals(config.getAspectBefore().trim()))) {
  78. advices.add(new GPMethodBeforeAdvice(aspectMethods.get (config.getAspectBefore()), aspectClass.newInstance()));
  79. }
  80. //后置通知
  81. if(!(null == config.getAspectAfter() || "".equals(config.getAspectAfter(). trim()))) {
  82. advices.add(new GPAfterReturningAdvice(aspectMethods.get (config.getAspectAfter()), aspectClass.newInstance()));
  83. }
  84. //异常通知
  85. if(!(null == config.getAspectAfterThrow() || "".equals(config.getAspectAfterThrow().trim()))) {
  86. GPAfterThrowingAdvice afterThrowingAdvice = new GPAfterThrowingAdvice (aspectMethods.get(config.getAspectAfterThrow()), aspectClass.newInstance());
  87. afterThrowingAdvice.setThrowingName(config.getAspectAfterThrowingName());
  88. advices.add(afterThrowingAdvice);
  89. }
  90. methodCache.put(m,advices);
  91. }
  92. }
  93. } catch (Exception e) {
  94. e.printStackTrace();
  95. }
  96. }
  97. }

3.5 GPAopProxy

GPAopProxy是代理工厂的顶层接口,其子类主要有两个:GPCglibAopProxy和GPJdkDynamicAopProxy,分别实现CGlib代理和JDK Proxy代理。


  1. package com.tom.spring.formework.aop;
  2. /**
  3. * 代理工厂的顶层接口,提供获取代理对象的顶层入口
  4. */
  5. //默认就用JDK动态代理
  6. public interface GPAopProxy {
  7. //获得一个代理对象
  8. Object getProxy();
  9. //通过自定义类加载器获得一个代理对象
  10. Object getProxy(ClassLoader classLoader);
  11. }

3.6 GPCglibAopProxy

本文未实现CglibAopProxy,感兴趣的“小伙伴”可以自行尝试。


  1. package com.tom.spring.formework.aop;
  2. import com.tom.spring.formework.aop.support.GPAdvisedSupport;
  3. /**
  4. * 使用CGlib API生成代理类,在此不举例
  5. * 感兴趣的“小伙伴”可以自行实现
  6. */
  7. public class GPCglibAopProxy implements GPAopProxy {
  8. private GPAdvisedSupport config;
  9. public GPCglibAopProxy(GPAdvisedSupport config){
  10. this.config = config;
  11. }
  12. @Override
  13. public Object getProxy() {
  14. return null;
  15. }
  16. @Override
  17. public Object getProxy(ClassLoader classLoader) {
  18. return null;
  19. }
  20. }

3.7 GPJdkDynamicAopProxy

下面来看GPJdkDynamicAopProxy的实现,主要功能在invoke()方法中。从代码量来看其实不多,主要是调用了GPAdvisedSupport的getInterceptorsAndDynamicInterceptionAdvice()方法获得拦截器链。在目标类中,每一个被增强的目标方法都对应一个拦截器链。


  1. package com.tom.spring.formework.aop;
  2. import com.tom.spring.formework.aop.intercept.GPMethodInvocation;
  3. import com.tom.spring.formework.aop.support.GPAdvisedSupport;
  4. import java.lang.reflect.InvocationHandler;
  5. import java.lang.reflect.Method;
  6. import java.lang.reflect.Proxy;
  7. import java.util.List;
  8. /**
  9. * 使用JDK Proxy API生成代理类
  10. */
  11. public class GPJdkDynamicAopProxy implements GPAopProxy,InvocationHandler {
  12. private GPAdvisedSupport config;
  13. public GPJdkDynamicAopProxy(GPAdvisedSupport config){
  14. this.config = config;
  15. }
  16. //把原生的对象传进来
  17. public Object getProxy(){
  18. return getProxy(this.config.getTargetClass().getClassLoader());
  19. }
  20. @Override
  21. public Object getProxy(ClassLoader classLoader) {
  22. return Proxy.newProxyInstance(classLoader,this.config.getTargetClass().getInterfaces(),this);
  23. }
  24. //invoke()方法是执行代理的关键入口
  25. @Override
  26. public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  27. //将每一个JoinPoint也就是被代理的业务方法(Method)封装成一个拦截器,组合成一个拦截器链
  28. List<Object> interceptorsAndDynamicMethodMatchers = config.getInterceptorsAndDynamicInterceptionAdvice(method,this.config.getTargetClass());
  29. //交给拦截器链MethodInvocation的proceed()方法执行
  30. GPMethodInvocation invocation = new GPMethodInvocation(proxy,this.config.getTarget(), method,args,this.config.getTargetClass(),interceptorsAndDynamicMethodMatchers);
  31. return invocation.proceed();
  32. }
  33. }

从代码中可以看出,从GPAdvisedSupport中获得的拦截器链又被当作参数传入GPMethodInvocation的构造方法中。那么GPMethodInvocation中到底又对方法链做了什么呢?

3.8 GPMethodInvocation

GPMethodInvocation的代码如下:


  1. package com.tom.spring.formework.aop.intercept;
  2. import com.tom.spring.formework.aop.aspect.GPJoinPoint;
  3. import java.lang.reflect.Method;
  4. import java.util.List;
  5. /**
  6. * 执行拦截器链,相当于Spring中ReflectiveMethodInvocation的功能
  7. */
  8. public class GPMethodInvocation implements GPJoinPoint {
  9. private Object proxy; //代理对象
  10. private Method method; //代理的目标方法
  11. private Object target; //代理的目标对象
  12. private Class<?> targetClass; //代理的目标类
  13. private Object[] arguments; //代理的方法的实参列表
  14. private List<Object> interceptorsAndDynamicMethodMatchers; //回调方法链
  15. //保存自定义属性
  16. private Map<String, Object> userAttributes;
  17. private int currentInterceptorIndex = -1;
  18. public GPMethodInvocation(Object proxy, Object target, Method method, Object[] arguments,
  19. Class<?> targetClass, List<Object> interceptorsAndDynamicMethodMatchers) {
  20. this.proxy = proxy;
  21. this.target = target;
  22. this.targetClass = targetClass;
  23. this.method = method;
  24. this.arguments = arguments;
  25. this.interceptorsAndDynamicMethodMatchers = interceptorsAndDynamicMethodMatchers;
  26. }
  27. public Object proceed() throws Throwable {
  28. //如果Interceptor执行完了,则执行joinPoint
  29. if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
  30. return this.method.invoke(this.target,this.arguments);
  31. }
  32. Object interceptorOrInterceptionAdvice =
  33. this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
  34. //如果要动态匹配joinPoint
  35. if (interceptorOrInterceptionAdvice instanceof GPMethodInterceptor) {
  36. GPMethodInterceptor mi = (GPMethodInterceptor) interceptorOrInterceptionAdvice;
  37. return mi.invoke(this);
  38. } else {
  39. //执行当前Intercetpor
  40. return proceed();
  41. }
  42. }
  43. @Override
  44. public Method getMethod() {
  45. return this.method;
  46. }
  47. @Override
  48. public Object[] getArguments() {
  49. return this.arguments;
  50. }
  51. @Override
  52. public Object getThis() {
  53. return this.target;
  54. }
  55. public void setUserAttribute(String key, Object value) {
  56. if (value != null) {
  57. if (this.userAttributes == null) {
  58. this.userAttributes = new HashMap<String,Object>();
  59. }
  60. this.userAttributes.put(key, value);
  61. }
  62. else {
  63. if (this.userAttributes != null) {
  64. this.userAttributes.remove(key);
  65. }
  66. }
  67. }
  68. public Object getUserAttribute(String key) {
  69. return (this.userAttributes != null ? this.userAttributes.get(key) : null);
  70. }
  71. }

从代码中可以看出,proceed()方法才是MethodInvocation的关键所在。在proceed()中,先进行判断,如果拦截器链为空,则说明目标方法无须增强,直接调用目标方法并返回。如果拦截器链不为空,则将拦截器链中的方法按顺序执行,直到拦截器链中所有方法全部执行完毕。

4 设计AOP基础实现

4.1 GPAdvice

GPAdvice作为所有回调通知的顶层接口设计,在Mini版本中为了尽量和原生Spring保持一致,只是被设计成了一种规范,并没有实现任何功能。


  1. /**
  2. * 回调通知顶层接口
  3. */
  4. public interface GPAdvice {
  5. }

4.2 GPAbstractAspectJAdvice

使用模板模式设计GPAbstractAspectJAdvice类,封装拦截器回调的通用逻辑,主要封装反射动态调用方法,其子类只需要控制调用顺序即可。


  1. package com.tom.spring.formework.aop.aspect;
  2. import java.lang.reflect.Method;
  3. /**
  4. * 封装拦截器回调的通用逻辑,在Mini版本中主要封装了反射动态调用方法
  5. */
  6. public abstract class GPAbstractAspectJAdvice implements GPAdvice {
  7. private Method aspectMethod;
  8. private Object aspectTarget;
  9. public GPAbstractAspectJAdvice(
  10. Method aspectMethod, Object aspectTarget) {
  11. this.aspectMethod = aspectMethod;
  12. this.aspectTarget = aspectTarget;
  13. }
  14. //反射动态调用方法
  15. protected Object invokeAdviceMethod(GPJoinPoint joinPoint,Object returnValue,Throwable ex)
  16. throws Throwable {
  17. Class<?> [] paramsTypes = this.aspectMethod.getParameterTypes();
  18. if(null == paramsTypes || paramsTypes.length == 0) {
  19. return this.aspectMethod.invoke(aspectTarget);
  20. }else {
  21. Object[] args = new Object[paramsTypes.length];
  22. for (int i = 0; i < paramsTypes.length; i++) {
  23. if(paramsTypes[i] == GPJoinPoint.class){
  24. args[i] = joinPoint;
  25. }else if(paramsTypes[i] == Throwable.class){
  26. args[i] = ex;
  27. }else if(paramsTypes[i] == Object.class){
  28. args[i] = returnValue;
  29. }
  30. }
  31. return this.aspectMethod.invoke(aspectTarget,args);
  32. }
  33. }
  34. }

4.3 GPMethodBeforeAdvice

GPMethodBeforeAdvice继承GPAbstractAspectJAdvice,实现GPAdvice和GPMethodInterceptor接口,在invoke()中控制前置通知的调用顺序。


  1. package com.tom.spring.formework.aop.aspect;
  2. import com.tom.spring.formework.aop.intercept.GPMethodInterceptor;
  3. import com.tom.spring.formework.aop.intercept.GPMethodInvocation;
  4. import java.lang.reflect.Method;
  5. /**
  6. * 前置通知具体实现
  7. */
  8. public class GPMethodBeforeAdvice extends GPAbstractAspectJAdvice implements GPAdvice, GPMethodInterceptor {
  9. private GPJoinPoint joinPoint;
  10. public GPMethodBeforeAdvice(Method aspectMethod, Object target) {
  11. super(aspectMethod, target);
  12. }
  13. public void before(Method method, Object[] args, Object target) throws Throwable {
  14. invokeAdviceMethod(this.joinPoint,null,null);
  15. }
  16. public Object invoke(GPMethodInvocation mi) throws Throwable {
  17. this.joinPoint = mi;
  18. this.before(mi.getMethod(), mi.getArguments(), mi.getThis());
  19. return mi.proceed();
  20. }
  21. }

4.4 GPAfterReturningAdvice

GPAfterReturningAdvice继承GPAbstractAspectJAdvice,实现GPAdvice和GPMethodInterceptor接口,在invoke()中控制后置通知的调用顺序。


  1. package com.tom.spring.formework.aop.aspect;
  2. import com.tom.spring.formework.aop.intercept.GPMethodInterceptor;
  3. import com.tom.spring.formework.aop.intercept.GPMethodInvocation;
  4. import java.lang.reflect.Method;
  5. /**
  6. * 后置通知具体实现
  7. */
  8. public class GPAfterReturningAdvice extends GPAbstractAspectJAdvice implements GPAdvice, GPMethodInterceptor {
  9. private GPJoinPoint joinPoint;
  10. public GPAfterReturningAdvice(Method aspectMethod, Object target) {
  11. super(aspectMethod, target);
  12. }
  13. @Override
  14. public Object invoke(GPMethodInvocation mi) throws Throwable {
  15. Object retVal = mi.proceed();
  16. this.joinPoint = mi;
  17. this.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());
  18. return retVal;
  19. }
  20. public void afterReturning(Object returnValue, Method method, Object[] args,Object target) throws Throwable{
  21. invokeAdviceMethod(joinPoint,returnValue,null);
  22. }
  23. }

4.5 GPAfterThrowingAdvice

GPAfterThrowingAdvice继承GPAbstractAspectJAdvice,实现GPAdvice和GPMethodInterceptor接口,在invoke()中控制异常通知的调用顺序。


  1. package com.tom.spring.formework.aop.aspect;
  2. import com.tom.spring.formework.aop.intercept.GPMethodInterceptor;
  3. import com.tom.spring.formework.aop.intercept.GPMethodInvocation;
  4. import java.lang.reflect.Method;
  5. /**
  6. * 异常通知具体实现
  7. */
  8. public class GPAfterThrowingAdvice extends GPAbstractAspectJAdvice implements GPAdvice, GPMethodInterceptor {
  9. private String throwingName;
  10. private GPMethodInvocation mi;
  11. public GPAfterThrowingAdvice(Method aspectMethod, Object target) {
  12. super(aspectMethod, target);
  13. }
  14. public void setThrowingName(String name) {
  15. this.throwingName = name;
  16. }
  17. @Override
  18. public Object invoke(GPMethodInvocation mi) throws Throwable {
  19. try {
  20. return mi.proceed();
  21. }catch (Throwable ex) {
  22. invokeAdviceMethod(mi,null,ex.getCause());
  23. throw ex;
  24. }
  25. }
  26. }

感兴趣的“小伙伴”可以参看Spring源码,自行实现环绕通知的调用逻辑。

4.6 接入getBean()方法

在上面的代码中,我们已经完成了Spring AOP模块的核心功能,那么接下如何集成到IoC容器中去呢?找到GPApplicationContext的getBean()方法,我们知道getBean()中负责Bean初始化的方法其实就是instantiateBean(),在初始化时就可以确定是否返回原生Bean或Proxy Bean。代码实现如下:


  1. //传一个BeanDefinition,返回一个实例Bean
  2. private Object instantiateBean(GPBeanDefinition beanDefinition){
  3. Object instance = null;
  4. String className = beanDefinition.getBeanClassName();
  5. try{
  6. //因为根据Class才能确定一个类是否有实例
  7. if(this.singletonBeanCacheMap.containsKey(className)){
  8. instance = this.singletonBeanCacheMap.get(className);
  9. }else{
  10. Class<?> clazz = Class.forName(className);
  11. instance = clazz.newInstance();
  12. GPAdvisedSupport config = instantionAopConfig(beanDefinition);
  13. config.setTargetClass(clazz);
  14. config.setTarget(instance);
  15. if(config.pointCutMatch()) {
  16. instance = createProxy(config).getProxy();
  17. }
  18. this.factoryBeanObjectCache.put(className,instance);
  19. this.singletonBeanCacheMap.put(beanDefinition.getFactoryBeanName(),instance);
  20. }
  21. return instance;
  22. }catch (Exception e){
  23. e.printStackTrace();
  24. }
  25. return null;
  26. }
  27. private GPAdvisedSupport instantionAopConfig(GPBeanDefinition beanDefinition) throws Exception{
  28. GPAopConfig config = new GPAopConfig();
  29. config.setPointCut(reader.getConfig().getProperty("pointCut"));
  30. config.setAspectClass(reader.getConfig().getProperty("aspectClass"));
  31. config.setAspectBefore(reader.getConfig().getProperty("aspectBefore"));
  32. config.setAspectAfter(reader.getConfig().getProperty("aspectAfter"));
  33. config.setAspectAfterThrow(reader.getConfig().getProperty("aspectAfterThrow"));
  34. config.setAspectAfterThrowingName(reader.getConfig().getProperty("aspectAfterThrowingName"));
  35. return new GPAdvisedSupport(config);
  36. }
  37. private GPAopProxy createProxy(GPAdvisedSupport config) {
  38. Class targetClass = config.getTargetClass();
  39. if (targetClass.getInterfaces().length > 0) {
  40. return new GPJdkDynamicAopProxy(config);
  41. }
  42. return new GPCglibAopProxy(config);
  43. }

从上面的代码中可以看出,在instantiateBean()方法中调用createProxy()决定代理工厂的调用策略,然后调用代理工厂的proxy()方法创建代理对象。最终代理对象将被封装到BeanWrapper中并保存到IoC容器。

5 织入业务代码

通过前面的代码编写,所有的核心模块和底层逻辑都已经实现,“万事俱备,只欠东风。”接下来,该是“见证奇迹的时刻了”。我们来织入业务代码,做一个测试。创建LogAspect类,实现对业务方法的监控。主要记录目标方法的调用日志,获取目标方法名、实参列表、每次调用所消耗的时间。

5.1 LogAspect

LogAspect的代码如下:


  1. package com.tom.spring.demo.aspect;
  2. import com.tom.spring.formework.aop.aspect.GPJoinPoint;
  3. import lombok.extern.slf4j.Slf4j;
  4. import java.util.Arrays;
  5. /**
  6. * 定义一个织入的切面逻辑,也就是要针对目标代理对象增强的逻辑
  7. * 本类主要完成对方法调用的监控,监听目标方法每次执行所消耗的时间
  8. */
  9. @Slf4j
  10. public class LogAspect {
  11. //在调用一个方法之前,执行before()方法
  12. public void before(GPJoinPoint joinPoint){
  13. joinPoint.setUserAttribute("startTime_" + joinPoint.getMethod().getName(),System.currentTimeMillis());
  14. //这个方法中的逻辑是由我们自己写的
  15. log.info("Invoker Before Method!!!" +
  16. "\nTargetObject:" + joinPoint.getThis() +
  17. "\nArgs:" + Arrays.toString(joinPoint.getArguments()));
  18. }
  19. //在调用一个方法之后,执行after()方法
  20. public void after(GPJoinPoint joinPoint){
  21. log.info("Invoker After Method!!!" +
  22. "\nTargetObject:" + joinPoint.getThis() +
  23. "\nArgs:" + Arrays.toString(joinPoint.getArguments()));
  24. long startTime = (Long) joinPoint.getUserAttribute("startTime_" + joinPoint.getMethod().getName());
  25. long endTime = System.currentTimeMillis();
  26. System.out.println("use time :" + (endTime - startTime));
  27. }
  28. public void afterThrowing(GPJoinPoint joinPoint, Throwable ex){
  29. log.info("出现异常" +
  30. "\nTargetObject:" + joinPoint.getThis() +
  31. "\nArgs:" + Arrays.toString(joinPoint.getArguments()) +
  32. "\nThrows:" + ex.getMessage());
  33. }
  34. }

通过上面的代码可以发现,每一个回调方法都加了一个参数GPJoinPoint,还记得GPJoinPoint为何物吗?事实上,GPMethodInvocation就是GPJoinPoint的实现类。而GPMethodInvocation又是在GPJdkDynamicAopPorxy的invoke()方法中实例化的,即每个被代理对象的业务方法会对应一个GPMethodInvocation实例。也就是说,MethodInvocation的生命周期是被代理对象中业务方法的生命周期的对应。前面我们已经了解,调用GPJoinPoint的setUserAttribute()方法可以在GPJoinPoint中自定义属性,调用getUserAttribute()方法可以获取自定义属性的值。

在LogAspect的before()方法中,在GPJoinPoint中设置了startTime并赋值为系统时间,即记录方法开始调用时间到MethodInvocation的上下文。在LogAspect的after()方法中获取startTime,再次获取的系统时间保存到endTime。在AOP拦截器链回调中,before()方法肯定在after()方法之前调用,因此两次获取的系统时间会形成一个时间差,这个时间差就是业务方法执行所消耗的时间。通过这个时间差,就可以判断业务方法在单位时间内的性能消耗,是不是设计得非常巧妙?事实上,市面上几乎所有的系统监控框架都是基于这样一种思想来实现的,可以高度解耦并减少代码侵入。

5.2 IModifyService

为了演示异常回调通知,我们给之前定义的IModifyService接口的add()方法添加了抛出异常的功能,看下面的代码实现:


  1. package com.tom.spring.demo.service;
  2. /**
  3. * 增、删、改业务
  4. */
  5. public interface IModifyService {
  6. /**
  7. * 增加
  8. */
  9. String add(String name, String addr) throws Exception;
  10. /**
  11. * 修改
  12. */
  13. String edit(Integer id, String name);
  14. /**
  15. * 删除
  16. */
  17. String remove(Integer id);
  18. }

5.3 ModifyService

ModifyService的代码如下:


  1. package com.tom.spring.demo.service.impl;
  2. import com.tom.spring.demo.service.IModifyService;
  3. import com.tom.spring.formework.annotation.GPService;
  4. /**
  5. * 增、删、改业务
  6. */
  7. @GPService
  8. public class ModifyService implements IModifyService {
  9. /**
  10. * 增加
  11. */
  12. public String add(String name,String addr) throws Exception {
  13. throw new Exception("故意抛出异常,测试切面通知是否生效");
  14. // return "modifyService add,name=" + name + ",addr=" + addr;
  15. }
  16. /**
  17. * 修改
  18. */
  19. public String edit(Integer id,String name) {
  20. return "modifyService edit,id=" + id + ",name=" + name;
  21. }
  22. /**
  23. * 删除
  24. */
  25. public String remove(Integer id) {
  26. return "modifyService id=" + id;
  27. }
  28. }

6 运行效果演示

在浏览器中输入 http://localhost/web/add.json?name=Tom&addr=HunanChangsha ,就可以直观明了地看到Service层抛出的异常信息,如下图所示。

控制台输出如下图所示。

通过控制台输出,可以看到异常通知成功捕获异常信息,触发了GPMethodBeforeAdvice 和GPAfterThrowingAdvice,而并未触发GPAfterReturningAdvice,符合我们的预期。

下面再做一个测试,输入 http://localhost/web/query.json?name=Tom ,结果如下图所示:

控制台输出如下图所示:

通过控制台输出可以看到,分别捕获了前置通知、后置通知,并打印了相关信息,符合我们的预期。

至此AOP模块大功告成,是不是有一种小小的成就感,跃跃欲试?在整个Mini版本实现中有些细节没有过多考虑,更多的是希望给“小伙伴们”提供一种学习源码的思路。手写源码不是为了重复造轮子,也不是为了装“高大上”,其实只是我们推荐给大家的一种学习方式。

本文为“Tom弹架构”原创,转载请注明出处。技术在于分享,我分享我快乐!

如果本文对您有帮助,欢迎关注和点赞;如果您有任何建议也可留言评论或私信,您的支持是我坚持创作的动力。

原创不易,坚持很酷,都看到这里了,小伙伴记得点赞、收藏、在看,一键三连加关注!如果你觉得内容太干,可以分享转发给朋友滋润滋润!

30个类手写Spring核心原理之AOP代码织入(5)的更多相关文章

  1. 30个类手写Spring核心原理之动态数据源切换(8)

    本文节选自<Spring 5核心原理> 阅读本文之前,请先阅读以下内容: 30个类手写Spring核心原理之自定义ORM(上)(6) 30个类手写Spring核心原理之自定义ORM(下)( ...

  2. 30个类手写Spring核心原理之环境准备(1)

    本文节选自<Spring 5核心原理> 1 IDEA集成Lombok插件 1.1 安装插件 IntelliJ IDEA是一款非常优秀的集成开发工具,功能强大,而且插件众多.Lombok是开 ...

  3. 30个类手写Spring核心原理之依赖注入功能(3)

    本文节选自<Spring 5核心原理> 在之前的源码分析中我们已经了解到,依赖注入(DI)的入口是getBean()方法,前面的IoC手写部分基本流程已通.先在GPApplicationC ...

  4. 30个类手写Spring核心原理之自定义ORM(上)(6)

    本文节选自<Spring 5核心原理> 1 实现思路概述 1.1 从ResultSet说起 说到ResultSet,有Java开发经验的"小伙伴"自然最熟悉不过了,不过 ...

  5. 30个类手写Spring核心原理之Ioc顶层架构设计(2)

    本文节选自<Spring 5核心原理> 1 Annotation(自定义配置)模块 Annotation的代码实现我们还是沿用Mini版本的,保持不变,复制过来便可. 1.1 @GPSer ...

  6. 30个类手写Spring核心原理之MVC映射功能(4)

    本文节选自<Spring 5核心原理> 接下来我们来完成MVC模块的功能,应该不需要再做说明.Spring MVC的入口就是从DispatcherServlet开始的,而前面的章节中已完成 ...

  7. 手写webpack核心原理,再也不怕面试官问我webpack原理

    手写webpack核心原理 目录 手写webpack核心原理 一.核心打包原理 1.1 打包的主要流程如下 1.2 具体细节 二.基本准备工作 三.获取模块内容 四.分析模块 五.收集依赖 六.ES6 ...

  8. 手写spring事务框架, 揭秘AOP实现原理。

    AOP面向切面编程:主要是通过切面类来提高代码的复用,降低业务代码的耦合性,从而提高开发效率.主要的功能是:日志记录,性能统计,安全控制,事务处理,异常处理等等. AOP实现原理:aop是通过cgli ...

  9. 手写Spring MVC

    闲及无聊 又打开了CSDN开始看一看有什么先进的可以学习的相关帖子,这时看到了一位大神写的简历装X必备,手写Spring MVC. 我想这个东西还是有一点意思的 就拜读了一下大佬的博客 通读了一遍相关 ...

随机推荐

  1. Python基础(使用模块)

    #!/usr/bin/env python3 # -*- coding: utf-8 -*- ' a test module ' __author__ = 'Michael Liao' import ...

  2. scrapy获取58同城数据

    1. scrapy项目的结构 项目名字 项目名字 spiders文件夹 (存储的是爬虫文件) init 自定义的爬虫文件 核心功能文件 **************** init items 定义数据 ...

  3. 面霸篇:Java 集合容器大满贯(卷二)

    面霸篇,从面试角度作为切入点提升大家的 Java 内功,所谓根基不牢,地动山摇. 码哥在 <Redis 系列>的开篇 Redis 为什么这么快中说过:学习一个技术,通常只接触了零散的技术点 ...

  4. [bzoj3351]Regions

    这道题有一种较为暴力的做法,对于每个点枚举所有与r2为该属性的询问并加以修改,最坏时间复杂度为o(nq),然而是可过的(97s) 发现只有当r2相同的询问数特别多时才会达到最坏时间复杂度,因此如果删除 ...

  5. html图片动态增加文字

    <body> <!-- <div class="logo"> <img src="${imagePath}/disc.PNG" ...

  6. HelloWorld与java运行机制

    HelloWorld 新建文件夹存放代码 新建一个java文件 文件后缀为.java Hello.java 注意文件拓展名改为java文件 编写代码 public class Hello{ #类名 p ...

  7. 文本分类:Keras+RNN vs传统机器学习

    摘要:本文通过Keras实现了一个RNN文本分类学习的案例,并详细介绍了循环神经网络原理知识及与机器学习对比. 本文分享自华为云社区<基于Keras+RNN的文本分类vs基于传统机器学习的文本分 ...

  8. JavaWeb Cookie,Session

    Cookie 1.Cookie翻译过来是饼干的意思.Cookie是服务器通知客户端保存键值对的一种技术.客户端有了Cookie 后,每次请求都发送给服务器.每个Cookie的大小不能超过4kb. 2. ...

  9. Codeforces 571E - Geometric Progressions(数论+阿巴细节题)

    Codeforces 题目传送门 & 洛谷题目传送门 u1s1 感觉此题思维难度不太大,不过大概是细节多得到了精神污染的地步所以才放到 D1E 的罢((( 首先我们对所有 \(a_i,b_i\ ...

  10. map与unordered_map区别及使用

    需要引入的头文件不同map: #include <map>unordered_map: #include <unordered_map> 内部实现机理不同map: map内部实 ...