Spring Data JPA的多数据源及分布式事务实现

作者: liushiping | 来源:发表于2023-06-26 09:29 被阅读0次

Spring Data JPA 实现原理
我是这样使用SpringBoot(使用 Spring data
Spring Data JPA 的使用
SpringBoot系列：6、整合JPA
Spring Boot的子项目Spring data JPA配置
从零开始学springboot-jdbc-atomikos多数据
Jpa多数据源，为每个数据源配置单独的命名策略
2018-06-07 springboot
Spring Data JPA 与 MyBatis简单对比
SpringBoot使用AOP记录请求日志和异常日志

一.Spring data JPA的多数据源实现

将数据源对象作为参数，传递到调用方法内部，这种方式增加额外的编码。
将Repository操作接口分包存放，Spring扫描不同的包，自动注入不同的数据源。这种方式实现简单，也是一种“约定大于配置”思想的典型应用。
使用Spring AOP面向切面编程，然后在持久层接口方法上面加注解，不同的注解使用表示使用不同的数据源。

本文将以第二种方式实现JPA的多数据源支持。

1.1 修改application.yml配置多数据源

配置2个数据源，primary数据源：testdb数据库，secondary数据源：testdb2数据库。

spring:
  datasource:
    primary:
      jdbc-url: jdbc:mysql://localhost:3306/testdb?useUnicode=true&characterEncoding=utf-8&useSSL=false
      username: root
      password: root
      driver-class-name: com.mysql.cj.jdbc.Driver
    secondary:
      jdbc-url: jdbc:mysql://localhost:3306/testdb2?useUnicode=true&characterEncoding=utf-8&useSSL=false
      username: root
      password: root
      driver-class-name: com.mysql.cj.jdbc.Driver
  jpa:
    database-platform: org.hibernate.dialect.MySQL5InnoDBDialect
    hibernate:
      ddl-auto: update
    database: mysql
    show-sql: true

testdb数据库中存在article表，testdb2中存在comment表

1.2 testdb数据库的数据持久层配置

创建cn.lsp.springboot.model.testdb包，将Article实体放入此包中；
创建cn.lsp.springboot.repository.testdb包，将ArticleRepository放入此包中；
testdb数据库的JPA数据持久层配置,需要配置：

DataSource数据源
EntityManager 实体管理器
EntityManagerFactoryBean 实体管理器工厂
PlatformTransactionManager 事务管理器

import org.springframework.boot.autoconfigure.orm.jpa.HibernateProperties;
import org.springframework.boot.autoconfigure.orm.jpa.HibernateSettings;
import org.springframework.boot.autoconfigure.orm.jpa.JpaProperties;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.annotation.Resource;
import javax.persistence.EntityManager;
import javax.sql.DataSource;
import java.util.Map;

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
        entityManagerFactoryRef="entityManagerFactoryPrimary",
        transactionManagerRef="transactionManagerPrimary",
        basePackages= {"cn.lsp.springboot.repository.testdb"})
public class JPAPrimaryConfig2 {

    @Resource
    private JpaProperties jpaProperties;

    @Resource
    private HibernateProperties hibernateProperties;

    @Primary
    @Bean(name = "primaryDataSource")
    @ConfigurationProperties(prefix="spring.datasource.primary")  //使用application.yml的primary数据源配置
    public DataSource primaryDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Primary
    @Bean(name = "entityManagerPrimary")        //primary实体管理器
    public EntityManager entityManager(EntityManagerFactoryBuilder builder) {
         return entityManagerFactoryPrimary(builder).getObject().createEntityManager();
    }

    @Primary
    @Bean(name = "entityManagerFactoryPrimary")    //primary实体工厂
    public LocalContainerEntityManagerFactoryBean entityManagerFactoryPrimary (EntityManagerFactoryBuilder builder) {

        Map<String,Object> properties =
                hibernateProperties.determineHibernateProperties(
                        jpaProperties.getProperties(),
                        new HibernateSettings());
        return builder.dataSource(primaryDataSource())
                .properties(properties)
                .packages("cn.lsp.springboot.model.testdb")
                .persistenceUnit("primaryPersistenceUnit")
                .build();
    }

