Spring6 - （15）面向切面编程AOP

最新推荐文章于 2024-05-22 14:11:15 发布

Julissa.

最新推荐文章于 2024-05-22 14:11:15 发布

阅读量181

点赞数

分类专栏： Spring6学习之路文章标签： java spring

本文链接：https://blog.csdn.net/chenyouchang/article/details/129793725

版权

Spring6学习之路专栏收录该内容

18 篇文章 2 订阅

订阅专栏

文章目录

Spring6 -（15）面向切面编程AOP

Spring6 -（15）面向切面编程AOP

IoC使软件组件松耦合。AOP让你能够捕捉系统中经常使用的功能，把它转化成组件。

AOP（Aspect Oriented Programming）：面向切面编程，面向方面编程。（AOP是一种编程技术）

AOP是对OOP的补充延伸。

AOP底层使用的就是动态代理来实现的。

Spring的AOP使用的动态代理是：JDK动态代理 + CGLIB动态代理技术。Spring在这两种动态代理中灵活切换，如果是代理接口，会默认使用JDK动态代理，如果要代理某个类，这个类没有实现接口，就会切换使用CGLIB。当然，你也可以强制通过一些配置让Spring只使用CGLIB。

1. AOP介绍

一般一个系统当中都会有一些系统服务，例如：日志、事务管理、安全等。这些系统服务被称为：交叉业务

这些交叉业务几乎是通用的，不管你是做银行账户转账，还是删除用户数据。日志、事务管理、安全，这些都是需要做的。

如果在每一个业务处理过程当中，都掺杂这些交叉业务代码进去的话，存在两方面问题：

第一：交叉业务代码在多个业务流程中反复出现，显然这个交叉业务代码没有得到复用。并且修改这些交叉业务代码的话，需要修改多处。
第二：程序员无法专注核心业务代码的编写，在编写核心业务代码的同时还需要处理这些交叉业务。

使用AOP可以很轻松的解决以上问题。

请看下图，可以帮助你快速理解AOP的思想：

用一句话总结AOP：将与核心业务无关的代码独立的抽取出来，形成一个独立的组件，然后以横向交叉的方式应用到业务流程当中的过程被称为AOP。

AOP的优点：

第一：代码复用性增强。
第二：代码易维护。
第三：使开发者更关注业务逻辑。

2. AOP的七大术语

package com.julissa.proxy.service;

public class StudentService {
    public void do1(){
        System.out.println("do 1");
    }
    public void do2(){
        System.out.println("do 2");
    }
    public void do3(){
        System.out.println("do 3");
    }
    public void do4(){
        System.out.println("do 4");
    }
    public void do5(){
        System.out.println("do 5");
    }
    // 核心业务方法
    public void service(){
        try {
            // Joinpoint连接点
            do1();// Pointcut切入点
            // Joinpoint连接点
            do2();// Pointcut切入点
            // Joinpoint连接点
            do3();// Pointcut切入点
            // Joinpoint连接点
            do5();// Pointcut切入点
            // Joinpoint连接点
        }catch (Exception e){
            // Joinpoint连接点
        }finally {
            // Joinpoint连接点
        }
    }
}

连接点 Joinpoint

在程序的整个执行流程中，可以织入切面的位置。方法的执行前后，异常抛出之后等位置。
切点 Pointcut

在程序执行流程中，真正织入切面的方法。（一个切点对应多个连接点）
通知 Advice

通知又叫增强，就是具体你要织入的代码。

通知包括：
- 前置通知
- 后置通知
- 环绕通知
- 异常通知
- 最终通知
切面 Aspect

切点 + 通知就是切面。
织入 Weaving

把通知应用到目标对象上的过程。
代理对象 Proxy

一个目标对象被织入通知后产生的新对象。
目标对象 Target

被织入通知的对象。

通过下图，大家可以很好的理解AOP的相关术语：

在这里插入图片描述

3. 切点表达式

切点表达式用来定义通知（Advice）往哪些方法上切入。

切入点表达式语法格式：

execution([访问控制权限修饰符] 返回值类型 [全限定类名]方法名(形式参数列表) [异常])

访问控制权限修饰符：

可选项。
没写，就是4个权限都包括。
写public就表示只包括公开的方法。

返回值类型：

必填项。
* 表示返回值类型任意。

全限定类名：

可选项。
两个点“…”代表当前包以及子包下的所有类。
省略时表示所有的类。

方法名：

必填项。
*表示所有方法。
set*表示所有的set方法。

