spring-aop 基本使用

spring-aop 基本使用

spring 的注解方式的 aop 步骤：
关键三个步骤如下：
1）、将业务逻辑组件和切面类都加在容器中，告诉spring哪个是切面类（@Aspect）
2）、在切面类上的每个通知方法上标注通知注解，告诉spring何时何地运行（切入点表达式）
3）、开启基于注解的aop模式，@EnableAspectJAutoProxy

具体步骤如下：

1，导入aop模块：spring aop：(spring-aspects)
2，定义一个业务逻辑类（MathCalculator）;业务逻辑运行的时候讲日志进行打印（方法之前，方法运行结束之后）
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，导入maven依赖

<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-aspects</artifactId>
	<version>4.3.12.RELEASE</version>
</dependency>

2，编写切面类

package com.test.spring.aop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;

import java.util.Arrays;

/**
 * 切面类
 */
@Aspect
//@Component
public class LogAspect {

    // 抽取公共的切入点表达式
    // 1，本类引用
    // 2，其他的切面引用; com.test.spring.aop.LogAspect.pointCut()
    @Pointcut("execution(public * com.test.spring.aop.MathCalculator.*(..))")
    public void pointCut(){

    }

    // @Before 在目标方法之前切入，切入点表达式（指定在哪个方法切入）
    @Before("pointCut()")
    public void logStart(JoinPoint joinPoint){
        Object[] args = joinPoint.getArgs();
        System.out.println(joinPoint.getSignature().getName() + "方法运行。。。，参数列表是：{"+ Arrays.asList(args)+"}");
    }

    @After("com.test.spring.aop.LogAspect.pointCut()")
    public void logEnd(JoinPoint joinPoint){
        System.out.println(joinPoint.getSignature().getName() + "方法运行结束。。。");
    }

    @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(JoinPoint joinPoint, Exception exception){
        exception.printStackTrace();
        System.out.println(joinPoint.getSignature().getName() + "方法执行发生异常，异常信息：{}");
    }

}

3，配置类

package com.test.spring.aop;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

/**
 * 1，导入aop模块：spring aop：(spring-aspects)
 * 2，定义一个业务逻辑类（MathCalculator）;业务逻辑运行的时候讲日志进行打印（方法之前，方法运行结束之后）
 * 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模式】
 *
 */
@Configuration
@EnableAspectJAutoProxy
public class MainConfigOfAop {

    @Bean
    public MathCalculator calulate(){
        return new MathCalculator();
    }

    @Bean
    public LogAspect logAspect(){
        return new LogAspect();
    }
}

4，业务类

package com.test.spring.aop;

/**
 *
 */
public class MathCalculator {

    public int div(int i, int j){
        System.out.println("...MathCalculator.div..方法运行。。。。");
        return i/j;
    }

}

5，测试类

package com.test.spring;

import com.test.spring.aop.MainConfigOfAop;
import com.test.spring.aop.MathCalculator;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * 
 */
public class IocTest_Aop {

    @Test
    public void test(){
        AnnotationConfigApplicationContext context
                = new AnnotationConfigApplicationContext(MainConfigOfAop.class);

        // 不能直接new对象，需要在spring容器中获取对象才能使用触发aop的作用
//        MathCalculator mathCalculator = new MathCalculator();
//        mathCalculator.div(1,1);

        MathCalculator calculator = context.getBean(MathCalculator.class);

    }

}