    @Primary
    @Bean(name = "transactionManagerPrimary")         //primary事务管理器
    public PlatformTransactionManager transactionManagerPrimary(EntityManagerFactoryBuilder builder) {
        return new JpaTransactionManager(entityManagerFactoryPrimary(builder).getObject());
    }
}

1.3 testdb2数据库的数据持久层配置

创建cn.lsp.springboot.model.testdb2包，将Comment实体放入此包中；
创建cn.lsp.springboot.repository.testdb2包，将CommentRepository放入此包中；
testdb2数据库的JPA数据持久层配置，因为这一组配置不是默认配置，该组数据源不是默认数据源，没有@Primary注解。

import org.springframework.boot.autoconfigure.orm.jpa.HibernateProperties;
import org.springframework.boot.autoconfigure.orm.jpa.HibernateSettings;
import org.springframework.boot.autoconfigure.orm.jpa.JpaProperties;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import java.util.Map;

import javax.annotation.Resource;
import javax.persistence.EntityManager;
import javax.sql.DataSource;

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
        entityManagerFactoryRef="entityManagerFactorySecondary",
        transactionManagerRef="transactionManagerSecondary",
        basePackages= { "cn.lsp.springboot.repository.testdb2" })
public class JPASecondaryConfig {

    @Resource
    private JpaProperties jpaProperties;

    @Resource
    private HibernateProperties hibernateProperties;

    @Bean(name = "secondaryDataSource")
    @ConfigurationProperties(prefix="spring.datasource.secondary")   //使用application.yml的secondary数据源配置
    public DataSource secondaryDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Bean(name = "entityManagerSecondary")      //secondary实体管理器
    public EntityManager entityManager(EntityManagerFactoryBuilder builder) {
        return entityManagerFactorySecondary(builder).getObject().createEntityManager();
    }


    @Bean(name = "entityManagerFactorySecondary")
    public LocalContainerEntityManagerFactoryBean entityManagerFactorySecondary (EntityManagerFactoryBuilder builder) {

        Map<String,Object> properties =
                hibernateProperties.determineHibernateProperties(
                        jpaProperties.getProperties(),
                        new HibernateSettings());
        return builder
                .dataSource(secondaryDataSource())
                .properties(properties)
                .packages("cn.lsp.springboot.model.testdb2")
                .persistenceUnit("secondaryPersistenceUnit")
                .build();
    }

    @Bean(name = "transactionManagerSecondary")
    PlatformTransactionManager transactionManagerSecondary(EntityManagerFactoryBuilder builder) {
        return new JpaTransactionManager(entityManagerFactorySecondary(builder).getObject());
    }
}

1.4 多数据源测试

@Slf4j
@SpringBootTest
public class JpaJtaTest {

    @Resource
    private ArticleRepository articleRepository;

    @Resource
    private CommentRepository commentRepository;

    @Test
    public void testJpaJta(){
        Article article = new Article();
        article.setTitle("SpringBoot实战");
        article.setContent("详细介绍SpringBoot的各种姿势");
        article.setAuthor("William");
        article.setCreateTime(new Date());
        Article savedArticle = articleRepository.save(article);

        Comment comment = new Comment();
        comment.setName("Tom");
        comment.setContent("内容详实，偏实战");
        comment.setCreateTime(new Date());
        comment.setArticleId(savedArticle.getId());
        commentRepository.save(comment);
    }
}

二.JPA+atomikos实现分布式事务

2.1整合JTA(atomikos)

通过maven坐标引入JTA atomikos。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jta-atomikos</artifactId>
</dependency>

