springboot學習筆記：10.springboot+atomikos+mysql+mybatis+druid+分佈式事務

時間 2019-11-24

標籤 springboot 學習筆記 10.springboot+atomikos+mysql+mybatis+druid atomikos mysql mybatis druid 分佈式事務欄目 Spring 简体版

原文原文鏈接

前言

上一篇文章咱們整合了springboot+druid+mybatis+mysql+多數據源；css

本篇文章你們主要跟隨大家濤兄在上一屆基礎上配置一下多數據源狀況下的分佈式事務；html

首先，到底啥是分佈式事務呢，好比咱們在執行一個業務邏輯的時候有兩步分別操做A數據源和B數據源，當咱們在A數據源執行數據更改後，在B數據源執行時出現運行時異常，那麼咱們必需要讓B數據源的操做回滾，並回滾對A數據源的操做；這種狀況在支付業務時經常出現；好比買票業務在最後支付失敗，那以前的操做必須所有回滾，若是以前的操做分佈在多個數據源中，那麼這就是典型的分佈式事務回滾；(分佈式事務詳解參考)前端

瞭解了什麼是分佈式事務，那分佈式事務在java的解決方案就是JTA(即Java Transaction API)；springboot官方提供了 Atomikos or Bitronix的解決思路；java

其實，大多數狀況下不少公司是使用消息隊列的方式實現分佈式事務，這個咱們後面的文章會單獨寫一篇使用MQ的方式實現分佈式事務；mysql

本篇文章重點講解springboot環境下，整合 Atomikos +mysql+mybatis+tomcat/jetty；
git

1、項目依賴

pom.xml中添加atomikos的springboot相關依賴：github

<!--分佈式事務-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jta-atomikos</artifactId>
        </dependency>

點進去會發現裏面整合好了：transactions-jms、transactions-jta、transactions-jdbc、javax.transaction-apiweb

2、把數據源的相關配置項單獨提煉到一個application.yml中：

注意：ajax

1.這回咱們的spring.datasource.type 是com.alibaba.druid.pool.xa.DruidXADataSource；spring

2.spring.jta.transaction-manager-id的值在你的電腦中是惟一的，這個詳細請閱讀官方文檔；

3.要把以前在application-dev.properties中的spring.datasource.*全部相關配置註釋掉；

完整的yml文件以下：

spring:
  datasource:
    type: com.alibaba.druid.pool.xa.DruidXADataSource
    druid:
    
      systemDB:
        name: systemDB
        url: jdbc:mysql://localhost:3306/springboot-mybatis?useUnicode=true&characterEncoding=utf-8
        username: root
        password: root
        # 下面爲鏈接池的補充設置，應用到上面全部數據源中
        # 初始化大小，最小，最大
        initialSize: 5
        minIdle: 5
        maxActive: 20
        # 配置獲取鏈接等待超時的時間
        maxWait: 60000
        # 配置間隔多久才進行一次檢測，檢測須要關閉的空閒鏈接，單位是毫秒
        timeBetweenEvictionRunsMillis: 60000
        # 配置一個鏈接在池中最小生存的時間，單位是毫秒
        minEvictableIdleTimeMillis: 30
        validationQuery: SELECT 1
        validationQueryTimeout: 10000
        testWhileIdle: true
        testOnBorrow: false
        testOnReturn: false
        # 打開PSCache，而且指定每一個鏈接上PSCache的大小
        poolPreparedStatements: true
        maxPoolPreparedStatementPerConnectionSize: 20
        filters: stat,wall
        # 經過connectProperties屬性來打開mergeSql功能；慢SQL記錄
        connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
        # 合併多個DruidDataSource的監控數據
        useGlobalDataSourceStat: true

      businessDB:
        name: businessDB

        url: jdbc:mysql://localhost:3306/springboot-mybatis2?useUnicode=true&characterEncoding=utf-8
        username: root
        password: root
        # 下面爲鏈接池的補充設置，應用到上面全部數據源中
        # 初始化大小，最小，最大
        initialSize: 5
        minIdle: 5
        maxActive: 20
        # 配置獲取鏈接等待超時的時間
        maxWait: 60000
        # 配置間隔多久才進行一次檢測，檢測須要關閉的空閒鏈接，單位是毫秒
        timeBetweenEvictionRunsMillis: 60000
        # 配置一個鏈接在池中最小生存的時間，單位是毫秒
        minEvictableIdleTimeMillis: 30
        validationQuery: SELECT 1
        validationQueryTimeout: 10000
        testWhileIdle: true
        testOnBorrow: false
        testOnReturn: false
        # 打開PSCache，而且指定每一個鏈接上PSCache的大小
        poolPreparedStatements: true
        maxPoolPreparedStatementPerConnectionSize: 20
        filters: stat,wall
        # 經過connectProperties屬性來打開mergeSql功能；慢SQL記錄
        connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
        # 合併多個DruidDataSource的監控數據
        useGlobalDataSourceStat: true

  #jta相關參數配置
  jta:
    log-dir: classpath:tx-logs
    transaction-manager-id: txManager

