一、AOP的配置（注解）

步骤一、导入jar包：

处理那5个jar包之外，还需要导入：

aopalliance
aspectjweaver
spring-aop
spring-aspects

步骤二、在配置文件中加入aop、context的命名空间

步骤三分为基于注解方式配置AOP和xml方式配置aop;

基于注解方式（本篇）

①在配置文件中加入如下配置；

1 <!-- 使AspjectJ注释起作用，自动匹配的类生成代理对象 -->

2  <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

②把横切关注点的代码都加入到切面的类中，

③切面首先是一个IOC中的bean，即加@Conponent注释

④切面需要加入@Aspect注释

⑤在类中声明各种通知：

@Before：前置通知，在方法执行前执行；
@After：后置通知，在方法执行后执行
@AfterRunning：返回通知，在方法返回结果后执行
@Afterthrowing：异常通知之后
@Around：环绕通知

二、AOP常用通知：

@Before：前置通知，在方法执行前执行；

    @Before("execution(public int lixiuming.spring.aop.impl.ArithmeticCaculator.*(int, int) )") // 作用于接口中的所有方法

    public void beforeMethod(JoinPoint joinPoint) {

        String method = joinPoint.getSignature().getName();// 方法的签名

        List<Object> args = Arrays.asList(joinPoint.getArgs());// 方法的参数

        System.out.println("the method " + method + " begins with" + args);

    }

@After：后置通知，在方法执行后执行,在后置通知中，不能访问目标方法执行的结果,如果有异常也执行，通知在异常之前；

1     @After("execution(public int lixiuming.spring.aop.impl.ArithmeticCaculator.*(int, int) )")

2     public void afterMethod(JoinPoint joinPoint) {

3         String method = joinPoint.getSignature().getName();

4         List<Object> args = Arrays.asList(joinPoint.getArgs());

5         System.out.println("the method " + method + " is end to " + args);

6     }

@AfterRunning：返回通知，在方法返回结果后执行，可以访问到返回值；

1     @AfterReturning(value = "execution(public int lixiuming.spring.aop.impl.ArithmeticCaculator.add(int, int) )", returning = "result")

2     public void afterReturn(JoinPoint joinPoint, Object result) {

3         String method = joinPoint.getSignature().getName();

4         System.out.println("the method " + method + " is end with " + result);

5     }

@Afterthrowing：异常通知之后，可以访问到异常，并且可以指定异常类型，只有符合该异常类型时才被执行

1     @AfterThrowing(value = "execution(public int lixiuming.spring.aop.impl.ArithmeticCaculator.add(int, int) )", throwing = "ex")

2     public void afterThrowing(JoinPoint joinPoint, Object ex) {

3         String method = joinPoint.getSignature().getName();

4         System.out.println("the method " + method + " occured exception: " + ex);

5     }

@Around：环绕通知；

环绕通知类似动态代理的全过程：ProceedingJoinPoint类型的参数可以决定是否执行日志方法且必须有返回值，返回值是目标方法的返回值

 1     @Around("execution(public int lixiuming.spring.aop.impl.ArithmeticCaculator.add(int, int) )")

 2     public Object aroundMethod(ProceedingJoinPoint point) {

 3         Object result = null;

 4         String method = point.getSignature().getName();

 5         // 执行目标方法

 6         try {

 7             // 前置通知

 8             System.out.println("the method " + method + " is begin with " + Arrays.asList(point.getArgs()));

 9             result = point.proceed();

10             // 返回通知

11             System.out.println("the method " + method + " is end to " + result);

12         } catch (Throwable e) {

13             // TODO Auto-generated catch block

14             System.out.println("the method " + method + " occured exception: " + e);

15             throw new RuntimeException(e);

16         }

17         System.out.println("the method " + method + " ends");

18

19         return 100;

20     }

三、切点表达式

表达式

1 execution(modifiers-pattern? ret-type-pattern declaring-type-pattern?name-pattern(param-pattern) throws-pattern?)

这里问号表示当前项可以有也可以没有，其中各项的语义如下：

modifiers-pattern：方法的可见性，如public，protected；
ret-type-pattern：方法的返回值类型，如int，void等；
declaring-type-pattern：方法所在类的全路径名，如com.spring.Aspect；
name-pattern：方法名类型，如buisinessService()；
param-pattern：方法的参数类型，如java.lang.String；
throws-pattern：方法抛出的异常类型，如java.lang.Exception；

举例说明：

//    @Before("execution(public int lixiuming.spring.aop.impl.ArithmeticCaculator.add(int, int) )")// 作用于接口中的add方法

