Spring攻略筆記-8 AspectJ支持

AspectJ是主流的AOP框架，Spring在其AOP中支持AspectJ註解編寫的POJO aspect。

首先我們需要在Bean配置文件中啓用，只要使用標籤<aop:aspectj-autoproxy>

<?xml version="1.0" encoding="UTF-8"?>
<beans
	xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:p="http://www.springframework.org/schema/p"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
						http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
						http://www.springframework.org/schema/context
						http://www.springframework.org/schema/context/spring-context-3.0.xsd
						http://www.springframework.org/schema/aop
						http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
						">
						
	<!-- 添加註解功能 -->
	<context:annotation-config/>
	<!-- 添加自動掃描 -->
	<context:component-scan base-package="com.lkt.entity.*"></context:component-scan>
	<!-- 添加面向切面功能 -->
	<aop:aspectj-autoproxy/>
</beans>

然後寫一個普通的接口

package com.lkt.entity.aspectj;


public interface IArithmeticCalculator {


	public  double add(double a, double b);
	public  double sub(double a, double b);
	public  double mul(double a, double b);
	public  double div(double a, double b);


}

寫實現接口的類，添加Spring的組件註解，可以讓Spring自動掃描到

package com.lkt.entity.aspectj;


import org.springframework.stereotype.Component;


@Component
public class ArithmeticCalculator implements IArithmeticCalculator {


	
	@Override
	public double add(double a,double b){
		System.out.println("加法運算："+(a+b));
		return a+b;
	}


	@Override
	public double sub(double a, double b) {
		System.out.println("減法運算："+(a-b));
		return a-b;
	}


	@Override
	public double mul(double a, double b) {
		System.out.println("乘法運算："+(a*b));
		return a*b;
	}


	@Override
	public double div(double a, double b) {
		System.out.println("除法運算："+(a/b));
		return a/b;
	}
}

然後編寫一個aspect類，用來對ArithmeticCalculator進行前置和後置通知

package com.lkt.entity.aspectj;

import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;
@Component
@Aspect
public class LogTest {

	@Before("execution(* IArithmeticCalculator.add(..))")
	public void logBefore(){
		System.out.println("前置通知");
	}
	@AfterReturning("execution(* IArithmeticCalculator.add(..))")
	public void logAfter(){
		System.out.println("後置通知");
	}
}

@Aspect表示爲一個aspect類，@Before("execution(* IArithmeticCalculator.add(..))")，表示執行IArithmeticCalculator的add方法之前要執行這個方法，@AfterReturning爲執行結束後再執行這個方法，*代表任何修飾符，後面的兩個點表示任何數量的參數

然後我們在執行add方法的時候就會打印

前置通知
加法運算：2.0
後置通知

如果你想在執行切入方法時，想知道是執行哪個方法時調用到該切入方法的，你可以使用JoinPoint這個對象實例。

後置通知中可以在@AfterReturning註解中添加一個returning屬性，訪問連接點的返回值，用於傳入返回值。

package com.lkt.entity.aspectj;


import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;
@Component
@Aspect
public class LogTest {


	@Before("execution(* IArithmeticCalculator.*(..))")
	public void logBefore(JoinPoint jp){
		String name=jp.getSignature().getName();
		System.out.println("前置通知,方法"+name);
	}
	@AfterReturning(pointcut="execution(* IArithmeticCalculator.*(..))",returning="result")
	public void logAfterReturning(JoinPoint jp,Object result){
		String name=jp.getSignature().getName();
		System.out.println("後置通知,方法："+name+",返回值："+result);
	}
	@After("execution(* IArithmeticCalculator.*(..))")
	public void logAfter(JoinPoint jp){
		System.out.println("最終通知");
	}
}

如果感覺每次都要定義重複的切入點很麻煩時，AspectJ也提供獨立定義切入點，在多個通知中重用

package com.lkt.entity.aspectj;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
@Component
@Aspect
public class LogTest {
	@Pointcut("execution(* IArithmeticCalculator.*(..))")
	private void logginOperation(){};
	
	@Before("logginOperation()")
	public void logBefore(JoinPoint jp){
		String name=jp.getSignature().getName();
		System.out.println("前置通知,方法"+name);
	}
	@AfterReturning(pointcut="logginOperation()",returning="result")
	public void logAfterReturning(JoinPoint jp,Object result){
		String name=jp.getSignature().getName();
		System.out.println("後置通知,方法："+name+",返回值："+result);
	}
	@After("logginOperation()")
	public void logAfter(JoinPoint jp){
		System.out.println("最終通知");
	}
}

這樣每次寫切入點的時候，就可以使用logginOperation()了