形式参数列表：

必填项
() 表示没有参数的方法
(…) 参数类型和个数随意的方法
(*) 只有一个参数的方法
(*, String) 第一个参数类型随意，第二个参数是String的。

异常：

可选项。
省略时表示任意异常类型。

理解以下的切点表达式：

service包下所有的类中以delete开始的所有方法

execution(public * com.powernode.mall.service.*.delete*(..))

mall包下所有的类的所有的方法

execution(* com.powernode.mall..*(..))

所有类的所有方法

execution(* *(..))

4. 使用Spring的AOP

Spring对AOP的实现包括以下3种方式：

第一种方式：Spring框架结合AspectJ框架实现的AOP，基于注解方式。
第二种方式：Spring框架结合AspectJ框架实现的AOP，基于XML方式。
第三种方式：Spring框架自己实现的AOP，基于XML配置方式。

实际开发中，都是Spring+AspectJ来实现AOP。所以我们重点学习第一种和第二种方式。

什么是AspectJ？（Eclipse组织的一个支持AOP的框架。AspectJ框架是独立于Spring框架之外的一个框架，Spring框架用了AspectJ）

AspectJ项目起源于帕洛阿尔托（Palo Alto）研究中心（缩写为PARC）。该中心由Xerox集团资助，Gregor Kiczales领导，从1997年开始致力于AspectJ的开发，1998年第一次发布给外部用户，2001年发布1.0 release。为了推动AspectJ技术和社团的发展，PARC在2003年3月正式将AspectJ项目移交给了Eclipse组织，因为AspectJ的发展和受关注程度大大超出了PARC的预期，他们已经无力继续维持它的发展。

4.1 准备工作

使用Spring+AspectJ的AOP需要引入的依赖如下

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>6.0.2</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
    <version>6.0.2</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>6.0.2</version>
</dependency>

Spring配置文件中添加context命名空间和aop命名空间

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

</beans>

4.2 基于AspectJ的AOP注解式开发

4.2.1 实现步骤

第一步：定义目标类以及目标方法

package com.julissa.spring6.service;

/**
 * 目标类
 */
public class OrderService {
    /**
     * 目标方法
     */
    public void generate(){
        System.out.println("订单已生成");
    }
}

第二步：定义切面类

package com.julissa.spring6.service;

import org.aspectj.lang.annotation.Aspect;

/**
 * 切面类
 */
@Aspect
public class MyAspect {
}

第三步：目标类和切面类都纳入spring bean管理

在目标类OrderService上添加**@Component**注解。
在切面类MyAspect类上添加**@Component**注解。

第四步：在spring配置文件中添加组建扫描

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 声明扫描的范围 -->
    <context:component-scan base-package="com.julissa.spring6.service"/>
</beans>

第五步：在切面类中添加通知

package com.julissa.spring6.service;

import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

/**
 * 切面类
 */
@Component
@Aspect
public class MyAspect {
    // 切面 = 切点 + 通知
    // 通知就是增强的方法
    public void advice(){
        System.out.println("我是一个通知");
    }
}

第六步：在通知上添加切点表达式

package com.julissa.spring6.service;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

/**
 * 切面类
 */
@Component
@Aspect
public class MyAspect {
    // 切面 = 切点 + 通知

    // 切点表达式
    // @Before 前置同时
    @Before("execution(* com.julissa.spring6.service.OrderService.*(..))")
    // 通知就是增强的方法
    public void advice(){
        System.out.println("我是一个通知");
    }
}

第七步：在spring配置文件中启用自动代理

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 声明扫描的范围 -->
    <context:component-scan base-package="com.julissa.spring6.service"/>

    <!-- 开启自动代理-->
    <aop:aspectj-autoproxy proxy-target-class="true"/>
</beans>

<aop:aspectj-autoproxy proxy-target-class=“true”/> 开启自动代理之后，凡事带有@Aspect注解的bean都会生成代理对象。

proxy-target-class=“true” 表示采用cglib动态代理。

proxy-target-class=“false” 表示采用jdk动态代理。默认值是false。即使写成false，当没有接口的时候，也会自动选择cglib生成代理类。

第八步：编写测试程序

@Test
public void test(){
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
    OrderService orderService = applicationContext.getBean("orderService", OrderService.class);
    orderService.generate();
}

第九步：运行测试程序

4.2.2 通知类型

通知类型包括：

