Spring AOP 使用注释（AspectJ）完成前置通知、后置通知、返回通知、异常通知的用法

小编用的是Intellij2017，用maven搭建了环境。

 

1.maven所用到的依赖如下

<!-- Spring需要 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>4.3.9.RELEASE</version>
    </dependency>

    <!-- Spring需要 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>4.3.7.RELEASE</version>
    </dependency>

    <!-- aspectj 的jar-->
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjrt</artifactId>
      <version>1.8.9</version>
    </dependency>
    
    <!-- aspectj 的jar-->
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjtools</artifactId>
      <version>1.8.9</version>
    </dependency>

    <!-- aspectj 的jar-->
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.7.4</version>
    </dependency>

    <!-- aop需要的jar-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>4.3.9.RELEASE</version>
    </dependency>

2.建立一个接口

package aop.impl;

public interface AtithmeticCalculator {

    int add(int i, int j);
    int sub(int i, int j);
    int mul(int i, int j);
    int div(int i, int j);
}

3.建立接口的实现类

 注意：因为要切实现类中的方法，所以要将实现类加到IOC容器中（@Component）

package aop.impl;

import org.springframework.stereotype.Component;

@Component
public class AtithmeticCalculatorImpl implements AtithmeticCalculator {
    public int add(int i, int j) {
        int result = i + j;
        return result;
    }

    public int sub(int i, int j) {
        int result = i - j;
        return result;
    }

    public int mul(int i, int j) {
        int result = i * j;
        return result;
    }

    public int div(int i, int j) {
        int result = i / j;
        return result;
    }
}

4.建立一个类，实现横切的方法

  注意：把这个类声明为切面，需要把类放到IOC容器中（@Component）、再声明为一个切面（@Aspect）

package aop.impl;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

import java.util.Arrays;
import java.util.List;

//把这个类声明为切面，需要把类放到IOC容器中、再声明为一个切面
@Aspect
@Component
class LoggingAspect {
    //该方法是一个前置通知，在目标方法开始之前执行
    @Before("execution(public int aop.impl.AtithmeticCalculator.*(int ,int ))")
    public void beforeMethod(JoinPoint joinPoint) {
        //获取当前执行的方法名
        String methodName = joinPoint.getSignature().getName();
        //获取当前运行的对象
        List<Object> args = Arrays.asList(joinPoint.getArgs());
        System.out.println("前置通知：The method" + methodName + " begins with " + args);
    }

    //后置通知：在目标方法执行后（无论是否发生异常），执行的通知
    //在后置通知中还不能访问目标方法执行的结果
    @After("execution(public int aop.impl.AtithmeticCalculator.*(int ,int ))")
    public void afterMethod(JoinPoint joinPoint) {
        //获取当前执行的方法名
        String methodName = joinPoint.getSignature().getName();
        System.out.println("后置通知：The method " + methodName + " ends");
    }

    //返回通知:在方法正常结束后反回的通知,可以访问到方法的返回值
    @AfterReturning(value = "execution(public int aop.impl.AtithmeticCalculator.*(int ,int ))",
            returning = "result")
    public void afterReturning(JoinPoint joinPoint, Object result) {
        String methodName = joinPoint.getSignature().getName();
        System.out.println("返回通知：The method " + methodName + " ends with " + result);

    }

    /**
     * 在目标方法出现异常时会执行的代码
     * 可以访问到异常对象；且可以指定在出现特定异常时在执行通知代码
     *
     * @param joinPoint
     * @param ex
     */
    //异常通知
    @AfterThrowing(value = "execution(public int aop.impl.AtithmeticCalculator.*(int ,int ))",
            throwing = "ex")
    public void afterThrowing(JoinPoint joinPoint, Exception ex) {
        String methodName = joinPoint.getSignature().getName();
        System.out.println("异常通知：The method " + methodName + " occurs exception: " + ex);
    }

    /**
     * 环绕通知需要携带 ProceedingJoinPoint 类型的参数
     * 环绕通知类似于动态代理的全过程：ProceedingJoinPoint 类型的参数可以决定是否执行目标方法
     * 且环绕通知必须有返回值，返回值必须为目标方法的返回值
     */
    @Around("execution(public int aop.impl.AtithmeticCalculator.*(..))")
    public Object aroundMethod(ProceedingJoinPoint pjd) {
        Object result = null;
        String methodName = pjd.getSignature().getName();
        //执行目标方法
        try {
            //前置通知
            System.out.println("环绕通知(前置)：The method " + methodName + " begins with " + Arrays.asList(pjd.getArgs()));
            result = pjd.proceed();
            //后置通知
            System.out.println("环绕通知(后置)The method ends with "+result);
        } catch (Throwable e) {
            e.printStackTrace();
            System.out.println("环绕通知(异常)The method ocuurs exception: " + e );
            throw new RuntimeException(e);
        }
        System.out.println("环绕通知(后置) The method ends");
        return result;
    }
}

5.建立一个Bean

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--配置自动扫描的包-->
    <context:component-scan base-package="aop.impl" ></context:component-scan>

    <!--使 AspjectJ 注释起作用：自动为匹配的类生成代理对象-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

6.测试类

package aop.impl;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {
   public static  void main(String args[]){
       //1.创建Spring的IOC容器
       ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
       //2.从IOC容器中获取Bean的实例
       AtithmeticCalculator atithmeticCalculator = context.getBean(AtithmeticCalculator.class);
       //3.使用Bean
       int result = atithmeticCalculator.add(3,6);
       System.out.println("result:"+result);

       result = atithmeticCalculator.mul(9,8);
       System.out.println("result："+result);

       result  = atithmeticCalculator.div(5,0);
       System.out.println(result);
   }
}