Spring3.X学习笔记-SpringAOP

Myth丶恋晨 2022-06-05 09:11 171阅读 0赞

> Spring AOP是AOP技术在Spring中的具体实现，Spring AOP构建于IoC之上，和IoC一同构成了Spring的两大核心。

## 1、AOP概述 ##

AOP（Aspect Oriented Programming），即面向切面编程，可以说是OOP（Object Oriented Programming，面向对象编程）的补充和完善。OOP引入封装、继承、多态等概念来建立一种对象层次结构，用于模拟公共行为的一个集合。不过OOP允许开发者定义纵向的关系，但并不适合定义横向的关系，例如日志功能。日志代码往往横向地散布在所有对象层次中，而与它对应的对象的核心功能毫无关系。对于其它类型的代码，如安全性、异常处理和透明的持续性也都是如此，这种散布在各处的无关的代码被称为横切（cross cutting），在OOP设计中，它导致了大量代码的重复，而不利于各个模块的重用。

AOP技术恰恰相反，它利用一种称为”横切”的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其命名为”Aspect”，即切面。所谓”切面”，简单说就是那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块之间的耦合度，并有利于未来的可操作性和可维护性。使用”横切”技术，AOP把软件系统分为两个部分：**核心关注点**和**横切关注点**。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。横切关注点的一个特点是，他们经常发生在核心关注点的多处，而各处基本相似，比如权限认证、日志、事物。AOP的作用在于分离系统中的各种关注点，将核心关注点和横切关注点分离开来。

### 1.1 AOP基础概念 ###

学习一个新事物首先就要了解其基本概念和关键术语，为了更好的理解AOP思想，下面先来看下有关AOP的重要概念：

*  **连接点（Joinpoint）：**被拦截到的点，因为Spring只支持方法类型的连接点，所以在Spring中连接点指的就是被拦截到的方法，实际上连接点还可以是字段或者构造器。连接点有两个信息确定：第一是方法表示的程序执行点；第二是相对点表示的方位。Spring使用切点对执行点进行定位，而方位在增强类型中定义。
 *  **切点（Pointcut）：**对连接点进行拦截的定义，AOP通过“切点”定位特定连接点，一个切点可以匹配多个连接点。
 *  **增强（Advice）：**指拦截到连接点之后要执行的代码，还包括方位信息，结合这个方位信息和上面的切点就可以定位到特定的连接点了。通知分为前置（BeforeAdvice）、后置（AfterRetuningAdvice）、异常（ThrowsAdvice）、最终、环绕通知五类。
 *  **目标对象（Target）：**增强逻辑的织入目标类。
 *  **引介（Introduction）：**在不修改代码的前提下，引介可以在运行期为类动态地添加一些方法或字段。
 *  **织入（Weaving）：**织入是将增强添加到目标类具体连接点上的过程。根据不同的实现技术，AOP有三种织入的方式:  
    
    
     *  编译期织入，这要求使用特殊的Java编译器；
     *  类装载期织入，这要求使用特殊的类装载器；
     *  动态代理织入，在运行期为目标类添加增强生成子类的方式。
 *  **代理（Proxy）：**一个类被AOP织入增强后，就生成了一个融合原类和增强逻辑的代理类。代理类可能是和原类具有相同接口的类，也可能就是原类的子类，所以我们可以采用调用原类相同的方式调用代理类。
 *  **切面（Aspect）：**切面是横切关注点的抽象。它由切点和增强(引介)组成，它既包括了横切逻辑的定义，也包括连接点的定义，Spring AOP就是负责实施切面的框架，它将切面所定义的横切逻辑织入到切面所指定的连接点中。

**提示：** *Spring采用动态代理织入，而Aspectj采用编译器织入和类装载器织入。*

### 1.2 基础知识 ###

Spring AOP使用动态代理技术在运行期织入增强的代码，包括两种代理机制，一种是基于JDk的动态代理；另一种是基于CGLib的动态代理。下面先看一个未使用动态代理的例子：

