AOP学习

AOP Demo

一、AOP注解

	
	/**
	* 标注于配置类上，开启基于注解的AOP模式
	*/
	@EnableAspectJAutoProxy

	/**
	* 标注在类上，告诉Spring这个类是一个AOP类
	*/
	@Aspect

    /**
     * 切入点
     */
    @Pointcut

    /**
     * 前置通知：标注在方法上，在目标方法运行前运行
     */
    @Before

    /**
     * 后置通知：标注在方法上，在目标方法运行结束后运行(无论方法是正常结束还是异常结束)
     */
    @After

    /**
     * 返回通知：标注在方法上，在目标方法运行结束后，正常返回结果后运行
     */
    @AfterReturning
  
    /**
     * 异常通知：标注在方法上，在目标方法出现异常后运行
     */
    @AfterThrowing

    /**
     * 环绕通知：标注在方法上，动态代理
     */
    @Around
   

一、Demo

1、目录结构

2、pom.xml导入AOP模块

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

3、代码

（1）业务类：Operation.java

package com.dashu.service;

public class Operation {


    public int division(int x, int y) {
        return x / y;
    }

}

（2）AOP类：LogAspects.java

package com.dashu.aspects;

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

//标注在类上，告诉Spring这个类是一个AOP类
@Aspect
public class LogAspects {

    /**
     * 切入点
     */
    @Pointcut("execution(* com.dashu.service..*(..))")
    public void logPointcut() {

    }

    /**
     * 前置通知：在目标方法运行前运行
     */
    @Before("logPointcut()")
    public void logBefore(JoinPoint joinPoint) {
        System.out.println("--------------前置通知--------------");
        System.out.println("前置通知：在目标方法运行前运行");
        System.out.println("方法[" + joinPoint.getSignature().getName() + "]运行了");
        System.out.println("参数：");
        Object[] args = joinPoint.getArgs();
        for (int i = 0; i < args.length; i++) {
            System.out.println("参数" + i + "：" + args[i] + "[" + args[i].getClass() + "]");
        }
        System.out.println("----------------------------");
    }

    /**
     * 后置通知：在目标方法运行结束后运行(无论方法是正常结束还是异常结束)
     */
    @After("logPointcut()")
    public void logAfter(JoinPoint joinPoint) {
        System.out.println("--------------后置通知--------------");
        System.out.println("后置通知：在目标方法运行结束后运行");
        System.out.println("方法[" + joinPoint.getSignature().getName() + "]运行结束了");
        System.out.println("----------------------------");

    }


    /**
     * 返回通知：在目标方法运行结束后，正常返回结果后运行
     */
    @AfterReturning(value = "logPointcut()", returning = "result")
    public void logAfterReturning(JoinPoint joinPoint, Object result) {
        System.out.println("--------------返回通知--------------");
        System.out.println("返回通知：在目标方法运行结束后，正常返回结果后运行");
        System.out.println("方法[" + joinPoint.getSignature().getName() + "]运行结束了,正常返回结果");
        System.out.println("返回值：" + result);

        System.out.println("----------------------------");
    }

    /**
     * 异常通知：在目标方法出现异常后运行
     */
    @AfterThrowing(value = "logPointcut()", throwing = "exception")
    public void logAfterThrowing(JoinPoint joinPoint, Exception exception) {
        System.out.println("--------------异常通知--------------");
        System.out.println("异常通知：在目标方法出现异常后运行");
        System.out.println("方法[" + joinPoint.getSignature().getName() + "]运行发生异常");
        System.out.println("异常信息：" + exception.getMessage());
        System.out.println("----------------------------");
    }


}

（3）配置类：BeanConfig.java

package com.dashu.config;
import com.dashu.aspects.LogAspects;
import com.dashu.service.Operation;
import org.springframework.context.annotation.*;

@EnableAspectJAutoProxy
@Configuration
public class BeanConfig {

    @Bean
    public LogAspects logAspects(){
        return new LogAspects();
    }

    @Bean
    public Operation operation(){
        return new Operation();
    }
}

（4）测试类：Main.java

package com.dashu;
import com.dashu.config.BeanConfig;
import com.dashu.service.Operation;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Main {

    public static void main(String[] args) {

        //加载配置类获取容器
        AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(BeanConfig.class);

        //容器中获取Operation
        Operation operation = annotationConfigApplicationContext.getBean(Operation.class);

        //运行方法
        operation.division(1,1);

    }

}

4、测试结果

（1）正常

		//运行方法
        operation.division(1,1);

（2）异常

	//运行方法
    operation.division(1,0);