3、在DruidConfig.java中實現多個數據源的註冊；分佈式事務管理器的註冊；druid的註冊；

package com.zjt.config;

import com.alibaba.druid.filter.stat.StatFilter;
import com.alibaba.druid.support.http.StatViewServlet;
import com.alibaba.druid.support.http.WebStatFilter;
import com.alibaba.druid.wall.WallConfig;
import com.alibaba.druid.wall.WallFilter;
import com.atomikos.icatch.jta.UserTransactionImp;
import com.atomikos.icatch.jta.UserTransactionManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.jta.atomikos.AtomikosDataSourceBean;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.core.env.Environment;
import org.springframework.transaction.jta.JtaTransactionManager;

import javax.sql.DataSource;
import javax.transaction.UserTransaction;
import java.util.Properties;

/**
 * Druid配置
 *
 * @author zhaojiatao
 */
@Configuration
public class DruidConfig {
    @Bean(name = "systemDataSource")
    @Primary
    @Autowired
    public DataSource systemDataSource(Environment env) {
        AtomikosDataSourceBean ds = new AtomikosDataSourceBean();
        Properties prop = build(env, "spring.datasource.druid.systemDB.");
        ds.setXaDataSourceClassName("com.alibaba.druid.pool.xa.DruidXADataSource");
        ds.setUniqueResourceName("systemDB");
        ds.setPoolSize(5);
        ds.setXaProperties(prop);
        return ds;

    }

    @Autowired
    @Bean(name = "businessDataSource")
    public AtomikosDataSourceBean businessDataSource(Environment env) {

        AtomikosDataSourceBean ds = new AtomikosDataSourceBean();
        Properties prop = build(env, "spring.datasource.druid.businessDB.");
        ds.setXaDataSourceClassName("com.alibaba.druid.pool.xa.DruidXADataSource");
        ds.setUniqueResourceName("businessDB");
        ds.setPoolSize(5);
        ds.setXaProperties(prop);

        return ds;
    }


    /** * 注入事物管理器 * @return
     */ @Bean(name = "xatx") public JtaTransactionManager regTransactionManager () { UserTransactionManager userTransactionManager = new UserTransactionManager(); UserTransaction userTransaction = new UserTransactionImp(); return new JtaTransactionManager(userTransaction, userTransactionManager); } private Properties build(Environment env, String prefix) {

        Properties prop = new Properties();
        prop.put("url", env.getProperty(prefix + "url"));
        prop.put("username", env.getProperty(prefix + "username"));
        prop.put("password", env.getProperty(prefix + "password"));
        prop.put("driverClassName", env.getProperty(prefix + "driverClassName", ""));
        prop.put("initialSize", env.getProperty(prefix + "initialSize", Integer.class));
        prop.put("maxActive", env.getProperty(prefix + "maxActive", Integer.class));
        prop.put("minIdle", env.getProperty(prefix + "minIdle", Integer.class));
        prop.put("maxWait", env.getProperty(prefix + "maxWait", Integer.class));
        prop.put("poolPreparedStatements", env.getProperty(prefix + "poolPreparedStatements", Boolean.class));

        prop.put("maxPoolPreparedStatementPerConnectionSize",
                env.getProperty(prefix + "maxPoolPreparedStatementPerConnectionSize", Integer.class));

        prop.put("maxPoolPreparedStatementPerConnectionSize",
                env.getProperty(prefix + "maxPoolPreparedStatementPerConnectionSize", Integer.class));
        prop.put("validationQuery", env.getProperty(prefix + "validationQuery"));
        prop.put("validationQueryTimeout", env.getProperty(prefix + "validationQueryTimeout", Integer.class));
        prop.put("testOnBorrow", env.getProperty(prefix + "testOnBorrow", Boolean.class));
        prop.put("testOnReturn", env.getProperty(prefix + "testOnReturn", Boolean.class));
        prop.put("testWhileIdle", env.getProperty(prefix + "testWhileIdle", Boolean.class));
        prop.put("timeBetweenEvictionRunsMillis",
                env.getProperty(prefix + "timeBetweenEvictionRunsMillis", Integer.class));
        prop.put("minEvictableIdleTimeMillis", env.getProperty(prefix + "minEvictableIdleTimeMillis", Integer.class));
        prop.put("filters", env.getProperty(prefix + "filters"));

        return prop;
    }