package com.hhxs.bbt.proxy;
    public class ForumServiceImpl implements ForumService { 
    
        @SuppressWarnings("static-access")
        @Override
        public void removeTopic(int topicId) {
            // 性能监视开始
            PerformanceMonitor.begin("com.hhxs.proxy.ForumServiceImpl.removeTopic");
            System.out.println("模拟删除Topic记录:" + topicId);
            try {
                Thread.currentThread().sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 性能监视结束
            PerformanceMonitor.end();
        }
    
        @SuppressWarnings("static-access")
        @Override
        public void removeForum(int forumId) {
            PerformanceMonitor.begin("com.hhxs.proxy.ForumServiceImpl.removeForum");
            System.out.println("模拟删除Forum记录:" + forumId);
            try {
                Thread.currentThread().sleep(40);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            PerformanceMonitor.end();
        }
    }

package com.hhxs.bbt.proxy;
    
    public class PerformanceMonitor {
    
        // 通过一个ThreadLocal保存调用线程相关的性能监视信息
        private static ThreadLocal<MethodPerformance> performanceRecord = new ThreadLocal<MethodPerformance>();
    
        // 启动对某一目标方法的性能监视
        public static void begin(String method) {
            System.out.println("begin monitor...");
            MethodPerformance mp = new MethodPerformance(method);
            performanceRecord.set(mp);
        }
    
        public static void end() {
            System.out.println("end monitor...");
            MethodPerformance mp = performanceRecord.get();
            mp.printPerformance();
        }
    }

package com.hhxs.bbt.proxy;
    public class MethodPerformance {
    
        private long begin;
        private long end;
        private String serviceMethod;
    
        public MethodPerformance(String serviceMethod) {
            this.serviceMethod = serviceMethod;
            this.begin = System.currentTimeMillis();
        }
    
        public void printPerformance() {
            end = System.currentTimeMillis();
            long elapse = end - begin;
            System.out.println(serviceMethod + "花费" + elapse + "毫秒。");
        }
    }

package com.iflytek.bbt.proxy;
    import com.hhxs.bbt.proxy.ForumService;
    import com.hhxs.bbt.proxy.ForumServiceImpl;
    public class TestForumService {
    
        public static void main(String[] args) {
            ForumService forumService = new ForumServiceImpl();
            forumService.removeForum(10);
            forumService.removeTopic(1012);
        }
    }

**运行结果如下：**

begin monitor...
    模拟删除Forum记录:10
    end monitor...
    com.hhxs.proxy.ForumServiceImpl.removeForum花费46毫秒。
    begin monitor...
    模拟删除Topic记录:1012
    end monitor...
    com.hhxs.proxy.ForumServiceImpl.removeTopic花费21毫秒。

正如上述代码所示，当某个方法需要进行性能监视，就必须调整方法代码，在方法前后分别添加上开启性能监视和结束性能监视的代码。我们希望通过代理的方式，将业务类方法中开启和结束性能监视的这些横切代码从业务类中完全剥离出来。并通过JDK动态代理技术或CGLib动态代理技术将横切代码织入到目标方法的相应位置。

#### 1.2.1 JDK动态代理 ####

JDK的动态代理主要涉及到`java.lang.reflect`包中的两个类：Proxy和InvocationHandler。其中InvocationHandler，通过实现该接口定义横切逻辑。而Proxy利用InvocationHandler动态创建一个符合某一接口的实例，生成目标类的代理对象。

package com.hhxs.bbt.proxy;
    public class ForumServiceImpl implements ForumService { 
    
        @SuppressWarnings("static-access")
        @Override
        public void removeTopic(int topicId) {
            System.out.println("模拟删除Topic记录:" + topicId);
            try {
                Thread.currentThread().sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    
        @SuppressWarnings("static-access")
        @Override
        public void removeForum(int forumId) {
            System.out.println("模拟删除Forum记录:" + forumId);
            try {
                Thread.currentThread().sleep(40);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

package com.hhxs.bbt.proxy;
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    public class PerformanceHandler implements InvocationHandler { 
        private Object target;
    
        public PerformanceHandler(Object target) {
            this.target = target;
        }
    
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            PerformanceMonitor.begin(target.getClass().getName()+"."+method.getName());
            Object obj = method.invoke(target, args);
            PerformanceMonitor.end();
            return obj;
        }
    }

**首先，我们实现了InvocationHandler接口，该接口定义了一个`invode(Object proxy,Method method,Object[] args)`的方法。其中，method是被代理目标实例的某个具体方法，通过它可以发起目标实例方法的反射调用；args是传给被代理实例某一个方法的入参数组，在方法反射调用时使用。此外，我们在构造函数里通过target传入希望被代理的目标对象，在InvocationHandler接口方法`invoke(Object proxy,Method method,Object[] args)`里，将目标实例传给method.invoke()方法，调用目标实例的方法。**

package com.iflytek.bbt.proxy;
    import java.lang.reflect.Proxy;
    import com.hhxs.bbt.proxy.ForumService;
    import com.hhxs.bbt.proxy.ForumServiceImpl;
    import com.hhxs.bbt.proxy.PerformanceHandler;
    
    public class TestForumService {
    
        public static void main(String[] args) {
            // 希望被代理的目标业务类
            ForumService target = new ForumServiceImpl();
            // 将目标业务类和横切代码编织到一起
            PerformanceHandler handler = new PerformanceHandler(target);
            // 根据编织了目标业务类逻辑和性能监视横切逻辑的InvocationHandler实例创建代理实例
            ForumService proxy = (ForumService) Proxy.newProxyInstance(target.getClass().getClassLoader(),
                    target.getClass().getInterfaces(),
                    handler);
            proxy.removeForum(10);
            proxy.removeTopic(1012);
        }
    }

上面的代码完成业务类代码和横切代码的编织工作并生成了代理实例。运行以上代码，输出结果：

begin monitor...
    模拟删除Forum记录:10
    end monitor...
    com.hhxs.bbt.proxy.ForumServiceImpl.removeForum花费42毫秒。
    begin monitor...
    模拟删除Topic记录:1012
    end monitor...
    com.hhxs.bbt.proxy.ForumServiceImpl.removeTopic花费25毫秒。

#### 1.2.2 CGLib动态代理 ####

通过上面的实例可以看出，使用JDK创建代理有一个限制，即它只能为接口创建代理实例。对于没有通过接口定义业务方法的类，JDK的代理技术就无法处理了，而CGLib采用非常底层的字节码技术，通过创建一个子类，并在子类中采用方法拦截所有父类方法的调用，并顺势织入横切逻辑。下面采用CGLib技术改造上面的例子：

package com.hhxs.bbt.proxy;
    
    import java.lang.reflect.Method;
    import net.sf.cglib.proxy.Enhancer;
    import net.sf.cglib.proxy.MethodInterceptor;
    import net.sf.cglib.proxy.MethodProxy;
    public class CglibProxy implements MethodInterceptor { 
        private Enhancer enhancer = new Enhancer();
        public Object getProxy(Class<?> clazz) {
            enhancer.setSuperclass(clazz);
            enhancer.setCallback(this);
            // 通过字节码技术动态创建子类实例
            return enhancer.create();
        }
    
        @Override
        public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
            PerformanceMonitor.begin(obj.getClass().getName()+"."+method.getName());
            Object result = proxy.invokeSuper(obj, args);
            PerformanceMonitor.end();
            return result;
        }
    }

上述代码中，`intercept(Object obj,Method method,Object[] args,MethodProxy proxy)`是CGLib定义Interceptor接口的方法，它拦截所有目标类方法的调用，obj表示目标类的实例：method为目标类方法的反射对象；args为方法的动态入参；而proxy为代理类实例。

package com.iflytek.bbt.proxy;
    
    import com.hhxs.bbt.proxy.CglibProxy;
    import com.hhxs.bbt.proxy.ForumServiceImpl;
    public class TestForumService {
    
        public static void main(String[] args) {
            CglibProxy proxy = new CglibProxy();
            ForumServiceImpl forumService = (ForumServiceImpl) proxy.getProxy(ForumServiceImpl.class);
            forumService.removeForum(10);
            forumService.removeTopic(1024);
        }
    }

运行以上代码，输出结果：

begin monitor...
    模拟删除Forum记录:10
    end monitor...
    com.hhxs.bbt.proxy.ForumServiceImpl$$EnhancerByCGLIB$$5f4be940.removeForum花费62毫秒。
    begin monitor...
    模拟删除Topic记录:1024
    end monitor...
    com.hhxs.bbt.proxy.ForumServiceImpl$$EnhancerByCGLIB$$5f4be940.removeTopic花费24毫秒。

**代理知识小结**

上述例子中，我们虽然通过PerformanceHandler或CglibProxy实现了性能监视横切逻辑的动态织入，但这种实现方式存在三个明显需要改进的地方：

*  目标类的所有方法都添加了性能监视横切逻辑，而有时，我们可能只是希望对业务类中的某些特定方法添加横切逻辑。
 *  我们通过硬编码的方式指定的织入横切逻辑的切入点。
 *  需要手工编写代理实例的创建过程，为不同类创建代理时，需要分别编写相应程序代码，无法做到通用。

以上三个问题，在AOP中占有重要的地位，Spring AOP的主要工作就是围绕以上三点展开：Spring AOP通过Pointcut（切点）指定在哪些类的哪些方法上织入横切逻辑，通过Advice（增强）描述横切逻辑和方法的具体织入点。此外，Spring通过Advisor（切面）将Pointcut和Advice两者组装起来。有了Advisor的信息，Spring就可以利用JDK或CGLib的动态代理技术采用统一的方式为目标Bean创建织入切面的代理对象了。**值得一提的是**，由于CGLib动态创建子类的方式生成代理对象，所以不能对目标类中的final，private等方法进行代理。

--------------------

————本文结束感谢您的阅读————