SpringAOP概念

作者: 逍遥白亦 | 来源:发表于2021-03-19 21:22 被阅读0次

1. AOP概念

1.1 定义

AOP全称为Aspet-Oriented Programming，中文名字为面向切面编程。使用AOP，我们可以对类似日志和安全等系统需求进行模块化的组织，简化系统需求与实现之间的对比关系，进而使得整个系统的实现更具模块化。

1.2 AOP国家的公民

1.2.1 Joinpoint

在系统运行之前，AOP的功能模块都需要织入到OOP的功能模块中。所以，要进行这种织入过程，我们需要知道在系统的哪些执行点上进行织入操作，这些将要在其之上进行织入操作的系统执行点就称之为Joinpoint。

以下是一些较为常见的Joinpoint类型

方法调用
方法执行
构造方法调用
构造方法执行
字段设置
字段获取
异常处理执行
类初始化

1.2.2 Pointcut

Pointcut概念代表的是Joinpoint的表述方式。将横切逻辑织入当前系统的过程中，需要参照Pointcut规定的Joinpoint信息，才可以知道应该往系统的哪些Joinpoint上织入横切逻辑。

1.2.3 Advice

是单一横切关注点逻辑的载体，它代表将会织入到Joinpoint的横切逻辑。

Advice可以分成多种具体形式。

Before Advice
After Advice
Around Advice

1.2.4 Aspect

Aspect是对系统中的横切关注点逻辑进行模块化封装的AOP概念实体。通常情况下，Aspect可以包含多个Pointcut以及相关Advice定义。

1.2.5 Weaving

用来将Aspect模块化的横切关注点集成到OOP的现存系统中。

1.2.6 目标对象

符合Pointcut所指定的条件，将在织入过程中被织入横切逻辑的对象。

最后附上一张AOP各个概念所处的场景图。
[图片上传失败...(image-26c2fc-1616160107453)]

1.3 Java平台上的AOP实现机制

1.3.1 动态代理

JDK1.3之后，引入了动态代理（Dynamic Proxy）机制，可以在运行期间，为相应的接口（Interface）动态生成对应的代理对象。所以，我们可以将横切关注点逻辑封装到动态代理的InvocationHandler中，然后在系统运行期间，根据横切关注点需要织入的模块位置，将横切逻辑织入到相应的代理类中。以动态代理类为载体的横切逻辑，现在当然就可以与系统其他实现模块一起工作了。

这种方式实现的唯一缺点是，所有需要织入横切关注点逻辑的模块类都得实现相应的接口。

SpringAOP默认情况采用这种机制来实现AOP机能。

1.3.2 动态字节码增强

通常的class文件都是从Java源代码文件使用Javac编译器编译而成的，但只要符合Javaclass规范，我们也可以使用ASM或者CGLIB等Java工具库，在程序运行期间，动态构建字节码的class文件。

Spring AOP在无法采用动态代理机制进行AOP功能扩展的时候，会使用CGLIB库的动态字节码增强支持来实现AOP的功能扩展。

1.3.3 Java代码生成

事务属于跨越整个系统的一种横切关注点，所以，EJB容器提供的声明性事务支持，属于一种AOP功能模块实现。但早期EJB容器在实现这一功能的时候，大多会采用Java代码生成技术，这就是我们不需要提供CMP的接口实现类的原因，也是EJB容器提供商大多提供部署接口或者专有部署工具的原因。

1.3.4 自定义类加载器

我们可以通过自定义类加载器的方式完成横切逻辑到系统的织入，自定义类加载器通过读取外部文件规定的织入规则和必要信息，在加载class文件期间就可以将横切逻辑添加到系统模块类的现有逻辑中，然后将改动后的class交给Java虚拟机运行。

1.3.5 AOL扩展

AOL扩展是最强大、也最难掌握的一种方式，我们之前提到的AspectJ就属于这种方式。在这种方式中，AOP的各种概念在AOL中大都有一一对应的实体。我们可以使用扩展过的AOL，实现任何AOP概念实体甚至OOP概念实体，比如Aspect以及Class。所有的AOP概念在AOL中得到了最完美的表达。

2. SpringAOP的实现机制

SpingAOP属于第二代AOP，采用动态代理机制和字节码生成技术实现。

先从动态代理机制的根源--代理模式开始介绍。

2.1 代理模式

在代理模式中通常涉及四种角色，如图所示。