//     @Before("execution(public int lixiuming.spring.aop.impl.ArithmeticCaculator.*(int, int) )") // 作用于接口中的所有方法 （所有方法是指public int类型的）

//    @Before("execution(* ixiuming.spring.aop.impl.ArithmeticCaculator.*(int, int) )") // 第一个* 表示：任意修饰符和任意返回值，第二个*代码任意参数为（int,int）方法

//    @Before("execution( public * ixiuming.spring.aop.impl.ArithmeticCaculator.*(..) )") // 第二个*代表任意方法；..代表任意个数的参数，即所有公有方法

//    @Before("execution( public double ixiuming.spring.aop.impl.ArithmeticCaculator.*(double.) )") // 返回所有double的第一个参数为double的public的方法

@Pointcut

使用@Pointcut 来声明切入点表达式，后面的其他通知直接使用方法名来引用当前的切入点表达式；如下代码，前置通知使用了方法名为declareJoinPointExpress来引用切点表达式；

这样做的好处是，可以统一管理切点表达式；

 1     @Pointcut("execution(public int lixiuming.spring.aop.impl.ArithmeticCaculator.*(..))")

 2     public void declareJoinPointExpress() {

 3

 4     }

 5

 6 //声明该方法是一个前置通知：在目标方法之前执行

 7     @Before("declareJoinPointExpress()")

 8     public void beforeMethod(JoinPoint joinPoint) {

 9         String method = joinPoint.getSignature().getName();

10         List<Object> args = Arrays.asList(joinPoint.getArgs());

11         System.out.println("the method " + method + " begins with" + args);

12     }

四、实例说明AOP配置：

以实现三(一)中的为ArithmeticCaculator添加各方法执行前和计算结果后的日志的AOP方案为实例；

步骤一、为ArithmeticCaculatorImpl类添加@Component 注解来表示该组件需要被sping容器管理

 1 package lixiuming.spring.aop.impl;

 2

 3 import org.springframework.stereotype.Component;

 4

 5 @Component

 6 public class ArithmeticCaculatorImpl2 implements ArithmeticCaculator {

 7

 8     @Override

 9     public int add(int i, int j) {

10         int result = i+j;

11         return result;

12     }

13

14     @Override

15     public int sub(int i, int j) {

16         int result = i-j;

17         return result;

18     }

19

20     @Override

21     public int mul(int i, int j) {

22         int result = i*j;

23         return result;

24     }

25

26     @Override

27     public int div(int i, int j) {

28         int result = i/j;

29         return result;

30     }

31

32 }

步骤二、需要添加一个切面：

关于切面声明的说明：

切面需要放置在spring 容器中；所以首先需要一个@Component注解
声明一个切面用注解 @Aspect；

为实现上述实例，需要添加一个前置通知和后置通知；前置通知即，在目标方法执行之前执行；后置通知，即在目标方法执行后执行，无论是否发生异常。

 1 package lixiuming.spring.aop.impl;

 2

 3 import java.util.Arrays;

 4 import java.util.List;

 5

 6 import org.aspectj.lang.JoinPoint;

 7 import org.aspectj.lang.annotation.After;

 8 import org.aspectj.lang.annotation.Aspect;

 9 import org.aspectj.lang.annotation.Before;

10 import org.springframework.stereotype.Component;

11

12 //把这个类声明为一个切面，需要把该类放入到IOC容器中，再声明为一个切面

13 @Aspect

14 @Component

15 public class LoggingAspect {

16     // 声明该方法是一个前置通知：在目标方法之前执行

18     @Before("execution(public int lixiuming.spring.aop.impl.ArithmeticCaculator.*(int, int) )") // 作用于接口中的所有方法

22     public void beforeMethod(JoinPoint joinPoint) {

23         String method = joinPoint.getSignature().getName();// 方法的签名

24         List<Object> args = Arrays.asList(joinPoint.getArgs());// 方法的参数

25         System.out.println("the method " + method + " begins with" + args);

26     }

27

28     // 声明后置通知：在目标方法执行后（无论是否发生异常）执行的通知

29     // 在后置通知中，不能访问目标方法执行的结果，需要在返回通知里面访问

30     @After("execution(public int lixiuming.spring.aop.impl.ArithmeticCaculator.*(int, int) )")

31     public void afterMethod(JoinPoint joinPoint) {

32         String method = joinPoint.getSignature().getName();

33         List<Object> args = Arrays.asList(joinPoint.getArgs());

34         System.out.println("the method " + method + " is end to " + args);

35     }

36

37 }

