30个类手写Spring核心原理之AOP代码织入
Posted _Tom弹架构
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了30个类手写Spring核心原理之AOP代码织入相关的知识，希望对你有一定的参考价值。
本文节选自《Spring 5核心原理》
前面我们已经完成了Spring IoC、DI、MVC三大核心模块的功能，并保证了功能可用。接下来要完成Spring的另一个核心模块—AOP，这也是最难的部分。
1 基础配置
首先，在application.properties中增加如下自定义配置，作为Spring AOP的基础配置：
#多切面配置可以在key前面加前缀
#例如 aspect.logAspect.
#切面表达式#
pointCut=public .* com.tom.spring.demo.service..*Service..*(.*)
#切面类#
aspectClass=com.tom.spring.demo.aspect.LogAspect
#切面前置通知#
aspectBefore=before
#切面后置通知#
aspectAfter=after
#切面异常通知#
aspectAfterThrow=afterThrowing
#切面异常类型#
aspectAfterThrowingName=java.lang.Exception
为了加强理解，我们对比一下Spring AOP的原生配置：
<bean id="xmlAspect" class="com.gupaoedu.aop.aspect.XmlAspect"></bean>
<!-- AOP配置 -->
<aop:config>
<!-- 声明一个切面，并注入切面Bean，相当于@Aspect -->
<aop:aspect ref="xmlAspect">
<!-- 配置一个切入点，相当于@Pointcut -->
<aop:pointcut expression="execution(* com.gupaoedu.aop.service..*(..))" id="simplePointcut"/>
<!-- 配置通知，相当于@Before、@After、@AfterReturn、@Around、@AfterThrowing -->
<aop:before pointcut-ref="simplePointcut" method="before"/>
<aop:after pointcut-ref="simplePointcut" method="after"/>
<aop:after-returning pointcut-ref="simplePointcut" method="afterReturn"/>
<aop:after-throwing pointcut-ref="simplePointcut" method="afterThrow" throwing="ex"/>
</aop:aspect>
</aop:config>
为了方便，我们用properties文件来代替XML，以简化操作。
2 AOP核心原理V1.0版本
AOP的基本实现原理是利用动态代理机制，创建一个新的代理类完成代码织入，以达到代码功能增强的目的。如果各位小伙伴对动态代理原理不太了解的话，可以回看一下我前段时间更新的“设计模式就该这样学”系列中的动态代理模式专题文章。那么Spring AOP又是如何利用动态代理工作的呢？其实Spring主要功能就是完成解耦，将我们需要增强的代码逻辑单独拆离出来放到专门的类中，然后，通过声明配置文件来关联这些已经被拆离的逻辑，最后合并到一起运行。Spring容器为了保存这种关系，我们可以简单的理解成Spring是用一个Map保存保存这种关联关系的。Map的key就是我们要调用的目标方法，Map的value就是我们要织入的方法。只不过要织入的方法有前后顺序，因此我们需要标记织入方法的位置。在目标方法前面织入的逻辑叫做前置通知，在目标方法后面织入的逻辑叫后置通知，在目标方法出现异常时需要织入的逻辑叫异常通知。Map的具体设计如下：
private Map<Method,Map<String, Method>> methodAdvices = new HashMap<Method, Map<String, Method>>();
下面我完整的写出一个简易的ApplicationContex，小伙伴可以参考 一下：
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class GPApplicationContext
private Properties contextConfig = new Properties();
private Map<String,Object> ioc = new HashMap<String,Object>();
//用来保存配置文件中对应的Method和Advice的对应关系
private Map<Method,Map<String, Method>> methodAdvices = new HashMap<Method, Map<String, Method>>();
public GPApplicationContext()
//为了演示，手动初始化一个Bean
ioc.put("memberService", new MemberService());
doLoadConfig("application.properties");
doInitAopConfig();
public Object getBean(String name)
return createProxy(ioc.get(name));
private Object createProxy(Object instance)
return new GPJdkDynamicAopProxy(instance).getProxy();
//加载配置文件
private void doLoadConfig(String contextConfigLocation)
//直接从类路径下找到Spring主配置文件所在的路径
//并且将其读取出来放到Properties对象中
//相对于scanPackage=com.gupaoedu.demo 从文件中保存到了内存中
InputStream is = this.getClass().getClassLoader().getResourceAsStream(contextConfigLocation);
try
contextConfig.load(is);
catch (IOException e)
e.printStackTrace();
finally
if(null != is)
try
is.close();
catch (IOException e)
e.printStackTrace();
private void doInitAopConfig()
try
Class apectClass = Class.forName(contextConfig.getProperty("aspectClass"));
Map<String,Method> aspectMethods = new HashMap<String,Method>();
for (Method method : apectClass.getMethods())
aspectMethods.put(method.getName(),method);
//PonintCut 表达式解析为正则表达式
String pointCut = contextConfig.getProperty("pointCut")
.replaceAll("\\\\.","\\\\\\\\.")
.replaceAll("\\\\\\\\.\\\\*",".*")
.replaceAll("\\\\(","\\\\\\\\(")
.replaceAll("\\\\)","\\\\\\\\)");
Pattern pointCutPattern = Pattern.compile(pointCut);
for (Map.Entry<String,Object> entry : ioc.entrySet())
Class<?> clazz = entry.getValue().getClass();
//循环找到所有的方法
for (Method method : clazz.getMethods())
//保存方法名
String methodString = method.toString();
if(methodString.contains("throws"))
methodString = methodString.substring(0,methodString.lastIndexOf("throws")).trim();
Matcher matcher = pointCutPattern.matcher(methodString);
if(matcher.matches())
Map<String,Method> advices = new HashMap<String,Method>();
if(!(null == contextConfig.getProperty("aspectBefore") || "".equals( contextConfig.getProperty("aspectBefore"))))
advices.put("before",aspectMethods.get(contextConfig.getProperty("aspectBefore")));
if(!(null == contextConfig.getProperty("aspectAfter") || "".equals( contextConfig.getProperty("aspectAfter"))))
advices.put("after",aspectMethods.get(contextConfig.getProperty("aspectAfter")));
if(!(null == contextConfig.getProperty("aspectAfterThrow") || "".equals( contextConfig.getProperty("aspectAfterThrow"))))
advices.put("afterThrow",aspectMethods.get(contextConfig.getProperty("aspectAfterThrow")));
methodAdvices.put(method,advices);
catch (Exception e)
e.printStackTrace();
class GPJdkDynamicAopProxy implements GPInvocationHandler
private Object instance;
public GPJdkDynamicAopProxy(Object instance)
this.instance = instance;
public Object getProxy()
return Proxy.newProxyInstance(instance.getClass().getClassLoader(),instance.getClass().getInterfaces(),this);
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
Object aspectObject = Class.forName(contextConfig.getProperty("aspectClass")).newInstance();
Map<String,Method> advices = methodAdvices.get(instance.getClass().getMethod(method.getName(),method.getParameterTypes()));
Object returnValue = null;
advices.get("before").invoke(aspectObject);
try
returnValue = method.invoke(instance, args);
catch (Exception e)
advices.get("afterThrow").invoke(aspectObject);
e.printStackTrace();
throw e;
advices.get("after").invoke(aspectObject);
return returnValue;
测试代码：
public class MemberServiceTest
public static void main(String[] args)
GPApplicationContext applicationContext = new GPApplicationContext();
IMemberService memberService = (IMemberService)applicationContext.getBean("memberService");
try
memberService.get("1");
memberService.save(new Member());
catch (Exception e)
e.printStackTrace();
我们通过简单几百行代码，就可以完整地演示Spring AOP的核心原理，是不是很简单呢？当然，小伙伴们还是要自己动手哈亲自体验一下，这样才会印象深刻。下面，我们继续完善，将Spring AOP 1.0升级到2.0，那么2.0版本我是完全仿真Spring的原始设计来写的，希望能够给大家带来不一样的手写体验，从而更加深刻地理解Spring AOP的原理。
3 完成AOP顶层设计
3.1 GPJoinPoint
定义一个切点的抽象，这是AOP的基础组成单元。我们可以理解为这是某一个业务方法的附加信息。可想而知，切点应该包含业务方法本身、实参列表和方法所属的实例对象，还可以在GPJoinPoint中添加自定义属性，看下面的代码：
package com.tom.spring.formework.aop.aspect;
import java.lang.reflect.Method;
/**
* 回调连接点，通过它可以获得被代理的业务方法的所有信息
*/
public interface GPJoinPoint
Method getMethod(); //业务方法本身
Object[] getArguments(); //该方法的实参列表
Object getThis(); //该方法所属的实例对象
//在JoinPoint中添加自定义属性
void setUserAttribute(String key, Object value);
//从已添加的自定义属性中获取一个属性值
Object getUserAttribute(String key);
3.2 GPMethodInterceptor
方法拦截器是AOP代码增强的基本组成单元，其子类主要有GPMethodBeforeAdvice、GPAfterReturningAdvice和GPAfterThrowingAdvice。
package com.tom.spring.formework.aop.intercept;
/**
* 方法拦截器顶层接口
*/
public interface GPMethodInterceptor
Object invoke(GPMethodInvocation mi) throws Throwable;
3.3 GPAopConfig
定义AOP的配置信息的封装对象，以方便在之后的代码中相互传递。
package com.tom.spring.formework.aop;
import lombok.Data;
/**
* AOP配置封装
*/
@Data
public class GPAopConfig
//以下配置与properties文件中的属性一一对应
private String pointCut; //切面表达式
private String aspectBefore; //前置通知方法名
private String aspectAfter; //后置通知方法名
private String aspectClass; //要织入的切面类
private String aspectAfterThrow; //异常通知方法名
private String aspectAfterThrowingName; //需要通知的异常类型
3.4 GPAdvisedSupport
GPAdvisedSupport主要完成对AOP配置的解析。其中pointCutMatch()方法用来判断目标类是否符合切面规则，从而决定是否需要生成代理类，对目标方法进行增强。而getInterceptorsAndDynamic- InterceptionAdvice()方法主要根据AOP配置，将需要回调的方法封装成一个拦截器链并返回提供给外部获取。
package com.tom.spring.formework.aop.support;
import com.tom.spring.formework.aop.GPAopConfig;
import com.tom.spring.formework.aop.aspect.GPAfterReturningAdvice;
import com.tom.spring.formework.aop.aspect.GPAfterThrowingAdvice;
import com.tom.spring.formework.aop.aspect.GPMethodBeforeAdvice;
import java.lang.reflect.Method;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* 主要用来解析和封装AOP配置
*/
public class GPAdvisedSupport
private Class targetClass;
private Object target;
private Pattern pointCutClassPattern;
private transient Map<Method, List<Object>> methodCache;
private GPAopConfig config;
public GPAdvisedSupport(GPAopConfig config)
this.config = config;
public Class getTargetClass()
return targetClass;
public void setTargetClass(Class targetClass)
this.targetClass = targetClass;
parse();
public Object getTarget()
return target;
public void setTarget(Object target)
this.target = target;
public List以上是关于30个类手写Spring核心原理之AOP代码织入的主要内容，如果未能解决你的问题，请参考以下文章
#yyds干货盘点# 30个类手写Spring核心原理之动态数据源切换