SpringBoot之AOP

面向切面编程（Aspect Oriented Programming, AOP）。它能够建立一种横向关系，对业务类使用横切技术，将多个类的公共方法抽取出来，留下业务核心方法，这样将业务类的关注点变成了核心关注点和横切关注点。

Springboot之AOP的Demo

1. 新建spring项目。
   pom.xml

   <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-aop</artifactId>
   </dependency>
   

2. Service层

package com.boot.bootaop.service;

import com.boot.bootaop.pojo.User;

import java.util.List;

/**
 * @description 操作User 的接口
 */
public interface UserService {
    //查询功能
    List<User> getUsers();
}

package com.boot.bootaop.service.impl;

import com.boot.bootaop.pojo.User;
import com.boot.bootaop.service.UserService;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

@Service("userService")
public class UserServiceImpl implements UserService {
    @Override
    public List<User> getUsers() {
        System.out.println("getUsers");
        List<User> list = new ArrayList<>();
        list.add(new User("ww",22));
        return list;
    }
}

3. Aspect类

package com.boot.bootaop.aspect;

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

/**
 * Aspect 注解让Spring知道这是一个切面程序
 * @description 切面类
 */
@Aspect
@Component
public class UserAspect {

    /**
     * 前置通知
     */
    @Before("execution ( * com.boot.bootaop.service.impl.UserServiceImpl.getUsers(..) )")
    public void before(){
        System.out.println("before...");
    }

    /**
     * 后置通知
     */
    @After("execution ( * com.boot.bootaop.service.impl.UserServiceImpl.getUsers(..) )")
    public void after(){
        System.out.println("after...");
    }

    /**
     * 返回通知
     */
    @AfterReturning("execution ( * com.boot.bootaop.service.impl.UserServiceImpl.getUsers(..) )")
    public void afterReturning(){
        System.out.println("afterReturning...");
    }

    /**
     * 异常通知
     */
    @AfterThrowing("execution ( * com.boot.bootaop.service.impl.UserServiceImpl.getUsers(..) )")
    public void afterThrowing(){
        System.out.println("afterThrowing");
    }
}

4. 测试类Controller

package com.boot.bootaop.controller;

import com.boot.bootaop.pojo.User;
import com.boot.bootaop.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

/**
 * @description 测试
 */
@RestController
public class MyController {

    @Autowired
    private UserService userService;

    @GetMapping("/get")
    public List<User> get(){
        return userService.getUsers();
    }
}

5. 查看运行结果
   

“execution ( * com.boot.bootaop.service.impl.UserServiceImpl.getUsers(…) )” 是一个切入点，是一个正则表达式，标明什么情况下启用AOP。

AOP术语

• 连接点（joinPoint）： 就是拦截的方法。
• 切点（pointCut）： 一系列连接点的集合，对于一个切面而言，执行的不仅仅是一个类的某个方法 ，也可以是多个类的多个方法，根据正则表达式找到连接点。
• 通知（Advice）： 在连接点处，AOP执行的动作。主要有5种通知，前置通知（BeforeAdvice）、后置通知（AfterAdvice）、返回通知（AfterReturningAdvice）、异常通知（AfterThroeingAdvice）、环绕通知（AroundAdvice）。
• 引入（introduction）： 在被通知的类中引入字段和方法。
• 目标对象（target）： 被代理的对象，即包含连接点的对象。
• 切面（aspect）： 可以定义各类通知、切点和引入的内容。
• 织入（weave）： 把切面连接到应用程序生，并生成一个被通知的对象。

AOP详解

连接点与两种代理

PointCut源码

先查看PointCut的源码

public interface Pointcut {

	//在程序中一个类会被多个代理进行代理，Spring会进入责任链模式，这里返回一个类过滤器。
	ClassFilter getClassFilter();

	//返回一个方法匹配器
	MethodMatcher getMethodMatcher();

	// 默认Pointcut实例
	Pointcut TRUE = TruePointcut.INSTANCE;
}

再看MethodMatcher 的源码

public interface MethodMatcher {

	boolean matches(Method method, Class<?> targetClass);

	//返回值决定使用静态匹配器还是动态匹配器，true则使用动态匹配器。
	boolean isRuntime();

