spring中AOP机制学习简单Demo

亦凉 2022-05-10 02:12 123阅读 0赞

### **什么是AOP** ###

Aspect Oriented Programming，面向切面/方面编程

即针对一批组件的通用业务逻辑进行编程，将通用的功能与业务模块分离，通用的功能就是可以复用的代码段

### AOP中的一些术语 ###

*  切面：封装通用业务逻辑的组件，作用到其他组件上，要求：
    
     *  必须是被Spring管理的bean组件中的方法
     *  无返回值（void）
     *  参数类型与通知类型一致
 *  切入点：指定哪些组件的哪些方法使用切面程序，**spring提供表达式来实现指定**，要求：
    
     *  必须是spring 管理的bean组件的方法
     *  不限定返回值
     *  不限定参数类型
 *  通知：切面程序插入到切入点程序的某个位置，根据位置的不同，分为：
    
     *  前置通知 ： 切面程序在目标方法执行前执行
     *  后置通知 ： 目标组件（切入点）**正常执行并返回参数后**执行
     *  异常通知 ： 目标组件抛出异常后执行
     *  最终通知 ： 目标组件**正常执行后、或者异常通知前** 执行，和finally 中的内容相似，最终通知中切面中的代码不管异常否，均会执行
     *  环绕通知 ： 可以取代之前的集中通知类型，具体见下面代码

### 切入点表达式 ###

1.  按函数匹配 ，形如：execution(\* com.lc.test.Boy.aspectTest(..))，注意的几点：
    
    1.  第一个 \* 表示任意修饰符及任意返回类型，不能省略；   如：写成 execution(public \* com.lc.test.Boy.\*(..))表示Boy类中用public修饰的方法、任意返回类型、任意参数的方法为切入点
    2.  \* 表示匹配一个，如果要两个参数，就要这样写：execution(\* com.lc.test.Boy.aspectTest(\*，\*))
    3.  两个点 .. 表示匹配任意参数（0个或多个）： execution(\* com.lc.test.Boy.aspectTest(..))
    4.  com..\*.\*(..)) ： 指定com下的所有类的任意参数的任意方法为切入点
2.  按类匹配， 形如：within(com.lc.test.Boy) ：指定这个类中所有方法 均为切入点
3.  按bean组件的id匹配：bean(boy) ：bean的id为boy的类 中所有方法 均为切入点，可用通配符 ，形如：bean(b\*)

### 环境搭建 ###

1.  spring 核心jar : core
2.  spring-aop， spring-aspects (spring-aop...， spring-aspects...， aopalliance...， aspectjweaver...，)

Demo部分代码及过程中遇到的问题：

前置通知：

// 切入点程序
    public class Boy {
        public void aspectTest(String param1, String param2){
    	    System.out.println("测试AOP");
        }
    }
    
    // 切面程序
    // JoinPoint jp 参数并不是必须的，这个参数可以获取目标组件的细节，如类名，方法名等
    public class AspectDemo{
    	public void doBefore(JoinPoint jp){
    		System.out.println("前置通知");
    		System.out.println(jp.getTarget().getClass().getName());
    	}
    }
    
    
    // applicationComtext.xml配置文件
    
    <bean id="boy" class="com.lc.test.Boy"></bean>
    <bean id="beforeAspect" class="com.lc.aspect.AspectDemo"></bean>
    
    <aop:config>
    	
    	<aop:pointcut id="targetPointcut" expression="execution(* com.lc.test.Boy.aspectTest(..))" />
    	
    	<aop:aspect ref="beforeAspect">
    		
    		<aop:before method="doBefore" pointcut-ref="targetPointcut"/>
    	</aop:aspect>
    </aop:config>

后置通知：

// 切入点程序和前置通知一样
    
    // 切面程序
    public void doAfterReturning(JoinPoint jp, Object result){
    	System.out.println("目标组件的返回值：" + result);
    	System.out.println("后置通知");
    }
    
    // 配置
    
    <bean id="boy" class="com.lc.test.Boy"></bean>
    <bean id="beforeAspect" class="com.lc.aspect.AspectDemo"></bean>
    
    <aop:config>
    	
    	<aop:pointcut id="targetPointcut" expression="bean(boy)" />
    	
    	<aop:aspect ref="beforeAspect">
    		
    		<aop:before method="doBefore" pointcut-ref="targetPointcut"/>
    		
    		<aop:after-returning method="doAfterReturning" pointcut-ref="targetPointcut" returning="result"/>
    	</aop:aspect>
    </aop:config>

异常通知：

