SpringAop02

最新推荐文章于 2024-10-29 16:48:18 发布

花海a

最新推荐文章于 2024-10-29 16:48:18 发布

阅读量173

点赞数 1

CC 4.0 BY-SA版权

分类专栏： SSM框架文章标签： SSM

本文链接：https://blog.youkuaiyun.com/weixin_44212815/article/details/93486098

SSM框架专栏收录该内容

12 篇文章

订阅专栏

上一篇博客讲解了Aop相关知识，此次介绍用Aop管理事务进行简单转账操作。先通过xml配置Aop进行事务管理，包括引入依赖、使用工具类、配置账户类、接口及实现等；接着用注解配置Aop进行事务管理，涉及修改配置文件、配置事务管理器和测试程序。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

上一篇博客已经讲解了Aop相关的知识，这次我们来写一个Aop管理事务（简单转账操作）
数据库字段只给了3个，id，name，money
1.下面开始用xml配置Aop来进行事务管理：
引入依赖：

<?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.itheima</groupId>
    <artifactId>spring_day04_1_aop_tx_xml</artifactId>
    <version>1.0-SNAPSHOT</version>

    
    <properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <!--aop配置必须的jar包-->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.9</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
        <dependency>
            <groupId>commons-dbutils</groupId>
            <artifactId>commons-dbutils</artifactId>
            <version>1.4</version>
        </dependency>
        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.1.2</version>
        </dependency>
    </dependencies>
</project>

从之前的代码中把我们自己写的两个工具类ConnectionUtil和TransactionManager拿过来：
ConnectionUtil：一个管理连接的工具类，用于实现连接和线程的绑定，保证当前线程中获取的Connection是同一个

package com.itheima.utils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;

/**
 * 一个管理连接的工具类，用于实现连接和线程的绑定
 *
 * 保证当前线程中获取的Connection是同一个
 *
 * @author 黑马程序员
 * @Company http://www.ithiema.com
 * @Version 1.0
 */
@Component
public class ConnectionUtil {
    private ThreadLocal<Connection> tl = new ThreadLocal<Connection>();