在第一节的配置基础上，把jdbc-url改成url，然后在spring前缀下面加:

spring:
  jta:
    atomikos:
      datasource:
        max-pool-size: 20
        borrow-connection-timeout: 60
      connectionfactory:
        max-pool-size: 20
        borrow-connection-timeout: 60

max-pool-size表示数据连接池最大连接数，请根据自己的应用规模进行调整
borrow-connection-timeout表示连接从连接池“借出”之后的超时时间，超时将抛出异常

2.2分布式事务管理器

删掉第一节的数据源配置及事务配置代码，加入如下代码，AtomikosJtaPlatform为固定代码不需修改；

public class AtomikosJtaPlatform extends AbstractJtaPlatform {

    private static final long serialVersionUID = 1L;

    static TransactionManager transactionManager;
    static UserTransaction transaction;

    @Override
    protected TransactionManager locateTransactionManager() {
        return transactionManager;
    }

    @Override
    protected UserTransaction locateUserTransaction() {
        return transaction;
    }
}

事务管理器的配置JPAAtomikosTransactionConfig ，以下除了设置JPA特性的部分，为固定代码不需修改;

@Configuration
@ComponentScan
@EnableTransactionManagement
public class JPAAtomikosTransactionConfig {

    @Bean
    public PropertySourcesPlaceholderConfigurer propertySourcesPlaceholderConfigurer() {
        return new PropertySourcesPlaceholderConfigurer();
    }

    //设置JPA特性
    @Bean
    public JpaVendorAdapter jpaVendorAdapter() {
        HibernateJpaVendorAdapter hibernateJpaVendorAdapter = new HibernateJpaVendorAdapter();
        //显示sql
        hibernateJpaVendorAdapter.setShowSql(true);
        //自动生成/更新表
        hibernateJpaVendorAdapter.setGenerateDdl(true);
        //设置数据库类型
        hibernateJpaVendorAdapter.setDatabase(Database.MYSQL);
        return hibernateJpaVendorAdapter;
    }

    @Bean(name = "userTransaction")
    public UserTransaction userTransaction() throws Throwable {
        UserTransactionImp userTransactionImp = new UserTransactionImp();
        userTransactionImp.setTransactionTimeout(10000);
        return userTransactionImp;
    }

    @Bean(name = "atomikosTransactionManager", initMethod = "init", destroyMethod = "close")
    public TransactionManager atomikosTransactionManager() throws Throwable {
        UserTransactionManager userTransactionManager = new UserTransactionManager();
        userTransactionManager.setForceShutdown(false);
        AtomikosJtaPlatform.transactionManager = userTransactionManager;
        return userTransactionManager;
    }

    @Bean(name = "transactionManager")
    @DependsOn({"userTransaction", "atomikosTransactionManager"})
    public PlatformTransactionManager transactionManager() throws Throwable {
        UserTransaction userTransaction = userTransaction();
        AtomikosJtaPlatform.transaction = userTransaction;
        TransactionManager atomikosTransactionManager = atomikosTransactionManager();
        return new JtaTransactionManager(userTransaction, atomikosTransactionManager);
    }

}

2.3数据源及实体管理配置(多数据源多份)

设置第一个数据库的primary数据源及实体扫描管理(扫描testdb目录)，实体管理器、数据源都要加上primary，以示区分:

@Configuration
@DependsOn("transactionManager")
@EnableJpaRepositories(basePackages = "cn.lsp.springboot.repository.testdb",  //注意这里
        entityManagerFactoryRef = "primaryEntityManager",
        transactionManagerRef = "transactionManager")
public class JPAPrimaryConfig {
    @Autowired
    private JpaVendorAdapter jpaVendorAdapter;

    //primary
    @Primary
    @Bean(name = "primaryDataSourceProperties")
    @ConfigurationProperties(prefix = "spring.datasource.primary")     //注意这里
    public DataSourceProperties primaryDataSourceProperties() {
        return new DataSourceProperties();
    }

