单体架构多数据源事务解决方案

最新推荐文章于 2024-08-12 08:30:00 发布
最新推荐文章于 2024-08-12 08:30:00 发布
阅读量1.4k 收藏 12
点赞数 2
文章标签： 事务 多数据源事务 springboot Atomikos JTA 多数据源 分布式事务 jta+atomikos
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuanshangshenghuo/article/details/107305107
版权

文章目录


演示源码github：链接

1. 本文适合场景

本文事务解决方案只适用于单体架构项目多数据源的场景，就是同一进程中多个数据源要想解决事务问题可以使用本方案。

1.1 场景介绍

比如说我们现在做一个出行项目，类似滴滴出行这样子的，然后呢项目是个单体架构，但是数据却存在了不同的库中了，比如说与司机有关的表都放在了driver_db 库中了，与订单有关的表都存放在了order_db 库中了，项目是使用配置多数据源的形式来操作数据库的。
现在，有个用户a下了一个用车订单，然后系统在order_db 库中的order_info 表中插入一条订单信息，下图：
在这里插入图片描述
id_ 是我们的订单编号，driver_id 是接单司机，create_time 就是咱们的创建时间，剩下的字段都省略掉…
接着driver_id为1的司机抢到了这个订单，这时候，需要在司机表中有个当前订单字段中填入 订单号，在订单信息中填入接单司机。
我们来看看这个司机表
在这里插入图片描述
id_是司机id，dirver_name 这个这里用不到，curr_order_id 是当前接到的订单，create_time司机注册时间。

这里咱们有这么一个业务要求就是： 司机接到订单的时候，需要订单信息要添加driver_id，司机信息中的curr_order_id要添加订单编号。
这两步要同时执行，保持一致性，要么都成功，要么都失败，否则会对影响业务，比如说driver_id 为1的司机抢到为1的订单，然后只将订单编号更新到driver_info 表的curr_order_id 了，没有将司机信息添加到订单信息中，这时候，系统认为该订单没有派出去，然后又继续通知司机们抢单，会造成一个订单被多个司机师傅接到。相反只将司机信息更新到了订单表中，然后司机表中的curr_order_id没有订单号，这时候司机师傅就不知道自己接到了订单，还会去抢别的订单，造成一个司机同时多个订单。

1.2 场景代码模拟

这里我们就用代码模拟下1.1 节介绍的内容，这里我们使用单体架构多数据源的形式，springboot+mybatis+druid

1.2.1 数据库

这里为了模拟多数据源，我们在同一个实例上面创建了两个db，一个是dirver_db 放的是司机有关的，一个是order_db放的是订单有关的。
在这里插入图片描述
我们需要在这两个库中分别创建driver_info 与order_info 表
司机表：