前置通知：@Before 目标方法执行之前的通知
后置通知：@AfterReturning 目标方法执行之后的通知
环绕通知：@Around 目标方法之前添加通知，同时目标方法执行之后添加通知。
异常通知：@AfterThrowing 发生异常之后执行的通知
最终通知：@After 放在finally语句块中的通知

接下来，编写程序来测试这几个通知的执行顺序：

package com.julissa.spring6.service;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

/**
 * 切面类
 */
@Component
@Aspect
public class MyAspect {
    // 切面 = 切点 + 通知

    @Around("execution(* com.julissa.spring6.service.OrderService.*(..))")
    public void aroundAdvice(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕通知开始");
        // 执行目标方法。
        proceedingJoinPoint.proceed();
        System.out.println("环绕通知结束");
    }

    @Before("execution(* com.julissa.spring6.service.OrderService.*(..))")
    public void beforeAdvice(){
        System.out.println("前置通知");
    }

    @AfterReturning("execution(* com.julissa.spring6.service.OrderService.*(..))")
    public void afterReturningAdvice(){
        System.out.println("后置通知");
    }

    @AfterThrowing("execution(* com.julissa.spring6.service.OrderService.*(..))")
    public void afterThrowingAdvice(){
        System.out.println("异常通知");
    }

    @After("execution(* com.julissa.spring6.service.OrderService.*(..))")
    public void afterAdvice(){
        System.out.println("最终通知");
    }
}

目标类和目标方法：

package com.julissa.spring6.service;

import org.springframework.stereotype.Service;

/**
 * 目标类
 */
@Service
public class OrderService {
    /**
     * 目标方法
     */
    public void generate(){
        System.out.println("订单已生成");
    }
}

测试程序

@Test
public void test(){
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
    OrderService orderService = applicationContext.getBean("orderService", OrderService.class);
    orderService.generate();
}

运行测试程序

结果中没有异常通知，这是因为目标程序执行过程中没有发生异常。我们尝试让目标方法发生异常：

package com.julissa.spring6.service;

import org.springframework.stereotype.Service;

/**
 * 目标类
 */
@Service
public class OrderService {
    /**
     * 目标方法
     */
    public void generate(){
        System.out.println("订单已生成");
        if (1 == 1) {
            throw new RuntimeException("模拟异常发生");
        }
    }
}

再次执行测试程序，结果如下：

通过测试得知，当发生异常之后，最终通知也会执行，因为最终通知@After会出现在finally语句块中。

出现异常之后，后置通知和环绕通知的结束部分不会执行。

4.2.3 切面的先后顺序

我们知道，业务流程当中不一定只有一个切面，可能有的切面控制事务，有的记录日志，有的进行安全控制，如果多个切面的话，顺序如何控制：可以使用@Order注解来标识切面类，为@Order注解的value指定一个整数型的数字，数字越小，优先级越高。

再定义一个切面类，如下：

package com.julissa.spring6.service;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

/**
 * 切面类
 */
@Component
@Aspect
@Order(2) //设置优先级
public class MyAspect2 {
    // 切面 = 切点 + 通知

    @Around("execution(* com.julissa.spring6.service.OrderService.*(..))")
    public void aroundAdvice(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("第二个环绕通知开始");
        // 执行目标方法。
        proceedingJoinPoint.proceed();
        System.out.println("第二个环绕通知结束");
    }

    @Before("execution(* com.julissa.spring6.service.OrderService.*(..))")
    public void beforeAdvice(){
        System.out.println("第二个前置通知");
    }

    @AfterReturning("execution(* com.julissa.spring6.service.OrderService.*(..))")
    public void afterReturningAdvice(){
        System.out.println("第二个后置通知");
    }

    @AfterThrowing("execution(* com.julissa.spring6.service.OrderService.*(..))")
    public void afterThrowingAdvice(){
        System.out.println("第二个异常通知");
    }

    @After("execution(* com.julissa.spring6.service.OrderService.*(..))")
    public void afterAdvice(){
        System.out.println("第二个最终通知");
    }
}

设置第一个切面的优先级

package com.julissa.spring6.service;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

/**
 * 切面类
 */
@Component
@Aspect
@Order(1)
public class MyAspect {
    // 切面 = 切点 + 通知

    @Around("execution(* com.julissa.spring6.service.OrderService.*(..))")
    public void aroundAdvice(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕通知开始");
        // 执行目标方法。
        proceedingJoinPoint.proceed();
        System.out.println("环绕通知结束");
    }