    @Primary
    @Bean(name = "primaryDataSource", initMethod = "init", destroyMethod = "close")
    @ConfigurationProperties(prefix = "spring.datasource.primary")
    public DataSource primaryDataSource() throws SQLException {
        MysqlXADataSource mysqlXaDataSource = new MysqlXADataSource();
        mysqlXaDataSource.setUrl(primaryDataSourceProperties().getUrl());
        mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true);
        mysqlXaDataSource.setPassword(primaryDataSourceProperties().getPassword());
        mysqlXaDataSource.setUser(primaryDataSourceProperties().getUsername());
        AtomikosDataSourceBean xaDataSource = new AtomikosDataSourceBean();
        xaDataSource.setXaDataSource(mysqlXaDataSource);
        xaDataSource.setUniqueResourceName("primary");
        xaDataSource.setBorrowConnectionTimeout(60);
        xaDataSource.setMaxPoolSize(20);
        return xaDataSource;
    }

    @Primary
    @Bean(name = "primaryEntityManager")
    @DependsOn("transactionManager")
    public LocalContainerEntityManagerFactoryBean primaryEntityManager() throws Throwable {

        Map<String, Object> properties = new HashMap<>();
        properties.put("hibernate.transaction.jta.platform", AtomikosJtaPlatform.class.getName());
        properties.put("javax.persistence.transactionType", "JTA");
        LocalContainerEntityManagerFactoryBean entityManager = new LocalContainerEntityManagerFactoryBean();
        entityManager.setJtaDataSource(primaryDataSource());
        entityManager.setJpaVendorAdapter(jpaVendorAdapter);
        //这里要修改成主数据源的扫描包
        entityManager.setPackagesToScan("cn.lsp.springboot.model.testdb");
        entityManager.setPersistenceUnitName("primaryPersistenceUnit");
        entityManager.setJpaPropertyMap(properties);
        return entityManager;
    }
}

设置第二个数据库的数据源及实体扫描管理(扫描testdb2目录):

@Configuration
@DependsOn("transactionManager")
@EnableJpaRepositories(basePackages = "cn.lsp.springboot.repository.testdb2",   //注意这里
        entityManagerFactoryRef = "secondaryEntityManager",
        transactionManagerRef = "transactionManager")
public class JPASecondaryConfig2 {
    @Autowired
    private JpaVendorAdapter jpaVendorAdapter;


    @Bean(name = "secondaryDataSourceProperties")
    @ConfigurationProperties(prefix = "spring.datasource.secondary")    //注意这里
    public DataSourceProperties masterDataSourceProperties() {
        return new DataSourceProperties();
    }


    @Bean(name = "secondaryDataSource", initMethod = "init", destroyMethod = "close")
    @ConfigurationProperties(prefix = "spring.datasource.secondary")
    public DataSource masterDataSource() throws SQLException {
        MysqlXADataSource mysqlXaDataSource = new MysqlXADataSource();
        mysqlXaDataSource.setUrl(masterDataSourceProperties().getUrl());
        mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true);
        mysqlXaDataSource.setPassword(masterDataSourceProperties().getPassword());
        mysqlXaDataSource.setUser(masterDataSourceProperties().getUsername());
        AtomikosDataSourceBean xaDataSource = new AtomikosDataSourceBean();
        xaDataSource.setXaDataSource(mysqlXaDataSource);
        xaDataSource.setUniqueResourceName("secondary");
        xaDataSource.setBorrowConnectionTimeout(60);
        xaDataSource.setMaxPoolSize(20);
        return xaDataSource;
    }

    @Bean(name = "secondaryEntityManager")
    @DependsOn("transactionManager")
    public LocalContainerEntityManagerFactoryBean masterEntityManager() throws Throwable {

        Map<String, Object> properties = new HashMap<>();
        properties.put("hibernate.transaction.jta.platform", AtomikosJtaPlatform.class.getName());
        properties.put("javax.persistence.transactionType", "JTA");
        LocalContainerEntityManagerFactoryBean entityManager = new LocalContainerEntityManagerFactoryBean();
        entityManager.setJtaDataSource(masterDataSource());
        entityManager.setJpaVendorAdapter(jpaVendorAdapter);
        //这里要修改成主数据源的扫描包
        entityManager.setPackagesToScan("cn.lsp.springboot.model.testdb2");
        entityManager.setPersistenceUnitName("secondaryPersistenceUnit");
        entityManager.setJpaPropertyMap(properties);
        return entityManager;
    }
}