    @Bean
    public ServletRegistrationBean druidServlet() {
        ServletRegistrationBean servletRegistrationBean = new ServletRegistrationBean(new StatViewServlet(), "/druid/*");

        //控制檯管理用戶，加入下面2行 進入druid後臺就須要登陸
        //servletRegistrationBean.addInitParameter("loginUsername", "admin");
        //servletRegistrationBean.addInitParameter("loginPassword", "admin");
        return servletRegistrationBean;
    }

    @Bean
    public FilterRegistrationBean filterRegistrationBean() {
        FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
        filterRegistrationBean.setFilter(new WebStatFilter());
        filterRegistrationBean.addUrlPatterns("/*");
        filterRegistrationBean.addInitParameter("exclusions", "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*");
        filterRegistrationBean.addInitParameter("profileEnable", "true");
        return filterRegistrationBean;
    }

    @Bean
    public StatFilter statFilter(){
        StatFilter statFilter = new StatFilter();
        statFilter.setLogSlowSql(true); //slowSqlMillis用來配置SQL慢的標準，執行時間超過slowSqlMillis的就是慢。
        statFilter.setMergeSql(true); //SQL合併配置
        statFilter.setSlowSqlMillis(1000);//slowSqlMillis的缺省值爲3000，也就是3秒。
        return statFilter;
    }

    @Bean
    public WallFilter wallFilter(){
        WallFilter wallFilter = new WallFilter();
        //容許執行多條SQL
        WallConfig config = new WallConfig();
        config.setMultiStatementAllow(true);
        wallFilter.setConfig(config);
        return wallFilter;
    }




}

4、分別配置每一個數據源對應的sqlSessionFactory，以及MapperScan掃描的包：

MybatisDatasourceConfig.java

package com.zjt.config;

import com.zjt.util.MyMapper;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;

import javax.sql.DataSource;

/**
 * @author <a href="zhaojiatao"></a>
 * @version 1.0, 2017/11/24
 * @description
 */
@Configuration
// 精確到 mapper 目錄，以便跟其餘數據源隔離
@MapperScan(basePackages = "com.zjt.mapper", markerInterface = MyMapper.class, sqlSessionFactoryRef = "sqlSessionFactory")
public class MybatisDatasourceConfig {

    @Autowired
    @Qualifier("systemDataSource")
    private DataSource ds;

    @Bean
    public SqlSessionFactory sqlSessionFactory() throws Exception {
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setDataSource(ds);
        //指定mapper xml目錄
        ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        factoryBean.setMapperLocations(resolver.getResources("classpath:mapper/*.xml"));
        return factoryBean.getObject();

    }

    @Bean
    public SqlSessionTemplate sqlSessionTemplate() throws Exception {
        SqlSessionTemplate template = new SqlSessionTemplate(sqlSessionFactory()); // 使用上面配置的Factory
        return template;
    }

    //關於事務管理器，不論是JPA仍是JDBC等都實現自接口 PlatformTransactionManager
    // 若是你添加的是 spring-boot-starter-jdbc 依賴，框架會默認注入 DataSourceTransactionManager 實例。
    //在Spring容器中，咱們手工註解@Bean 將被優先加載，框架不會從新實例化其餘的 PlatformTransactionManager 實現類。
    /*@Bean(name = "transactionManager")
    @Primary
    public DataSourceTransactionManager masterTransactionManager() {
        //MyBatis自動參與到spring事務管理中，無需額外配置，只要org.mybatis.spring.SqlSessionFactoryBean引用的數據源
        // 與DataSourceTransactionManager引用的數據源一致便可，不然事務管理會不起做用。
        return new DataSourceTransactionManager(ds);

    }*/

}

MybatisDatasource2Config.java

package com.zjt.config;

import com.zjt.util.MyMapper;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;

import javax.sql.DataSource;

/**
 * @author <a href="zhaojiatao"></a>
 * @version 1.0, 2017/11/24
 * @description
 */
@Configuration
// 精確到 mapper 目錄，以便跟其餘數據源隔離
@MapperScan(basePackages = "com.zjt.mapper2", markerInterface = MyMapper.class, sqlSessionFactoryRef = "sqlSessionFactory2")
public class MybatisDatasource2Config {

    @Autowired
    @Qualifier("businessDataSource")
    private DataSource ds;

    @Bean
    public SqlSessionFactory sqlSessionFactory2() throws Exception {
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setDataSource(ds);
        //指定mapper xml目錄
        ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        factoryBean.setMapperLocations(resolver.getResources("classpath:mapper2/*.xml"));
        return factoryBean.getObject();

    }

    @Bean
    public SqlSessionTemplate sqlSessionTemplate2() throws Exception {
        SqlSessionTemplate template = new SqlSessionTemplate(sqlSessionFactory2()); // 使用上面配置的Factory
        return template;
    }

