使用SpringAop 动态代理实现业务层对持久层的的事务处理

最新推荐文章于 2024-09-25 11:06:23 发布

学习JAVA的小白菜

最新推荐文章于 2024-09-25 11:06:23 发布

阅读量109

点赞数 1

文章标签： java junit spring

本文链接：https://blog.csdn.net/m0_69533218/article/details/132417363

版权

1.1：什么是SpringAop:

AOP：全称是 Aspect Oriented Programming 即：面向切面编程。

简单的说它就是把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的

基础上，对我们的已有方法进行增强。

1.2：Aop的作用以及优势

作用：

在程序运行期间，不修改源码对已有方法进行增强。

优势：

减少重复代码

提高开发效率

维护方便

1.3：Aop的实现方式

使用动态代理技术

2.1Spring 中 AOP 的细节

2.1.1 说明

我们学习 spring 的 aop ，就是通过配置的方式，实现上一章节的功能。

2.1.2 AOP 相关术语

Joinpoint(连接点):

所谓连接点是指那些被拦截到的点。在 spring 中 , 这些点指的是方法 , 因为 spring 只支持方法类型的

连接点。

Pointcut(切入点):

所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义。 Advice( 通知 / 增强 ):

所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知。

通知的类型：前置通知 , 后置通知 , 异常通知 , 最终通知 , 环绕通知。

注意：切入点一定是连接点，但是连接点不一定是切入点

Introduction(引介):

引介是一种特殊的通知在不修改类代码的前提下 , Introduction 可以在运行期为类动态地添加一些方

法或 Field 。

Target(目标对象):

代理的目标对象。

Weaving(织入):

是指把增强应用到目标对象来创建新的代理对象的过程。

spring 采用动态代理织入，而 AspectJ 采用编译期织入和类装载期织入。

Proxy（代理）:

一个类被 AOP 织入增强后，就产生一个结果代理类。

Aspect(切面):

是切入点和通知（引介）的结合。

2.1.3 学习 spring 中的 AOP 要明确的事

a、开发阶段（我们做的）

编写核心业务代码（开发主线）：大部分程序员来做，要求熟悉业务需求。

把公用代码抽取出来，制作成通知。（开发阶段最后再做）： AOP 编程人员来做。

在配置文件中，声明切入点与通知间的关系，即切面。： AOP 编程人员来做。

b、运行阶段（Spring 框架完成的）

Spring 框架监控切入点方法的执行。一旦监控到切入点方法被运行，使用代理机制，动态创建目标对

象的代理对象，根据通知类别，在代理对象的对应位置，将通知对应的功能织入，完成完整的代码逻辑运行。

2.1.4 关于代理的选择

在 spring 中，框架会根据目标类是否实现了接口来决定采用哪种动态代理的方式。

2.2基于 XML 的 AOP 配置

示例：

我们在学习 spring 的 aop 时，采用账户转账作为示例。

并且把 spring 的 ioc 也一起应用进来

3.1环境搭建

我采用了JDK17基于maven项目

maven的坐标依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.itHaipeng</groupId>
    <artifactId>springAop_Account</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <!--导入spring核心IOC-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.23</version>
        </dependency>
        <!--spring整合junit-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.3.23</version>
        </dependency>
        <!--动态代理-->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.6</version>
        </dependency>
        <!--数据库相关-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.48</version>
        </dependency>
        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.1.2</version>
        </dependency>
        <dependency>
            <groupId>commons-dbutils</groupId>
            <artifactId>commons-dbutils</artifactId>
            <version>1.4</version>
        </dependency>
        <dependency>
            <groupId>javax.annotation</groupId>
            <artifactId>javax.annotation-api</artifactId>
            <version>1.3.2</version>
        </dependency>
        <dependency>
            <groupId>javax.inject</groupId>
            <artifactId>javax.inject</artifactId>
            <version>1</version>
        </dependency>
    </dependencies>
    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
</project>

注意：spring核心Ioc对应的字节码版本要小于等于jdk对应的字节码版本，5.3.23对应的字节码版本是52，Java8，我的运行环境是jdk17因此是可以运行的

3.2 SpringIoc以及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:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">
   <context:component-scan base-package="com.itHaipeng"/>
   <bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner"/>
   <context:property-placeholder location="classpath:jdbc.properties"/>
   <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
      <property name="driverClass" value="${jdbc.driver}"/>
      <property name="jdbcUrl" value="${jdbc.url}"/>
      <property name="user" value="${jdbc.username}"/>
      <property name="password" value="${jdbc.password}"/>
   </bean>
   <aop:config>
      <!--指定切入点-->
      <aop:pointcut id="pointcut" expression="execution(* com.itHaipeng.service.impl.IAccountServiceImpl.*(..))"/>
      <!--配置切面-->
      <aop:aspect id="transactionAdvice" ref="transactionManager">
         <!--指定前置通知 开启事物-->
         <aop:before method="openTransaction" pointcut-ref="pointcut"/>
        <!--指定后置通知：提交事物-->
        <aop:after-returning method="commitTransaction" pointcut-ref="pointcut"/>
         <!--配置异常通知，回滚事物-->
         <aop:after-throwing method="rollbackTransaction" pointcut-ref="pointcut"/>
         <!--配置最终通知：释放连接-->
         <aop:after method="closeTransaction" pointcut-ref="pointcut"/>
      </aop:aspect>
   </aop:config>
</beans>

注意：我使用注解＋xml注入。

切入点就是需要增强的函数或者方法，通知就是去掉原来方法里的后，新增的东西（可以这么理解）

3.21：数据源配置文件 jdbc.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql:///${对应操作数据库的名字}?useSSL=false
jdbc.username=${用户名}
jdbc.password=${密码}

