本文節選自《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" ></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 = https://www.cnblogs.com/gupaoedu-tom/p/null;
advices.get("before").invoke(aspectObject);
try {
returnValue = https://www.cnblogs.com/gupaoedu-tom/p/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<Object> getInterceptorsAndDynamicInterceptionAdvice(Method method, Class<?> targetClass) throws Exception {
List<Object> cached = methodCache.get(method);
//快取未命中，則進行下一步處理
if (cached == null) {
Method m = targetClass.getMethod(method.getName(),method.getParameterTypes());
cached = methodCache.get(m);
//存入快取
this.methodCache.put(m, cached);
}
return cached;
}
public boolean pointCutMatch(){
return pointCutClassPattern.matcher(this.targetClass.toString()).matches();
}
private void parse(){
//pointCut運算式
String pointCut = config.getPointCut()
.replaceAll("\\.","\\\\.")
.replaceAll("\\\\.\\*",".*")
.replaceAll("\\(","\\\\(")
.replaceAll("\\)","\\\\)");
String pointCutForClass = pointCut.substring(0,pointCut.lastIndexOf("\\(") - 4);
pointCutClassPattern = Pattern.compile("class " + pointCutForClass.substring (pointCutForClass.lastIndexOf(" ")+1));
methodCache = new HashMap<Method, List<Object>>();
Pattern pattern = Pattern.compile(pointCut);
try {
Class aspectClass = Class.forName(config.getAspectClass());
Map<String,Method> aspectMethods = new HashMap<String,Method>();
for (Method m : aspectClass.getMethods()){
aspectMethods.put(m.getName(),m);
}
//在這里得到的方法都是原生方法
for (Method m : targetClass.getMethods()){
String methodString = m.toString();
if(methodString.contains("throws")){
methodString = methodString.substring(0,methodString.lastIndexOf("throws")).trim();
}
Matcher matcher = pattern.matcher(methodString);
if(matcher.matches()){
//能滿足切面規則的類，添加到AOP配置中
List<Object> advices = new LinkedList<Object>();
//前置通知
if(!(null == config.getAspectBefore() || "".equals(config.getAspectBefore().trim()))) {
advices.add(new GPMethodBeforeAdvice(aspectMethods.get (config.getAspectBefore()), aspectClass.newInstance()));
}
//后置通知
if(!(null == config.getAspectAfter() || "".equals(config.getAspectAfter(). trim()))) {
advices.add(new GPAfterReturningAdvice(aspectMethods.get (config.getAspectAfter()), aspectClass.newInstance()));
}
//例外通知
if(!(null == config.getAspectAfterThrow() || "".equals(config.getAspectAfterThrow().trim()))) {
GPAfterThrowingAdvice afterThrowingAdvice = new GPAfterThrowingAdvice (aspectMethods.get(config.getAspectAfterThrow()), aspectClass.newInstance());
afterThrowingAdvice.setThrowingName(config.getAspectAfterThrowingName());
advices.add(afterThrowingAdvice);
}
methodCache.put(m,advices);
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
3.5 GPAopProxy
GPAopProxy是代理工廠的頂層介面，其子類主要有兩個：GPCglibAopProxy和GPJdkDynamicAopProxy，分別實作CGlib代理和JDK Proxy代理，
package com.tom.spring.formework.aop;
/**
* 代理工廠的頂層介面，提供獲取代理物件的頂層入口
*/
//默認就用JDK動態代理
public interface GPAopProxy {
//獲得一個代理物件
Object getProxy();
//通過自定義類加載器獲得一個代理物件
Object getProxy(ClassLoader classLoader);
}
3.6 GPCglibAopProxy
本文未實作CglibAopProxy，感興趣的“小伙伴”可以自行嘗試，
package com.tom.spring.formework.aop;
import com.tom.spring.formework.aop.support.GPAdvisedSupport;
/**
* 使用CGlib API生成代理類，在此不舉例
* 感興趣的“小伙伴”可以自行實作
*/
public class GPCglibAopProxy implements GPAopProxy {
private GPAdvisedSupport config;
public GPCglibAopProxy(GPAdvisedSupport config){
this.config = config;
}
@Override
public Object getProxy() {
return null;
}
@Override
public Object getProxy(ClassLoader classLoader) {
return null;
}
}
3.7 GPJdkDynamicAopProxy
下面來看GPJdkDynamicAopProxy的實作，主要功能在invoke()方法中，從代碼量來看其實不多，主要是呼叫了GPAdvisedSupport的getInterceptorsAndDynamicInterceptionAdvice()方法獲得攔截器鏈，在目標類中，每一個被增強的目標方法都對應一個攔截器鏈，
package com.tom.spring.formework.aop;
import com.tom.spring.formework.aop.intercept.GPMethodInvocation;
import com.tom.spring.formework.aop.support.GPAdvisedSupport;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.List;
/**
* 使用JDK Proxy API生成代理類
*/
public class GPJdkDynamicAopProxy implements GPAopProxy,InvocationHandler {
private GPAdvisedSupport config;
public GPJdkDynamicAopProxy(GPAdvisedSupport config){
this.config = config;
}
//把原生的物件傳進來
public Object getProxy(){
return getProxy(this.config.getTargetClass().getClassLoader());
}
@Override
public Object getProxy(ClassLoader classLoader) {
return Proxy.newProxyInstance(classLoader,this.config.getTargetClass().getInterfaces(),this);
}
//invoke()方法是執行代理的關鍵入口
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//將每一個JoinPoint也就是被代理的業務方法（Method）封裝成一個攔截器，組合成一個攔截器鏈
List<Object> interceptorsAndDynamicMethodMatchers = config.getInterceptorsAndDynamicInterceptionAdvice(method,this.config.getTargetClass());
//交給攔截器鏈MethodInvocation的proceed()方法執行
GPMethodInvocation invocation = new GPMethodInvocation(proxy,this.config.getTarget(), method,args,this.config.getTargetClass(),interceptorsAndDynamicMethodMatchers);
return invocation.proceed();
}
}
從代碼中可以看出，從GPAdvisedSupport中獲得的攔截器鏈又被當作引數傳入GPMethodInvocation的構造方法中，那么GPMethodInvocation中到底又對方法鏈做了什么呢？
3.8 GPMethodInvocation
GPMethodInvocation的代碼如下：
package com.tom.spring.formework.aop.intercept;
import com.tom.spring.formework.aop.aspect.GPJoinPoint;
import java.lang.reflect.Method;
import java.util.List;
/**
* 執行攔截器鏈，相當于Spring中ReflectiveMethodInvocation的功能
*/
public class GPMethodInvocation implements GPJoinPoint {
private Object proxy; //代理物件
private Method method; //代理的目標方法
private Object target; //代理的目標物件
private Class<?> targetClass; //代理的目標類
private Object[] arguments; //代理的方法的實參串列
private List<Object> interceptorsAndDynamicMethodMatchers; //回呼方法鏈
//保存自定義屬性
private Map<String, Object> userAttributes;
private int currentInterceptorIndex = -1;
public GPMethodInvocation(Object proxy, Object target, Method method, Object[] arguments,
Class<?> targetClass, List<Object> interceptorsAndDynamicMethodMatchers) {
this.proxy = proxy;
this.target = target;
this.targetClass = targetClass;
this.method = method;
this.arguments = arguments;
this.interceptorsAndDynamicMethodMatchers = interceptorsAndDynamicMethodMatchers;
}
public Object proceed() throws Throwable {
//如果Interceptor執行完了，則執行joinPoint
if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
return this.method.invoke(this.target,this.arguments);
}
Object interceptorOrInterceptionAdvice =
this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
//如果要動態匹配joinPoint
if (interceptorOrInterceptionAdvice instanceof GPMethodInterceptor) {
GPMethodInterceptor mi = (GPMethodInterceptor) interceptorOrInterceptionAdvice;
return mi.invoke(this);
} else {
//執行當前Intercetpor
return proceed();
}
}
@Override
public Method getMethod() {
return this.method;
}
@Override
public Object[] getArguments() {
return this.arguments;
}
@Override
public Object getThis() {
return this.target;
}
public void setUserAttribute(String key, Object value) {
if (value != null) {
if (this.userAttributes == null) {
this.userAttributes = new HashMap<String,Object>();
}
this.userAttributes.put(key, value);
}
else {
if (this.userAttributes != null) {
this.userAttributes.remove(key);
}
}
}
public Object getUserAttribute(String key) {
return (this.userAttributes != null ? this.userAttributes.get(key) : null);
}
}
從代碼中可以看出，proceed()方法才是MethodInvocation的關鍵所在，在proceed()中，先進行判斷，如果攔截器鏈為空，則說明目標方法無須增強，直接呼叫目標方法并回傳，如果攔截器鏈不為空，則將攔截器鏈中的方法按順序執行，直到攔截器鏈中所有方法全部執行完畢，
4 設計AOP基礎實作
4.1 GPAdvice
GPAdvice作為所有回呼通知的頂層介面設計，在Mini版本中為了盡量和原生Spring保持一致，只是被設計成了一種規范，并沒有實作任何功能，
/**
* 回呼通知頂層介面
*/
public interface GPAdvice {
}
4.2 GPAbstractAspectJAdvice
使用模板模式設計GPAbstractAspectJAdvice類，封裝攔截器回呼的通用邏輯，主要封裝反射動態呼叫方法，其子類只需要控制呼叫順序即可，
package com.tom.spring.formework.aop.aspect;
import java.lang.reflect.Method;
/**
* 封裝攔截器回呼的通用邏輯，在Mini版本中主要封裝了反射動態呼叫方法
*/
public abstract class GPAbstractAspectJAdvice implements GPAdvice {
private Method aspectMethod;
private Object aspectTarget;
public GPAbstractAspectJAdvice(
Method aspectMethod, Object aspectTarget) {
this.aspectMethod = aspectMethod;
this.aspectTarget = aspectTarget;
}
//反射動態呼叫方法
protected Object invokeAdviceMethod(GPJoinPoint joinPoint,Object returnValue,Throwable ex)
throws Throwable {
Class<?> [] paramsTypes = this.aspectMethod.getParameterTypes();
if(null == paramsTypes || paramsTypes.length == 0) {
return this.aspectMethod.invoke(aspectTarget);
}else {
Object[] args = new Object[paramsTypes.length];
for (int i = 0; i < paramsTypes.length; i++) {
if(paramsTypes[i] == GPJoinPoint.class){
args[i] = joinPoint;
}else if(paramsTypes[i] == Throwable.class){
args[i] = ex;
}else if(paramsTypes[i] == Object.class){
args[i] = returnValue;
}
}
return this.aspectMethod.invoke(aspectTarget,args);
}
}
}
4.3 GPMethodBeforeAdvice
GPMethodBeforeAdvice繼承GPAbstractAspectJAdvice，實作GPAdvice和GPMethodInterceptor介面，在invoke()中控制前置通知的呼叫順序，
package com.tom.spring.formework.aop.aspect;
import com.tom.spring.formework.aop.intercept.GPMethodInterceptor;
import com.tom.spring.formework.aop.intercept.GPMethodInvocation;
import java.lang.reflect.Method;
/**
* 前置通知具體實作
*/
public class GPMethodBeforeAdvice extends GPAbstractAspectJAdvice implements GPAdvice, GPMethodInterceptor {
private GPJoinPoint joinPoint;
public GPMethodBeforeAdvice(Method aspectMethod, Object target) {
super(aspectMethod, target);
}
public void before(Method method, Object[] args, Object target) throws Throwable {
invokeAdviceMethod(this.joinPoint,null,null);
}
public Object invoke(GPMethodInvocation mi) throws Throwable {
this.joinPoint = mi;
this.before(mi.getMethod(), mi.getArguments(), mi.getThis());
return mi.proceed();
}
}
4.4 GPAfterReturningAdvice
GPAfterReturningAdvice繼承GPAbstractAspectJAdvice，實作GPAdvice和GPMethodInterceptor介面，在invoke()中控制后置通知的呼叫順序，
package com.tom.spring.formework.aop.aspect;
import com.tom.spring.formework.aop.intercept.GPMethodInterceptor;
import com.tom.spring.formework.aop.intercept.GPMethodInvocation;
import java.lang.reflect.Method;
/**
* 后置通知具體實作
*/
public class GPAfterReturningAdvice extends GPAbstractAspectJAdvice implements GPAdvice, GPMethodInterceptor {
private GPJoinPoint joinPoint;
public GPAfterReturningAdvice(Method aspectMethod, Object target) {
super(aspectMethod, target);
}
@Override
public Object invoke(GPMethodInvocation mi) throws Throwable {
Object retVal = mi.proceed();
this.joinPoint = mi;
this.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());
return retVal;
}
public void afterReturning(Object returnValue, Method method, Object[] args,Object target) throws Throwable{
invokeAdviceMethod(joinPoint,returnValue,null);
}
}
4.5 GPAfterThrowingAdvice
GPAfterThrowingAdvice繼承GPAbstractAspectJAdvice，實作GPAdvice和GPMethodInterceptor介面，在invoke()中控制例外通知的呼叫順序，
package com.tom.spring.formework.aop.aspect;
import com.tom.spring.formework.aop.intercept.GPMethodInterceptor;
import com.tom.spring.formework.aop.intercept.GPMethodInvocation;
import java.lang.reflect.Method;
/**
* 例外通知具體實作
*/
public class GPAfterThrowingAdvice extends GPAbstractAspectJAdvice implements GPAdvice, GPMethodInterceptor {
private String throwingName;
private GPMethodInvocation mi;
public GPAfterThrowingAdvice(Method aspectMethod, Object target) {
super(aspectMethod, target);
}
public void setThrowingName(String name) {
this.throwingName = name;
}
@Override
public Object invoke(GPMethodInvocation mi) throws Throwable {
try {
return mi.proceed();
}catch (Throwable ex) {
invokeAdviceMethod(mi,null,ex.getCause());
throw ex;
}
}
}
感興趣的“小伙伴”可以參看Spring原始碼，自行實作環繞通知的呼叫邏輯，
4.6 接入getBean()方法
在上面的代碼中，我們已經完成了Spring AOP模塊的核心功能，那么接下如何集成到IoC容器中去呢？找到GPApplicationContext的getBean()方法，我們知道getBean()中負責Bean初始化的方法其實就是instantiateBean()，在初始化時就可以確定是否回傳原生Bean或Proxy Bean，代碼實作如下：
//傳一個BeanDefinition，回傳一個實體Bean
private Object instantiateBean(GPBeanDefinition beanDefinition){
Object instance = null;
String className = beanDefinition.getBeanClassName();
try{
//因為根據Class才能確定一個類是否有實體
if(this.singletonBeanCacheMap.containsKey(className)){
instance = this.singletonBeanCacheMap.get(className);
}else{
Class<?> clazz = Class.forName(className);
instance = clazz.newInstance();
GPAdvisedSupport config = instantionAopConfig(beanDefinition);
config.setTargetClass(clazz);
config.setTarget(instance);
if(config.pointCutMatch()) {
instance = createProxy(config).getProxy();
}
this.factoryBeanObjectCache.put(className,instance);
this.singletonBeanCacheMap.put(beanDefinition.getFactoryBeanName(),instance);
}
return instance;
}catch (Exception e){
e.printStackTrace();
}
return null;
}
private GPAdvisedSupport instantionAopConfig(GPBeanDefinition beanDefinition) throws Exception{
GPAopConfig config = new GPAopConfig();
config.setPointCut(reader.getConfig().getProperty("pointCut"));
config.setAspectClass(reader.getConfig().getProperty("aspectClass"));
config.setAspectBefore(reader.getConfig().getProperty("aspectBefore"));
config.setAspectAfter(reader.getConfig().getProperty("aspectAfter"));
config.setAspectAfterThrow(reader.getConfig().getProperty("aspectAfterThrow"));
config.setAspectAfterThrowingName(reader.getConfig().getProperty("aspectAfterThrowingName"));
return new GPAdvisedSupport(config);
}
private GPAopProxy createProxy(GPAdvisedSupport config) {
Class targetClass = config.getTargetClass();
if (targetClass.getInterfaces().length > 0) {
return new GPJdkDynamicAopProxy(config);
}
return new GPCglibAopProxy(config);
}
從上面的代碼中可以看出，在instantiateBean()方法中呼叫createProxy()決定代理工廠的呼叫策略，然后呼叫代理工廠的proxy()方法創建代理物件，最終代理物件將被封裝到BeanWrapper中并保存到IoC容器，
5 織入業務代碼
通過前面的代碼撰寫，所有的核心模塊和底層邏輯都已經實作，“萬事俱備，只欠東風，”接下來，該是“見證奇跡的時刻了”，我們來織入業務代碼，做一個測驗，創建LogAspect類，實作對業務方法的監控，主要記錄目標方法的呼叫日志，獲取目標方法名、實參串列、每次呼叫所消耗的時間，
5.1 LogAspect
LogAspect的代碼如下：
package com.tom.spring.demo.aspect;
import com.tom.spring.formework.aop.aspect.GPJoinPoint;
import lombok.extern.slf4j.Slf4j;
import java.util.Arrays;
/**
* 定義一個織入的切面邏輯，也就是要針對目標代理物件增強的邏輯
* 本類主要完成對方法呼叫的監控，監聽目標方法每次執行所消耗的時間
*/
@Slf4j
public class LogAspect {
//在呼叫一個方法之前，執行before()方法
public void before(GPJoinPoint joinPoint){
joinPoint.setUserAttribute("startTime_" + joinPoint.getMethod().getName(),System.currentTimeMillis());
//這個方法中的邏輯是由我們自己寫的
log.info("Invoker Before Method!!!" +
"\nTargetObject:" + joinPoint.getThis() +
"\nArgs:" + Arrays.toString(joinPoint.getArguments()));
}
//在呼叫一個方法之后，執行after()方法
public void after(GPJoinPoint joinPoint){
log.info("Invoker After Method!!!" +
"\nTargetObject:" + joinPoint.getThis() +
"\nArgs:" + Arrays.toString(joinPoint.getArguments()));
long startTime = (Long) joinPoint.getUserAttribute("startTime_" + joinPoint.getMethod().getName());
long endTime = System.currentTimeMillis();
System.out.println("use time :" + (endTime - startTime));
}
public void afterThrowing(GPJoinPoint joinPoint, Throwable ex){
log.info("出現例外" +
"\nTargetObject:" + joinPoint.getThis() +
"\nArgs:" + Arrays.toString(joinPoint.getArguments()) +
"\nThrows:" + ex.getMessage());
}
}
通過上面的代碼可以發現，每一個回呼方法都加了一個引數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()方法添加了拋出例外的功能，看下面的代碼實作：
package com.tom.spring.demo.service;
/**
* 增、刪、改業務
*/
public interface IModifyService {
/**
* 增加
*/
String add(String name, String addr) throws Exception;
/**
* 修改
*/
String edit(Integer id, String name);
/**
* 洗掉
*/
String remove(Integer id);
}
5.3 ModifyService
ModifyService的代碼如下：
package com.tom.spring.demo.service.impl;
import com.tom.spring.demo.service.IModifyService;
import com.tom.spring.formework.annotation.GPService;
/**
* 增、刪、改業務
*/
@GPService
public class ModifyService implements IModifyService {
/**
* 增加
*/
public String add(String name,String addr) throws Exception {
throw new Exception("故意拋出例外，測驗切面通知是否生效");
// return "modifyService add,name=" + name + ",addr=" + addr;
}
/**
* 修改
*/
public String edit(Integer id,String name) {
return "modifyService edit,id=" + id + ",name=" + name;
}
/**
* 洗掉
*/
public String remove(Integer id) {
return "modifyService id=" + id;
}
}
6 運行效果演示
在瀏覽器中輸入 http://localhost/web/add.json?name=Tom&addr=HunanChangsha ，就可以直觀明了地看到Service層拋出的例外資訊，如下圖所示，
控制臺輸出如下圖所示，
通過控制臺輸出，可以看到例外通知成功捕獲例外資訊，觸發了GPMethodBeforeAdvice 和GPAfterThrowingAdvice，而并未觸發GPAfterReturningAdvice，符合我們的預期，
下面再做一個測驗，輸入 http://localhost/web/query.json?name=Tom ，結果如下圖所示：
控制臺輸出如下圖所示：
通過控制臺輸出可以看到，分別捕獲了前置通知、后置通知，并列印了相關資訊，符合我們的預期，
至此AOP模塊大功告成，是不是有一種小小的成就感，躍躍欲試？在整個Mini版本實作中有些細節沒有過多考慮，更多的是希望給“小伙伴們”提供一種學習原始碼的思路，手寫原始碼不是為了重復造輪子，也不是為了裝“高大上”，其實只是我們推薦給大家的一種學習方式，
本文為“Tom彈架構”原創，轉載請注明出處，技術在于分享，我分享我快樂！
如果本文對您有幫助，歡迎關注和點贊；如果您有任何建議也可留言評論或私信，您的支持是我堅持創作的動力，
原創不易，堅持很酷，都看到這里了，小伙伴記得點贊、收藏、在看，一鍵三連加關注！如果你覺得內容太干，可以分享轉發給朋友滋潤滋潤！
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/380815.html
標籤：Java