    @Before("execution(* com.julissa.spring6.service.OrderService.*(..))")
    public void beforeAdvice(){
        System.out.println("前置通知");
    }

    @AfterReturning("execution(* com.julissa.spring6.service.OrderService.*(..))")
    public void afterReturningAdvice(){
        System.out.println("后置通知");
    }

    @AfterThrowing("execution(* com.julissa.spring6.service.OrderService.*(..))")
    public void afterThrowingAdvice(){
        System.out.println("异常通知");
    }

    @After("execution(* com.julissa.spring6.service.OrderService.*(..))")
    public void afterAdvice(){
        System.out.println("最终通知");
    }
}

运行测试程序

通过修改@Order注解的整数值来切换顺序，执行测试程序：

4.2.4 优化使用切点表达式

观察切面类的代码中的切点表达式

package com.julissa.spring6.service;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

/**
 * 切面类
 */
@Component
@Aspect
@Order(1)
public class MyAspect {
    // 切面 = 切点 + 通知

    @Around("execution(* com.julissa.spring6.service.OrderService.*(..))")
    public void aroundAdvice(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕通知开始");
        // 执行目标方法。
        proceedingJoinPoint.proceed();
        System.out.println("环绕通知结束");
    }

    @Before("execution(* com.julissa.spring6.service.OrderService.*(..))")
    public void beforeAdvice(){
        System.out.println("前置通知");
    }

    @AfterReturning("execution(* com.julissa.spring6.service.OrderService.*(..))")
    public void afterReturningAdvice(){
        System.out.println("后置通知");
    }

    @AfterThrowing("execution(* com.julissa.spring6.service.OrderService.*(..))")
    public void afterThrowingAdvice(){
        System.out.println("异常通知");
    }

    @After("execution(* com.julissa.spring6.service.OrderService.*(..))")
    public void afterAdvice(){
        System.out.println("最终通知");
    }
}

缺点是：

第一：切点表达式重复写了多次，没有得到复用。
第二：如果要修改切点表达式，需要修改多处，难维护。

可以这样做：将切点表达式单独的定义出来，在需要的位置引入即可。如下：-

package com.julissa.spring6.service;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

/**
 * 切面类
 */
@Component
@Aspect
@Order(1)
public class MyAspect {
    // 切面 = 切点 + 通知

    // 定义切点表达式
    @Pointcut("execution(* com.julissa.spring6.service.OrderService.*(..))")
    public void pointcut(){}

    @Around("pointcut()")
    public void aroundAdvice(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕通知开始");
        // 执行目标方法。
        proceedingJoinPoint.proceed();
        System.out.println("环绕通知结束");
    }

    @Before("pointcut()")
    public void beforeAdvice(){
        System.out.println("前置通知");
    }

    @AfterReturning("pointcut()")
    public void afterReturningAdvice(){
        System.out.println("后置通知");
    }

    @AfterThrowing("pointcut()")
    public void afterThrowingAdvice(){
        System.out.println("异常通知");
    }

    @After("pointcut()")
    public void afterAdvice(){
        System.out.println("最终通知");
    }
}

使用@Pointcut注解来定义独立的切点表达式。

注意这个@Pointcut注解标注的方法随意，只是起到一个能够让@Pointcut注解编写的位置。

4.2.5 全注解式开发AOP

就是编写一个类，在这个类上面使用大量注解来代替spring的配置文件，spring配置文件消失了，如下：

package com.julissa.spring6.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration // 声明该类为配置类
@ComponentScan("com.julissa.spring6.service") // 声明扫描范围
@EnableAspectJAutoProxy(proxyTargetClass = true) // 开启自动代理
public class Spring6Configuration {
}

编写测试程序,注意要使用AnnotationConfigApplicationContext实现类

@Test
public void test2(){
    ApplicationContext applicationContext = new AnnotationConfigApplicationContext(Spring6Configuration.class);
    OrderService orderService = applicationContext.getBean("orderService", OrderService.class);
    orderService.generate();
}

运行测试程序

4.3 基于XML配置方式的AOP（了解）

第一步：编写目标类和目标方法

package com.julissa.spring6.service;

/**
 * 目标类
 */
public class UserService {
    /**
     * 目标方法
     */
    public void add(){
        System.out.println("添加用户信息");
    }
}

第二步：编写切面类，并且编写通知

package com.julissa.spring6.service;

/**
 * 切面类
 */
public class MyAspect3 {

