spring-boot-aop

什么是 aop

面向切面的程序设计（Aspect-oriented programming，AOP，又译作面向方面的程序设计、剖面导向程序设计）是计算机科学中的一种程序设计思想，旨在将横切关注点与业务主体进行进一步分离，以提高程序代码的模块化程度。通过在现有代码基础上增加额外的通知（Advice）机制，能够对被声明为“切点（Pointcut）”的代码块进行统一管理与装饰，如“对所有方法名以‘set*’开头的方法添加后台日志”。该思想使得开发人员能够将与代码核心业务逻辑关系不那么密切的功能（如日志功能）添加至程序中，同时又不降低业务代码的可读性。面向切面的程序设计思想也是面向切面软件开发的基础。

面向切面的程序设计将代码逻辑切分为不同的模块（即关注点（Concern），一段特定的逻辑功能 )。几乎所有的编程思想都涉及代码功能的分类，将各个关注点封装成独立的抽象模块（如函数、过程、模块、类以及方法等），后者又可供进一步实现、封装和重写。部分关注点“横切”程序代码中的数个模块，即在多个模块中都有出现，它们即被称作“横切关注点（Cross-cutting concerns, Horizontal concerns）”。

日志功能即是横切关注点的一个典型案例，因为日志功能往往横跨系统中的每个业务模块，即“横切”所有有日志需求的类及方法体。而对于一个信用卡应用程序来说，存款、取款、帐单管理是它的核心关注点，日志和持久化将成为横切整个对象结构的横切关注点。

切面的概念源于对面向对象的程序设计的改进，但并不只限于此，它还可以用来改进传统的函数。与切面相关的编程概念还包括元对象协议、主题（Subject）、混入（Mixin）和委托（Delegate）。

AOP 中的相关概念

看过了上面解释，想必大家对 aop 已经有个大致的雏形了, 但是又对上面提到的切面之类的术语有一些模糊的地方，接下来就来讲解一下 AOP 中的相关概念，了解了 AOP 中的概念，才能真正的掌握 AOP 的精髓。

• Aspect（切面）：Aspect 声明类似于 Java 中的类声明，在 Aspect 中会包含着一些 Pointcut 以及相应的 Advice。
• Joint point（连接点）：表示在程序中明确定义的点，典型的包括方法调用，对类成员的访问以及异常处理程序块的执行等等，它自身还可以嵌套其它 joint point。
• Pointcut（切点）：表示一组 joint point，这些 joint point 或是通过逻辑关系组合起来，或是通过通配、正则表达式等方式集中起来，它定义了相应的 Advice 将要发生的地方。
• Advice（增强）：Advice 定义了在 Pointcut 里面定义的程序点具体要做的操作，它通过 before、after 和 around 来区别是在每个 joint point 之前、之后还是代替执行的代码。
• Target（目标对象）：织入 Advice 的目标对象.。

Weaving（织入）：将 Aspect 和其他对象连接起来, 并创建 Adviced object 的过程

spring aop

Spring AOP 使用纯 Java 实现，它不需要专门的编译过程，也不需要特殊的类装载器，它在运行期通过代理方式向目标类织入增强代码。在 Spring 中可以无缝地将 Spring AOP、IoC 和 AspectJ 整合在一起。Spring AOP 构建在动态代理基础之上，因此，Spring 对 AOP 的支持局限于方法拦截。在 Java 中动态代理有两种方式：JDK 动态代理和 CGLib 动态代理

• jdk proxy

java 动态代理是利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用 InvokeHandler 来处理。

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * <p>
 *
 * @author leone
 * @since 2018-11-09
 **/
public class JdkProxy {

    interface IUserService {Integer delete(Integer userId);
    }

    static class UserServiceImpl implements IUserService {
        @Override
        public Integer delete(Integer userId) {
            // 业务
            System.out.println("delete user");
            return userId;
        }
    }

    // 自定义 InvocationHandler
    static class UserServiceProxy implements InvocationHandler {
        // 目标对象
        private Object target;

