spring 第10 天 AOP 面向切面-CSDN博客

本文链接：https://blog.csdn.net/luobing_csdn/article/details/66969912


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>