Spring AOP详解（附带实例）

AOP（Aspect-OrientedProgramming，面向切面编程）不是一种新的技术，也不是一种框架，而是一种编程思想，可以理解为 OOP（Object-Oriented Programing，面向对象编程）的补充和完善。

OOP 引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。当我们需要为分散的对象引入公共行为的时候，OOP 则显得无能为力。也就是说，OOP 允许你定义从上到下的关系，但并不适合定义从左到右的关系。

例如日志功能，日志代码往往水平地散布在所有对象层次中，而与它所散布到的对象的核心功能毫无关系。对于其他类型的代码，如安全性、异常处理和透明的持续性也是如此。这种散布在各处的无关代码被称为横切（cross-cutting）代码，在 OOP 设计中，它导致了大量代码的重复，不利于各个模块的重用。

AOP 技术则恰恰相反，它利用一种称为“横切”的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其命名为“Aspect”，即方面。

所谓“方面”，简单地说就是将那些与业务无关却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可操作性和可维护性。

AOP 代表的是一个横向的关系，如果说“对象”是一个空心的圆柱体，其中封装的是对象的属性和行为，那么面向方面编程的方法就像一把利刃，将这些空心圆柱体剖开，以获得其内部的消息，而剖开的切面也就是所谓的“方面”了。

AOP 涉及的基本概念如下表所示：

术语	描述
Aspect（切面）	通常是一个类，里面可以定义切入点和通知。
JointPoint（连接点）	程序执行过程中明确的点，一般是方法的调用。
Advice（通知）	AOP 在特定的切入点上执行的增强处理，有 before、after、afterReturning、afterThrowing、around。
Pointcut（切入点）	带有通知的连接点，在程序中主要体现为书写切入点表达式。
AOP 代理	AOP 框架创建的对象，代理就是目标对象的加强。Spring 中的 AOP 代理可以是 JDK 动态代理，也可以是 CGLIB 代理，前者基于接口，后者基于子类。

通知方法有以下几种：

前置通知（@Before）：在我们执行目标方法之前运行；
后置通知（@After）：在我们目标方法运行结束之后，不管有没有异常；
返回通知（@AfterReturning）：在我们的目标方法正常返回值后运行；
异常通知（@AfterThrowing）：在我们的目标方法出现异常后运行；
环绕通知（@Around）：动态代理，需要手动执行 joinPoint.procced()（目标方法执行之前相当于前置通知，执行之后就相当于后置通知）。

Spring 中的 AOP 代理还是离不开 Spring 的 IoC 容器。代理的生成、管理及其依赖关系都是由 IoC 容器负责的，Spring 默认使用 JDK 动态代理。在需要代理类而不是代理接口的时候，Spring 会自动切换为使用 CGLIB 代理，不过现在的项目都是面向接口编程的，所以 JDK 动态代理相对来说用得还是多一些。

基于注解的AOP实现

以下是一个切面编程的典型应用，即关于日志的横切业务注入具体目标业务方法中。下面的 Calculator 计算器类将作为目标类，里面有除法运算方法，日志将会在除法运算前后加入相关打印信息。

1) 定义一个日志切面，为其定义切入点 PointCut，并在某些方法上通过 @Before、@After 等注解定义通知，具体代码如下：

// LogAspects.java
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;

// 日志切面类
@Aspect
public class LogAspects {
    @Pointcut("execution(public int com.mrchi.aop.Calculator.*(..))")
    public void pointCut() {
        // @Before 代表在目标方法执行前切入，并指定在哪个方法前切入
        @Before("pointCut()")
        public void logStart() {
            System.out.println("除法运行......参数列表是：()");
        }
        @After("pointCut()")
        public void logEnd() {
            System.out.println("除法结束...... ");
        }
        @AfterReturning("pointCut()")
        public void logReturn() {
            System.out.println("除法正常返回......运行结果是：!");
        }
        @AfterThrowing("pointCut()")
        public void logException() {
            System.out.println("运行异常......异常信息是：!");
        }
        @Around("pointCut()")
        public Object Around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
            System.out.println("@Around:执行目标方法之前...");
            Object obj = proceedingJoinPoint.proceed(); // 相当于开始调用目标方法
            System.out.println("@Around:执行目标方法之后...");
            return obj;
        }
    }
}

SpringAOP 的存在是为了解耦。AOP 可以让一些类共享相同的行为。Spring 支持 AspectJ 的注解式的切面编程，包含 @Aspect、@After、@Before、@Around 和 @PointCut 注解。

所有符合上述代码中 PointCut 表达式的业务方法，都会在合适的时机执行 LogAspects 切面类的各个方法。

以上注解定义来自 aspectjweaver 项目，所以项目的 pom.xml 需要引入依赖，代码如下：

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.8.13</version>
</dependency>

execution 切点表达式是指通过配置执行类的方法配置不同的切面。例如，“execution(*cn..*Serivice.*(..))”是指对 cn 包下以 Service 约束的类或接口中的所有方法（无论接收多少参数，返回什么类型的值）进行拦截。在注解中使用 @Pointcut，在 XML 中声明 AspectJExpressionPointcut 类的 expression 属性来设置切点表达式。

2) 定义目标方法，代码如下：

// Calculator.java
public class Calculator {
    // 业务逻辑方法
    public int div(int i, int j){
        System.out.println("---------");
        return i/j;
    }
}

3) 在 Spring IoC 容器中定义 Bean。

// AOPBeanConfig.java
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import com.mrchi.aop.Calculator;
import com.mrchi.aop.LogAspects;
@Configuration
@EnableAspectJAutoProxy
public class AOPBeanConfig {
    @Bean
    public Calculator calculator() {
        return new Calculator();
    }
    @Bean
    public LogAspects logAspects() {
        return new LogAspects();
    }
}

@EnableAspectJAutoProxy 注解在 @Configuration 类上，用于启用 Spring 的注解 Aspect 功能。

4) 测试类，用于根据注解初始化 Bean 对象，并手动调用 Calculator 的除法运算方法，观察控制台切面代码的输出。

// AOPTest.java
public class AOPTest {
    @Test
    public void test01(){
        AnnotationConfigApplicationContext app = new AnnotationConfigApplicationContext(AOPBeanConfig.class);
        Calculator c = app.getBean(Calculator.class);
        int result = c.div(4, 3);
        System.out.println(result);
        app.close();
    }
}

运行结果如下：

@Arount:执行目标方法之前...
除法运行......参数列表是:{}
---------------
@Aro unt:执行目标方法之后...
除法结束......
除法正常返回......运行结果是:{}
1

Spring AOP详解（附带实例）

基于注解的AOP实现

相关文章