CREATE TABLE `driver_info` (
  `id_` int(11) NOT NULL AUTO_INCREMENT COMMENT '司机id',
  `driver_name` varchar(20) DEFAULT NULL COMMENT '司机姓名',
  `curr_order_id` int(11) DEFAULT NULL COMMENT '当前接到的订单',
  `create_time` datetime DEFAULT NULL COMMENT '创建时间',
  PRIMARY KEY (`id_`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

插入编号1的司机：

insert into driver_info (id_,driver_name,create_time) values(1,'driver01','2020-07-13 00:00:00')

订单表：

CREATE TABLE `order_info` (
  `id_` int(11) NOT NULL AUTO_INCREMENT COMMENT '订单id\n',
  `driver_id` int(11) DEFAULT NULL COMMENT '接单司机id',
  `create_time` datetime DEFAULT NULL COMMENT '订单创建时间',
  PRIMARY KEY (`id_`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;

创建订单号为1的订单：

insert into order_info (id_,create_time) values(1,'2020-07-13 23:00:00')
1.2.2 单体多数据源项目
1.2.2.1 pom
 <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.1.RELEASE</version>
        <relativePath/>
 </parent>
 <dependencies>
		<!--web starter-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
        </dependency>
        <!--druid 数据源-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.21</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
        </dependency>
        <!--mybatis-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.1.1</version>
        </dependency>
		<!--mysql 	驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>6.0.6</version>
        </dependency>
		<!--单元测试-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>
1.2.2.2 配置文件application

我们需要在配置文件application.yml中添加多数据源

# 配置多数据源
spring:
  datasource:
    driver:
      type: com.alibaba.druid.pool.DruidDataSource
      driver-class-name: com.mysql.cj.jdbc.Driver
      jdbc-url: jdbc:mysql://192.168.3.36:3306/driver_db?useUnicode=true&characterEncoding=utf-8&useSSL=false&allowMultiQueries=true
      username: root
      password: 123456
    order:
      type: com.alibaba.druid.pool.DruidDataSource
      driver-class-name: com.mysql.cj.jdbc.Driver
      jdbc-url: jdbc:mysql://192.168.3.36:3306/order_db?useUnicode=true&characterEncoding=utf-8&useSSL=false&allowMultiQueries=true
      username: root
      password: 123456
  application:
    name: multi-datasource-distributed-transaction

server:
  port: 8080
1.2.2.3 主启动类

这里就是普通的springboot主启动类
在这里插入图片描述

1.2.2.4 多数据源配置类
  1. DriverDatasourceConfiguration

@Configuration
@MapperScan(basePackages = {"com.xuzhaocai.multi.dao.driver"}, sqlSessionTemplateRef = "driverSqlSessionTemplate")
public class DriverDatasourceConfiguration {
    @Bean(name = "driverDatasource")
    @ConfigurationProperties(prefix = "spring.datasource.driver")
    public DataSource driverDruidDatasource() {

        return DataSourceBuilder.create().build();
        //return xaDataSource;
    }

    //配置数据源
    @Bean(name = "driverSqlSessionFactory")
    public SqlSessionFactory driverSqlSessionFactory(@Qualifier("driverDatasource") DataSource dataSource) throws Exception {
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        PathMatchingResourcePatternResolver pathMatchingResourcePatternResolver = new PathMatchingResourcePatternResolver();
             //mapper.xml 的位置
        Resource[] resources1 = pathMatchingResourcePatternResolver.getResources("classpath*:com/xuzhaocai/multi/dao/driver/*.xml");
        factoryBean.setMapperLocations(resources1);
        factoryBean.setDataSource(dataSource);
        return factoryBean.getObject();

    }
    // 事务管理器
    @Bean(name = "driverTransactionManger")
    public DataSourceTransactionManager driverTransactionManger(@Qualifier("driverDatasource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }

    @Bean(name = "driverSqlSessionTemplate")
    public SqlSessionTemplate driverSqlSessionTemplate(@Qualifier("driverSqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
        return new SqlSessionTemplate(sqlSessionFactory);
    }

}
  1. OrderDatasourceConfiguration

@Configuration
@MapperScan(basePackages = {"com.xuzhaocai.multi.dao.order"}, sqlSessionTemplateRef = "orderSqlSessionTemplate")
public class OrderDatasourceConfiguration {



    @Bean(name = "orderDatasource")
    @ConfigurationProperties(prefix = "spring.datasource.order")
    @Primary
    public DataSource orderDatasource() {
        return DataSourceBuilder.create().build();
    }


    //配置数据源
    @Bean(name = "orderSqlSessionFactory")
    @Primary
    public SqlSessionFactory orderSqlSessionFactory(@Qualifier("orderDatasource") DataSource dataSource) throws Exception {
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        PathMatchingResourcePatternResolver pathMatchingResourcePatternResolver = new PathMatchingResourcePatternResolver();
        Resource[] resources1 = pathMatchingResourcePatternResolver.getResources("classpath*:com/xuzhaocai/multi/dao/order/*.xml");
        factoryBean.setMapperLocations(resources1);
        factoryBean.setDataSource(dataSource);
        return factoryBean.getObject();

    }
    // 事务管理器
    @Bean(name = "orderTransactionManger")
    @Primary
    public DataSourceTransactionManager orderTransactionManger(@Qualifier("orderDatasource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }

    @Bean(name = "orderSqlSessionTemplate")
    @Primary
    public SqlSessionTemplate orderSqlSessionTemplate(@Qualifier("orderSqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
        return new SqlSessionTemplate(sqlSessionFactory);
    }

}
1.2.2.5 dao 与mapper

这种多数据源是使用分包来区别的，不同的包下的dao用不同的数据源
在这里插入图片描述
DriverInfoDao：

@Repository
public interface DriverInfoDao {
    /**
     * 修改司机信息表中，当前接单的订单
     * @param driverInfo 司机信息
     * @return
     */
    public int updateReceivedOrder(@Param("driverInfo") DriverInfo driverInfo);
    /**
     * 通过司机id获取司机信息
     * @param id  司机id
     * @return 司机信息
     */
    public DriverInfo selectById(@Param("dirverId") Integer id);
}

OrderInfoDao：

@Repository
public interface OrderInfoDao {
    /**
     * 修改订单信息中司机接单信息
     * @param orderInfo 订单详情
     * @return
     */
    public int updateOrderAddDriverInfo(@Param("orderInfo") OrderInfo orderInfo);

    //通过订单ID查询订单信息
    public  OrderInfo selectById(@Param("orderId") Integer oid);
}

同样mapper也是一样的，需要与dao放在同一个目录下：
在这里插入图片描述
DriverInfoMapper.xml：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.xuzhaocai.multi.dao.driver.DriverInfoDao" >
    <update id="updateReceivedOrder">
        update driver_info set curr_order_id=#{driverInfo.currOrderId}  where id_=#{driverInfo.id}
    </update>
    <select id="selectById" resultType="com.xuzhaocai.multi.entity.DriverInfo">
         select
          id_ as id,
          driver_name  as driverName,
          curr_order_id as currOrderId ,
          create_time as  createTime
        from driver_info where id_=#{dirverId}
    </select>
</mapper>

OrderInfoMapper.xml：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.xuzhaocai.multi.dao.order.OrderInfoDao" >
    <update id="updateOrderAddDriverInfo" >
        update order_info  set driver_id = #{orderInfo.driverId}  where id_=#{orderInfo.id}
    </update>
    <select id="selectById" resultType="com.xuzhaocai.multi.entity.OrderInfo">
        select
        id_ as id,
        driver_id as driverId,
        create_time as createTime
        from order_info where id_=#{orderId}
    </select>
</mapper>
1.2.2.5 service与impl

在这里插入图片描述
service
DirverInfoService:

public interface DirverInfoService {
    public String takeOrder(Integer driverId, Integer orderId);
}

OrderInfoService:

public interface OrderInfoService {
}

impl
DriverInfoServiceImpl:

这里我们就根据上面的业务模拟一个司机接单的动作，先是将 司机信息与订单信息拿出来，然后判断司机信息中的当前订单id是否是空，订单信息中的接单司机是否为空，这里还有司机强单问题我们就处理了，我们就当这个司机拿到这个抢单机会，接着就是往订单表中添加司机id，往司机信息中添加订单id，分别更新到库中，当然我们还模拟了出问题。

@Service
public class DriverInfoServiceImpl implements DirverInfoService {
    @Autowired
    private DriverInfoDao driverInfoDao;
    @Autowired
    private OrderInfoDao orderInfoDao;

    //接单操作。
    @Transactional(transactionManager = "driverTransactionManger")
    @Override
    public String takeOrder(Integer driverId, Integer orderId) {
        OrderInfo orderInfo = orderInfoDao.selectById(orderId);
        DriverInfo driverInfo = driverInfoDao.selectById(driverId);
        // 验证 当前司机没有接单，当前订单没有被司机接走
        if (driverInfo==null || driverInfo.getCurrOrderId()!=null || orderInfo==null || orderInfo.getDriverId()!=null  ){
            return "失败";
        }
        orderInfo.setDriverId(driverId);
        driverInfo.setCurrOrderId(orderId);
        int updateDriverFlag = driverInfoDao.updateReceivedOrder(driverInfo);

        int updateOrderFlag = orderInfoDao.updateOrderAddDriverInfo(orderInfo);
        // 模拟出问题
        int i= 1/0;
        if (updateDriverFlag+updateOrderFlag==2){
            return "成功";
        }
        return "失败";
    }
}

OrderInfoServiceImpl：
这个order的service我们这里没用用到

@Service
public class OrderInfoServiceImpl implements OrderInfoService {
}
1.2.2.6 实体

司机实体(driver_info)：

// 司机信息
public class DriverInfo {
    private Integer  id;
    private  String driverName;
    private Integer currOrderId;
    private Date createTime;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getDriverName() {
        return driverName;
    }
    public void setDriverName(String driverName) {
        this.driverName = driverName;
    }
    public Integer getCurrOrderId() {
        return currOrderId;
    }
    public void setCurrOrderId(Integer currOrderId) {
        this.currOrderId = currOrderId;
    }
    public Date getCreateTime() {
        return createTime;
    }
    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }
}

订单实体（order_info ）：

// 订单信息表
public class OrderInfo {
    private Integer id;
    private Integer driverId;
    private Date createTime;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public Integer getDriverId() {
        return driverId;
    }
    public void setDriverId(Integer driverId) {
        this.driverId = driverId;
    }
    public Date getCreateTime() {
        return createTime;
    }
    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }
}
1.2.2.7 controller

这里我们使用controller来触发这个接单操作

@RestController
@RequestMapping("/driver/")
public class DriverInfoController {
    @Autowired
    private DirverInfoService dirverInfoService;
    /**
     * 接单方法
     * @return
     */
    @RequestMapping(value = "/takeOrder",method = RequestMethod.GET)
    public String takeOrder(){
        Integer driverId =1;
        Integer orderId=1;
        return dirverInfoService.takeOrder(driverId,orderId);
    }
}
1.2.2.8 触发接单，查看效果

我们启动项目，然后请求接口http://127.0.0.1:8080/driver/takeOrder 触发接单。
请求完成后我们可以看到这里出了问题，然后我们看下数据库里面的表：
在driver_info司机表中没有插入订单id，也就是司机端就看不到自己接单了
在这里插入图片描述
而在订单表中，则是有了司机id。
在这里插入图片描述
这时，可以发现数据出现了不一致的情况，司机没有接到订单，而订单中确是这个司机接到到这个订单。
我们可以看下代码，代码中我们使用是事务管理器是司机那个数据源的，然后报错后，会把司机这个操作回滚。而订单操作的这个事务它是管不到的，所以就没有回滚。
在这里插入图片描述
那么我们使用订单的事务管理器可以不，答案是不可以，订单管理器也只能管着订单的回滚，并不能管着司机操作的回滚，同样会出现数据不一致的情况。

2.使用jta+atomikos解决多数据源事务方案

2.1 jta是什么

百度百科是这样说的

JTA，即Java Transaction API，JTA允许应用程序执行分布式事务处理——在两个或多个网络计算机资源上访问并且更新数据。JDBC驱动程序的JTA支持极大地增强了数据访问能力。
JTA与JDBC对比：
JTA事务比JDBC事务更强大。一个JTA事务可以有多个参与者，而一个JDBC事务则被限定在一个单一的数据库连接。下列任一个Java平台的组件都可以参与到一个JTA事务中：JDBC连接、JDO PersistenceManager 对象、JMS 队列、JMS 主题、企业JavaBeans（EJB）、一个用J2EE Connector Architecture 规范编译的资源分配器。

2.2 atomikos是什么

atomikos是一个实现JTA事务管理第三方管理工具，为Java平台提供增值服务的并且开源类事务管理器。

2.3 改造上述案例实现多数据源事务管理
2.3.1 pom

pom文件中添加对atomikos的支持

<dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-jta-atomikos</artifactId>
</dependency>
2.3.2 配置文件application

需要将配置文件中jdbc-url改成url

spring:
  datasource:
    driver:
      type: com.alibaba.druid.pool.DruidDataSource
      driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://192.168.3.36:3306/driver_db?useUnicode=true&characterEncoding=utf-8&useSSL=false&allowMultiQueries=true
      username: root
      password: 123456
    order:
      type: com.alibaba.druid.pool.DruidDataSource
      driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://192.168.3.36:3306/order_db?useUnicode=true&characterEncoding=utf-8&useSSL=false&allowMultiQueries=true
      username: root
      password: 123456
  application:
    name: multi-datasource-distributed-transaction

server:
  port: 8080
2.3.3 编写数据源配置properties

这里只是将配置文件中的配置信息放到properties中
DriverDatasourceProperties：

@Component
@ConfigurationProperties(prefix = "spring.datasource.driver")
public class DriverDatasourceProperties {
    private String driverClassName;
    private String url;
    private String username;
    private String password;
    public String getDriverClassName() {
        return driverClassName;
    }
    public void setDriverClassName(String driverClassName) {
        this.driverClassName = driverClassName;
    }
    public String getUrl() {
        return url;
    }
    public void setUrl(String url) {
        this.url = url;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
}

OrderDatasourceProperties：

@Component
@ConfigurationProperties(prefix = "spring.datasource.order")
public class OrderDatasourceProperties {
    private String driverClassName;
    private String url;
    private String username;
    private String password;
    public String getDriverClassName() {
        return driverClassName;
    }
    public void setDriverClassName(String driverClassName) {
        this.driverClassName = driverClassName;
    }
    public String getUrl() {
        return url;
    }
    public void setUrl(String url) {
        this.url = url;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
}
2.3.4 修改数据源配置

这里主要是将datasource包上一层atomikos的datasource。
DriverDatasourceConfiguration:

@Configuration
@MapperScan(basePackages = {"com.xuzhaocai.multi.dao.driver"}, sqlSessionTemplateRef = "driverSqlSessionTemplate")
public class DriverDatasourceConfiguration {
    @Autowired
    private DriverDatasourceProperties driverDatasourceProperties;
    @Bean(name = "driverDatasource")
    public DataSource driverDruidDatasource() {
        DruidXADataSource datasource = new DruidXADataSource();
        BeanUtils.copyProperties(driverDatasourceProperties,datasource);
        AtomikosDataSourceBean xaDataSource = new AtomikosDataSourceBean();
        xaDataSource.setXaDataSource(datasource);
        xaDataSource.setUniqueResourceName("driverDatasource");
        //return DataSourceBuilder.create().build();
        return xaDataSource;
    }

    //配置数据源
    @Bean(name = "driverSqlSessionFactory")
    public SqlSessionFactory driverSqlSessionFactory(@Qualifier("driverDatasource") DataSource dataSource) throws Exception {
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        PathMatchingResourcePatternResolver pathMatchingResourcePatternResolver = new PathMatchingResourcePatternResolver();
             //mapper.xml 的位置
        Resource[] resources1 = pathMatchingResourcePatternResolver.getResources("classpath*:com/xuzhaocai/multi/dao/driver/*.xml");
        factoryBean.setMapperLocations(resources1);
        factoryBean.setDataSource(dataSource);
        return factoryBean.getObject();
    }
    // 事务管理器
   /* @Bean(name = "driverTransactionManger")
    public DataSourceTransactionManager driverTransactionManger(@Qualifier("driverDatasource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }*/

    @Bean(name = "driverSqlSessionTemplate")
    public SqlSessionTemplate driverSqlSessionTemplate(@Qualifier("driverSqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
        return new SqlSessionTemplate(sqlSessionFactory);
    }
}

OrderDatasourceConfiguration:

@Configuration
@MapperScan(basePackages = {"com.xuzhaocai.multi.dao.order"}, sqlSessionTemplateRef = "orderSqlSessionTemplate")
public class OrderDatasourceConfiguration {

    @Autowired
    private  OrderDatasourceProperties orderDatasourceProperties;
    @Bean(name = "orderDatasource")
    @Primary
    public DataSource orderDatasource() {
        DruidXADataSource datasource = new DruidXADataSource();
        BeanUtils.copyProperties(orderDatasourceProperties,datasource);
        AtomikosDataSourceBean xaDataSource = new AtomikosDataSourceBean();
        xaDataSource.setXaDataSource(datasource);
        xaDataSource.setUniqueResourceName("orderDatasource");
        return xaDataSource;
    }
    //配置数据源
    @Bean(name = "orderSqlSessionFactory")
    @Primary
    public SqlSessionFactory orderSqlSessionFactory(@Qualifier("orderDatasource") DataSource dataSource) throws Exception {
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        PathMatchingResourcePatternResolver pathMatchingResourcePatternResolver = new PathMatchingResourcePatternResolver();
        Resource[] resources1 = pathMatchingResourcePatternResolver.getResources("classpath*:com/xuzhaocai/multi/dao/order/*.xml");
        factoryBean.setMapperLocations(resources1);
        factoryBean.setDataSource(dataSource);
        return factoryBean.getObject();

    }
   /* // 事务管理器
    @Bean(name = "orderTransactionManger")
    @Primary
    public DataSourceTransactionManager orderTransactionManger(@Qualifier("orderDatasource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }*/

    @Bean(name = "orderSqlSessionTemplate")
    @Primary
    public SqlSessionTemplate orderSqlSessionTemplate(@Qualifier("orderSqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
        return new SqlSessionTemplate(sqlSessionFactory);
    }

}
2.3.5 修改接单方法

这里就不需要指定事务管理器了，直接使用Transactional注解就好了。

	@Transactional()
    @Override
    public String takeOrder(Integer driverId, Integer orderId) {
        OrderInfo orderInfo = orderInfoDao.selectById(orderId);
        DriverInfo driverInfo = driverInfoDao.selectById(driverId);
        // 验证 当前司机没有接单，当前订单没有被司机接走
        if (driverInfo==null || driverInfo.getCurrOrderId()!=null || orderInfo==null || orderInfo.getDriverId()!=null  ){
            return "失败";
        }
        orderInfo.setDriverId(driverId);
        driverInfo.setCurrOrderId(orderId);
        int updateDriverFlag = driverInfoDao.updateReceivedOrder(driverInfo);
        int updateOrderFlag = orderInfoDao.updateOrderAddDriverInfo(orderInfo);
        // 模拟出问题
        int i= 1/0;
        if (updateDriverFlag+updateOrderFlag==2){
            return "成功";
        }
        return "失败";
    }
2.3.6 测试

首先我们要把数据置为原始样子，然后重启项目，发起接单请求，这时候再看数据情况，发现报错之后都没有提交事务，这就达成了数据的一致性。
在这里插入图片描述
在这里插入图片描述

$码出未来
关注
专栏目录
双剑合璧：SpringBoot下多数据源与事务管理的完美攻略
java专栏
06-16 345
🔥关注墨瑾轩，带你探索Java的奥秘！🚀🔥超萌技术攻略，轻松晋级编程高手！🚀🔥技术宝库已备好，就等你来挖掘！🚀🔥订阅墨瑾轩，智趣学习不孤单！🚀🔥即刻启航，编程之旅更有趣！🚀Spring Boot在处理多数据源和事务管理时，提供了灵活的配置方式和强大的支持。以下是一个关于如何在Spring Boot应用中配置多数据源及实现事务管理的详细示例，包括必要的代码和注释说明。
Spring Boot 多数据源及事务解决方案
m0_71777195的博客
06-20 3921
3.2.1 定义管理接口通过继承即可实现。为了方便对数据源进行操作，我们定义一个接口，为业务提供操作数据源的统一接口。该接口主要是对数据表中定义的数据源，提供基础管理功能。3.2.2 自定义数据源的实现如下图所示：根据前面的分析，是在容器启动的时候，执行注入数据源对象，完成之后无法对数据源进行修改。则实现接口，可以将数据表中的数据源加载到dataSources。3.2.3 切面处理这一块的处理跟配置文件数据源方案处理方式相同，都是通过AOP技术切换lookup key。
(一) 单体项目配置多数据源jta-atomikos
u013008898的博客
03-08 380
pom.xml <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-configuration-processor</art...
SpringBoot多数据源事务如何管理
最新发布
Flying_Fish_roe的博客
08-12 1219
配置每个数据源对应的事务管理器，并在需要的地方通过 `@Transactional` 注解指定使用的事务管理器。- 使用 `TransactionTemplate` 提供显式的事务控制。- 对于跨多个数据源的分布式事务，考虑使用专门的分布式事务管理解决方案。确保你的事务配置与你的业务需求相匹配，并充分测试事务在多数据源环境中的行为。
springboot单体项目多数据源，事务失效解决方案
m0_61296542的博客
11-02 825
背景在业务中，会同时保存数据到两个数据源的情况，还要保持数据的一致性，就要用到全局事务。使用spring注解@Transactional不能控制两个数据源的事务，会导致数据源无法切换。
Spring boot事务管理(单体架构下)
weixin_41847607的博客
11-01 398
一些概念 声明式的事务管理是基于AOP的，在springboot中可以通过@Transactional注解的方式获得支持，这种方式的优点是： 1）非侵入式，业务逻辑不受事务管理代码的污染。 2）方法级别的事务回滚，合理划分方法的粒度可以做到符合各种业务场景的事务管理。 本文使用目前最常用的mybatis框架来配置springboot的事务管理机制。下面进入配置方法介绍。   sprin...
(二) 单体项目配置多数据源jta-atomikos
u013008898的博客
03-08 183
MybatisMultilDataSourceController: package com.kejin.twosoc.controller; import com.kejin.twosoc.test01.service.UserServiceTest01; import com.kejin.twosoc.test02.service.UserServiceTest02; import o...
关于SpringBoot的多数据源以及事务解决方案
m0_73533108的博客
09-04 1415
关于SpringBoot的多数据源以及事务解决方案
微服务架构下的分布式事务解决方案
"分布式事务-常用的分布式事务解决方案介绍.pptx" 分布式事务是现代软件系统，尤其是微服务架构中至关重要的一个概念。当业务逻辑跨越多个数据库或服务时，确保这些操作的一致性和原子性就变得复杂，这时就需要用到...
【体系-单体架构】13-Spring 的事务管理
SomeWay
07-14 185
Spring事务管理
单体架构中事务的使用姿势略谈
热门推荐
夜郎King的博客
10-25 4万+
不论是单体架构还是分布式架构，事务一定会使用到的。单体架构下，通常使用数据库自带的ACID机制加上Spring的AOP可以解决大多数场景的需求。分布式事务会比较复杂，有2PC，3PC，TCC等。本文暂不涉及分布式事务，考虑以后另写文章，讨论分布式事务。 事务本身是用来保证一次请求或者操作的一致性，完整性的。因此不得不讨论一下一次请求或者一次操作。一次请求可以理解为后台一个controller方法的调用，单体架构下MVC模式使用较多。通常会分为三层，controller用于接收终......
spring 非分布式 多数据源强事务尝试解决方案
07-25 375
spring 非分布式 多数据源强事务尝试解决方案背景常见问题示例代码 背景 springboot项目中用到了多数据源，但是框架又没有采用分布式的，导致不能使用市场上的分布式事务解决方案来解决多数据源的事务问题，但是现在问题要得到解决，没办法，网上找了很多资料，将最终的解决方案分享给大家，实际使用的话比较繁琐，有更好的解决方案，欢迎分享。 常见问题 问什么在一个事务管理器里面不能做到切换数据源（...
08.分布式事务解决方案答案
Gblfy_Blog
02-19 485
08.分布式事务解决方案答案
SpringBoot 多数据源及事务解决方案
Java笔记虾
04-04 1534
1. 背景一个主库和N个应用库的数据源，并且会同时操作主库和应用库的数据，需要解决以下两个问题：如何动态管理多个数据源以及切换？如何保证多数据源场景下的数据一致性(事务)？本文主要探讨这两个问题的解决方案，希望能对读者有一定的启发。2. 数据源切换原理通过扩展Spring提供的抽象类AbstractRoutingDataSource，可以实现切换数据源。其类结构如下图所示：targetDataSo...
分布式锁和事务解决方案
kzx0616的博客
05-27 1164
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、分布式事务的解决方案二、分布式锁的解决方案1.redis锁redis锁的几个问题2.redission锁redission锁的优势针对上述redis锁，锁过期业务未执行结束的问题，它底层实现了watchdog模式，不需要手动判断。redisson定时器使用的是netty-common包中的HashedWheelTime来实现的。3.zookeeper锁总结 前言 分布式事务和锁的来源背景： 单系统应用随着业务范围的扩大，.
Spring, MyBatis 多数据源的配置和管理
raohenglena的专栏
01-15 2585
同一个项目有时会涉及到多个数据库，也就是多数据源。多数据源又可以分为两种情况：   1）两个或多个数据库没有相关性，各自独立，其实这种可以作为两个项目来开发。比如在游戏开发中一个数据库是平台数据库，其它还有平台下的游戏对应的数据库；   2）两个或多个数据库是master-slave的关系，比如有mysql搭建一个 master-master，其后又带有多个slave；或者
openfeign seata事务不回滚_微服务分布式事务4种解决方案实战
weixin_39683144的博客
12-06 1805
分布式事务分布式事务是指事务的参与者，支持事务的服务器，资源服务器分别位于分布式系统的不同节点之上，通常一个分布式事物中会涉及到对多个数据源或业务系统的操作。典型的分布式事务场景：跨银行转操作就涉及调用两个异地银行服务CAP理论CAP理论：一个分布式系统不可能同时满足一致性，可用性和分区容错性这个三个基本需求，最多只能同时满足其中两项一致性(C)：数据在多个副本之间是否能够保持一致的特性。可用性(...
Spring Boot项目多数据源事务不生效的问题
千言万语ROOM
10-15 5286
1.问题场景描述 在方法中操作数据库，向表中插入一条数据；然后抛出RuntimeException，发现事务没有回滚，插入的数据依然提交到了数据库中。 2.问题查找及分析过程 2.1 首先查看项目中是否配置了事务 项目中确实做了事务相关的配置： spring.transaction.expression=execution(* xxxxxxx*Impl.*(..)) 那么这个配置是否生效呢？我们在执行insert后面手动抛出一个RuntimeException，看到如下的报错信息，说明异常确实抛
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

$码出未来

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值