自定义事务管理器TransactionManager对象

最新推荐文章于 2022-11-02 17:00:59 发布
最新推荐文章于 2022-11-02 17:00:59 发布
阅读量1.7k 收藏 1
点赞数
文章标签： java spring 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43896929/article/details/122153534
版权

自定义事务管理器TransactionManager对象

以aop思想，实现事务管理切面

1. DataSource注册容器

<?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 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.hang"/>

    <!--导入jdbc.properties文件-->
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <!--配置druid数据库连接池-->
    <bean class="com.alibaba.druid.pool.DruidDataSource" id="dataSource">
        <property name="url" value="${jdbc.url}"/>
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="initialSize" value="${jdbc.initialSize}"/>
    </bean>

    <!--开启aop注解-->
    <aop:aspectj-autoproxy/>
</beans>

2. 定义事务管理器MyTransactionManager对象

定义事务管理器MyTransactionManager对象，注册进spring容器。(依赖Druid连接池，获取连接，开始事务，提交事务，回滚事务，关闭连接)

@Component
public class MyTransactionManager {
    @Autowired
    private DataSource dataSource;

    // 获取连接
    public Connection getConnection(){
        Connection conn = null;
        try {
            conn = dataSource.getConnection();
            ConnUtil.setConn(conn);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return conn;
    }

    // 开始事务
    public void openTransaction(){
        try {
            ConnUtil.getConn().setAutoCommit(false);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    // 提交事务
    public void openCommit(){
        try {
            ConnUtil.getConn().commit();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    // 回滚事务
    public void openRollback(){
        try {
            ConnUtil.getConn().rollback();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    // 关闭连接
    public void closeConnection(){
        Connection conn = ConnUtil.getConn();
        try {
            if (conn!=null){
                conn.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public DataSource getDataSource() {
        return dataSource;
    }

    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }
}

3. 定义dao接口

定义dao接口，使用jdbc定义dao实现，不要使用mybatis，把dao实现注册spring容器(curd)

public interface SysUserDao {

    SysUser queryById(Integer id) throws Exception;
    
    Integer insert(SysUser sysUser) throws Exception;
    
    int update(SysUser sysUser);

    int deleteById(Long id);
}


@Repository
public class SysUserDaoImpl implements SysUserDao {
    private Connection conn = null;
    private ResultSet rs = null;
    private PreparedStatement ps = null;

    @Override
    public SysUser queryById(Integer id) throws Exception {
        SysUser sysUser = null;
        conn = ConnUtil.getConn();
        ps = conn.prepareStatement("select * from db_stage_three.sys_user where  id = ?");
        ps.setInt(1, id);
        rs = ps.executeQuery();
        if (rs.next()) {
            sysUser = new SysUser();
            sysUser.setUname("hello");
        }
        return sysUser;
    }

    @Override
    public Integer insert(SysUser sysUser) throws Exception {
        Integer result = null;
        conn = ConnUtil.getConn();
        ps = conn.prepareStatement("insert into db_stage_three.sys_user ( uname, uphone, upwd, uwechat, uemail, role_id, dept_id) values (?,?,?,?,?,?,?)");
        ps.setString(1, sysUser.getUname());
        ps.setString(2, sysUser.getUphone());
        ps.setString(3, sysUser.getUpwd());
        ps.setString(4, sysUser.getUwechat());
        ps.setString(5, sysUser.getUemail());
        ps.setInt(6, sysUser.getRoleId());
        ps.setInt(7, sysUser.getDeptId());
        result = ps.executeUpdate();
        return result;
    }

    @Override
    public int update(SysUser sysUser) {
        return 0;
    }

    @Override
    public int deleteById(Long id) {
        return 0;
    }

}

4. 定义service接口

定义service接口，定义service实现，注册容器(curd)。

public interface SysUserService {
    
    SysUser queryById(Integer id);

    SysUser insert(SysUser sysUser);
}

@Service()
public class SysUserServiceImpl implements SysUserService {
    @Resource
    private SysUserDao sysUserDao;

    @Override
    public SysUser queryById(Integer id) {
        Connection conn = null;
        // 织入获取连接，开始事务,提交事务,回滚事务,关闭连接
        SysUser sysUser = null;
        try {
            sysUser = this.sysUserDao.queryById(id);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return sysUser;
    }

    @Transaction // 使用基于自定义注解方式定义切入点表达式
    @Override
    public SysUser insert(SysUser sysUser) {
        try {
            this.sysUserDao.insert(sysUser);
        } catch (Exception e) {
            e.printStackTrace();
        }
        int i = 1/0;
        return sysUser;
    }

}

自定义注解代码如下：

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Transaction {
}

5. 定义事务切面(依赖MyTransactionManag)

定义事务切面(依赖MyTransactionManag)，定义环绕通知，织入到service层的数据库操作方法，执行方法之前打开事务，异常回滚，方法返回提交事务，最终关闭连接。定义 ServiceTransAspect 类作为切面

@Component
@Aspect
public class ServiceTransAspect {

    @Autowired
    private MyTransactionManager transactionManager;

    // 基于 AspectJ 的切入点表达式
    @Pointcut("execution(* com.hang.service.impl.SysUserServiceImpl.*(..))")
    public void servicePointCut() {
    }

    // 后置通知关闭数据库连接对象
    @After("servicePointCut()")
    public void closeConnection(){
        Connection conn = ConnUtil.getConn();
        if (conn!=null){
            try {
                conn.close();
                ConnUtil.clear();
                conn = null;
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    // 基于自定义注解形式
    @Pointcut("@annotation(com.hang.aspect.Transaction)")
    public void annotationPointCut() {
    }

    // 环绕通知 实现事务的开启、回滚、提交和连接对象的关闭
    @Around(value = "annotationPointCut()")
    public Object serviceManage(ProceedingJoinPoint pjp) {
        Object result = null;
        try {
            transactionManager.getConnection();
            transactionManager.openTransaction();
            result = pjp.proceed();
            transactionManager.openCommit();
        } catch (Throwable throwable) {
            transactionManager.openRollback();
            throwable.printStackTrace();
        } finally {
            transactionManager.closeConnection();
        }
        return result;
    }

}

6. 自定义工具类

在并发环境下，如果没使用ThreadLocal类维护线程内部的局部变量Connection（单Connection对象），两个线程共同访问一个公共变量。例如A用户获取数据库连接对象，并将Connection对象占为己有，对数据进行操作时，B用户也获取到数据库连接对象，获取Connection对象，此时A不具有Connection对象，B用户完成事务提交关闭连接，此时Connection对象为null，A用户数据则会提交失败。

ThreadLocal类用来提供线程内部的局部变量。这种变量在多线程环境下访问（通过get和set方法访问）时能保证各个线程的变量相对独立于其他线程内的变量。

对ThreadLocal作用的总结：

  1. 线程并发: 在多线程并发的场景下
  2. 传递数据: 我们可以通过ThreadLocal在同一线程，不同组件中传递公共变量
  3. 线程隔离: 每个线程的变量都是独立的，不会互相影响
@Component
public class ConnUtil {
    private static ThreadLocal<Connection> threadLocalConn  = new ThreadLocal<>();
    @Resource
    private MyTransactionManager tm;

    private static MyTransactionManager manager;

    public static void clear() {
        threadLocalConn.remove();
    }

    @PostConstruct
    public void setTransactionManager(){
        manager = tm;
    }

    public static Connection getConn() {
        Connection connection = threadLocalConn.get();
        if (connection!=null){
            return  connection;
        }else {
            return manager.getConnection();
        }
    }
    public static void setConn(Connection conn) {
        threadLocalConn.set(conn);
    }
}
Antarcticc
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
自定义事务管理器，让MyBatis-Plus适应你的业务需求
奇妙的Bug之旅
01-07 480
在使用MyBatis-Plus时，默认使用了Spring的事务管理器来管理数据库操作的事务。但是有时候我们可能需要自定义事务管理器，以满足特殊的业务需求。本文将介绍如何自定义事务管理器，并提供一个完整的实例。首先，我们需要创建一个自定义的事务管理器类，该类需要实现Spring的PlatformTransactionManager接口。@Override// 手动开启事务try {@Override// 手动提交事务try {@Override// 手动回滚事务。
事务管理自定义事务管理器
DreamCloud714的博客
03-09 1087
事务管理自定义事务管理器 public class DBUtils { //获取链接 //在当前线程中存储所使用的链接 private ThreadLocal<Connection> threadLocal = new ThreadLocal<>(); //注入数据源 private DataSource dataSource; ...
自己实现的TransactionManager
jamesby
02-23 370
[b]背景：[/b] [color=red]目前有一个系统，系统已经写好了，但是要不停的添加新的功能，用Struts， 业务逻辑写在Action中，以后可能增加一层Service。 业务处理和持久层没有使用任何框架，目前是用Dao担任业务处理加持久层双重操作， 但是有些业务处理很复杂，固设计了一个事务处理框架，大家帮我看下有没有线程安全的问题， 第一次使用ThreadLocal，请多指教...
spring 自定义事务管理器，编程式事务，声明式事务@Transactional使用
07-13
本代码使用H2内存数据库演示spring事务使用，包括编程式事务，声明式事务@Transactional使用，自定义事务事务注解实现自定义事务管理器
自定义支持事务操作的资源管理器
weixin_34375233的博客
11-01 161
（一）应用场景 在使用事务时，我们多是基于已经提供事务管理功能的资源管理器进行事务操作，比如各种数据库，这基本上能够满足需求，但是有些时候，我们需要对一些内存中的对象进行事务管理，如：在使用EF时，当事务回滚时，数据库中的数据会进行回滚，但是EF缓存中的数据仍会保持被修改后的状态，不会进行回滚，这样在一些特殊的应用下也许会产生错误。到目前为止，EF似乎还不支持二级缓存，但是网上已经流传出EF实现...
详解Spring学习之编程式事务管理
08-29
我们首先创建了一个 TransactionTemplate 对象，并将事务管理器设置为 transactionManager。然后，我们使用 execute() 方法来执行事务操作。在事务操作中，我们使用 JdbcTemplate 来执行 UPDATE 语句来更新账户余额...
myBatis系列之七：事务管理
08-14
这种模式适用于需要自定义事务边界或者复杂事务逻辑的情况。例如，当多个DAO操作需要在一个事务中执行时，可以通过手动控制事务来确保这些操作要么全部成功，要么全部失败。 2. **自动事务管理**：MyBatis可以与...
spring事务管理
07-31
2. 事务管理器（TransactionManager）：Spring支持多种类型的事务管理器，如DataSourceTransactionManager（适用于JDBC）、HibernateTransactionManager（适用于Hibernate）、JtaTransactionManager（适用于JTA，...
Spring事务管理(全)
08-07
- **灵活的事务配置**：Spring允许开发者自定义事务的传播行为、隔离级别等属性，从而满足更复杂的事务需求。 #### 六、总结 综上所述，Spring事务管理通过一套统一的编程模型实现了事务管理和数据访问的关注点...
spring_tx编程式事务代码
01-24
- 可以自定义事务属性，适应不同的业务场景。 - 事务管理代码与业务逻辑分离，提高了代码的可测试性和可维护性。 总结来说，`Spring_tx编程式事务代码`主要涉及Spring的`TransactionTemplate`类，它是Spring事务...
事务管理---------自定义事务管理器 AOP通知配置
DreamCloud714的博客
03-09 358
事务管理---------自定义事务管理器 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" ...
Spring自定义事务管理器+自定义注解
最新发布
weixin_43504955的博客
11-02 870
Spring自定义事务管理器
数据库事务(三)：构建自己的TransactionManager实现事务处理
Stony_Confident的博客
02-06 2688
在上一篇中我们提出，要实现一个可靠的事务处理机制，关键在于保证同一个事务中使用相同的Connection对象。本文将继续探讨如何保证获取到同一个Connection对象。 因此我们需要单独创建一个全局公用类，用于管理connection对象，所有数据库操作都从该类中获取connection; 全局公用类管理Connection对象 定义一个ConnectionHolder类： pu
Spring--06自定义事务控制器
Ur_Eyes_的博客
08-08 259
项目需求 实现账户间转账，能够实现事务的一致性，出现异常，事务回滚。 项目说明 基于XML的IoC配置 自定义事务控制器 c3p0作为数据源 dbutils作为数据封装工具类 自定义连接工具类 生产方法增强的工厂类 整合了spring和junit 新建实体类Account package com.cncs.domain; import java.io.Serializable; public class Account implements Serializable { private i
事务管理者自定义事务声明式事务
qq_44694485的博客
08-23 658
事务实现 启动类加入注解@EnableTransacctionManagement @SpringBootApplication @EnableTransactionManagement public class Demo11Application { public static void main(String[] args) { SpringApplication.run(Demo11Application.class, args); } } 指定事务管理器 @Configuration
XATransactionManager
maqingbin8888的专栏
03-04 340
拥有的子方法 underlying 替在的,在下面的TransactionManager ger getUnderlyingTransactionManager();返回的是一个jdk的标准的事物管理器DataSource wrapDataSource(DatabaseType databaseType, XADataSource xaDataSource, String data...
事务配置_AOP配置自定义事务TransactionManager+xml+注解配置bean的例子
weixin_39782355的博客
12-01 313
自己写的类,开启注解扫描给spring托管bean别人写的用xml配置bean<aop:aspectj-autoproxy>注解配置事务没有xml配置好,原因是要写很多个@事务注解这里如果用注解方式会出问题,原因是先调用了最终通知,而最终通知把connection对象还回了连接池,然而当前线程也被还回线程池,但是最终通知解绑了线程和connection对象,接着再执行after通知的时...
事务管理器的具体实现DataSourceTransactionManager
yangzsirr的博客
11-13 2146
前文我们讨论了抽象的TransactionManager实现AbstractPlatformTransactionManager，其定义诸多模板方法，主要目的是处理事务的传播行为，在合适的时机挂起当前事务，本事务完成后重放挂起的事务，参见AbstractPlatformTransactionManager解析，而DataSourceTransactionManager作为抽象类的具体实现，就是实现了对与DB数据源如何创建事务，提交事务等等，也就是对抽象类中抽象方法的实现。 doGetTra...
TransactionManagerLookupFactory
tmmh
03-27 275
[code="java"] TransactionManagerLookupFactory.getTransactionManagerLookup根据hibernate.transaction.manager_lookup_class确定TransactionMangerLookup,简要介绍TransactionMangerLookup public TransactionManage...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值