Spring AOP
spring AOP(面向方面编程)框架,用于在模块化方面的横切关注点。
简单得说,它只是一个拦截器拦截一些过程,在方法执行之前或之后添加额外的功能。
基于xml配置文件的管理方式:使用spring配置文件定义切面及切点。
<?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:mvc="http://www.springframework.org/schema/mvc"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-4.0.xsd ">
AOP术语
1、切面(Aspect)
描述的一个应用系统的一个方面或者领域,如:日志、权限、事务等。
2、连接点(JoinPoint)
连接点是应用程序执行过程中插入切面的点,这些点可以是一个方法的调用、异常的抛出等。
3、通知(advise)
通知它是切面的具体实现,它表示切面的行为。
定义了切面是什么、如何使用等,描述了切面要实现的工作。
spring支持五种类型的通知:
Before(前) : org.apringframework.aop.MethodBeforeAdvice
After-returning(返回后) : org.springframework.aop.AfterReturningAdvice
After-throwing(抛出后) : org.springframework.aop.ThrowsAdvice
Arround(周围) : org.aopaliance.intercept.MethodInterceptor
Introduction(引入) : org.springframework.aop.IntroductionInterceptor
一个简单实例
定义切面:
package com.wm.spring.AOP.Aspect;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
public class DefaultAspect {
// 前置通知
public void doBefore(JoinPoint jp) {
System.out.println("method before 。。。");
System.out.println("method name: "+jp.getTarget().getClass().getName() + " - "+jp.getSignature().getName());
}
// 返回后通知
public void doAfter(JoinPoint jp) {
System.out.println("method name: "+jp.getTarget().getClass().getName() + " - "+jp.getSignature().getName());
System.out.println("method after 。。。");
}
// 环绕通知
public void doAround(ProceedingJoinPoint jp) throws Throwable {
System.out.println(" before ....");
jp.proceed();
System.out.println(" method name: "+jp.getTarget().getClass().getName() + " - "+jp.getSignature().getName());
System.out.println(" after ....");
}
// 抛出异常后通知
public void doThrow(Throwable e){
System.out.println("after throw ..... "+e);
}
}
JoinPoint 里包含了如下几个常用方法:
Object[] getArgs(): 返回执行目标方法时的参数。
Signature getSignature(): 返回被增强的方法的相关信息。
Object getTarget(): 返回被织入增强处理的目标对象。
Object getThis(): 返回 AOP 框架为目标对象生成的代理对象。
基于xml配置管理方式
<aop:config>
<aop:aspect id="myAspect" ref="defaultAspect">
<aop:pointcut expression="execution(* com.wm.spring.IOC.*.*(..))" id="myPoincut"/>
<!-- 前置通知 -->
<aop:before method="doBefore" pointcut-ref="myPoincut"/>
<!-- 返回后通知 -->
<aop:after-returning method="doAfter" pointcut-ref="myPoincut"/>
<!-- 环绕通知 -->
<aop:around method="doAround" pointcut-ref="myPoincut"/>
<!-- 抛出异常后通知 -->
<aop:after-throwing method="doThrow" pointcut-ref="myPoincut" throwing="e"/>
</aop:aspect>
</aop:config>
<bean id="defaultAspect" class="com.wm.spring.AOP.Aspect.DefaultAspect"></bean>
<bean id="people" class="com.wm.spring.IOC.People">
<property name="name" value="Tom" />
<property name="age" value="19"></property>
</bean>
抛出异常后通知中,< aop:after-throwing />要在通知中获取 异常,就必须配置属性 throwing=”e”,这样就可以获取到,不然会报错的。
目标对象:
package com.wm.spring.IOC;
public class People {
private String name;
private int age;
public void eat(){
System.out.println(name+ " 正在吃饭。。。。。。");
}
public void sleep(){
System.out.println(name + " 正在睡觉。。。。。");
}
public void doErrorThing() {
throw new IllegalArgumentException("做错事。。。。。");
}
@Override
public String toString() {
return String.format("姓名:%s <-> 年龄:%d", name,age);
}
。。。。。。
setting and getting
}
测试及结果:
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.wm.spring.IOC.People;
public class AOPTest {
private ApplicationContext ac ;
@Before
public void init(){
ac = new ClassPathXmlApplicationContext("ApplicationContext.xml");
}
@Test
public void doTestAOP(){
People pp = (People)ac.getBean("people");
pp.eat();
pp.sleep();
pp.doErrorThing();
}
}
运行结果:
信息: Loading XML bean definitions from class path resource [ApplicationContext.xml]
method before 。。。
method name: com.wm.spring.IOC.People - eat
before ....
Tom 正在吃饭。。。。。。
method name: com.wm.spring.IOC.People - eat
after ....
method name: com.wm.spring.IOC.People - eat
method after 。。。
method before 。。。
method name: com.wm.spring.IOC.People - sleep
before ....
Tom 正在睡觉。。。。。
method name: com.wm.spring.IOC.People - sleep
after ....
method name: com.wm.spring.IOC.People - sleep
method after 。。。
method before 。。。
method name: com.wm.spring.IOC.People - doErrorThing
before ....
after throw ..... java.lang.IllegalArgumentException: 做错事。。。。。
额外的配置
maven pom.xml
需要引入:
aspectjrt.jar
aspectjweaver.jar
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjrt</artifactId>
<version>1.8.6</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.8.6</version>
</dependency>
基于注解的方式(使用Aspectj)
一个小例子:
定义一个切面:
package com.wm.spring.AOP.Aspect;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
@Order(1) // order 可以定义切面的优先级 ---> 越小越优先
@Aspect // 声明切面
@Component // bean 注册到容器中去
public class BaseOnAnnotationAspect {
// 前置通知
@Before("execution(* com.wm.spring.IOC.People.*(..))")
public void doBefore(JoinPoint jp) {
System.out.println("method before 。。。");
System.out.println("method name: "+jp.getTarget().getClass().getName() + " - "+jp.getSignature().getName());
}
// 返回后通知
@AfterReturning(value = "execution(* com.wm.spring.IOC.People.*(..))")
public void doAfterReturning(JoinPoint jp) {
System.out.println("method name: "+jp.getTarget().getClass().getName() + " - "+jp.getSignature().getName());
System.out.println("method after returning 。。。");
}
// 后置通知 //出现异常一样的返回
@After(value = "execution(* com.wm.spring.IOC.People.*(..))")
public void doAfter(JoinPoint jp) {
System.out.println(jp.getTarget().getClass().getSuperclass());
System.out.println("method name: "+jp.getTarget().getClass().getName() + " - "+jp.getSignature().getName());
System.out.println("method after 。。。");
}
// 环绕通知
@Around(value = "execution(* com.wm.spring.IOC.People.*(..))")
public void doAround(ProceedingJoinPoint jp) throws Throwable {
System.out.println(" before ....");
jp.proceed();
System.out.println(" method name: "+jp.getTarget().getClass().getName() + " - "+jp.getSignature().getName());
System.out.println(" after ....");
}
// 抛出异常后通知
@AfterThrowing(throwing = "e" , value = "execution(* com.wm.spring.IOC.People.*(..))")
public void doThrow(Throwable e){
System.out.println("after throw ..... "+e);
}
}
其中
注解:@Order 可以在多个切面中实现优先级,优先级越高,order值越小。
注解:@Pointcut 可以定义一个切点的方法:
@Pointcut("execution(* com.wm.spring.IOC.People.*(..))") // 定义的切点
public void definePointCut(){} // 方法体内 不要写内容
// 前置通知
@Before("definePointCut()") // 使用定义的切点方法 实现切点
public void doBefore(JoinPoint jp) {
System.out.println("method before 。。。");
System.out.println("method name: "+jp.getTarget().getClass().getName() + " - "+jp.getSignature().getName());
}
配置文件:
<?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:mvc="http://www.springframework.org/schema/mvc"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-4.0.xsd ">
<!-- 自动扫描 切面 所在的包 -->
<context:component-scan base-package="com.wm.spring.AOP.Aspect"></context:component-scan>
<!-- 使用注解方式的 ,这个必须加, 是自动实现代理模式 -->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>
必须要引用AOP的命名空间和约束,才能使用