AOP(Aspect Orient Programming)也就是 面向切面编程,AOP和OOP 互补
<?xml version="1.0" encoding="UTF-8"?>
<!-- 采用 DTD 来约束spring 配置文件
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN" "http://www.springframework.org/dtd/spring-beans-2.0.dtd">
-->
<!-- 下面采用 XML Schema 约束-->
<!--default-autowire-candidates="*abc" 该bens 下面的 所以以abc 结尾的 bean 不作为 自动注入的bean -->
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.2.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd">
<!--自动搜索bean组件,自动搜索切面类--->
<context:component-scan base-package="annotation.model,annotation.aop">
<context:include-filter type="annotation" expression="org.aspectj.lang.annotation.Aspect"/>
</context:component-scan>
<!-- 这种表示全部使用 注解来配置aop 而且采用cglib来生成代理-->
<aop:aspectj-autoproxy proxy-target-class="true"/>
<!--如果不采用 XML Schema配置方式,则需要配置 下面的bean
<bean class="org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator"/>
-->
</beans>
package annotation.aop.point;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
//定义一个切面
@Aspect
public class SystemArchitecture {
/**
* execution(pat1 pat2 pat3 pat4 pat5 pat6) 包含6部分
* pat1 : modifiers-pattern: 方法的修饰符 public default protected private 可以省略
* pat2 : ret-type-pattern: 方法的返回值类型 "*" 表示匹配所有的返回值类型
* pat3 : decaring-type-pattern: 指定方法所属的类 支持通配符 ,可以省略.
* pat4 : name-pattern: 方法名字 ,支持通配符, 可以使用 * 匹配所有方法
* pat5 : param-pattern: 方法 的参数列表 "*" 表示一个任意类型的参数 ".." 任意个数任意类型的参数
* pat6 :throws-pattern: 指定方法声明抛出的异常,支持通配符,可以省略
*
*/
//定义一个 切入点
// 这个表达式 是 pat1=(省略) pat2=* pat3=annotation.model.impl.Peo* pat4=eat* pat5=(..) pat6=(省略)
@Pointcut("execution(* annotation.model.impl.Peo*.eat*(..))")
public void myPointcut(){
}
//匹配所有 public 方法
@Pointcut("execution(public * * (..))")
public void pintcut1(){
}
//所有set 开头的方法
@Pointcut("execution(* set*(..))")
public void pintcut2(){
}
//所有impl 包下所有类的所有方法
@Pointcut("execution(* annotation.model.impl.*.*(..))")
public void pintcut3(){
}
//所有People类 下的所有 方
@Pointcut("execution(* annotation.model.impl.People.*(..))")
public void pintcut4(){
}
//impl 包中的所有 连接点
@Pointcut("within(annotation.model.impl.*)")
public void pintcut5(){
}
//impl 和 impl 子包中的所有 连接点
@Pointcut("within(annotation.model.impl..*)")
public void pintcut6(){
}
//匹配实现了Perosn接口的目标对象的所有连接点
@Pointcut("this(annotation.model.interfaces.Person)")
public void pintcut7(){
}
//限定目标对象 必须是指定类的实例
@Pointcut("target(annotation.model.interfaces.Person)")
public void pintcut8(){
}
//对连接点的参数类型进行设置
//匹配只接受一个参数.且是 Serializable的所有连 接点
//和 execution的区别是 args 是匹配运行时候的 参数类型
//execution 是匹配方法签名 时候的参数类型
@Pointcut("args(java.io.serializabel)")
public void pintcut9(){
}
//匹配以People的bean 内的连接点
@Pointcut("bean(*People)")
public void pintcut10(){
}
//匹配以stoneAxe 内方法的连接点
@Pointcut("bean(stoneAxe)")
public void pintcut11(){
}
@AfterReturning(pointcut="myPointcut() && args(name,..)",returning="rtv")
public void writeLog(String name,Object rtv){
System.out.println("内部");
System.out.println("参数值name:"+name);
System.out.println("返回值:"+rtv);
}
}
//before 在方法之前执行
package annotation.aop;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
@Aspect
public class BeforeAdviceTest{
@Before("execution(* annotation.model.impl.*.*(..))")
public void authrity(){
System.out.println("before: 模拟执行权限检查");
}
}
//afterReturning 只有在目标方法执行完后被织入,能够获取方法的返回值,如果中途出现异常了,就不会被增强
package annotation.aop;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
@Aspect
public class AfterRetruningAdviceTest {
//只有 在方法 完成返回后 才能执行 如果中间 出现异常了 是不会执行的
@AfterReturning(returning="rvt",pointcut="execution(* annotation.model.impl.*.*(..))")
public void log(Object rvt){ //如果是Object 则 返回值 为任意类型的 都会被拦截 进行处理
System.out.println("AfterReturning获取目标返回值:"+rvt);
System.out.println("AfterReturning 模拟记录日志功能...");
}
@AfterReturning(returning="rvt",pointcut="execution(* annotation.model.impl.*.*(..))")
public void log(int rvt){ //只拦截 返回值为 int的 方法
System.out.println("AfterReturning 我要的结果:"+rvt);
}
}
//AfterThrowing 主要用于处理程序中未处理的异常,能够指定值增强抛出那些异常的方法
package annotation.aop;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;
@Aspect
//@Component
public class AfterThrowingAdviceTest {
//可以 指定只抛出指定的异常 可以对抛出的异常进行处理,但是不能对异常进行完全处理,异常还是会向上抛出
@AfterThrowing(throwing="ex",pointcut="execution(* annotation.model.impl.*.*(..))")
public void doRecoveryActions(Throwable ex){ //NullPointerException ex
System.out.println("AfterThrowing 目标方法中抛出的异常:"+ex);
System.out.println("AfterThrowing 模拟抛出异常后的增强处理...");
}
}
//after 不管目标方法 怎么结束(正常结束,抛出异常结束) 都会织入, 所以类是 finally{}
package annotation.aop;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
@Aspect
public class AfterAdviceTet {
//类是 finally{
//dosomething...
//}
@After("execution(* annotation.model.impl.*.*(..))")
public void release(){
System.out.println("After 模拟方法结束后关闭资源");
}
}
//Around (before + afterReturning) 该增强处理比较强大,
比before强大; 在目标方法执行前,进行增强,可以决定 目标方法 是否执行,和什么时候执行.可以改变目标方法的参数值(也可以阻止目标方法执行)
比afterReturning强大: 可以在方法正常结束后进行增强, 可以改变方法的返回值.
注意:由于 Around 功能强大,因此需要在线程安全的环境下使用,如过用 before 和afterReturning能够解决的问题,就没必要 用 Around 了
package annotation.aop;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
@Aspect
public class AroundAdviceTest {
@Around("execution(* annotation.model.impl.*.*(..))")
public Object proccesTx(ProceedingJoinPoint jp) throws Throwable{
System.out.println("Around :执行目标方法前开始事务");
Object rvt=jp.proceed(new String[]{"被改变的参数"});
System.out.println("Around:执行目标方法之后,模拟结束事务");
return rvt+"Around:新增的内容";
}
}
//访问目标方法的 参数
//Object[] getArgs(): 获取目标方法的参数
//Sigature getSignature()返回被增强法方法的相关信息
//Object getTarget() 返回被织入 增强处理的目标对象
//Object getThis() 返回AOP框架为目标对象生成的代理对象
//==============================================
package annotation.aop;
import java.util.Arrays;
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.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
@Aspect
@Order(1)
//@Component
public class FourAdviceTest {
static{
System.out.println("aop 1");
}
@Around("execution(* annotation.model.impl.*.*(..))")
public Object processTx(ProceedingJoinPoint jp) throws Throwable{
System.out.println("-------------------Around增强: 执行目标方法前 ,模拟开始事务....");
//获取执行目标方法的参数
Object[] args=jp.getArgs();
if(args!=null && args.length>0 && args[0].getClass() == String.class){
args[0]="被改变的参数";
}
Object rvt=jp.proceed(args);
System.out.println("Around增强:执行目标方法之后,模拟结束事务...");
return rvt+"新增的内容";
}
@Before("execution(* annotation.model.impl.*.*(..))")
public void authority(JoinPoint jp){
System.out.println("-------------------Before增强处理:");
System.out.println("模拟执行权限检查");
System.out.println("被织入增强处理的目标方法为"+jp.getSignature().getName());
System.out.println("目标方法参数为:"+Arrays.toString(jp.getArgs()));
System.out.println("被织入增强处理的目标对象为:"+jp.getTarget());
}
@AfterReturning(pointcut="execution(* annotation.model.impl.*.*(..))",returning="rvt")
public void log(JoinPoint jp,Object rvt){
System.out.println("-------------------AfterReturning增强处理");
System.out.println("获取目标返回值:"+rvt);
System.out.println("模拟日志记录功能");
System.out.println("被织入增强处理的目标方法为"+jp.getSignature().getName());
System.out.println("目标方法参数为:"+Arrays.toString(jp.getArgs()));
System.out.println("被织入增强处理的目标对象为:"+jp.getTarget());
}
@After("execution(* annotation.model.impl.*.*(..))")
public void release(JoinPoint jp){
System.out.println("-------------------After增强处理");
System.out.println("模拟方法结束后,释放资源");
System.out.println("被织入增强处理的目标方法为"+jp.getSignature().getName());
System.out.println("目标方法参数为:"+Arrays.toString(jp.getArgs()));
System.out.println("被织入增强处理的目标对象为:"+jp.getTarget());
}
}
采用XML配置文件来配置AOP
<?xml version="1.0" encoding="UTF-8"?> <!-- 采用 DTD 来约束spring 配置文件 <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN" "http://www.springframework.org/dtd/spring-beans-2.0.dtd"> --> <!-- 下面采用 XML Schema 约束--> <!--default-autowire-candidates="*abc" 该bens 下面的 所以以abc 结尾的 bean 不作为 自动注入的bean --> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context" xmlns:mvc="http://www.springframework.org/schema/mvc" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd"> <context:component-scan base-package="annotation.model,annotation.aop"> </context:component-scan> <!--使用xml来配置AOP --> <!-- 定义一个切面类 <bean id="fourAdvice" class="annotation.aop.FourAdviceTest"/> <bean id="fourAdvice1" class="annotation.aop.FourAdviceTest1"/> --> <!-- proxy-target-class="false": 默认 采用 com.sun.proxy 代理(表示被代理的类必须是实现了接口,纯 接口实现类) 如果被代理的累是 一个javaBean 则 只能使用 cglib 创建代理 expose-proxy="true" : 决定当前代理是否被暴露在一个ThreadLocal 中以便被目标对象访问。 如果目标对象需要获取代理而且exposeProxy属性被设为 true, 目标对象可以使用AopContext.currentProxy()方法。 --> <aop:config proxy-target-class="true"> <aop:pointcut id="pt1" expression="execution(* annotation.model.impl.*.*(..))"/> <aop:aspect id="oneAdvice" ref="fourAdvice" order="1"> <aop:after method="release" pointcut-ref="pt1"/> <aop:before method="authority" pointcut-ref="pt1"/> <aop:after-returning returning="rvt" method="log" pointcut-ref="pt1"/> <!-- 匹配返回值为 String的 --> <aop:around method="processTx" pointcut="execution(String annotation.model.impl.*.*(..))"/> </aop:aspect> <!-- 注解的时候 使用 && || ! 在使用XML配置的时候 使用 and or not --> <aop:aspect id="twoAdvice" ref="fourAdvice1" order="2"> <aop:pointcut id="pt2" expression="execution(* annotation.model.impl.*.*(..)) and args(name)"/> <aop:before method="authority" pointcut-ref="pt2"/> </aop:aspect> <aop:aspect id="errorAdvice" ref="afterThrowingAdviceTest" order="1"> <aop:after-throwing method="doRecoveryActions" pointcut-ref="pt1" throwing="ex"/> </aop:aspect> </aop:config> </beans>