        public UserServiceProxy(Object target) {this.target = target;}

        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println("------ 方法调用前 ---------");
            // 执行相应的目标方法
            Object result = method.invoke(target, args);
            System.out.println("------ 方法调用后 ---------");
            return result;
        }
    }

    public static void main(String[] args) {IUserService userService = new UserServiceImpl();
        // 创建调用处理类
        UserServiceProxy handler = new UserServiceProxy(userService);
        // 得到代理类实例
        IUserService proxy = (IUserService) Proxy.newProxyInstance(UserServiceImpl.class.getClassLoader(),
                                 new Class[]{IUserService.class}, handler);
        // 调用代理类的方法
        Integer userId = proxy.delete(3);
        System.out.println(userId);
    }

}

• cglib proxy

而 cglib 动态代理是利用 asm 开源包，对代理对象类的 class 文件加载进来，通过修改其字节码生成子类来处理。

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * <p>
 *
 * @author leone
 * @since 2018-11-09
 **/
public class CglibProxy {

    static class UserService implements MethodInterceptor {

        private Object target;

        /**
         * 业务方法
         *
         * @param userId
         * @return
         */
        public Integer delete(Integer userId) {System.out.println("delete user");
            return userId;
        }

        /**
         * 利用 Enhancer 类生成代理类
         *
         * @param target
         * @return
         */
        public Object getInstance(Object target) {
            this.target = target;
            // 创建加强器，用来创建动态代理类
            Enhancer enhancer = new Enhancer();
            // 为加强器指定要代理的业务类（即：为下面生成的代理类指定父类）enhancer.setSuperclass(target.getClass());
            // 设置回调：对于代理类上所有方法的调用，都会调用 CallBack，而 Callback 则需要实现 intercept() 方法进行拦
            enhancer.setCallback(this);
            // 创建动态代理类对象并返回
            return enhancer.create();}


        /**
         * @param o
         * @param method
         * @param objects
         * @param methodProxy
         * @return
         * @throws Throwable
         */
        @Override
        public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) 
                                throws Throwable {System.out.println("------ 方法调用前 ---------");
            Object object = methodProxy.invokeSuper(o, objects);
            System.out.println("------ 方法调用后 ---------");
            return object;
        }

    }

    public static void main(String[] args) {UserService userService = new UserService();
        UserService proxy = (UserService) userService.getInstance(userService);
        Integer userId = proxy.delete(2);
        System.out.println(userId);
    }

}

1、如果目标对象实现了接口，默认情况下会采用 JDK 的动态代理实现 AOP，可以强制使用 CGLIB 实现 AOP
2、如果目标对象没有实现了接口，必须采用 CGLIB 库，spring 会自动在 JDK 动态代理和 CGLIB 之间转换

spirng boot aop

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

Advice 的主要类型

• @Before：该注解标注的方法在业务模块代码执行之前执行，其不能阻止业务模块的执行，除非抛出异常；
• @AfterReturning：该注解标注的方法在业务模块代码执行之后执行；
• @AfterThrowing：该注解标注的方法在业务模块抛出指定异常后执行；
• @After：该注解标注的方法在所有的 Advice 执行完成后执行，无论业务模块是否抛出异常，类似于 finally 的作用；
• @Around：该注解功能最为强大，其所标注的方法用于编写包裹业务模块执行的代码，其可以传入一个 ProceedingJoinPoint 用于调用业务模块的代码，无论是调用前逻辑还是调用后逻辑，都可以在该方法中编写，甚至其可以根据一定的条件而阻断业务模块的调用；
• @DeclareParents：其是一种 Introduction 类型的模型，在属性声明上使用，主要用于为指定的业务模块添加新的接口和相应的实现。

切点表达式

1. 通配符

• [*] 匹配任意字符，但只能匹配一个元素
• [..] 匹配任意字符，可以匹配任意多个元素，表示类时，必须和 * 联合使用
• [+] 必须跟在类名后面，如 Horseman+，表示类本身和继承或扩展指定类的所有类

2. 逻辑运算符

表达式可由多个切点函数通过逻辑运算组成

• && 与操作，求交集，也可以写成 and

