Spring_AOP_01——概念讲解

该文主要讲Spring AOP的一些概念，不会细讲如何使用AOP。
关于AOP的使用，可以参考文末链接。

AOP 概述

AOP是Spring框架的另一个基本组成部分。这一次我们就探讨一下Spring的这一重要特性。面向切面（Aspect Oriented Programming）

需要明确的是，AOP并不是Spring独有，AspectJ也实现了AOP的功能。AOP和OOP一样，是一种编程范式。而Spring实现的AOP功能比较经典。

实现AOP使用的是代理模式。通过对需要切入类的包装和增强，创建代理类。从而实现切入到执行过程中的作用。

代理主要分为两种方式：

静态代理，基本的代理方式，AspectJ使用。
动态代理，Spring使用的代理方式，使用了JDK和CGLIB的代理方式。

具体的代理实现AOP的原理，在下一期细讲。

什么是AOP？
AOP（Aspect Oriented Programming）面向切面编程，可以说是OOP（Object Oriented Programming）面向对象编程的补充和完善。

具体来说，AOP是通过 预编译方式 和 运行时的动态代理 实现程序功能的统一维护的一种技术。AOP是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。

为什么要用AOP？
随着开发的系统越来越复杂，传统OOP程序会出现一些不自然的现象。核心业务中总掺杂一些不相关的业务。例如：日志记录，权限验证，事务控制，性能检测等等。这些功能模块可以说跟核心业务并无关系，而且核心业务也不关心他们。

这些场景就是一些分散的对象，涉及到了公共的行为。OOP在这方面显得无能为力。
这里要说一下，虽然可以使用继承来对公共行为做抽象，但是继承是一个纵向的关系，并且是强耦合的一种方式。有时候子类并不需要这个行为，而在很多情况下，需要这样行为的类之间根本就毫无关系。
如果非要使用这种方式，不仅会导致大量的重复代码，维护起来也是相当麻烦的一件事情，一点都不优雅。

而AOP引入了一种 "横切" 的技术，它是一种横向的关系。AOP使得我们可以把一些公共行为抽离出来，并且把这些行为，横向地插入到业务代码执行的过程中间。所以称之为切面（Aspect）
这些横切进去的行为与具体业务无关，又嵌入到了业务模块的执行逻辑流程中，共同封装起来。便于减少重复代码，也降低了耦合度。利于系统的扩展性和可维护性。

可以用一张图简单的说明AOP的作用

AOP

AOP的功能

用于横切关注点的分离和织入横切关注点到系统。例如日志，权限等
对OOP的完善
降低组件和模块之间的耦合性
使得系统更易于扩展
分离关注点可以获得组件更好的复用

AOP的使用场景

Authentication 权限
Caching 缓存
Context passing 内容传递
Error handling 错误处理
Lazy loading 懒加载
Debugging 调试
logging, tracing, profiling and monitoring 记录跟踪优化校准
Performance optimization 性能优化
Persistence 持久化
Resource pooling 资源池
Synchronization 同步
Transactions 事务

AOP 核心概念

切面（Aspect）
切面是一个关注点，或者说希望抽象出来的功能的模块化。这个关注点或者功能可以横切多个对象。对应代码中，就是声明出来切面的类和其中的所有逻辑。

连接点（JoinPoint）
连接点是指在程序中某个特定的点，通过这个点来和切面建立连接，将切面的功能组合进去。他表示了可以组合 Advice 的位置。
也就连接点，是允许你执行通知的地方。在Spring中允许的通知有五种（接下来讲）。AspectJ还允许在构造器和属性注入时执行通知。
简单来说，在Spring中，方法的前前后后都是连接点，

通知（Advice）
通知是在切面上某个连接点上执行的特定操作。也就是我们抽离出来公共功能代码的逻辑部分。Spring切面中支持五种通知：

前置通知（Before）在目标方法，或者说切点被调用前执行的通知。
后置通知（After）在切点被调用后执行。
返回通知（After-returning）在切点执行成功并返回以后执行
异常通知（After-throwing）在方法抛出异常之后执行
环绕通知（Around）包围一个连接点，在被通知的方法之前和之后执行。（内部调用 proceed() 来执行通知方法）

