1、AOP基于注解的开发实例

what's AOP：指在程序运行期间将某段代码切入到指定方法位置进行运行的编程方式

示例：定义一个业务逻辑类，在业务逻辑运行的时候将日志进行打印（方法之前，方法之后，方法出现异常）

（1）pom.xml中导入spring-aspects的jar包

（2）编写业务逻辑类

public class Calculator {
    public int divide (int i,int j){
        return i / j;
    } 
}

（3）编写业务切面类

基本知识：

功能：定义一个切面类，感知divide方法运行到哪里

通知方法：

• 前置通知（@Before）
• 后置通知（@After）在目标方法运行结束后，无论是否正常结束，都进行调用
• 返回通知（@AfterReturning）
• 异常通知（@AfterThrowing）
• 环绕通知（@Around）动态代理（joinPoint.proceed()）

//告诉Spring这是一个切面类
@Aspect
@Component
public class LogAspects {

   //抽取公共点的切点表达式
    @Pointcut("execution(public int aop.MyCalculator.divide(int,int))")
    public void pointcut(){}

    //目标方法执行前切入
    @Before("pointcut()")
    public void logStart  (JoinPoint joinPoint) {
        //joinPoint.getArgs()   获取方法参数列表
        //joinPoint.getSignature().getName() 获取方法名
        //joinPoint.getSignature().getDeclaringType() 获取类名
        System.out.println("-------除法运行前打印-------");
        System.out.println("切面的方法名：" + joinPoint.getSignature().getName());
        System.out.println("class name:" + joinPoint.getSignature().getDeclaringType());
        System.out.println("args:" + Arrays.toString(joinPoint.getArgs()));
    }

    //目标方法执行后执行
    @After("pointcut()")
    public void logEnd (JoinPoint joinPoint) {
        System.out.println("-------除法运行后打印-------");
    }

    //返回值的时候打印
    @AfterReturning(value = "pointcut()",returning = "result")
    public void logReturn  (Object result) {
        System.out.println("-------获取返回的时候打印-------");
        System.out.println("切面的方法返回值：" + result);
    }

    //程序异常报错时打印
    @AfterThrowing(value = "pointcut()",throwing = "exception")
    public void logException (Exception exception) {
        System.out.println("-------除法异常的时候打印-------");
        System.out.println("打印异常：" + exception.toString());
        System.out.println("打印异常信息：" + exception.getMessage());
    }
}

（4）在注解中传递需要切入的方法，和参数

（5）将切面类和业务逻辑类都加入到Spring容器中

@Configuration
public class SpringMainConfig {
    //业务逻辑类加到容器中（需要插入切面的类）
    @Bean
    public MyCalculator myCalculator () {
        return new MyCalculator();
    }

    //切面类
    @Bean
    public LogAspects logAspects () {
        return new LogAspects();
    }
}

（6）告知Spring哪一个是切面类

//告诉Spring容器这是一个切面类
@Aspect
public class LogAspects {
    @Before("execution(public int aop.MyCalculator.*(..))")
    public void logStart () {
        System.out.println("除法运行前。。。");
    }
    public void logEnd () {
        System.out.println("除法运行后。。。");
    }
    public void logReturn () {
        System.out.println("查看除法结果。。。");
    
}

（7）给配置类开启基于注解的AOP模式

//开启基于注解的AOP模式
//相当于Spring配置文件中的配置基于注解的AOP模式
//<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

@EnableAspectJAutoProxy
@Configuration
public class SpringMainConfig {
    ......
}

（8）测试

工程路径/test/java下的测试类

public class AspectTest {
    @Test
    public void test01 () {
        AnnotationConfigApplicationContext ctx = ContextUtil.getContext();
        MyCalculator calculator = (MyCalculator) ctx.getBean("myCalculator");
        calculator.divide(20,4);
    }
}

（9）输出

-------除法运行前打印-------
切面的方法名：divide
class name:class aop.MyCalculator
args:[20, 4]
-------除法运行后打印-------
-------获取返回的时候打印-------
切面的方法返回值：5