Small Spring系列八：aop (一)
摘要：
路漫漫其修遠兮 吾將上下而求索。
概述
我們終於不辱使命完成了 Spring 的註解注入，接下來我們要實現更為關鍵 aop 部分，在這開始之前你需要了解什麼事 aop 以及 aop 的常用術語，參考 連結
準備工作
bean-v5.xml
我們使用 xml ...
路漫漫其修遠兮 吾將上下而求索。
概述
我們終於不辱使命完成了 Spring 的註解注入，接下來我們要實現更為關鍵 aop 部分，在這開始之前你需要了解什麼事 aop 以及 aop 的常用術語，參考 連結
準備工作
bean-v5.xml
我們使用 xml 配置的方式實現aop
<?xml version="1.0" encoding="UTF-8"?> <!-- 增加namespace--> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop"> <!-- 掃描哪個包下面的檔案 --> <context:component-scan base-package="com.niocoder.dao.v5,com.niocoder.service.v5"> </context:component-scan> <!-- 模擬 TransactionManager--> <bean id="tx" class="com.niocoder.tx.TransactionManager"/> <!-- aop 配置--> <aop:config> <!-- aop 核心配置 依賴tx--> <aop:aspect ref="tx"> <!-- 切入點配置 包下面的placeOrder 方法--> <aop:pointcut id="placeOrder" expression="execution(* com.niocoder.service.v5.*.placeOrder(..))"/> <!-- 通知配置，--> <aop:before pointcut-ref="placeOrder" method="start"/> <aop:after-returning pointcut-ref="placeOrder" method="commit"/> <aop:after-throwing pointcut-ref="placeOrder" method="rollback"/> </aop:aspect> </aop:config> </beans>
AccountDao
package com.niocoder.dao.v5;
import com.niocoder.stereotype.Component;
@Component
public class AccountDao {
}
ItemDao
package com.niocoder.dao.v5;
import com.niocoder.stereotype.Component;
@Component
public class ItemDao {
}
NioCoderService
新增 placeOrder 方法用於測試 aop , MessageTracker 用於測試 TransactionManager 是否執行。
package com.niocoder.service.v5;
import com.niocoder.beans.factory.Autowired;
import com.niocoder.dao.v5.AccountDao;
import com.niocoder.dao.v5.ItemDao;
import com.niocoder.stereotype.Component;
import com.niocoder.util.MessageTracker;
@Component("nioCoder")
public class NioCoderService {
@Autowired
AccountDao accountDao;
@Autowired
ItemDao itemDao;
public NioCoderService() {
}
public AccountDao getAccountDao() {
return accountDao;
}
public ItemDao getItemDao() {
return itemDao;
}
public void placeOrder() {
System.out.println("place order");
MessageTracker.addMsg("place order");
}
}
MessageTracker
工具類用於記錄 msg
package com.niocoder.util;
import java.util.ArrayList;
import java.util.List;
/**
* 記錄msg
*/
public class MessageTracker {
private static List<String> MESSAGES = new ArrayList<>();
public static void addMsg(String msg) {
MESSAGES.add(msg);
}
public static void clearMsgs() {
MESSAGES.clear();
}
public static List<String> getMsgs() {
return MESSAGES;
}
}
TransactionManager
模擬事務的執行。
package com.niocoder.tx;
import com.niocoder.util.MessageTracker;
import org.junit.Before;
/**
* 用於測試AOP順序
*/
public class TransactionManager {
@Before
public void setUp() {
MessageTracker.clearMsgs();
}
public void start() {
System.out.println("start tx");
MessageTracker.addMsg("start tx");
}
public void commit() {
System.out.println("commit tx");
MessageTracker.addMsg("commit tx");
}
public void rollback() {
System.out.println("rollback tx");
}
}
Pointcut
<aop:pointcut id="placeOrder" expression="execution(* com.niocoder.service.v5.*.placeOrder(..))"/>
我們先從最簡單的 Pointcut 開始,很明顯我們需要一個類來表達這個概念。當給定一個類的方法，判斷該方法是否符合 pointcut 的表示式。設計類圖如下: 
關於 expression 表示式的解析，我們使用 org.aspectj.aspectjweaver 來實現。所以需要在 pom.xml 中新增依賴
<dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.8.13</version> </dependency>
MethodMatcher
給定一個類的方法，判斷是否匹配。
package com.niocoder.aop;
import java.lang.reflect.Method;
public interface MethodMatcher {
/**
* 給定一個方法判斷是否匹配
*
* @param method
* @return
*/
boolean matches(Method method /*,Class<?> targetClass*/);
}
Pointcut
獲取 expression 和 MethodMatcher 。
package com.niocoder.aop;
public interface Pointcut {
/**
* 獲取MethodMatcher 判斷方法時候匹配
*
* @return
*/
MethodMatcher getMethodMatcher();
/**
* 獲取expression表示式
*
* @return
*/
String getExpression();
}
AspectJExpressionPointcut
實現 MethodMatcher 和 Pointcut ,使用 aspectj 實現。
package com.niocoder.aop.aspectj;
import com.niocoder.aop.MethodMatcher;
import com.niocoder.aop.Pointcut;
import com.niocoder.util.ClassUtils;
import com.niocoder.util.StringUtils;
import org.aspectj.weaver.reflect.ReflectionWorld;
import org.aspectj.weaver.tools.*;
import java.lang.reflect.Method;
import java.util.HashSet;
import java.util.Set;
public class AspectJExpressionPointcut implements Pointcut, MethodMatcher {
private static final Set<PointcutPrimitive> SUPPORTED_PRIMITIVES = new HashSet<PointcutPrimitive>();
static {
SUPPORTED_PRIMITIVES.add(PointcutPrimitive.EXECUTION);
SUPPORTED_PRIMITIVES.add(PointcutPrimitive.ARGS);
SUPPORTED_PRIMITIVES.add(PointcutPrimitive.REFERENCE);
SUPPORTED_PRIMITIVES.add(PointcutPrimitive.THIS);
SUPPORTED_PRIMITIVES.add(PointcutPrimitive.TARGET);
SUPPORTED_PRIMITIVES.add(PointcutPrimitive.WITHIN);
SUPPORTED_PRIMITIVES.add(PointcutPrimitive.AT_ANNOTATION);
SUPPORTED_PRIMITIVES.add(PointcutPrimitive.AT_WITHIN);
SUPPORTED_PRIMITIVES.add(PointcutPrimitive.AT_ARGS);
SUPPORTED_PRIMITIVES.add(PointcutPrimitive.AT_TARGET);
}
/**
* 條件表示式 即 expression="execution(* com.niocoder.service.v5.*.placeOrder(..))"
*/
private String expression;
private PointcutExpression pointcutExpression;
private ClassLoader pointcutClassLoader;
public AspectJExpressionPointcut() {
}
@Override
public MethodMatcher getMethodMatcher() {
return this;
}
@Override
public String getExpression() {
return this.expression;
}
public void setExpression(String expression) {
this.expression = expression;
}
@Override
public boolean matches(Method method/*, Class<?> targetClass*/) {
// 判斷是否設定條件表示式
checkReadyToMatch();
// 根據傳入的method 返回shadowatch
ShadowMatch shadowMatch = getShadowMatch(method);
// 判斷是否匹配
if (shadowMatch.alwaysMatches()) {
return true;
}
return false;
}
private ShadowMatch getShadowMatch(Method method) {
ShadowMatch shadowMatch = null;
try {
shadowMatch = this.pointcutExpression.matchesMethodExecution(method);
} catch (ReflectionWorld.ReflectionWorldException ex) {
throw new RuntimeException("not implemented yet");
}
return shadowMatch;
}
private void checkReadyToMatch() {
if (getExpression() == null) {
throw new IllegalStateException("Must set property 'expression' before attempting to match");
}
if (this.pointcutExpression == null) {
this.pointcutClassLoader = ClassUtils.getDefaultClassLoader();
this.pointcutExpression = buildPointcutExpression(this.pointcutClassLoader);
}
}
private PointcutExpression buildPointcutExpression(ClassLoader classLoader) {
PointcutParser parser = PointcutParser
.getPointcutParserSupportingSpecifiedPrimitivesAndUsingSpecifiedClassLoaderForResolution(
SUPPORTED_PRIMITIVES, classLoader);
return parser.parsePointcutExpression(replaceBooleanOperators(getExpression()),
null, new PointcutParameter[0]);
}
private String replaceBooleanOperators(String pcExpr) {
String result = StringUtils.replace(pcExpr, " and ", " && ");
result = StringUtils.replace(result, " or ", " || ");
result = StringUtils.replace(result, " not ", " ! ");
return result;
}
}
PointcutTest
測試 Pointcut 。
public class PointcutTest {
@Test
public void testPointCutTest() throws Exception {
String expression = "execution(* com.niocoder.service.v5.*.placeOrder(..))";
AspectJExpressionPointcut pc = new AspectJExpressionPointcut();
pc.setExpression(expression);
MethodMatcher mm = pc.getMethodMatcher();
{
Class<?> targetClass = NioCoderService.class;
Method placeOrder = targetClass.getMethod("placeOrder");
Assert.assertTrue(mm.matches(placeOrder));
Method getAccountDao = targetClass.getMethod("getAccountDao");
Assert.assertFalse(mm.matches(getAccountDao));
}
{
Class<?> targetClass = com.niocoder.service.v4.NioCoderService.class;
Method placeOrder = targetClass.getMethod("getAccountDao");
Assert.assertFalse(mm.matches(placeOrder));
}
}
}
我們已經實現了一個簡單 Pointcut 表示式，關於更多 Pointcut 可以參考 連結
定位Method
<!-- 模擬 TransactionManager--> <bean id="tx" class="com.niocoder.tx.TransactionManager"/> <!-- aop 配置--> <aop:config> <!-- aop 核心配置 依賴tx--> <aop:aspect ref="tx"> <!-- 通知配置，--> <aop:before pointcut-ref="placeOrder" method="start"/> </aop:aspect> </aop:config>
在 aop 中，我們需要根據 beanName 為 tx ，方法名稱為 start 來定位到 TransactionManager.start() 方法。因此我們需要一個類，根據 targetBeanName 和 methodName 返回 Method 物件。因需要根據 beanName 返回物件，所以在此類中需要設定 BeanFactory ,並在 BeanFactory 中新增 Class<?> getType(String name) 方法。
BeanFactory
新增 Class<?> getType(String name) 方法，根據 beanName 返回 Class 物件。
package com.niocoder.beans.factory;
/**
* 建立bean的例項
*
* @author zhenglongfei
*/
public interface BeanFactory {
/**
* 獲取bean的例項
*
* @param beanId
* @return
*/
Object getBean(String beanId);
/**
* 根據bean 名稱 返回 class 物件
*
* @param name
* @return
*/
Class<?> getType(String name) throws NoSuchBeanDefinitionException;
}
DefaultBeanFactory
DefaultBeanFactory 中實現 getType 方法。
public class DefaultBeanFactory extends DefaultSingletonBeanRegistry implements ConfigurableBeanFactory, BeanDefinitionRegistry {
.......
@Override
public Class<?> getType(String name) throws NoSuchBeanDefinitionException {
BeanDefinition bd = this.getBeanDefinition(name);
if (null == bd) {
throw new NoSuchBeanDefinitionException(name);
}
resolveBeanClass(bd);
return bd.getBeanClass();
}
}
AbstractApplicationContext
因為 ApplicationContext 繼承 BeanFactory 介面，所以在抽象類 AbstractApplicationContext 也需要實現 getType 方法。
public abstract class AbstractApplicationContext implements ApplicationContext{
@Override
public Class<?> getType(String name) throws NoSuchBeanDefinitionException {
return this.factory.getType(name);
}
}
MethodLocatingFactory
根據 targetBeanName 和 methodName 返回 Method 物件。
package com.niocoder.aop.config;
import com.niocoder.beans.BeanUtils;
import com.niocoder.beans.factory.BeanFactory;
import com.niocoder.util.StringUtils;
import java.lang.reflect.Method;
public class MethodLocatingFactory {
private String targetBeanName;
private String methodName;
private Method method;
public void setTargetBeanName(String targetBeanName) {
this.targetBeanName = targetBeanName;
}
public void setMethodName(String methodName) {
this.methodName = methodName;
}
/**
* 設定beanFactory 只有beanFactory才能根據bean的名稱返回bean的class 物件
* 設定時需要前置判斷，beanName 和 methodName
*
* @param beanFactory
*/
public void setBeanFactory(BeanFactory beanFactory) {
if (!StringUtils.hasText(this.targetBeanName)) {
throw new IllegalArgumentException("Property 'targetBeanName' is required");
}
if (!StringUtils.hasText(this.methodName)) {
throw new IllegalArgumentException("Property 'methodName' is required");
}
Class<?> beanClass = beanFactory.getType(this.targetBeanName);
if (beanClass == null) {
throw new IllegalArgumentException("Can't determine type of bean with name '" + this.targetBeanName + "'");
}
// 給method 賦值
this.method = BeanUtils.resolveSignature(this.methodName, beanClass);
if (this.method == null) {
throw new IllegalArgumentException("Unable to locate method [" + this.methodName +
"] on bean [" + this.targetBeanName + "]");
}
}
/**
* 返回Method物件
*
* @return
*/
public Method getObject() {
return this.method;
}
}
MethodLocatingFactoryTest
測試 MethodLocatingFactory 。
public class MethodLocatingFactoryTest {
@Test
public void testGetMethod() throws Exception {
DefaultBeanFactory factory = new DefaultBeanFactory();
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(factory);
reader.loadBeanDefinition(new ClassPathResource("bean-v5.xml"));
MethodLocatingFactory methodLocatingFactory = new MethodLocatingFactory();
methodLocatingFactory.setTargetBeanName("tx");
methodLocatingFactory.setMethodName("start");
methodLocatingFactory.setBeanFactory(factory);
Method start = methodLocatingFactory.getObject();
Assert.assertTrue(TransactionManager.class.equals(start.getDeclaringClass()));
Assert.assertTrue(start.equals(TransactionManager.class.getMethod("start")));
TransactionManager tx = (TransactionManager) factory.getBean("tx");
start.invoke(tx);
}
}