Spring注解驱动开发—AOP: AOP功能测试

一丶 基本概念

AOP: [动态代理]
  指在程序运行期间动态的将某段代码切入到指定方法指定位置进行运行的编程方式。

  1丶导入 aop模块：Spring Aop: (spring-aspects)
  2丶定义一个业务逻辑类（MathCalulcator）;在业务逻辑运行的时候将日志进行打印（方法之前，方法运行结束丶方法出现异常，）
  3丶定义一个日志切面类（LogAspects）:切面类里面的方法需要动态感知MathCalculator.div
  通知方法：
  前置通知(@Before)：logStart: 在目标方法（div）运行之前运行
  后置通知(@After)：logEnd;在目标方法（div）运行结束之后运行（无论方法正常接结束还是异常结束）
  返回通知(@AfterReturning)：logReturn:在目标方法（div）正常返回之后运行
  异常通知(@AfterThrowing)：logexception：在目标方法（div）出现异常以后运行
  环绕通知(@Around)：动态代理，手动推进目标方法运行（joinPoint.procced()）
 4、给切面类的目标方法标注何时何地运行（通知注解）

三步
 5丶将切面类和业务逻辑类（目标方法所在类）都加入到容器中
 6、必须告诉Spring哪个是切面类，在切面类上加上注解。@Aspect
 7、给配置类中加@EnableAspectJAutoProxy 开启基于注解的切面模式（Aop 模式）

 

二 测试

1 业务方法

package com.mongoubiubiu.aop;

public class MathCalculator {
        
    public int div(int i,int j){
        return i/j;
    }

}

2 切面类

package com.mongoubiubiu.aop;

import java.util.Arrays;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;

import com.mchange.v1.util.ArrayUtils;

/**
 * 切面类
 * @author 86138
 *
 */
@Aspect
public class LogAspects {
    //抽取公共的切入点表达式
    //1丶本类引用     在MathCalulator的任意方法 任意参数执行切入
    @Pointcut("execution(public int com.mongoubiubiu.aop.MathCalculator.*(..))")
    public void pointCut(){}

    @Before("pointCut()")
    public void logStart(JoinPoint joinpoint){
        Object args=    joinpoint.getArgs();
        System.out.println(joinpoint.getSignature().getName()+"名字运行。。。。。参数列表是：{"+Arrays.asList(args)+"}");
    }
    
    @After("pointCut()")
    public void logEnd(){
        System.out.println("除法结束。。。。参数列表是：{}");
    }
    
    //JoinPoint 一定要出现在参数表的第一位
    @AfterReturning(value="pointCut()",returning="result")
    public void logreturn(JoinPoint joinpoint,Object result){
        System.out.println(joinpoint.getSignature().getName()+"名字运行正常返回。。。。结果是：{"+result+"}");
    }
    
    @AfterThrowing(value="pointCut()",throwing="exception")
    public void logexception(Exception exception){
        System.out.println("除法异常信息。。。。异常信息：{"+exception+"}");
    }
    
}

3 配置类

package com.mongoubiubiu.conf;

import org.aspectj.lang.annotation.Aspect;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

import com.mongoubiubiu.aop.LogAspects;
import com.mongoubiubiu.aop.MathCalculator;

/**
 * AOP: [动态代理]
 *       指在程序运行期间动态的将某段代码切入到指定方法指定位置进行运行的编程方式。
 * 
 * 1丶导入 aop模块：Spring Aop: (spring-aspects)
 * 2丶定义一个业务逻辑类（MathCalulcator）;在业务逻辑运行的时候将日志进行打印（方法之前，方法运行结束丶方法出现异常，）
 * 3丶定义一个日志切面类（LogAspects）:切面类里面的方法需要动态感知MathCalculator.div
 *       通知方法：
 *               前置通知(@Before)：logStart: 在目标方法（div）运行之前运行
 *               后置通知(@After)：logEnd;在目标方法（div）运行结束之后运行（无论方法正常接结束还是异常结束）
 *               返回通知(@AfterReturning)：logReturn:在目标方法（div）正常返回之后运行
 *               异常通知(@AfterThrowing)：logexception：在目标方法（div）出现异常以后运行
 *               环绕通知(@Around)：动态代理，手动推进目标方法运行（joinPoint.procced()）
 *4、给切面类的目标方法标注何时何地运行（通知注解）
 *
 *三步
 *5丶将切面类和业务逻辑类（目标方法所在类）都加入到容器中
 *6、必须告诉Spring哪个是切面类，在切面类上加上注解。@Aspect
 *7、给配置类中加@EnableAspectJAutoProxy 开启基于注解的切面模式（Aop 模式）
 *
 *
 *
 *
 */
@EnableAspectJAutoProxy
@Configuration
public class MainConfigOfAop {
    //业务逻辑类加入容器中
    @Bean
     public MathCalculator mathCalculator(){
         return new MathCalculator();
     }
     //切面类加入容器中
    @Bean
    public LogAspects logAspects(){
        return new LogAspects();
    }
    

}

4 Junit测试类

package com.mongougbiubiu.test;

import javax.sql.DataSource;

import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import com.mongoubiubiu.aop.MathCalculator;
import com.mongoubiubiu.conf.MainConfigOfAop;
import com.mongoubiubiu.conf.MainConfigOfAutowired;
import com.mongoubiubiu.conf.MainConfigOfProfile;


public class IOC_Test_Aop {
    

    @Test
    public void Test01(){
        //创建ioc 容器
        AnnotationConfigApplicationContext applica=    new AnnotationConfigApplicationContext(MainConfigOfAop.class);

        MathCalculator clazz=    applica.getBean(MathCalculator.class);
        
        clazz.div(1, 0);
        applica.close();
    } 

}

5 结果