// 切入点程序
    public void aspectTest(){
    	System.out.println("测试AOP");
    	// 创造一个抛出异常的点
            System.out.println(3/0);
    }
    
    // 切面程序
    public void doThrowable(JoinPoint jp, Throwable t){
    	System.out.println("异常信息："+ t.getMessage());
    	System.out.println("异常通知");
    }
    
    //配置
    
    <bean id="boy" class="com.lc.test.Boy"></bean>
    <bean id="beforeAspect" class="com.lc.aspect.AspectDemo"></bean>
    
    <aop:config>
    	
    	<aop:pointcut id="targetPointcut" expression="bean(boy)" />
    	
    	<aop:aspect ref="beforeAspect">
    		
    		<aop:before method="doBefore" pointcut-ref="targetPointcut"/>
    		
    		<aop:after-returning method="doAfterReturning" pointcut-ref="targetPointcut" returning="result"/>
    		
    		<aop:after-throwing method="doThrowable" pointcut-ref="targetPointcut" throwing="t" />
    	</aop:aspect>
    </aop:config>

最终通知（暂时没搞清和后置通知有啥区别，但是有一点，**后置通知可以获取到目标组件的返回值**）：

// 切面程序
    public void doAfter(JoinPoint jp){
    	System.out.println("最终通知");
    }
    
    // 配置
    
    <bean id="boy" class="com.lc.test.Boy"></bean>
    <bean id="beforeAspect" class="com.lc.aspect.AspectDemo"></bean>
    
    <aop:config>
    	
    	<aop:pointcut id="targetPointcut" expression="bean(boy)" />
    	
    	<aop:aspect ref="beforeAspect">
    		
    		<aop:before method="doBefore" pointcut-ref="targetPointcut"/>
    		
    		<aop:after-returning method="doAfterReturning" pointcut-ref="targetPointcut" returning="result"/>
    		
    		<aop:after-throwing method="doThrowable" pointcut-ref="targetPointcut" throwing="t" />
    		
    		<aop:after method="doAfter" pointcut-ref="targetPointcut"/>
    	</aop:aspect>
    </aop:config>

环绕通知：参数为org.aspectj.lang.ProceedingJoinPoin（pjp）， 是JoinPoint的子类，提供proceed()方法；

执行过程：proceed方法调用目标组件（切入点）方法，并返回其返回值，Object result = pjp.proceed();

取代前几种通知类型的方式：

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td style="width:247px;">proceed方法之前的代码</td> 
   <td style="width:251px;">前置通知</td> 
  </tr> 
  <tr> 
   <td style="width:247px;">proceed方法之后的代码</td> 
   <td style="width:251px;">后置通知</td> 
  </tr> 
  <tr> 
   <td style="width:247px;">异常中的代码</td> 
   <td style="width:251px;">异常通知</td> 
  </tr> 
  <tr> 
   <td style="width:247px;">finally中的代码</td> 
   <td style="width:251px;">最终通知</td> 
  </tr> 
 </tbody> 
</table>

// 切面程序
    public void doArround(ProceedingJoinPoint pjp){
    	try {
    		System.out.println("前置通知");
    		Object result = pjp.proceed();
    		System.out.println("后置通知:" + result );
    	} catch (Throwable t) {
    		System.out.println("异常通知：" + t.getMessage());
    	}finally{
    		System.out.println("最终通知");
    	}
    }
    
    // 切入点程序
    public String aspectTest(){
    	System.out.println("测试AOP");
    	//System.out.println(3/0);
    	return "success";
    }
    
    // 配置
    
    <bean id="boy" class="com.lc.test.Boy"></bean>
    <bean id="beforeAspect" class="com.lc.aspect.AspectDemo"></bean>
    
    <aop:config>
    	
    	<aop:pointcut id="targetPointcut" expression="bean(boy)" />
    	
    	<aop:aspect ref="beforeAspect">
    		
    		<aop:around method="doArround" pointcut-ref="targetPointcut"/>
    	</aop:aspect>
    </aop:config>

### 用配置文件配置，配置比较繁琐，下面用注解配置一下： ###

前提条件：

1.  引入了aspectj包，因为要使用包中的@Aspect注解标注组件为切面（这个Demo中是com.lc.aspect.AspectDemo）
2.  开启自动扫描 ：<context:component-scan base-package="com.lc"></context:component-scan>
3.  开启aspectj的自动代理模式  <aop:aspectj-autoproxy><aop:aspectj-autoproxy/>

前置通知：

