详解Spring学习总结——Spring实现AOP的多种方式

什么是AOP

AOP(Aspect Oriented Programming)面向切面编程，是一种基于面向对象编程的一种编程方式。它是通过预编译的方式和运行期动态代理实现在不修改源代码的情况下给程序动态添加新的功能。

Spring实现AOP的多种方式

Spring框架支持多种方式实现AOP，包括：

• 基于XML配置AspectJ
• 使用注解实现AOP
• 使用AspectJ注解实现AOP

下面分别对这三种方式进行详细介绍。

基于XML配置AspectJ

AspectJ是AOP的实现工具，它提供了一种创建切面的方式，可以用来实现在Spring中的AOP。代码示例：

<!-- AOP 配置信息 -->
<aop:config>
    <!-- 连接点规则 -->
    <aop:pointcut id="logPoint" expression="execution(* com.example.service.*.*(..))" />
    <!-- 增强规则 -->
    <aop:aspect ref="logAspect">
        <aop:before method="before" pointcut-ref="logPoint" />
        <aop:after method="after" pointcut-ref="logPoint" />
        <aop:after-returning method="afterReturning" pointcut-ref="logPoint" returning="result" />
        <aop:after-throwing method="afterThrowing" pointcut-ref="logPoint" throwing="throwable" />
    </aop:aspect>
</aop:config>

上述代码中定义了一个名为logPoint的通过表达式限定的连接点规则，并为它定义了增强规则，分别为前置增强、后置增强、返回增强以及异常增强。

接下来定义一个Java类来实现切面：

public class LogAspect {
    public void before() {
        System.out.println("before");
    }

    public void after() {
        System.out.println("after");
    }

    public void afterReturning(Object result) {
        System.out.println("afterReturning " + result);
    }

    public void afterThrowing(Throwable throwable) {
        System.out.println("afterThrowing " + throwable.getMessage());
    }
}

上述代码中定义了4个方法来分别实现前置增强、后置增强、返回增强和异常增强。方法的名称需要和上述配置中的method属性保持一致。

使用注解实现AOP

Spring提供了使用注解来实现AOP的方式。通过在Java类的方法上添加注解来定义切面，代码示例：

@Aspect
@Component
public class LogAspect {

    @Before("execution(* com.example.service.*.*(..))")
    public void before() {
        System.out.println("before");
    }

    @After("execution(* com.example.service.*.*(..))")
    public void after() {
        System.out.println("after");
    }

    @AfterReturning(pointcut = "execution(* com.example.service.*.*(..))", returning = "result")
    public void afterReturning(Object result) {
        System.out.println("afterReturning " + result);
    }

    @AfterThrowing(pointcut = "execution(* com.example.service.*.*(..))", throwing = "throwable")
    public void afterThrowing(Throwable throwable) {
        System.out.println("afterThrowing " + throwable.getMessage());
    }
}

上述代码中使用了@Before、@After、@AfterReturning和@AfterThrowing注解来实现前置增强、后置增强、返回增强和异常增强，注解中的expression属性定义了连接点，连接点定义的方式同基于XML配置的实现方式。

实现AOP的类需使用@Aspect和@Component注解。

使用AspectJ注解实现AOP

AspectJ提供了一种更加简单的方式，即使用Java注解来定义切面。通过在Java类中添加如@Before、@After、@Around等注解来实现切面，代码示例：

@Aspect
@Component
public class LogAspect {

    @Before("execution(* com.example.service.*.*(..))")
    public void before() {
        System.out.println("before");
    }

    @After("execution(* com.example.service.*.*(..))")
    public void after() {
        System.out.println("after");
    }

    @AfterReturning(pointcut = "execution(* com.example.service.*.*(..))", returning = "result")
    public void afterReturning(Object result) {
        System.out.println("afterReturning " + result);
    }

    @AfterThrowing(pointcut = "execution(* com.example.service.*.*(..))", throwing = "throwable")
    public void afterThrowing(Throwable throwable) {
        System.out.println("afterThrowing " + throwable.getMessage());
    }
}

AspectJ注解同样支持@Before、@After、@Around等注解，其定义方式和前面介绍的使用注解实现AOP的方式完全一致。

总结

Spring实现AOP的方式有多种，包括基于XML配置AspectJ，通过注解实现AOP以及使用AspectJ注解实现AOP等。针对不同的场景和需求，可以选择不同的实现方式。同时，AspectJ作为AOP的实现工具，提供了更加灵活和简洁的方式来定义切面。