spring （学习记录）AOP：前置，后置，返回，异常，环绕通知

阳光穿透心脏的1/2处 2022-03-26 16:18 347阅读 0赞

AspectJ:java社区最完整最完善的AOP框架；

AspectJ支持的5种类型的通知注解：

@Before:前置通知，在方法执行之前执行

@After：后置通知，在方法执行之后执行

@AfterRunning：返回通知，在方法返回结果后执行

@AfterThrowing：异常通知，在方法抛出异常之后执行

@Around：环绕通知，围绕着方法执行  
　　  
Spring也有自身的AOP框架。可以使用基于AspectJ注解或基于XMl配置的AOP。  
注解方式：

1、除spring基本jar包，额外需要加入jar包：aopalliance、aspectj.weaver、aop.RELRESE、aspects.RELEASE

2、配置自动扫描  
配置文件

<?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-4.0.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">
    
           
           <context:component-scan base-package="com.spring.aop.impl"></context:component-scan>
           
           <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
    </beans>

创建接口：

package com.spring.aop.impl;
    
    import javax.swing.JInternalFrame;
    public interface CalCulator {
           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.spring.aop.impl;
    
    import org.springframework.stereotype.Component;
    
    @Component
    public class CalCulatorImpl implements CalCulator {
    
    	@Override
    	public int add(int i, int j) {
    		// TODO Auto-generated method stub
    		int result=i+j;
    		return result;
    	}
    
    	@Override
    	public int sub(int i, int j) {
    		// TODO Auto-generated method stub
    		int result=i-j;
    		return result;
    	}
    
    	@Override
    	public int mul(int i, int j) {
    		// TODO Auto-generated method stub
    		int result=i*j;
    		return result;
    	}
    
    	@Override
    	public int div(int i, int j) {
    		// TODO Auto-generated method stub
    		int result=i/j;
    		return result;
    	}
    
    }

创建日志切面：

package com.spring.aop.impl;
    
    import java.util.Arrays;
    import java.util.List;
    
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    import org.springframework.stereotype.Component;
    
    //把这个类声明为一个切面：需要把该类放入到IOC容器中，声明为一个切面
    @Aspect
    @Component
    public class LoggingAspect {
    	   //声明该方法是一个前置通知：在目标方法开始之前执行 可以指定方法名，
    	  // 如果那个接口里的所有方法都要加，那就直接*号，其他的也可以用*号代替
    	   @Before("execution(* com.spring.aop.impl.*.*(int, int))")
           public void beforeMethod(JoinPoint joinPoint){
    		   String methodName=joinPoint.getSignature().getName();
    		   List<Object> args=Arrays.asList(joinPoint.getArgs());
    		   
        	   System.out.println("The method "+ methodName +" begins with "+args);
           }
    //后置通知：在目标方法执行后（无论是否发生异常），执行的通知
    	   //在后置通知中还不能访问目标方法执行的结果
    	   @After("execution(* com.spring.aop.impl.*.*(int,int))")
    	   public void afterMethod(JoinPoint joinPoint) {
    		   String methodName=joinPoint.getSignature().getName();
    		   System.out.println("The method "+methodName+" ends");
    		   
    	   }
    	   
    }

运行主类：

package com.spring.aop.impl;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class Main {
    	
           public static void main(String[] args) {
    		//1.加入spring的IOC容器
        	   ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
        	   //2.从IOC容器中获取bean 的实例
        	   CalCulator calCulator=ctx.getBean(CalCulator.class);
        	   
        	   //3.使用bean
        	   int result=calCulator.add(3, 6);
        	   System.out.println("result: "+result);
        	   
        	   result=calCulator.div(2, 1);
        	   System.out.println("result: "+result);
    	}
    }

(前置通知，后置通知）运行结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3Nzc0MTcx_size_16_color_FFFFFF_t_70]  
在日志切面做如下修改。在正常结束后执行的代码

/* 
    	   * 在方法正常结束后执行的代码
    	   * 返回通知是可以访问到方法的返回值的
    	   */
    	   @AfterReturning(value="execution(* com.spring.aop.impl.*.*(..))",
    			   returning="result")
    	   
    	   public void afterReturning(JoinPoint joinPoint,Object result) {
    		   String methodName =joinPoint.getSignature().getName();
    		   System.out.println("The method"+methodName+" ends with "+result);
    	   }

运行  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3Nzc0MTcx_size_16_color_FFFFFF_t_70 1]  
异常通知

/*
    	    * 在目标方法出现异常时会执行的代码
    	    * 可以访问到异常对象，且可以指定在出现特定异常时再执行通知代码
    	   */
    	   @AfterThrowing(value="execution(* com.spring.aop.impl.*.*(..))",
    			   throwing="ex")
    	   public void afterThrowing(JoinPoint joinPoint,Exception ex) {
    		   String methodName=joinPoint.getSignature().getName();
    		   System.out.println("The method "+methodName+" occurs excetion:"+ex);
    	   }

环绕通知

/*
    	    * 环绕通知需要携带ProceedingJoinPoint类型的参数
    	    * 环绕通知类似于动态代理的全过程：ProceedingJoinPoint 类型的参数可以决定是否执行目标方法
    	    * 且环绕通知必须要有返回值，返回值即为目标方法的返回值
    	   */
    	   //环绕通知是最强的，可以实现以上四种通知
    	   
    	   @Around("execution(* com.spring.aop.impl.*.*(..))")
    	   public Object aroundMethod(ProceedingJoinPoint pjd) {
    		  Object result=null;
    		  String methodName =pjd.getSignature().getName();
    		  
    		   
    		try {
    			//前置通知
    			System.out.println("The method "+methodName+" begins with "+Arrays.asList(pjd.getArgs()));
    			//执行目标方法
    			result=pjd.proceed();
    			//返回通知
    			System.out.println("The method ends with "+result);
    		} catch (Throwable e) {
    			//异常通知
    			System.out.println("The method "+methodName+" occurs exception:"+e);
    			throw new RuntimeException(e);
    		}
    		//后置通知
    		System.out.println("The method "+methodName+" ends");
    		  return result;
    	   }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3Nzc0MTcx_size_16_color_FFFFFF_t_70]: /images/20220326/3369b9ed324544aea2dee4552dce953c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3Nzc0MTcx_size_16_color_FFFFFF_t_70 1]: /images/20220326/b67d9a39c0734fae8d7005216fca85ca.png