// 切入点程序
    public String aspectTest(){
    	System.out.println("测试AOP");
    	//System.out.println(3/0);
    	return "success";
    }
    
    // 切面程序
    @Aspect
    public class AspectDemo {
            // 注意这里是execution，不是配置文件中的expression
            // 另外：bean(boy)  , within(com.lc.test.Boy) 也可以
    	@Before(value="execution(* com.lc.test.Boy.aspectTest())")
    	public void doBefore(JoinPoint jp){
    		System.out.println("前置通知");
    		System.out.println(jp.getTarget().getClass().getName());
    	}
    }
    
    // 因为这个没有注解类为bean组件，在配置文件里面配置
    
    <context:component-scan base-package="com.lc"></context:component-scan>
    
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
    
    
    <bean id="boy" class="com.lc.test.Boy"></bean>
    <bean id="beforeAspect" class="com.lc.aspect.AspectDemo"></bean>

后置通知、异常通知、最终通知、环绕通知：

@Aspect
    public class AspectDemo {
    	@Before(value="execution(* com.lc.test.Boy.*())")
    	// 注意这里是execution，不是配置文件中的expression
            // 另外：bean(boy)  , within(com.lc.test.Boy) 也可以
    	public void doBefore(JoinPoint jp){
    		System.out.println("前置通知");
    		System.out.println(jp.getTarget().getClass().getName());
    	}
    	
    	@AfterReturning(pointcut="execution(* com.lc.test.Boy.*())", returning="result")
    	public void doAfterReturning(Object result){
    		System.out.println("目标组件的返回值：" + result);
    		System.out.println("后置通知");
    	}
    	
    	@AfterThrowing(pointcut="execution(* com.lc.test.Boy.*())",throwing="t")
    	public void doThrowable(JoinPoint jp, Throwable t){
    		System.out.println("异常信息："+ t.getMessage());
    		System.out.println("异常通知");
    	}
    	
    	@After(value="execution(* com.lc.test.Boy.*())")
    	public void doAfter(JoinPoint jp){
    		System.out.println("最终通知");
    	}
    	
    	@Around(value="execution(* com.lc.test.Boy.*())")
    	public void doArround(ProceedingJoinPoint pjp){
    		try {
    			System.out.println("前置通知");
    			Object result = pjp.proceed();
    			System.out.println("后置通知:" + result );
    		} catch (Throwable t) {
    			System.out.println("异常通知：" + t.getMessage());
    		}finally{
    			System.out.println("最终通知");
    		}
    	}
    }

像上面的注解配置中，对于切入点的配置，其实不管是

@AfterReturning(pointcut="execution(\* com.lc.test.Boy.\*())", returning="result") 中的 pointcut 取值， 还是其他通知，比如：

@After(value="execution(\* com.lc.test.Boy.\*())") 中的 value 取值

它们都是同一个取值，此时，为了简化配置，我们可以这样写（定义一个公共的切入点）：

@Aspect
    public class AspectDemo {
    	// 定义切入点
    	@Pointcut(value="execution(* com.lc.test.Boy.aspectTest())")
    	public void pointcutName(){}
    	
    	@Before("pointcutName()")
    	// 注意这里是execution，不是配置文件中的expression
            // 另外：bean(boy)  , within(com.lc.test.Boy) 也可以
    	public void doBefore(JoinPoint jp){
    		System.out.println("前置通知");
    		System.out.println(jp.getTarget().getClass().getName());
    	}
    	
    	@AfterReturning(pointcut="pointcutName()", returning="result")
    	public void doAfterReturning(Object result){
    		System.out.println("目标组件的返回值：" + result);
    		System.out.println("后置通知");
    	}
    	
    	@AfterThrowing(pointcut="pointcutName()",throwing="t")
    	public void doThrowable(JoinPoint jp, Throwable t){
    		System.out.println("异常信息："+ t.getMessage());
    		System.out.println("异常通知");
    	}
    	
    	@After(value="pointcutName()")
    	public void doAfter(JoinPoint jp){
    		System.out.println("最终通知");
    	}
    	
    	@Around(value="pointcutName()")
    	public void doArround(ProceedingJoinPoint pjp){
    		try {
    			System.out.println("前置通知");
    			Object result = pjp.proceed();
    			System.out.println("后置通知:" + result );
    		} catch (Throwable t) {
    			System.out.println("异常通知：" + t.getMessage());
    		}finally{
    			System.out.println("最终通知");
    		}
    	}
    }

总结：aop可以**通过通知**来实现对一些通用业务逻辑进行编程（代码复用）： 日志打印、事务控制、权限控制......