3.3:项目结构图以及外部库

4.1：业务层代码

接口：

public interface IAccountService {
    List<Account> selectAll();
    Account selectByName(String name);
    void upData(Account account);

    /**
     *
     * @param targetName :转入账户
     * @param primaryName ：转出账户
     * @param money ：多少钱
     */
    void transfer(String targetName,String primaryName,float money);
}

实现类：

@Service(value = "iAccountServiceImpl")
public class IAccountServiceImpl implements IAccountService {
    @Autowired
    private IDaoAccount iDaoAccount;
    @Override
    public List<Account> selectAll() {
        return iDaoAccount.queryAll();
    }

    @Override
    public Account selectByName(String name) {
        return iDaoAccount.findByName(name);
    }

    @Override
    public void upData(Account account) {
        iDaoAccount.upData(account);
    }
    /**
     *
     * @param targetName :转入账户
     * @param primaryName ：转出账户
     * @param money ：多少钱
     */
    @Override
    public void transfer(String targetName, String primaryName, float money) {
        Account byName = iDaoAccount.findByName(targetName);
        Account byName1 = iDaoAccount.findByName(primaryName);
        byName1.setMoney(byName1.getMoney()-money);
        byName.setMoney(byName.getMoney()+money);
        iDaoAccount.upData(byName);
        iDaoAccount.upData(byName1);
    }
}

如何将业务线绑定在一个线程上？

为什么要绑定在一个线程上，我们可以看上面transfer方法中，业务线共有4条连接线，分别是不同的线程，在实际项目中，这样会很危险，假设这个业务线程哪出了问题，对应的账户没有改变，那这既是银行的损失，也是户主的损失

连接的工具类，用于从数据源中获取一个链接并且和一个线程进行绑定绑定

@Service(value = "connectionUtil")
public class ConnectionUtil {
    //先new一个TheadLocal对象
    private final ThreadLocal<Connection> connectionThreadLocal=new ThreadLocal<>();
    @Autowired
    private DataSource dataSource;
    /**
     * 提供一个获取当前线程的链接
     *
     * @return
     */
   public Connection getThreadConnection(){
       try {
             //获取当前的连接
           Connection connection = connectionThreadLocal.get();
           if(connection==null){//判断该连接是否被连接，是null就是没有连接
               //获取数据源的连接
               connection= dataSource.getConnection();
               connectionThreadLocal.set(connection);
           }
           return connection;
       }catch (SQLException e){
           throw  new RuntimeException(e);
       }

和事物管理相关的工具类，它包含了开启事物，提交事物，回滚事物，和释放连接

@Service(value = "transactionManager")
public class TransactionManager {
    @Autowired
    private ConnectionUtil connectionUtil;
    /**
     * 开启事物
     */
    public void openTransaction(){
        try {
            connectionUtil.getThreadConnection().setAutoCommit(false);
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
    //提交事物
    public void commitTransaction() throws SQLException {
        connectionUtil.getThreadConnection().commit();
    }
    //事物回滚
    public void rollbackTransaction()  {
        try {
            connectionUtil.getThreadConnection().rollback();
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
    //释放连接
    public void closeTransaction()  {
        try {
            connectionUtil.getThreadConnection().close();
            //解除绑定
            connectionUtil.unbindingConnection();
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
}

4.2持久层代码

接口：

public interface IDaoAccount {
    /**
     *
     * @param name :查询对应用户是否为一
     * @return
     */
    Account findByName(String name);

    /**
     * 查询所有
     * @return
     */
    List<Account> queryAll();
    void upData(Account account);
}

实现类：

@Repository(value = "iDaoAccountImpl")
public class IDaoAccountImpl implements IDaoAccount {
    @Autowired
    private QueryRunner queryRunner;
    @Autowired
    private ConnectionUtil connectionUtil;
    @Override
    public Account findByName(String name) {
        try {
            List<Account> accountList = queryRunner.query(connectionUtil.getThreadConnection(),"select *from account where name=?", new BeanListHandler<>(Account.class), name);
            if (accountList.size() != 1){
                throw new RuntimeException("数据输入的有问题");
            }
            return accountList.get(0);
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public List<Account> queryAll() {
        try {
            return queryRunner.query(connectionUtil.getThreadConnection(),"select * from account;",new BeanListHandler<>(Account.class));
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public void upData(Account account) {
        try {
            queryRunner.update(connectionUtil.getThreadConnection(), "update account set money=?,name=?where id=?",account.getMoney(),account.getName(),account.getId());
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
}

5.1:将数据库的列名封装的实体类

public class Account {
    private Integer id;
    private String name;
    private Float money;

    public Account(Integer id, String name, Float money) {
        this.id = id;
        this.name = name;
        this.money = money;
    }

    public Account() {
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Float getMoney() {
        return money;
    }

    public void setMoney(Float money) {
        this.money = money;
    }

    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", money=" + money +
                '}';
    }
}

5.2对应数据库的sql语句(mysql)

create table account(
	id int primary key auto_increment,
	name varchar(40),
	money float
)character set utf8 collate utf8_general_ci;

insert into account(name,money) values('aaa',1000);
insert into account(name,money) values('bbb',1000);
insert into account(name,money) values('ccc',1000);

6.1：测试方法，采用了spring整合Junit

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:bean.xml")
public class AccountTest {
    @Autowired
    private IAccountService iAccountService;
    @Test
    public void selectAll(){
        List<Account> accounts = iAccountService.selectAll();
        System.out.println(accounts);
    }
    @Test
    public void transfer(){
        iAccountService.transfer("bbb","aaa",100f);
    }
}