用 AspectJ 注解声明切面：
- 要在 Spring 中声明 AspectJ 切面 , 只需要在 IOC 容器中将切面声明为 bean 实例。当在 Spring IOC 容器中初始化 AsjectJ 切面之后 , Spring IOC 容器就会为那些与 AspectJ 切面相匹配的 bean 创建代理。
- 在 ApectJ 注解中 , 切面只是一个带有 @Asject 注解的 Java 类。
- 通知是标注有某种注解的简单的 Java 方法。
- AspectJ 支持 5 种类型的通知注解：
- @Before：前置通知 , 在方法执行之前执行。
- @After：后置通知 , 在方法执行之后执行。
- @AfterReturning：返回通知 , 在方法返回结果之后执行。
- @AfterThrowing：异常通知 , 在方法抛出异常之后。
- @Around：环绕通知 , 围绕着方法执行。
前置通知：
<?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:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> <!-- IOC 扫描包 -->
<context:component-scan base-package="com.itdoc.spring.aop.impl"></context:component-scan>
<!-- 使 AspectJ 注解起作用, 自动为匹配的类生成代理对象 -->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy> </beans>
注意：一定要添加 aop 命名空间。
package com.itdoc.spring.aop.impl; import org.springframework.stereotype.Component; /**
* http://www.cnblogs.com/goodcheap
*
* @author: Wáng Chéng Dá
* @create: 2017-03-03 19:34
*/
@Component
public interface Arithmetic { int add(int i, int j); int sub(int i, int j); int mul(int i, int j); int div(int i, int j); }
package com.itdoc.spring.aop.impl; import org.springframework.stereotype.Component; /**
* http://www.cnblogs.com/goodcheap
*
* @author: Wáng Chéng Dá
* @create: 2017-03-03 19:35
*/
@Component("arithmetic")
public class ArithmeticImpl implements Arithmetic {
@Override
public int add(int i, int j) {
int result = i + j;
return result;
} @Override
public int sub(int i, int j) {
int result = i - j;
return result;
} @Override
public int mul(int i, int j) {
int result = i * j;
return result;
} @Override
public int div(int i, int j) {
int result = i / j;
return result;
}
}
package com.itdoc.spring.aop.impl; import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component; import java.util.Arrays; /**
* http://www.cnblogs.com/goodcheap
* 声明为一个切面的类: 需要把该类放到 IOC 容器中, 再声明为一个切面。
* @author: Wáng Chéng Dá
* @create: 2017-03-03 21:37
*/
@Aspect
@Component
public class LoggingAspect { //声明该方法为前置通知: 在目标方法执行之前开始执行。
@Before("execution(* com.itdoc.spring.aop.impl.*.*(..))")
public void beforeMethod(JoinPoint joinPoint) {
Object methodName = joinPoint.getSignature().getName();
Object args = Arrays.asList(joinPoint.getArgs());
System.out.println("The method " + methodName + " begins with " + args);
}
}
@Before("execution(* com.itdoc.spring.aop.impl.*.*(..))")
- 第一颗 * ：代表任意修饰符 , 任意返回值。
- 第二颗 * ：代表任意对象。
- 第三颗 * ：代表任意方法。
- 最后的 .. ：代表任意参数。
注意：在 AspectJ 中 , 切点表达式可以通过操作符 && , || , ! 结合起来。
package com.itdoc.spring.aop.impl; import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext; /**
* http://www.cnblogs.com/goodcheap
*
* @author: Wáng Chéng Dá
* @create: 2017-03-03 21:32
*/
public class Main { public static void main(String[] args) { ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
Arithmetic arithmetic = (Arithmetic) ctx.getBean("arithmetic");
System.out.println("result = " + arithmetic.add(9, 5));
System.out.println("result = " + arithmetic.sub(9, 5));
}
}
控制台输出：
|
The method add begins with [9, 5] |
后置通知：
- 后置通知是在连接点完成之后执行的 , 即连接点返回结果或者抛出异常的时候。
- 一个切面可以包括一个或者多个通知。
package com.itdoc.spring.aop.impl; import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component; import java.util.Arrays; /**
* http://www.cnblogs.com/goodcheap
* 声明为一个切面的类: 需要把该类放到 IOC 容器中, 再声明为一个切面。
* @author: Wáng Chéng Dá
* @create: 2017-03-03 21:37
*/
@Aspect
@Component
public class LoggingAspect { //声明该方法为前置通知: 在目标方法执行之前开始执行。
@Before("execution(* com.itdoc.spring.aop.impl.*.*(..))")
public void beforeMethod(JoinPoint joinPoint) {
Object methodName = joinPoint.getSignature().getName();
Object args = Arrays.asList(joinPoint.getArgs());
System.out.println("The method " + methodName + " begins with " + args);
} //声明该方法为后置通知: 在目标方法执行之后(无论是否发生异常)开始执行。
@After("execution(* com.itdoc.spring.aop.impl.*.*(..))")
public void afterMethod(JoinPoint joinPoint) {
Object methodName = joinPoint.getSignature().getName();
Object args = Arrays.asList(joinPoint.getArgs());
System.out.println("The method " + methodName + " ends with " + args);
}
}
package com.itdoc.spring.aop.impl; import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext; /**
* http://www.cnblogs.com/goodcheap
*
* @author: Wáng Chéng Dá
* @create: 2017-03-03 21:32
*/
public class Main { public static void main(String[] args) { ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
Arithmetic arithmetic = (Arithmetic) ctx.getBean("arithmetic");
System.out.println("result = " + arithmetic.add(9, 5));
System.out.println("result = " + arithmetic.div(9, 0));
}
}
控制台输出：
|
Exception in thread "main" java.lang.ArithmeticException: / by zero |
返回通知：
无论连接点是正常返回还是抛出异常 , 后置通知都会执行。如果只想在连接点返回的时候记录日志 , 应使用返回通知代替后置通知。
package com.itdoc.spring.aop.circular; import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component; /**
* 通知
* http://www.cnblogs.com/goodcheap
*
* @author: Wáng Chéng Dá
* @create: 2017-03-04 9:50
*/
@Aspect
@Component
public class AsjectLogging { /**
* 在方法正常结束后执行代码。
* 返回通知是可以访问到方法的返回值的。
*/
@AfterReturning(value = "execution(* com.itdoc.spring.aop.circular.*.*(..))", returning = "result")
public void afterReturning(JoinPoint joinPoint, Object result) {
Object methodName = joinPoint.getSignature().getName();
System.out.println("The method " + methodName + " ends with " + result);
}
}
异常通知：
package com.itdoc.spring.aop.circular; import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component; /**
* 通知
* http://www.cnblogs.com/goodcheap
*
* @author: Wáng Chéng Dá
* @create: 2017-03-04 9:50
*/
@Aspect
@Component
public class AsjectLogging { /**
* 在目标方法出现异常时候执行的代码。
* 可以访问到异常对象, 且可以指定在出现特定异常时再执行的代码。
*/
@AfterThrowing(value = "execution(* com.itdoc.spring.aop.circular.*.*(..))", throwing = "e")
public void afterThrowing(JoinPoint joinPoint, Exception e) {
Object methodName = joinPoint.getSignature().getName();
System.out.println("The method " + methodName + " exception with " + e);
}
}
环绕通知：
package com.itdoc.spring.aop.circular; import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component; import java.util.Arrays; /**
* 通知
* http://www.cnblogs.com/goodcheap
*
* @author: Wáng Chéng Dá
* @create: 2017-03-04 9:50
*/
@Aspect
@Component
public class AsjectLogging { /**
* 环绕通知需携带 ProceedingJoinPoint 类型的参数。
* 环绕通知类似于动态代理的全过程: ProceedingJoinPoint 类型参数可以决定是否执行目标方法。
* 环绕通知必须有返回值, 返回值即目标方法的返回值。
*
* @param point
* @return
*/
@Around("execution(* com.itdoc.spring.aop.circular.*.*(..))")
public Object around(ProceedingJoinPoint point) {
Object methodName = point.getSignature().getName();
Object[] args = point.getArgs();
Object result = null;
try {
//前置通知
System.out.println("The method " + methodName + " begins with" + Arrays.asList(args));
//执行方法
result = point.proceed();
//返回通知
System.out.println("The method " + methodName + " ends with " + result);
} catch (Throwable e) {
e.printStackTrace();
//异常通知
System.out.println("The method " + methodName + " exception with " + e);
} finally {
//后置通知
System.out.println("The method " + methodName + " ends");
}
return result;
}
}