Spring学习(二十一)-切面编程AOP

小灰灰 2024-02-19 16:06 62阅读 0赞

介绍：
    AOP：【动态代理】
         指在程序运行期间动态的将某段代码切入到指定方法指定位置进行运行的编程方式;

AOP的全称是Aspect Orient Programming，即面向切面编程。是对OOP（Object Orient Programming）的一种补充，战门用于处理一些具有横切性质的服务。常常用于日志输出、安全控制等。主要的的实现技术主要有Spring AOP和AspectJ。

1、AspectJ的底层技术。

AspectJ的底层技术是静态代理，即用一种AspectJ支持的特定语言编写切面，通过一个命令来编译，生成一个新的代理类，该代理类增强了业务类，这是在编译时增强，相对于下面说的运行时增强，编译时增强的性能更好。

2.Spring AOP：

其采用的是动态代理，在运行期间对业务方法进行增强，所以不会生成新类，对于动态代理技术，Spring AOP提供了对JDK动态代理的支持（面向接口）以及CGLib的支持。

**使用方式：**

项目中要使用切面必须注入spring AOP模块（Spring AOP：(spring-aspects)），在配置类上还需要开启AOP模式（@EnableAspectJAutoProxy 【开启基于注解的aop模式】），同时，在切面类上需要加上该注解（@Aspect）表明这个是一个切面类。

切面类中可以定义很多方法同时可以使用不同的注解，区分在那个位置进行切入：

通知方法：
            前置通知(@Before)：logStart：在目标方法(div)运行之前运行
            后置通知(@After)：logEnd：在目标方法(div)运行结束之后运行（无论方法正常结束还是异常结束） 
            返回通知(@AfterReturning)：logReturn：在目标方法(div)正常返回之后运行
            异常通知(@AfterThrowing)：logException：在目标方法(div)出现异常以后运行
            环绕通知(@Around)：动态代理，手动推进目标方法运行（joinPoint.procced()）

**测试：**

注解类：

@Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.METHOD)
    public @interface AroundAuthority {
        String memthodName() default "";
    }

普通类：

import com.spring.config.AroundAuthority;
    
    import java.math.BigDecimal;
    
    public class MathCalculator {
    
    	public int div(int i,int j){
    		System.out.println("MathCalculator...div...");
    		return BigDecimal.valueOf(i).divide(BigDecimal.valueOf(j)).intValue();
    	}
    
    	/**
    	 * 自定义注解管理切面时机
    	 */
    	@AroundAuthority(memthodName = "annotationMethodAop")
    	public void annotationMethodAop(){
    		System.out.println("annotationMethodAop...annotationMethodAop..");
    	}
    
    
    }

配置类：

@EnableAspectJAutoProxy
    @Configuration
    public class MainConfigOfAOP {
    
    	//业务逻辑类加入容器中
    	@Bean
    	public MathCalculator calculator(){
    		return new MathCalculator();
    	}
    
    	//切面类加入到容器中
    	@Bean
    	public LogAspects logAspects(){
    		return new LogAspects();
    	}
    }

切面类：

/**
     * 切面类
     * @author lfy
     *
     * @Aspect： 告诉Spring当前类是一个切面类
     *
     */
    @Aspect
    public class LogAspects {
    
    	/**
    	 * 抽取切入点表达式 统一管理
    	 */
    	@Pointcut("execution(public int com.spring.aop.MathCalculator.*(..))")
    	public void pointCut(){};
    
    	/**
    	 * @Before在目标方法之前切入
    	 * 前置通知(@Before)：logStart：在目标方法运行之前运行
    	 * @param joinPoint
    	 */
    	@Before("pointCut()")
    	public void logStart(JoinPoint joinPoint){
    		Object[] args = joinPoint.getArgs();
    		System.out.println(""+joinPoint.getSignature().getName()+"运行。。。@Before:参数列表是：{"+Arrays.asList(args)+"}");
    	}
    
    	/**
    	 * 后置通知(@After)：在目标方法运行结束之后运行（无论方法正常结束还是异常结束）
    	 * @param joinPoint
    	 */
    	@After("pointCut()")
    	public void logEnd(JoinPoint joinPoint){
    		System.out.println(""+joinPoint.getSignature().getName()+"结束。。。@After");
    	}
    
    	/**
    	 * JoinPoint 参数位置必须在首位，不然报错
    	 * 返回通知(@AfterReturning)：在目标方法正常返回之后运行
    	 * @AfterReturning
    	 * @param joinPoint
    	 * @param result
    	 */
    	@AfterReturning(value="pointCut()",returning="result")
    	public void logReturn(JoinPoint joinPoint,Object result){
    		System.out.println(""+joinPoint.getSignature().getName()+"正常返回。。。@AfterReturning:运行结果：{"+result+"}");
    	}
    
    	/**
    	 * 异常通知(@AfterThrowing)：在目标方法出现异常以后运行
    	 * @param joinPoint
    	 * @param exception
    	 */
    	@AfterThrowing(value="pointCut()",throwing="exception")
    	public void logException(JoinPoint joinPoint,Exception exception){
    		System.out.println(""+joinPoint.getSignature().getName()+"异常。。。异常信息：{"+exception+"}");
    	}
    
    	/**
    	 * 环绕通知(@Around)：动态代理，手动推进目标方法运行（joinPoint.procced()）
    	 * @annotation(aroundAuthority):使用自定义注解 进行切面管理
    	 */
    	@Around(value = "@annotation(aroundAuthority)")
    	public void aroundMethod(ProceedingJoinPoint proceedingJoinPoint, AroundAuthority aroundAuthority){
    		try {
    			System.out.println(aroundAuthority.memthodName());
    			proceedingJoinPoint.proceed();
    		} catch (Throwable throwable) {
    			throwable.printStackTrace();
    		}
    	}
    
    
    }

测试类：

@Test
    	public void test01(){
    		AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfAOP.class);
    		MathCalculator mathCalculator = applicationContext.getBean(MathCalculator.class);
    		mathCalculator.div(1, 2);
    		mathCalculator.annotationMethodAop();
    		applicationContext.close();
    	}

结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU0OTU3OA_size_16_color_FFFFFF_t_70][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU0OTU3OA_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/29/9a27b378b0f14e409f01d729b34edd84.png