2. Spring4.x AOP

AOP的基本使用

1. pom.xml中导入依赖

    org.springframework.boot
    spring-boot-starter-aop

2. 新建一个拦截规则的注解

package com.xiaohan.aop;

import java.lang.annotation.*;

/**
 * 拦截规则的注解
 */

@Target(ElementType.METHOD)             // 限制该注解只能使用在方法基本上
@Retention(RetentionPolicy.RUNTIME)     // 保留策略 运行时可见
@Documented
public @interface SysLog {
    String name();
}

3. 定义被拦截的类

package com.xiaohan.aop;

import org.springframework.stereotype.Service;

//使用 方法规则的 被拦截类
@Service
public class DemoMethodService {

    public void add() {
    }
}

package com.xiaohan.aop;

import org.springframework.stereotype.Service;

//使用 注解的 被拦截类
@Service
public class DemoAnnotionService {

    @SysLog(name = "注解方式拦截的add操作")
    public void add() {
    }
}

4. 定义切面类
   @Before 前置通知 在目标方法执行之前执行
   @After 后置通知 在目标方法执行之后执行 无论是否发生异常
   @AfterReturning 返回通知 在目标方法返回结果之后执行
   @AfterThrowing 异常通知 在目标方法抛出异常之后通知
   @Around 环绕通知 围绕着目标方法执行

package com.xiaohan.aop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;
import java.lang.reflect.Method;

//  声明这是一个切面类
@Aspect
@Component
public class LogAspect {

    //  定义拦截规则(切点)
    @Pointcut("@annotation(com.xiaohan.aop.SysLog)")
    public void annotationPointCut() {
    }

    // 使用@Pointcut定义的切点规则
    @After("annotationPointCut()")
    public void after(JoinPoint joinPoint) {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        SysLog sysLog = method.getAnnotation(SysLog.class);
        System.err.println("后置通知 " + sysLog.name());
    }

    // 使用execution表达式定义的切点规则
    @Before("execution(* com.xiaohan.aop.DemoMethodService.*(..))")
    public void before(JoinPoint joinPoint) {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        System.err.println("前置通知 " + "方法规则方式拦截的方法" + method.getName());
    }

    // 环绕通知是唯一一个可以 终止连接点(方法)执行 的通知
    @Around("annotationPointCut()")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        MethodSignature signature = (MethodSignature) point.getSignature();
        Method method = signature.getMethod();
        long beginTime = System.currentTimeMillis();
        //执行方法
        Object result = point.proceed();
        //执行时长(毫秒)
        long time = System.currentTimeMillis() - beginTime;
        System.err.println("环绕通知 拦截" + "注解的" + method.getName() + "方法执行了" + time + "毫秒");
        return result;
    }
}

5. 新建一个配置类

package com.xiaohan.aop;

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

@Configuration
@ComponentScan("com.xiaohan.aop")

//开启Spring对AspectJ代理的支持
@EnableAspectJAutoProxy
public class AopConfig {
}

6. 创建一个Main方法 初始化容器 并测试

package com.xiaohan.aop;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

// AOP
public class Main {
    public static void main(String[] args) {
        ApplicationContext ac = new AnnotationConfigApplicationContext(AopConfig.class);
        DemoMethodService demoMethodService = ac.getBean(DemoMethodService.class);
        demoMethodService.add();
        DemoAnnotionService demoAnnotionService = ac.getBean(DemoAnnotionService.class);
        demoAnnotionService.add();
    }
}

输出

前置通知 方法规则方式拦截的方法add
环绕通知 拦截注解的add方法执行了7毫秒
后置通知 注解方式拦截的add操作