步骤三、配置文件：引入了context和aop的命名空间

 1 <?xml version="1.0" encoding="UTF-8"?>

 2 <beans xmlns="http://www.springframework.org/schema/beans"

 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

 4     xmlns:aop="http://www.springframework.org/schema/aop"

 5     xmlns:context="http://www.springframework.org/schema/context"

 6     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd

 7         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd

 8         http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd">

 9

10 <context:component-scan base-package="lixiuming.spring.aop.impl"/>

11 <!-- 使AspjectJ注释起作用，自动匹配的类生成代理对象 -->

12 <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

13 </beans>

使用main方法测试：

 1 public static void main(String[] args) {

 2         ApplicationContext cxt = new ClassPathXmlApplicationContext("ApplicationContext.xml");

 3         ArithmeticCaculator arithmeticCaculator = cxt.getBean(ArithmeticCaculator.class);

 4

 5         int result = arithmeticCaculator.add(1, 2);

 6         System.out.println("-->" + result);

 7

 8         int result1 = arithmeticCaculator.div(4, 2);

 9         System.out.println("-->" + result1);

10

11         int result2 = arithmeticCaculator.mul(4, 2);

12         System.out.println("-->" + result2);

13

14         int result3 = arithmeticCaculator.sub(4, 2);

15         System.out.println("-->" + result3);

16

17     }

测试运行结果：

the method add begins with[1, 2]

the method add is end to [1, 2]

-->3

the method div begins with[4, 2]

the method div is end to [4, 2]

-->2

the method mul begins with[4, 2]

the method mul is end to [4, 2]

-->8

the method sub begins with[4, 2]

the method sub is end to [4, 2]

-->2

步骤二中除了使用前置和后置通知，还可以使用环绕通知来实现上述功能；

代码如下：

 1 package lixiuming.spring.aop.impl;

 2

 3 import java.util.Arrays;

 4

 5 import org.aspectj.lang.ProceedingJoinPoint;

 6 import org.aspectj.lang.annotation.Around;

 7 import org.aspectj.lang.annotation.Aspect;

 8 import org.aspectj.lang.annotation.Pointcut;

 9 import org.springframework.stereotype.Component;

10

11 //把这个类声明为一个切面，需要把该类放入到IOC容器中

12 @Aspect

13 @Component

14 public class LoggingAspect {

15

16     // 定义一个方法，用于声明切入点表达式，一般该方法中不需要其他的代码

17     // 使用@Pointcut 来声明切入点表达式，

18     // 后面的其他通知直接使用方法名来引用当前的切入点表达式

19     @Pointcut("execution(public int lixiuming.spring.aop.impl.ArithmeticCaculator.*(..))")

20     public void declareJoinPointExpress() {

21

22     }

23

24     /**

25      * 环绕通知需要携带ProceedingJoinPoint类型的参数

26      * 环绕通知类似动态代理的全过程：ProceedingJoinPoint类型的参数可以决定是否执行日志方法 且必须有返回值，返回值是目标方法的返回值

27      */

28     @Around("declareJoinPointExpress()")

29     public Object aroundMethod(ProceedingJoinPoint point) {

30         Object result = null;

31         String method = point.getSignature().getName();

32         // 执行目标方法

33         try {

34             // 前置通知

35             System.out.println("the method " + method + " is begin with " + Arrays.asList(point.getArgs()));

36             result = point.proceed();

37             // 后置通知

38             System.out.println("the method " + method + " is end to " + Arrays.asList(point.getArgs()));

39         } catch (Throwable e) {

40             // TODO Auto-generated catch block

41             System.out.println("the method " + method + " occured exception: " + e);

42             throw new RuntimeException(e);

43         }

44

45         return result;

46     }

47 }

五、切面的优先级

使用@Order(index)指定执行顺序的优先级，index为数字，index越小，优先级越高；@Order位置为放置在@Aspect前面；代码如下：

@Order(1)//执行顺序的优先级

@Aspect

@Component

//验证通知

public class VlidationAspect {

    @Before("LoggingAspect.declareJoinPointExpress()")

    public void validationArgs(JoinPoint jointPoint){

        System.out.println("-->validation:"+Arrays.asList(jointPoint.getArgs()));

    }

}

六、xml方式配置AOP

ArithmeticCaculator 不变；ArithmeticCaculatorImpl移除@Component；

LoggingAspect：

 1 package lixiuming.spring.aop.impl2;

 2

 3 import java.util.Arrays;

 4 import java.util.List;

 5

 6 import org.aspectj.lang.JoinPoint;

 7 import org.aspectj.lang.ProceedingJoinPoint;

 8 import org.aspectj.lang.annotation.After;

 9 import org.aspectj.lang.annotation.AfterReturning;