    @Autowired
    private DataSource dataSource;

    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }
    /**
     * 获取当前线程上绑定的连接
     * @return
     */
    public Connection getThreadConnection() {
        try {
            //1.先看看线程上是否绑了
            Connection conn = tl.get();
            if(conn == null) {
                //2.从数据源中获取一个连接
                conn = dataSource.getConnection();
                //3.和线程局部变量绑定
                tl.set(conn);
            }
            //4.返回线程上的连接
            return tl.get();
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 把连接和当前线程解绑
     */
    public void remove() {
        tl.remove();
    }
}

TransactionManager：事务管理器: 是aop的通知对象

package com.itheima.utils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.sql.SQLException;

/**
 * 事务管理器: 是aop的通知对象
 * @author 黑马程序员
 * @Company http://www.ithiema.com
 * @Version 1.0
 */
@Component
public class TransactionManager {

    @Autowired
    private ConnectionUtil connectionUtil;

    public void setConnectionUtil(ConnectionUtil connectionUtil) {
        this.connectionUtil = connectionUtil;
    }

    //开启事务
    public void beginTransaction() {
        //从当前线程上获取连接，实现开启事务
        try {
            connectionUtil.getThreadConnection().setAutoCommit(false);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    //提交事务
    public void commit() {
        try {
            connectionUtil.getThreadConnection().commit();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }


    //回滚事务
    public void rollback() {
        try {
            connectionUtil.getThreadConnection().rollback();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    //释放连接
    public void release() {
        try {
            connectionUtil.getThreadConnection().setAutoCommit(true);
            //关闭连接（还回池中）
            connectionUtil.getThreadConnection().close();
            //解绑线程：把连接和线程解绑
            connectionUtil.remove();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

账户Account类：

package com.itheima.domain;

/**
 * @author 黑马程序员
 * @Company http://www.ithiema.com
 * @Version 1.0
 */
public class Account {

    private Integer id;
    private String name;
    private Float money;

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

    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;
    }
}

Service接口：

package com.itheima.service;

/**
 * @author 黑马程序员
 * @Company http://www.ithiema.com
 * @Version 1.0
 */
public interface AccountService {

    public void transfer(String fromName ,String toName ,Float money);
}

接口实现：

package com.itheima.service.impl;

import com.itheima.dao.AccountDao;
import com.itheima.domain.Account;
import com.itheima.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * @author 黑马程序员
 * @Company http://www.ithiema.com
 * @Version 1.0
 */
@Service
public class AccountServiceImpl implements AccountService {

    @Autowired
    AccountDao accountDao;



    @Override
    public void transfer(String fromName, String toName, Float money) {
        //查询转换的账户
        Account fromAccount = accountDao.findByName(fromName);
        //查询接收的账户
        Account toAccount = accountDao.findByName(toName);
        //开始转账
        fromAccount.setMoney(fromAccount.getMoney() - money);
        toAccount.setMoney(toAccount.getMoney() + money);
        //持久化到数据库
        accountDao.update(fromAccount);
        System.out.println(1/0);
        accountDao.update(toAccount);
    }
}

Dao接口：

package com.itheima.dao;

import com.itheima.domain.Account;

/**
 * @author 黑马程序员
 * @Company http://www.ithiema.com
 * @Version 1.0
 */
public interface AccountDao {
    /**
     * 根据name查询账户
     * @param fromName
     * @return
     */
    Account findByName(String fromName);

    /**
     * 更新
     * @param fromAccount
     */
    void update(Account fromAccount);
}

Dao接口实现：

package com.itheima.dao.impl;

import com.itheima.dao.AccountDao;
import com.itheima.domain.Account;
import com.itheima.utils.ConnectionUtil;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import java.sql.SQLException;

/**
 * @author 黑马程序员
 * @Company http://www.ithiema.com
 * @Version 1.0
 */
@Repository
public class AccountDaoImpl implements AccountDao {
    @Autowired
    ConnectionUtil connectionUtil;

    @Autowired
    QueryRunner queryRunner;

    @Override
    public Account findByName(String name) {
        String sql = "select * from account where name = ?";
        try {
            return queryRunner.query(connectionUtil.getThreadConnection(),sql ,new BeanHandler<>(Account.class),name);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

    @Override
    public void update(Account account) {
        String sql = "update account set money = ? where name = ?";
        try {
            queryRunner.update(connectionUtil.getThreadConnection(),sql ,account.getMoney() ,account.getName());
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

配置文件：

<?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.itheima"></context:component-scan>

    <!--dao层需要注入queryRunner-->
    <bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner">
    </bean>
    <!--需要dataSource-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"></property>
        <property name="jdbcUrl" value="${jdbc.url}"></property>
        <property name="user" value="${jdbc.user}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>
    <!--引入外部属性文件-->
    <context:property-placeholder location="jdbc.properties"></context:property-placeholder>

    <!--
        使用aop解决事务问题
            事务管理器类：通知对象
    -->
    <aop:config>
        <!--配置切面-->
        <aop:aspect ref="transactionManager">
            <!--切入点-->
            <aop:pointcut id="pointcut" expression="execution(* com.itheima.service.impl.*.*(..))"></aop:pointcut>
            <!--织入-->
            <!--前置增强：开启事务-->
            <aop:before method="beginTransaction" pointcut="execution(* com.itheima.service.impl.*.*(..))"></aop:before>
            <!--后置增强：提交事务-->
            <aop:after-returning method="commit" pointcut-ref="pointcut"></aop:after-returning>
            <!--异常增强：回滚事务-->
            <aop:after-throwing method="rollback" pointcut-ref="pointcut"></aop:after-throwing>
            <!--最终增强：释放资源-->
            <aop:after method="release" pointcut-ref="pointcut"></aop:after>
        </aop:aspect>
    </aop:config>



</beans>

2.下面使用注解来配置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">
    <!--开启注解，扫描包-->
    <context:component-scan base-package="com.itheima"></context:component-scan>

    <!--dao层需要注入queryRunner-->
    <bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner">
    </bean>
    <!--需要dataSource-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"></property>
        <property name="jdbcUrl" value="${jdbc.url}"></property>
        <property name="user" value="${jdbc.user}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>
    <!--引入外部属性文件-->
    <context:property-placeholder location="jdbc.properties"></context:property-placeholder>

    <!--开启aop自动代理注解-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

使用注解配置事务管理器：

package com.itheima.utils;

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

import java.sql.SQLException;

/**
 * 事务管理器: 是aop的通知对象
 * @author 黑马程序员
 * @Company http://www.ithiema.com
 * @Version 1.0
 */
@Component
@Aspect
public class TransactionManager {

    @Autowired
    private ConnectionUtil connectionUtil;

    public void setConnectionUtil(ConnectionUtil connectionUtil) {
        this.connectionUtil = connectionUtil;
    }


    /**
     * 环绕增强
     */
    @Around("execution(* com.itheima.service.impl.*.*(..))")
    public void around(ProceedingJoinPoint joinPoint){

        try {
            //前置增强
            beginTransaction();
            //执行原来的方法
            joinPoint.proceed();
            //后置增强
            commit();
        } catch (Throwable throwable) {
            //异常增强
            rollback();
            throwable.printStackTrace();
        } finally {
            //最终增强
            release();
        }
    }

    //开启事务
    public void beginTransaction() {
        //从当前线程上获取连接，实现开启事务
        try {
            connectionUtil.getThreadConnection().setAutoCommit(false);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    //提交事务
    public void commit() {
        try {
            connectionUtil.getThreadConnection().commit();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }


    //回滚事务
    public void rollback() {
        try {
            connectionUtil.getThreadConnection().rollback();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    //释放连接
    public void release() {
        try {
            connectionUtil.getThreadConnection().setAutoCommit(true);
            //关闭连接（还回池中）
            connectionUtil.getThreadConnection().close();
            //解绑线程：把连接和线程解绑
            connectionUtil.remove();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

测试程序：

package com.itheima;

import com.itheima.service.AccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**
 * @author 黑马程序员
 * @Company http://www.ithiema.com
 * @Version 1.0
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class TestTransfer {
    @Autowired
    AccountService accountService;

    @Test
    public void test(){
        accountService.transfer("aaa","ccc",20f);
    }
}