DataSourceProperties数据源配置、Datasource数据源、EntityManager实体管理器都是2套。分别是primary和secondary
实体和Repository的扫描目录也是2组，分别是testdb和testdb2
但是事务管理器只有一个，那就是transactionManager，是基于atomikos实现的。事务管理器只有一个，决定了不同的数据源使用同一个事务管理器，从而实现分布式事务。

2.4 JPA分布式事务测试

service代码：

@Slf4j
@Service
public class ArticleServiceImpl implements ArticleService {

    @Resource
    private ArticleRepository articleRepository;

    @Resource
    private CommentRepository commentRepository;

    @Override
    @Transactional
    public Article saveArticleAndComment(Article article, Comment comment) {
        Article savedArticle = articleRepository.save(article);
        comment.setArticleId(savedArticle.getId());
        commentRepository.save(comment);
//        int a= 2/0;
        return  article;
    }
}

test代码：

@Slf4j
@SpringBootTest
public class JpaJtaTest {

    @Resource
    private ArticleService articleService;

    @Test
    public void saveArticle() {
        Article article = new Article();
        article.setTitle("SpringBoot实战");
        article.setContent("详细介绍SpringBoot的各种姿势");
        article.setAuthor("William");
        article.setCreateTime(new Date());

        Comment comment = new Comment();
        comment.setName("Tom");
        comment.setContent("内容详实，偏实战");
        comment.setCreateTime(new Date());

        articleService.saveArticleAndComment(article, comment);
    }
}

service里面分别向testdb插入article，testdb2插入comment，数据插入都成功。人为制造一个被除数为0的异常，数据插入都失败。

Spring Data JPA 实现原理
Spring Data JPA 实现原理在使用Spring Data JPA的时候，只需使用简单的接口定义，通过...
我是这样使用SpringBoot(使用 Spring data
目录 Spring data jpa是Spring使用jpa的组件。采用Hibernate实现jpa能力。但是比自...
Spring Data JPA 的使用
上一篇Spring JavaConfig中配置数据源使用了JPA,这里就介绍一下Spring data jpa的常...
SpringBoot系列：6、整合JPA
1、Spring Data JPA介绍 1.1 Spring Data JPA介绍 Spring Data JPA...
Spring Boot的子项目Spring data JPA配置
Spring Boot 的spring data JPA配置多数据源项目过程分析：工程结构： POM.xml <...
从零开始学springboot-jdbc-atomikos多数据
前言上章我们通过jpa和atomikos实现了分布式事务的处理案例。这节，我们来实现jdbc多数据源+atomi...
Jpa多数据源，为每个数据源配置单独的命名策略
起因： spring data jpa多数据源配置可以参考Jpa多数据源配置，我就是参考这篇文章配置好的。我的数...
2018-06-07 springboot
前言Spring Data JPA为Java持久性API（JPA）提供存储库支持。它简化了需要访问JPA数据源的应...
Spring Data JPA 与 MyBatis简单对比
Spring Data JPA 与 MyBatis对比 Spring Data JPA是Spring Data的子...
SpringBoot使用AOP记录请求日志和异常日志
本文基础WEB环境使用SpringBoot及Spring-Data-Jpa构建关于SpringBoot及JPA用...