关于通知的执行优先级。
在不同的切面中，如果有多个通知需要在同一个切点函数指定的方法上执行，那么将会按照在代码中定义的顺序依次执行。

切点（PointCut）
简单来说，切点是匹配连接点的表达式或者说断言。
在上面切面概念的基础上，我们知道，方法的前后都可以是连接点，但我们并不希望在所有这些地方都执行通知，我们需要一个自己定义执行通知的地方。也就是切点。
通过切点的定义，就是让我们可以筛选出我们想要拦截的方法。

引入（Introduction）
在不修改代码的前提下，引入可以在 运行期 动态地为类添加一些方法或者字段。
也就是把切面应用到目标类中。

目标对象（Target Object）
引入中提到的目标类，也就是被通知的对象（具体的业务逻辑）。
目标对象可以在不关心切面的情况下被引入切面的新功能，实现了功能的解耦。

AOP代理（AOP Proxy）
AOP代理指AOP框架创建的，对象和切面的契约，也可以说是切面实现的方式。
事实上，一般AOP是通过代理的方式实现的。（代理又分为静态代理和动态代理，Spring使用的是动态代理）
AOP代理的目的，就是将切面织入到目标对象。

织入（Wearving）
把切面应用到目标对象，来创建代理对象的过程。Spring采用的是运行时织入，具体有两种方式JDK和CGLIB。AspectJ采用的是编译期织入。（这个下一期AOP原理分析时细讲）

以下是Spring使用注解方式实现AOP的简单例子（当然还可以使用xml配置的方式实现AOP）

使用Spring的AOP支持需要引入Spring-aspect的包，如果要启用注解支持，还需要添加AspectJ类库。

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
        <version>5.0.1.RELEASE</version>
    </dependency>

    <!-- aspectJ -->
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjrt</artifactId>
        <version>1.8.10</version>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.8.10</version>
    </dependency>

/**
 * @Author Antony
 * @Since 2017/11/30 16:35
 */
@Aspect
@Component
public class SychLockAspect {    //该类就是切面

    private static final Logger logger = LoggerFactory.getLogger(SychLockAspect.class);

    @Pointcut("execution (* com.antony.service.*.*(..))")    //这是切点表达式
    public void SychLockMethod(){}  //该方法体就是通知，内部是通知的逻辑，同时可以有before after , around 等 5种通知动作。

    @Before(value = "SychLockMethod()")
    public void beforeAspect(JoinPoint joinPoint){
        String sychKey = getSychKey(joinPoint);
        logger.info("sychKey={}", sychKey);
        logger.info("AspectBefore......");

    }


    @After(value = "SychLockMethod()")
    public void afterAspect(JoinPoint joinPoint){
        String sychKey = getSychKey(joinPoint);
        logger.info("sychKey={}", sychKey);
        logger.info("AspectAfter......");
    }


    @Around(value = "SychLockMethod()")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("Around before...");
        proceedingJoinPoint.proceed();
        System.out.println("Around After...");
    }
}

Spring AOP 的支持

Spring中的AOP代理，由Spring IOC 容器负责生成和管理。其依赖关系也由IOC容器负责管理。AOP代理可以直接使用容器中的其他Bean实例作为目标，这种关系可以由IOC容器的依赖注入提供。

Spring 默认使用JDK动态代理来创建AOP代理类。Spring目前仅支持将方法调用作为连接点（JoinPoint），如果需要把堆成员变量的访问和更新页作为增强处理的连接点，则可以考虑使用AspectJ。

Spring侧重于AOP实现和IOC容器之间的整合。

Spring 框架对AOP的使用
Spring 事务处理
SpringMVC（例如@ControllerAdvice）
Spring Security
（由于对Spring的各个功能模块都还没有完整的了解，目前已知的是这些，应该还有更多，后续补充）

（如果有什么错误或者建议，欢迎留言指出）
（本文内容是对各个知识点的转载整理，用于个人技术沉淀，以及大家学习交流用）

参考资料：
关于SpringAOP你该知晓的一切
 Spring之AOP-简书（主要是AOP基本概念和如何使用AOP）
AOP低层实现——JDK和CGLIB的动态代理