代理模式类图

ISubject:该接口是对被访问者或者被访问资源的抽象
SubjectImpl:被访问者或者被访问资源的具体实现类
SubjectProxy:被访问者或者被访问资源的代理实现类，该类持有一个ISubject接口的具体实例。在这个场景中，我们要SubjectImpl进行代理，那么SubjectProxy现在持有的就是SubjectImpl的实例
Client。代表访问者的抽象角色。

SubjectImpl和SubjectProxy都实现了相同的接口ISubject，而SubjectProxy内部持有SubjectImpl的引用。当Client通过request()请求服务的时候，SubjectProxy将转发该请求给SubjectImpl。从这个角度来说，SubjectProxy反而有多此一举之嫌了。不过，SubjectProxy的作用不只局限于请求的转发，更多时候是对请求添加更多访问限制。

在将请求转发给被代理对象SubjectImp1之前或者之后，都可以根据情况插入其他处理逻辑，比如在转发之前记录方法执行开始时间，在转发之后记录结束时间，这样就能够对SubjectImpl的 request()执行的时间进行检测。或者，可以只在转发之后对SubjectImpl的request()方法返回结果进行覆盖，返回不同的值。甚至，可以不做请求转发，这样，就不会有SubjectImpl的访问发生。如果你不希望某人访问你的SubjectImpl，这种场景正好适合。

代理对象subjectProxy就像是subjectImpl的影子，只不过这个影子通常拥有更多的功能。如果 SubjectImpl是系统中的Joinpoint所在的对象，即目标对象，那么就可以为这个目标对象创建一个代理对象，然后将横切逻辑添加到这个代理对象中。

SpringAOP本质上就是采用这种代理机制实现的，但是，具体实现细节上有所不同。

2.1.1 示例代码

先上代码，把上边的流程图变为具体代码。

package com.spring.aop;

public interface ISubject {

    void request();

}

package com.spring.aop;

public class SubjectImpl implements ISubject {

    @Override
    public void request() {
        System.out.println("执行代理类的方法");
    }
}

package com.spring.aop;

public class SubjectProxy implements ISubject {

    private ISubject iSubject;

    public SubjectProxy(ISubject iSubject) {
        this.iSubject = iSubject;
    }

    @Override
    public void request() {
        //添加前置逻辑
        iSubject.request();
        //添加后置逻辑
    }
}

package com.spring.aop;

public class Client {

    public static void main(String[] args) {
        SubjectProxy subjectProxy = new SubjectProxy(new SubjectImpl());
        subjectProxy.request();
    }

}

假设我们要对系统中所有的request()方法进行拦截，那么我们应该为SubjectImpl提供一个ServiceControlSubjectProxy，以添加这种横切逻辑。

package com.spring.aop;

public class ServiceControlSubjectProxy implements ISubject {

    private ISubject subject;

    public ServiceControlSubjectProxy(ISubject subject) {
        this.subject = subject;
    }

    @Override
    public void request() {
        //添加新的前置逻辑
        subject.request();
        //添加新的后置逻辑
    }
}

之后我们使用ServiceControlSubjectProxy代替SubjectImpl使用，如下所示

        ServiceControlSubjectProxy serviceControlSubjectProxy = 
                new ServiceControlSubjectProxy(new SubjectImpl());
        serviceControlSubjectProxy.request();

但是系统中不一定就ISubject的实现类有request()方法，如果要对所有request()方法都添加这个逻辑，那么还需要新写一个代理类，而实际上，这些代理对象所要添加的横切逻辑是一样的。当系统中存在成百上千目标对象时，我们就要为这成百上千的目标对象创建成百上千的代理对象。

2.2 动态代理

JDK1.3之后引入了一种称之为动态代理（Dynamic Proxy）的机制。使用该机制，我们可以为指定的接口在系统运行期间动态地生成代理对象，从而帮助我们走出最初使用静态代理实现AOP的窘境。

动态代理机制的实现主要由一个类和一个接口组成，即java.lang.reflect.Proxy类和java.lang.reflect.InvocationHåndler接口。下面，让我们看一下，如何使用动态代理来实现之前的功能。虽然要为ISubject和TRequestable两种类型提供代理对象，但因为代理对象中要添加的横切逻辑是一样的，所以，我们只需要实现一个TnvocationHandler就可以了。

2.2.1 具体代码