    /**
     * 通知
     */
    public void advice(){
        System.out.println("我是一个通知");
    }
}

第三步：编写spring配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--纳入spring bean管理-->
    <bean id="userService" class="com.julissa.spring6.service.UserService"/>
    <bean id="myAspect3" class="com.julissa.spring6.service.MyAspect3"/>

    <!-- aop管理-->
    <aop:config>
        <!--切点表达式-->
        <aop:pointcut id="p" expression="execution(* com.julissa.spring6.service.UserService.*(..))"/>
        <!--切面-->
        <aop:aspect ref="myAspect3">
            <!--切面=通知 + 切点-->
            <aop:before method="advice" pointcut-ref="p"/>
        </aop:aspect>
    </aop:config>
</beans>

第四步：编写测试程序

@Test
public void test3(){
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
    UserService userService = applicationContext.getBean("userService", UserService.class);
    userService.add();
}

第五步：运行测试程序

5. AOP的实际案例：事务处理

项目中的事务控制是在所难免的。在一个业务流程当中，可能需要多条DML语句共同完成，为了保证数据的安全，这多条DML语句要么同时成功，要么同时失败。这就需要添加事务控制的代码。例如以下伪代码：

class 业务类1{
    public void 业务方法1(){
        try{
            // 开启事务
            startTransaction();
            
            // 执行核心业务逻辑
            step1();
            step2();
            step3();
            ....
            
            // 提交事务
            commitTransaction();
        }catch(Exception e){
            // 回滚事务
            rollbackTransaction();
        }
    }
    public void 业务方法2(){
        try{
            // 开启事务
            startTransaction();
            
            // 执行核心业务逻辑
            step1();
            step2();
            step3();
            ....
            
            // 提交事务
            commitTransaction();
        }catch(Exception e){
            // 回滚事务
            rollbackTransaction();
        }
    }
    public void 业务方法3(){
        try{
            // 开启事务
            startTransaction();
            
            // 执行核心业务逻辑
            step1();
            step2();
            step3();
            ....
            
            // 提交事务
            commitTransaction();
        }catch(Exception e){
            // 回滚事务
            rollbackTransaction();
        }
    }
}

class 业务类2{
    public void 业务方法1(){
        try{
            // 开启事务
            startTransaction();
            
            // 执行核心业务逻辑
            step1();
            step2();
            step3();
            ....
            
            // 提交事务
            commitTransaction();
        }catch(Exception e){
            // 回滚事务
            rollbackTransaction();
        }
    }
    public void 业务方法2(){
        try{
            // 开启事务
            startTransaction();
            
            // 执行核心业务逻辑
            step1();
            step2();
            step3();
            ....
            
            // 提交事务
            commitTransaction();
        }catch(Exception e){
            // 回滚事务
            rollbackTransaction();
        }
    }
    public void 业务方法3(){
        try{
            // 开启事务
            startTransaction();
            
            // 执行核心业务逻辑
            step1();
            step2();
            step3();
            ....
            
            // 提交事务
            commitTransaction();
        }catch(Exception e){
            // 回滚事务
            rollbackTransaction();
        }
    }
}
//......

可以看到，这些业务类中的每一个业务方法都是需要控制事务的，而控制事务的代码又是固定的格式，都是：

try{
    // 开启事务
    startTransaction();

    // 执行核心业务逻辑
    //......

    // 提交事务
    commitTransaction();
}catch(Exception e){
    // 回滚事务
    rollbackTransaction();
}

这个控制事务的代码就是和业务逻辑没有关系的“交叉业务”。以上伪代码当中可以看到这些交叉业务的代码没有得到复用，并且如果这些交叉业务代码需要修改，那必然需要修改多处，难维护，怎么解决？可以采用AOP思想解决。可以把以上控制事务的代码作为环绕通知，切入到目标类的方法当中。接下来我们做一下这件事，有两个业务类，如下：

银行账户的业务类

package com.julissa.spring6.service;

import org.springframework.stereotype.Service;

/**
 * 业务类
 */
@Service // 纳入bean管理
public class AccountService { // 目标对象
    // 转账业务方法
    public void transfer(){ // 目标方法
        System.out.println("正在进行银行账户转账");
    }
    // 取款业务方法
    public void withdraw(){ // 目标方法
        System.out.println("正在进行取款操作");
    }
}

订单业务类

package com.julissa.spring6.service;

import org.springframework.stereotype.Service;

/**
 * 业务类
 */