	boolean matches(Method method, Class<?> targetClass, Object... args);

	MethodMatcher TRUE = TrueMethodMatcher.INSTANCE;
}

两个matches方法，区别多了args参数，定义了两种匹配器，一种为静态匹配器，对方法的名称和入参类型进行一次匹配判断；另一种动态匹配器，因为参数的不同，每次增强方法都会进行判断。

JDK代理与cglib代理

SpringBoot有两种代理，JDK与cglib。引入spring-boot-starter-aop,默认启动AOP,也可以在配置文件中配置，spring.aop.auto = true。

使用配置文件进行配置，

spring:
  aop:
    proxy-target-class: true

默认为true,即使用cglib代理，false则使用jdk代理。
具体使用哪种代理，根据代理类是否实现了接口决定，如果实现接口则使用jdk代理；如果没有实现接口，就算设置 spring.aop.proxy-target-class=false,也会使用cglib代理。

也可以使用@EnableAspectJAutoProxy注解，表示启动AOP,优先级会高于application.xml。
第一个参数表示使用什么代理，true为cglib代理，默认为false。第二个参数表示在横切关注点中可以使用AopContext这个类。

如

@SpringBootApplication
@EnableAspectJAutoProxy(proxyTargetClass = true,exposeProxy = true)
@PropertySource(value = "classpath:application.xml",ignoreResourceNotFound = true)
public class JdkProxyTest {

    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(MyConfig.class);
        UserService userService = (UserService) context.getBean("userService");
        System.out.println(userService.getClass().getName());
    }
}

//代理类
public List<User> getUsers() {
		//System.out.println("getUsers ");
        System.out.println("getUsers "+ AopContext.currentProxy());
        List<User> list = new ArrayList<>();
        list.add(new User("ww",22));
        return list;
    }

切面

就是我们前面用@Aspect注解的类，有了连接点后，我们就需要切面来增强功能。

• 定义切面。需要@Aspect说明注解的类是一个切面，在使用@Component注解将切面交给Spring的IOC容器进行管理。

• 增强功能。对切点做一些增强操作：前置增强，后置增强等。

切点

切点就是一些连接点二点集合。
之前在每个注解上都写了匹配的正则表达式，比较复杂，可以使用@PointCut注解进行简化。
对之前的切点进行简化

@Aspect
@Component
public class UserAspect {

    @Pointcut("execution ( * com.boot.bootaop.service.impl.UserServiceImpl.getUsers(..) )")
    public void pointCut(){}

    /**
     * 前置通知
     */
    @Before("pointCut()")
    public void before(){
        System.out.println("before...");
    }

    /**
     * 后置通知
     */
    @After("pointCut()")
    public void after(){
        System.out.println("after...");
    }

    /**
     * 返回通知
     */
    @AfterReturning("pointCut()")
    public void afterReturning(){
        System.out.println("afterReturning...");
    }

    /**
     * 异常通知
     */
    @AfterThrowing("pointCut()")
    public void afterThrowing(){
        System.out.println("afterThrowing");
    }
}

切点表达式

切点表达式的语法：
execution ( [可见性] 返回类型 [声明类型].方法名(参数)[异常] )

常见通配符和运算符如下：

• * ：匹配所有字符。
• .. ：匹配多个参数。
• + ：匹配类及其子类。
• &&、||、！：运算符。

指示符：

• execution：匹配执行连接点指示符。
• within: 匹配连接点的类或者包。
• this: 向通知方法传入代理对象。
• target: 向通知方法传入目标对象。
• args: 根据目标方法的参数进行匹配。
• @within: 在类上的匹配注解类型。
• annotation(): 限定带有指定注解的连接点。

多个切面与@Order

多个切面的顺序如何确定，使用Order注解。
如

@Aspect
@Order(1)
@Component
public class UserAspect {

    @Pointcut("execution ( * com.boot.bootaop.service.impl.UserServiceImpl.getUsers(..) )")
    public void pointCut(){}

    /**
     * 前置通知
     */
    @Before("execution ( * com.boot.bootaop.service.impl.UserServiceImpl.getUsers(..) )")
    public void before(){
        System.out.println("before...");
    }
	...
}