spring AOP编程--AspectJ注解方式

1. AOP 简介


2. AOP的术语和图形表达





通知：

　　前置通知(before advice)：在切入点之前执行。

　　后置通知(after returning advice)：在切入点执行完成后，执行通知。无论是否抛出异常，都会执行。在后置通知中不能访问方法返回的结果

　　环绕通知(around advice)：包围切入点，调用方法前后完成自定义行为。

　　异常通知(after throwing advice)：在切入点抛出异常后，执行通知。

方式一、aspectj注解：

1、需要引入一个




2、ArithmeticCalculator.java

package com.proc;

public interface ArithmeticCalculator {
int add(int i, int j);
int sub(int i, int j);

int mul(int i, int j);
int div(int i, int j);
}

3、ArithmeticCalculatorImpl.java

package com.proc;
import org.springframework.stereotype.Component;

@Component("arithmeticCalculator")
public class ArithmeticCalculatorImpl implements ArithmeticCalculator{
public int add(int i, int j) {
int result = i + j;
return result;
}

public int sub(int i, int j) {
int result = i - j;
return result;
}

public int mul(int i, int j) {
int result = i * j;
return result;
}

public int div(int i, int j) {
int result = i / j;
return result;
}
}

4、LoggingAspect.java

package com.proc;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class LoggingAspect {

@Before("execution(* *.*(int,int))")
public void beforeMethod(JoinPoint point){
System.out.println("正在执行方法： "+point.getSignature().getName());
}
}

　　这是一个日志切面类，该类首先是一个IoC中的bean，通过@Component将bean交个容器管理，然后@Aspect声明这是一个切面。

　　@Before是通知时机，表示在调用方法之前通知。 里面字符串格式为execution (访问修饰符 返回类型 包名.类名.方法名(参数类型...))。

　　beforeMethod是定一个的一个切面执行的方法，方法名可以任意指定。可以不带参数，也可以指定一个JoinPoint连接点的参数。

配置

<context:component-scan base-package="com.proc" />
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

　　aop:aspectj-autoproxy：使得@Aspect注解生效

测试代码：

ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
ArithmeticCalculator calc=(ArithmeticCalculator) ctx.getBean("arithmeticCalculator");
System.out.println(calc.add(3, 5));
System.out.println(calc.sub(3, 5));
System.out.println(calc.mul(6, 2));
System.out.println(calc.div(6, 2));

输出结果

正在执行方法add
8
正在执行方法sub
-2
正在执行方法mul
12
正在执行方法div
3

上面方法是用的前置通知。下面我们讲解一下后置通知、返回通知、异常通知和环绕通知

☆后置通知

　　后置通知无论方法是否抛出异常，都会执行。在后置通知中不能访问返回结果，因为可能会出现异常，就没有返回值

@After("execution(* *.*(int,int))")
public void afterMethod(JoinPoint point){
System.out.println("方法执行结束： "+point.getSignature().getName());
}

☆返回通知

　　当方法有异常时，不会执行返回通知，只有在方法正常执行结束才能够执行返回通知。在结果通知中用参数returning来指定接收返回结果对象的名称，直接传递给下面方法中对应的参数

@AfterReturning(value="execution(* *.*(int,int))",returning="retVal")
public void afterReturningMethod(JoinPoint point,Object retVal){
System.out.println("方法： "+point.getSignature().getName()+"执行结果为："+retVal);
}

☆异常通知

　　当方法有异常时，才会执行返回异常通知

@AfterThrowing(value="execution(* *.*(int,int))",throwing="ex")
public void afterThrowingMethod(JoinPoint point,Exception ex){
System.out.println("执行方法： "+point.getSignature().getName()+"出现了异常："+ex.getMessage());
}

【注意】：在指定异常类型时，只能捕获到该类型或子类型的异常。比如指定NullPointerException异常，就只能捕获空指针异常，所以，我们可以指定为异常的父类型。

☆环绕通知

　　环绕通知是一个比较强大，但相对复杂一点的通知，我们通常不使用

@Around("execution(* *.*(int,int))")
public Object aroundMethod(ProceedingJoinPoint point){

System.out.println("环绕通知： "+point.getSignature().getName());
Object result=null;
//这里相当于前置通知
try {
//执行方法
result= point.proceed();
//这里相当于结果通知
} catch (Throwable e) {
//这里相当于异常通知
e.printStackTrace();

}
//这里相当于后置通知
System.out.println("环绕通知： "+point.getSignature().getName());
return result;
}

【注意】：环绕通知要求有一个返回值point.proceed()执行方法，并提供一个返回值