@Service // 纳入bean管理
public class OrderService { // 目标对象
    // 生成订单
    public void generate(){ // 目标方法
        System.out.println("正在生成订单");
    }
    // 取消订单
    public void cancel(){ // 目标方法
        System.out.println("正在取消订单");
    }
}

接下来我们给以上两个业务类的4个方法添加事务控制代码，使用AOP来完成：

事务切面类：

package com.julissa.spring6.service;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

/**
 * 切面类
 */
@Aspect // 声明为切面类
@Component // 纳入bean管理
public class TransactionAspect {

    //切面
    @Around("execution(* com.julissa.spring6.service.*.*(..))")
    public void aroundAdvice(ProceedingJoinPoint joinPoint){
        try {
            System.out.println("开启事务");
            //执行目标
            joinPoint.proceed();
            System.out.println("提交事务");
        }catch (Throwable e) {
            System.out.println("回滚事务");
            throw new RuntimeException(e);
        }
    }
}

接下来创建配置类

package com.julissa.spring6.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration // 声明为配置类
@ComponentScan("com.julissa.spring6.service") // 声明bean扫描范围
@EnableAspectJAutoProxy(proxyTargetClass = true) // 开启自动代理
public class Spring6Config {
}

编写测试程序

@Test
public void test(){
    ApplicationContext applicationContext = new AnnotationConfigApplicationContext(Spring6Config.class);
    AccountService accountService = applicationContext.getBean("accountService", AccountService.class);
    OrderService orderService = applicationContext.getBean("orderService", OrderService.class);
    accountService.transfer();
    accountService.withdraw();
    orderService.generate();
    orderService.cancel();
}

运行测试程序

通过测试可以看到，所有的业务方法都添加了事务控制的代码。

6. AOP的实际案例：安全日志

需求是这样的：项目开发结束了，已经上线了。运行正常。客户提出了新的需求：凡是在系统中进行修改操作的，删除操作的，新增操作的，都要把这个人记录下来。因为这几个操作是属于危险行为。例如有业务类和业务方法：

用户业务类

package com.julissa.spring6.service;

import org.springframework.stereotype.Service;

/**
 * 用完业务类
 */
@Service // 纳入bean管理
public class UserService { // 目标对象
    public void getUser(){
        System.out.println("获取用户信息");
    }
    public void saveUser(){
        System.out.println("保存用户");
    }
    public void deleteUser(){
        System.out.println("删除用户");
    }
    public void modifyUser(){
        System.out.println("修改用户");
    }
}

接下来我们使用aop来解决上面的需求：编写一个负责安全的切面类

package com.julissa.spring6.service;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Aspect // 声明为切面类
@Component // 纳入bean管理
public class SecurityAspect {
    @Pointcut("execution(* com.julissa.spring6.service..save*(..))")
    public void savePointcut(){}

    @Pointcut("execution(* com.julissa.spring6.service..delete*(..))")
    public void deletePointcut(){}

    @Pointcut("execution(* com.julissa.spring6.service..modify*(..))")
    public void modifyPointcut(){}

    @Before("savePointcut() || deletePointcut() || modifyPointcut()")
    public void beforeAdivce(JoinPoint joinpoint){
        System.out.println("XXX操作员正在操作"+joinpoint.getSignature().getName()+"方法");
    }
}

解析定义配置类

package com.julissa.spring6.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration // 声明为配置类
@ComponentScan("com.julissa.spring6.service") // 声明bean扫描范围
@EnableAspectJAutoProxy(proxyTargetClass = true) // 开启自动代理
public class Spring6Config {
}

编写测试程序

@Test
public void test2(){
    ApplicationContext applicationContext = new AnnotationConfigApplicationContext(Spring6Config.class);
    UserService userService = applicationContext.getBean("userService", UserService.class);
    userService.getUser();
    userService.deleteUser();
    userService.modifyUser();
    userService.saveUser();
}

运行测试程序

Julissa.

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring6 - （15）面向切面编程AOP

日志事务管理安全等。交叉业务这些交叉业务几乎是通用的，不管你是做银行账户转账，还是删除用户数据。日志、事务管理、安全，这些都是需要做的。第一：交叉业务代码在多个业务流程中反复出现，显然这个交叉业务代码没有得到复用。并且修改这些交叉业务代码的话，需要修改多处。第二：程序员无法专注核心业务代码的编写，在编写核心业务代码的同时还需要处理这些交叉业务。使用AOP可以很轻松的解决以上问题。
复制链接

扫一扫