例如 execution(* chop(..)) && target(Horseman)  表示 Horseman 及其子类的 chop 方法

• || 或操作，任一表达式成立即为 true，也可以写成 or

例如 execution(* chop(..)) || args(String)  表示名称为 chop 的方法或者有一个 String 型参数的方法

• ! 非操作，表达式为 false 则结果为 true，也可以写成 not

例如 execution(* chop(..)) and !args(String)  表示名称为 chop 的方法但是不能是只有一个 String 型参数的方法

• execution() 方法匹配模式串

表示满足某一匹配模式的所有目标类方法连接点。如 execution(* save(..)) 表示所有目标类中的 save() 方法。

由于 Spring 切面粒度最小是达到方法级别，而 execution 表达式可以用于明确指定方法返回类型，类名，方法名和参数名等与方法相关的部件，并且在 Spring 中，大部分需要使用 AOP 的业务场景也只需要达到方法级别即可，因而 execution 表达式的使用是最为广泛的。如下是 execution 表达式的语法

execution(modifiers-pattern? ret-type-pattern declaring-type-pattern?name-pattern(param-pattern) throws-pattern?)

execution(< 修饰符 > < 返回类型 > < 类路径 > < 方法名 >(< 参数列表 >) < 异常模式 > )

• modifiers-pattern：方法的可见性，如 public，protected；
• ret-type-pattern：方法的返回值类型，如 int，void 等；
• declaring-type-pattern：方法所在类的全路径名，如 com.spring.Aspect；
• name-pattern：方法名类型，如 buisinessService()；
• param-pattern：方法的参数类型，如 java.lang.String；
• throws-pattern：方法抛出的异常类型，如 java.lang.Exception；

切点函数

• @annotation(annotation-type) 方法注解类名

  如下示例表示匹配使用 com.leone.aop.AopTest 注解标注的方法：

  @annotation(com.leone.aop.AopTest)

• args(param-pattern) 方法入参切点函数

  如下示例表示匹配所有只有一个参数，并且参数类型是 java.lang.String 类型的方法：

  args(java.lang.String)

• @args(annotation-type) 方法入参类注解切点函数

  如下示例表示匹配使用了 com.leone.aop.AopTest 注解标注的类作为参数的方法：

  @args(com.leone.aop.AopTest)

• within(declaring-type-pattern) 类名匹配切点函数

  within 表达式只能指定到类级别，如下示例表示匹配 com.leone.aop.UserService 中的所有方法：

  within(com.leone.aop.UserService)

• @within(annotation-type) 类注解匹配切点函数

  如下示例表示匹配使用 org.springframework.web.bind.annotation.RestController 注解标注的类：

  @within(org.springframework.web.bind.annotation.RestController)

• target(declaring-type-pattern) 类名切点函数

  如下示例表示匹配 com.leone.aop.UserService 中的所有方法：

  target(com.leone.aop.UserService)

• this

spring-boot-aop 实战

• 配置切面类，实现代理

1. 在类上使用 @Component 注解把切面类加入到 IOC 容器中
2. 在类上使用 @Aspect 注解使之成为切面类

import lombok.extern.slf4j.Slf4j;
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;

/**
 * 描述一个切面类
 *
 * @author leone
 * @since 2018-06-21
 **/
@Slf4j
@Aspect
@Component
public class AopConfig {

    /**
     * 1. 通配符
     * [*]  匹配任意字符，但只能匹配一个元素
     * <p>
     * [..] 匹配任意字符，可以匹配任意多个元素，表示类时，必须和 * 联合使用
     * <p>
     * [+]  必须跟在类名后面，如 Horseman+，表示类本身和继承或扩展指定类的所有类
     * <p>
     * 切点表达式分为 修饰符  返回类型  包路径  方法名  参数
     * <p>
     * 2. 切点表达式
     * <p>
     * 3. 逻辑运算符
     * 表达式可由多个切点函数通过逻辑运算组成
     * ** && 与操作，求交集，也可以写成 and
     * <p>
     * 例如 execution(* chop(..)) && target(Horseman)  表示 Horseman 及其子类的 chop 方法
     * <p>
     * ** || 或操作，任一表达式成立即为 true，也可以写成 or
     * <p>
     * 例如 execution(* chop(..)) || args(String)  表示名称为 chop 的方法或者有一个 String 型参数的方法
     * <p>
     * ** ! 非操作，表达式为 false 则结果为 true，也可以写成 not
     * <p>
     * 例如 execution(* chop(..)) and !args(String)  表示名称为 chop 的方法但是不能是只有一个 String 型参数的方法
     */
    @Pointcut("execution(* com.leone.boot.aop.service.*.*(..))")
    public void pointCut() {}