package com.spring.aop;

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

public class ProxyInvocationHandler implements InvocationHandler {

    private Object target;

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("添加前置逻辑");
        Object object = method.invoke(target, args);
        System.out.println("添加后置逻辑");
        return object;
    }
}

package com.spring.aop;

import java.lang.reflect.Proxy;

public class Client {

    public static void main(String[] args) {
        ISubject subject = new SubjectImpl();
        subject = (ISubject) Proxy.newProxyInstance(
                subject.getClass().getClassLoader(),
                subject.getClass().getInterfaces(),
                new ProxyInvocationHandler(subject)
        );

        subject.request();

        IRequestable requestable = new RequestableImpl();
        requestable = (IRequestable) Proxy.newProxyInstance(
                requestable.getClass().getClassLoader(),
                requestable.getClass().getInterfaces(),
                new ProxyInvocationHandler(requestable)
        );

        requestable.request();

    }
}

动态代理虽好，但不能满足所有的需求。因为动态代理机制只能对实现了相应Interface的类使用，如果某个类没有实现任何的Interface，就无法使用动态代理机制为其生成相应的动态代理对象。虽然面向接口编程应该是提倡的做法，但不排除其他的编程实践。对于没有实现任何Interface的目标对象，我们需要寻找其他方式为其动态的生成代理对象。

默认情况下，如果Spring AOP发现目标对象实现了相应Interface，则采用动态代理机制为其生成代理对象实例。而如果目标对象没有实现任何Interface，Spring AOP会尝试使用一个称为CGLIB（Code GenerationLibrary）的开源的动态字节码生成类库，为目标对象生成动态的代理对象实例。

2.3 动态字节码生成

使用动态字节码生成技术扩展对象行为的原理是，我们可以对目标对象进行继承扩展，为其生成相应的子类，而子类可以通过覆写来扩展父类的行为，只要将横切逻辑的实现放到子类中，然后让系统使用扩展后的目标对象的子类，就可以达到与代理模式相同的效果了。

但是，使用继承的方式来扩展对象定义，也不能像静态代理模式那样，为每个不同类型的目标对象都单独创建相应的扩展子类。所以，我们要借助于CGLIB这样的动态字节码生成库，在系统运行期间动态地为目标对象生成相应的扩展子类。

2.3.1 代码

package com.spring.aop;

public class Subject {

    public void request(){
        System.out.println("没有接口的目标类");
    }

}

package com.spring.aop;


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

import java.lang.reflect.Method;

public class CGLIBProxy implements MethodInterceptor {

    @Override
    public Object intercept(Object object, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        System.out.println("这是CGLIB前置逻辑");
        Object result = methodProxy.invokeSuper(object, args);
        System.out.println("这是CGLIB后置逻辑");
        return result;
    }
}

package com.spring.aop;

import org.springframework.cglib.proxy.Enhancer;

public class Client {

    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(Subject.class);
        enhancer.setCallback(new CGLIBProxy());
        Subject proxy = (Subject) enhancer.create();
        proxy.request();
    }
}

3. SpringAOP中的术语

切面(Aspect):指关注点模块化，这个关注点可能会横切多个对象。事务管理是企业级Java应用中有关横切关注点的例子。在Spring AOP中，切面可以使用通用类基于模式的方法或者在普通类中以@Aspect注解来实现
连接点(Join point):在Spring AOP中，一个连接点总是代表一个方法的执行，其实就代表增强的方法
通知(Advice):在切面的某个特定的连接点上执行的动作。通知有多种类型，包括"around"、"before"和"after"等待。通知的类型将在后面的章节进行讨论。许多AOP框架，包括Spring在内，都是以拦截器做通知模型的，并维护着一个以连接点为中心的拦截器链
目标对象(Target):目标对象指将要被增强的对象。即包含主业务逻辑的类的对象
切点(Pointcut):匹配连接点的断言。通知和切点表达式相关联，并在满足这个切点的连接点上运行(例如，当执行某个特定名称的方法时)。切点表达式如何和连接点匹配是AOP的核心:Spring默认使用AspectJ切点语义
顾问(Advisor):顾问是Advice的一种包装体现，Advisor是Pointcut以及Advice的一个结合，用来管理Advice和Pointcut。应用无需关心
织入(Weaving):将通知切入连接点的过程叫织入
引入(Introductions):可以将其他接口和实现动态引入到targetClass中