10 import org.aspectj.lang.annotation.AfterThrowing;

11 import org.aspectj.lang.annotation.Around;

12 import org.aspectj.lang.annotation.Aspect;

13 import org.aspectj.lang.annotation.Before;

14 import org.aspectj.lang.annotation.Pointcut;

15 import org.springframework.stereotype.Component;

16

17 public class LoggingAspect {

18

19     public void beforeMethod(JoinPoint joinPoint){

20         String method = joinPoint.getSignature().getName();

21         List<Object> args = Arrays.asList(joinPoint.getArgs());

22         System.out.println("the method "+method+" begins with"+args);

23     }

24

25     public void afterMethod(JoinPoint joinPoint){

26         String method =  joinPoint.getSignature().getName();

27         List<Object> args = Arrays.asList(joinPoint.getArgs());

28         System.out.println("the method "+method+" is end to "+args);

29     }

30

31     /**

32      *在方法正常结束后执行的代码

33      *返回通知是可以访问到方法的返回值

34      */

35     public void afterReturn(JoinPoint joinPoint,Object result){

36         String method = joinPoint.getSignature().getName();

37         System.out.println("the method "+method+" is end with " +result);

38     }

39

40     public void afterThrowing(JoinPoint joinPoint,Object ex){

41         String method = joinPoint.getSignature().getName();

42         System.out.println("the method "+method+" occured exception: " + ex);

43     }

44

45     public Object aroundMethod(ProceedingJoinPoint point){

46         Object result = null;

47         String method = point.getSignature().getName();

48         //执行目标方法

49         try {

50             //前置通知

51             System.out.println("the method "+method+" is begin with "+Arrays.asList(point.getArgs()));

52             result = point.proceed();

53             //返回通知

54             System.out.println("the method "+method+" is end to "+ result);

55         } catch (Throwable e) {

56             // TODO Auto-generated catch block

57             System.out.println("the method "+method+" occured exception: " + e);

58             throw new RuntimeException(e);

59         }

60         System.out.println("the method "+method+" ends");

61

62         return 100;

63     }

64 }

VlidationAspect：

 1 package lixiuming.spring.aop.impl2;

 2

 3 import java.util.Arrays;

 4

 5 import org.aspectj.lang.JoinPoint;

 6 import org.aspectj.lang.annotation.Aspect;

 7 import org.aspectj.lang.annotation.Before;

 8 import org.springframework.core.annotation.Order;

 9 import org.springframework.stereotype.Component;

10 //验证通知

11 public class VlidationAspect {

12     public void validationArgs(JoinPoint jointPoint){

13         System.out.println("-->validation:"+Arrays.asList(jointPoint.getArgs()));

14     }

15

16

17 }

配置文件：

 1 <?xml version="1.0" encoding="UTF-8"?>

 2 <beans xmlns="http://www.springframework.org/schema/beans"

 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

 4     xmlns:aop="http://www.springframework.org/schema/aop"

 5     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd

 6         http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd">

 7

 8 <!-- 配置bean -->

 9 <bean id="aop" class="lixiuming.spring.aop.impl2.ArithmeticCaculatorImpl2"></bean>

10 <!-- 配置切面的bean -->

11 <bean id="LoggingAspect" class="lixiuming.spring.aop.impl2.LoggingAspect"></bean>

12 <bean id="VlidationAspect" class="lixiuming.spring.aop.impl2.VlidationAspect"></bean>

13

14 <!-- 配置AOP -->

15 <aop:config>

16     <!-- 配置切面表达式 -->

17     <aop:pointcut expression="execution(* lixiuming.spring.aop.impl2.ArithmeticCaculator.*(int,int))" id="pointcut"/>

18     <!-- 配置切面及通知 -->

19     <aop:aspect ref="LoggingAspect" order="2">

20         <aop:before method="beforeMethod" pointcut-ref="pointcut"/>

21         <aop:after method="afterMethod" pointcut-ref="pointcut"/>

22         <aop:after-throwing method="afterThrowing" pointcut-ref="pointcut" throwing="ex"/>

23         <aop:after-returning method="afterReturn" pointcut-ref="pointcut" returning="result"/>

24         <aop:around method="aroundMethod" pointcut-ref="pointcut"/>

25      </aop:aspect>

26

27      <aop:aspect ref="VlidationAspect" order="1">

28          <aop:before method="validationArgs" pointcut-ref="pointcut"/>

29       </aop:aspect>

30 </aop:config>

31 </beans>

巴特西

三(二)、AOP配置