    /**
     * 环绕通知在 target 开始和结束执行
     *
     * @param point
     * @return
     */
    @Around(value = "pointCut()")
    public Object around(ProceedingJoinPoint point) {long start = System.currentTimeMillis();
        String methodName = point.getSignature().getName();
        log.info("around method name: {} params: {}", methodName, Arrays.asList(point.getArgs()));
        try {log.info("around end time: {}", (System.currentTimeMillis() - start) + "ms!");
            return point.proceed();} catch (Throwable e) {log.error("message: {}", e.getMessage());
        }
        return null;
    }

    /**
     * 前置通知在 target 前执行
     *
     * @param joinPoint
     */
    // @Before("@annotation(com.leone.boot.aop.anno.AopBefore)")
    // @Before("within(com.leone.boot.aop.controller.*)")
    // @Before("@within(org.springframework.web.bind.annotation.RestController)")
    // @Before("target(com.leone.boot.aop.controller.UserController)")
    @Before("@target(com.leone.boot.aop.anno.ClassAop) && @annotation(com.leone.boot.aop.anno.AopBefore)")
    public void beforeMethod(JoinPoint joinPoint) {String methodName = joinPoint.getSignature().getName();
        List<Object> args = Arrays.asList(joinPoint.getArgs());
        log.info("before inform method name: {} param: {}", methodName, args);
    }

    /**
     * 后置通知在 target 后执行
     *
     * @param joinPoint
     */
    @After("@args(org.springframework.stereotype.Component) && 
            execution(* com.leone.boot.aop.controller.*.*(..))")
    public void afterMethod(JoinPoint joinPoint) {String methodName = joinPoint.getSignature().getName();
        List<Object> args = Arrays.asList(joinPoint.getArgs());
        log.info("after inform method name : {} param: {}", methodName, args);
    }

    /**
     * 后置返回在 target 返回后执行
     *
     * @param joinPoint
     * @param result
     */
    @AfterReturning(value = "within(com.leone.boot.aop.controller.*)", returning = "result")
    public void afterReturning(JoinPoint joinPoint, Object result) {String methodName = joinPoint.getSignature().getName();
        log.info("afterReturning inform method name: {} return value: {}", methodName, result);
    }

    /**
     * 后置异常通知在 target 异常后执行
     *
     * @param joinPoint
     * @param ex
     */
    @AfterThrowing(value = "args(com.leone.boot.common.entity.User) && 
            execution(* com.leone.boot.aop.controller.*.*(..))", throwing ="ex")
    public void afterThrowing(JoinPoint joinPoint, Exception ex) {String methodName = joinPoint.getSignature().getName();
        log.info("afterThrowing inform method name: {} exceptions: {}" + methodName, ex);
    }
}

• 测试类

import com.leone.boot.aop.anno.AopBefore;
import com.leone.boot.aop.anno.ClassAop;
import com.leone.boot.aop.interf.UserService;
import com.leone.boot.common.entity.User;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author leone
 * @since 2018-06-21
 **/
@Slf4j
@ClassAop
@RestController
@RequestMapping("/api")
public class UserController {

    private UserService userService;

    public UserController(UserService userService) {this.userService = userService;}


    @AopBefore
    @RequestMapping(value = "/user/{userId}", method = RequestMethod.GET)
    public User findOne(@PathVariable Long userId) {return userService.findOne(userId);
    }

    @AopBefore
    @RequestMapping("/user")
    public User save(User user) {return user;}
}

github