    //關於事務管理器，不論是JPA仍是JDBC等都實現自接口 PlatformTransactionManager
    // 若是你添加的是 spring-boot-starter-jdbc 依賴，框架會默認注入 DataSourceTransactionManager 實例。
    //在Spring容器中，咱們手工註解@Bean 將被優先加載，框架不會從新實例化其餘的 PlatformTransactionManager 實現類。
    /*@Bean(name = "transactionManager2")
    @Primary
    public DataSourceTransactionManager masterTransactionManager() {
        //MyBatis自動參與到spring事務管理中，無需額外配置，只要org.mybatis.spring.SqlSessionFactoryBean引用的數據源
        // 與DataSourceTransactionManager引用的數據源一致便可，不然事務管理會不起做用。
        return new DataSourceTransactionManager(ds);
    }*/

}

4、因爲咱們本例中只使用一個事務管理器：xatx，故就不在使用TxAdviceInterceptor.java和TxAdvice2Interceptor.java中配置的事務管理器了；有需求的童鞋能夠本身配置其餘的事務管理器；

5、新建分佈式業務測試接口JtaTestService.java和實現類JtaTestServiceImpl.java

其實就是一個很簡單的test01()方法，在該方法中咱們分別前後調用classService.saveOrUpdateTClass(tClass);和teacherService.saveOrUpdateTeacher(teacher);

實現前後操做兩個數據源：而後咱們能夠本身debug跟蹤事務的提交時機，此外，也能夠在在兩個方法全執行結束以後，手動製造一個運行時異常，來檢查分佈式事務是否所有回滾；

注意：

在實現類的方法中我使用的是：

@Transactional(transactionManager = "xatx", propagation = Propagation.REQUIRED, rollbackFor = { java.lang.RuntimeException.class })

從而指定了使用哪一個事務管理器，事務隔離級別(通常都用我這個默認的)，回滾的條件(通常可使用Exception)，這三個能夠本身根據業務實際修改；

package com.zjt.service3;

import java.util.Map;

public interface JtaTestService {

    public Map<String,Object> test01();

}

package com.zjt.service3.impl;


import com.zjt.entity.TClass;
import com.zjt.entity.Teacher;
import com.zjt.service.TClassService;
import com.zjt.service2.TeacherService;
import com.zjt.service3.JtaTestService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import java.util.LinkedHashMap;
import java.util.Map;

@Service("jtaTestServiceImpl")
public class JtaTestServiceImpl implements JtaTestService{

    @Autowired
    @Qualifier("teacherServiceImpl")
    private TeacherService teacherService;
    @Autowired
    @Qualifier("tclassServiceImpl")
    private TClassService tclassService;

    @Override
    @Transactional(transactionManager = "xatx", propagation = Propagation.REQUIRED, rollbackFor = { java.lang.RuntimeException.class })  public Map<String, Object> test01() {
        LinkedHashMap<String,Object> resultMap=new LinkedHashMap<String,Object>();
        TClass tClass=new TClass();
        tClass.setName("8888");
        tclassService.saveOrUpdateTClass(tClass);

        Teacher teacher=new Teacher();
        teacher.setName("8888");
        teacherService.saveOrUpdateTeacher(teacher);

        System.out.println(1/0);

        resultMap.put("state","success");
        resultMap.put("message","分佈式事務同步成功");
        return resultMap;
    }
}

6、創建JtaTestContoller.java，接受一個來自前端的http請求，觸發JtaTestService 的test01方法:

package com.zjt.web;


import com.zjt.service3.JtaTestService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.LinkedHashMap;
import java.util.Map;

@Controller
@RequestMapping("/jtaTest")
public class JtaTestContoller {

    @Autowired
    @Qualifier("jtaTestServiceImpl")
    private JtaTestService taTestService;



    @ResponseBody
    @RequestMapping("/test01")
    public Map<String,Object> test01(){
        LinkedHashMap<String,Object> resultMap=new LinkedHashMap<String,Object>();
        try {
            return taTestService.test01();
        }catch (Exception e){
            resultMap.put("state","fail");
            resultMap.put("message","分佈式事務同步失敗");
            return resultMap;
        }
    }






}

7、在test.ftl中增長一個按鈕來測試；

//分佈式事務測試
        $("#JTATest").click(function(){
            $.ajax({
                type: "POST",
                url: "${basePath!}/jtaTest/test01",
                data: {}    ,
                async: false,
                error: function (request) {
                    layer.alert("與服務器鏈接失敗/(ㄒoㄒ)/~~");
                    return false;
                },
                success: function (data) {
                    if (data.state == 'fail') {
                        layer.alert(data.message);
                        return false;
                    }else if(data.state == 'success'){
                        layer.alert(data.message);
                    }
                }
            });
        });




<button class="layui-btn" id="JTATest">同時向班級和老師表插入名爲8888的班級和老師</button>