三(二)、AOP配置

一、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>