`
wx1569567608
  • 浏览: 71217 次
最近访客 更多访客>>
lyf7799
文章分类
社区版块
存档分类
最新评论

18.从零开始学springboot-jpa-atomikos多数据源分布式事务案例

 
阅读更多

前言

前章我们已经能够流畅的写出一个基于springboot2.1.3的多数据源的案例了，而且我们选择很多，可以通过jpa搭建，也可以通过jdbc。有了多数据源，必然会碰到多数据源事务处理的问题，也就是分布式事务，所以，这节，我们就通过jpa多数据源+atomikos的方式来实现分布式事务的处理案例。

Atomikos介绍

Atomikos 是一个为Java平台提供增值服务的并且开源类事务管理器。我们通过它来管理事务。springboot本身对其有很好的支持，依赖为spring-boot-starter-jta-atomikos。

创建空项目

1.png

添加依赖

 <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jta-atomikos</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

2.png

添加配置

application.yml：

spring:
  datasource:
    master:
      username: root
      password: 123456
      url: jdbc:mysql://192.168.145.131:3306/test
      driver-class-name: com.mysql.cj.jdbc.Driver
    slave:
      username: root
      password: 123456
      url: jdbc:mysql://192.168.145.131:3306/test2
      driver-class-name: com.mysql.cj.jdbc.Driver
  jta:
    atomikos:
      datasource:
        max-pool-size: 20
        borrow-connection-timeout: 60
      connectionfactory:
        max-pool-size: 20
        borrow-connection-timeout: 60
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true

hibernate.properties(和application.yml同目录):

##坑，springboot2.1.3已经不支持网上的那些控制jpa建innodb表的配置了，必须创建这个文件配置。
hibernate.dialect.storage_engine=innodb

建库

创建test、test2库即可，本次我们通过jpa自动建表，运行代码时会动创建student和teacher表 也可手动创建 test：

CREATE TABLE `student` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `age` int(11) NOT NULL,
  `grade` int(11) NOT NULL,
  `name` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;

test2:

CREATE TABLE `teacher` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `age` int(11) NOT NULL,
  `course` int(11) NOT NULL,
  `name` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;

完善

目录结构 3.png

根据目录结构，请自行创建package和class。

config/AtomikosJtaPlatform

package com.mrcoder.sbjpamultidbatomikos.config;

import org.hibernate.engine.transaction.jta.platform.internal.AbstractJtaPlatform;

import javax.transaction.TransactionManager;
import javax.transaction.UserTransaction;

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

config/DataSourceConfig

package com.mrcoder.sbjpamultidbatomikos.config;

import com.atomikos.icatch.jta.UserTransactionImp;
import com.atomikos.icatch.jta.UserTransactionManager;
import org.hibernate.dialect.MySQL5Dialect;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.DependsOn;
import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;
import org.springframework.orm.jpa.JpaVendorAdapter;
import org.springframework.orm.jpa.vendor.Database;
import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import org.springframework.transaction.jta.JtaTransactionManager;
import javax.transaction.TransactionManager;
import javax.transaction.UserTransaction;

@Configuration
@ComponentScan
@EnableTransactionManagement
public class DataSourceConfig {

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

}

config/MasterConfig

package com.mrcoder.sbjpamultidbatomikos.config;

import com.mysql.cj.jdbc.MysqlXADataSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jta.atomikos.AtomikosDataSourceBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.DependsOn;
import org.springframework.context.annotation.Primary;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.orm.jpa.JpaVendorAdapter;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;

import javax.sql.DataSource;
import java.sql.SQLException;
import java.util.HashMap;

@Configuration
@DependsOn("transactionManager")
@EnableJpaRepositories(basePackages = "com.mrcoder.sbjpamultidbatomikos.entity.master", entityManagerFactoryRef = "masterEntityManager", transactionManagerRef = "transactionManager")
public class MasterConfig {
    @Autowired
    private JpaVendorAdapter jpaVendorAdapter;

    //master库
    @Primary
    @Bean(name = "masterDataSourceProperties")
    @Qualifier("masterDataSourceProperties")
    @ConfigurationProperties(prefix = "spring.datasource.master")
    public DataSourceProperties masterDataSourceProperties() {
        return new DataSourceProperties();
    }


    @Primary
    @Bean(name = "masterDataSource", initMethod = "init", destroyMethod = "close")
    @ConfigurationProperties(prefix = "spring.datasource.master")
    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("xads1");
        xaDataSource.setBorrowConnectionTimeout(60);
        xaDataSource.setMaxPoolSize(20);
        return xaDataSource;

    }

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

        HashMap<String, Object> properties = new HashMap<String, Object>();
        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("com.mrcoder.sbjpamultidbatomikos.entity.master");
        entityManager.setPersistenceUnitName("masterPersistenceUnit");
        entityManager.setJpaPropertyMap(properties);
        return entityManager;
    }
}

config/SlaveConfig

package com.mrcoder.sbjpamultidbatomikos.config;

import com.mysql.cj.jdbc.MysqlXADataSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jta.atomikos.AtomikosDataSourceBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.DependsOn;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.orm.jpa.JpaVendorAdapter;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;

import javax.sql.DataSource;
import java.sql.SQLException;
import java.util.HashMap;

@Configuration
@DependsOn("transactionManager")
@EnableJpaRepositories(basePackages = "com.mrcoder.sbjpamultidbatomikos.entity.slave", entityManagerFactoryRef = "slaveEntityManager", transactionManagerRef = "transactionManager")
public class SlaveConfig {
    @Autowired
    private JpaVendorAdapter jpaVendorAdapter;

    @Bean(name = "slaveDataSourceProperties")
    @Qualifier("slaveDataSourceProperties")
    @ConfigurationProperties(prefix = "spring.datasource.slave")
    public DataSourceProperties slaveDataSourceProperties() {
        return new DataSourceProperties();
    }


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

    @Bean(name = "slaveEntityManager")
    @DependsOn("transactionManager")
    public LocalContainerEntityManagerFactoryBean slaveEntityManager() throws Throwable {
        HashMap<String, Object> properties = new HashMap<String, Object>();
        properties.put("hibernate.transaction.jta.platform", AtomikosJtaPlatform.class.getName());
        properties.put("javax.persistence.transactionType", "JTA");
        LocalContainerEntityManagerFactoryBean entityManager = new LocalContainerEntityManagerFactoryBean();
        entityManager.setJtaDataSource(slaveDataSource());
        entityManager.setJpaVendorAdapter(jpaVendorAdapter);
        entityManager.setPackagesToScan("com.mrcoder.sbjpamultidbatomikos.entity.slave");
        entityManager.setPersistenceUnitName("slavePersistenceUnit");
        entityManager.setJpaPropertyMap(properties);
        return entityManager;
    }
}

entity/master/Student

package com.mrcoder.sbjpamultidbatomikos.entity.master;

import javax.persistence.*;

@Entity(name = "student")
public class Student {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id", unique = true, nullable = false)
    private int id;

    private String name;

    private int age;

    private int grade;

    public Student() {
    }

    public Student(String name, int age, int grade) {
        this.name = name;
        this.age = age;
        this.grade = grade;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", grade=" + grade +
                '}';
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getGrade() {
        return grade;
    }

    public void setGrade(int grade) {
        this.grade = grade;
    }
}

entity/master/StudentDao

package com.mrcoder.sbjpamultidbatomikos.entity.master;
import org.springframework.data.jpa.repository.JpaRepository;

public interface StudentDao extends JpaRepository<Student, Integer> {


}

entity/slave/Teacher

package com.mrcoder.sbjpamultidbatomikos.entity.slave;

import javax.persistence.*;

@Entity(name = "teacher")
public class Teacher {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id", unique = true, nullable = false)
    private int id;
    private String name;
    private int age;
    private int course;

    public Teacher() {
    }

    public Teacher(String name, int age, int course) {
        this.name = name;
        this.age = age;
        this.course = course;
    }

    @Override
    public String toString() {
        return "Teacher{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age='" + age + '\'' +
                ", course='" + course + '\'' +
                '}';
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getCourse() {
        return course;
    }

    public void setCourse(int course) {
        this.course = course;
    }
}

entity/slave/TeacherDao

package com.mrcoder.sbjpamultidbatomikos.entity.slave;
import org.springframework.data.jpa.repository.JpaRepository;

public interface TeacherDao extends JpaRepository<Teacher,Integer> {

}

service/CurdService

package com.mrcoder.sbjpamultidbatomikos.service;

import com.mrcoder.sbjpamultidbatomikos.entity.master.Student;
import com.mrcoder.sbjpamultidbatomikos.entity.master.StudentDao;
import com.mrcoder.sbjpamultidbatomikos.entity.slave.Teacher;
import com.mrcoder.sbjpamultidbatomikos.entity.slave.TeacherDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class CurdService {

    @Autowired
    private StudentDao studentDao;

    @Autowired
    private TeacherDao teacherDao;

    @Transactional
    public void add(int code) {
        Student s1 = new Student();
        s1.setAge(10);
        s1.setGrade(10);
        s1.setName("s1");
        studentDao.save(s1);

        Teacher t1 = new Teacher();
        t1.setAge(10);
        t1.setName("t1");
        t1.setCourse(10);
        teacherDao.save(t1);

        int result = 1/code;
    }
}

controller/JpaAtomikosController

package com.mrcoder.sbjpamultidbatomikos.controller;


import com.mrcoder.sbjpamultidbatomikos.entity.master.StudentDao;
import com.mrcoder.sbjpamultidbatomikos.service.CurdService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class JpaAtomikosController {

    @Autowired
    private CurdService curdService;

    @Autowired
    private StudentDao studentDao;

    @RequestMapping("/add")
    public void add() {
        curdService.add(1);
    }

    @RequestMapping("/test")
    public void test() {
        curdService.add(0);
    }

    @RequestMapping("/list")
    public void list() {
        System.out.println(studentDao.findAll());

    }
}

运行

http://localhost:8080/add 会在test库的student和test2库的teacher表中各新增一条记录

http://localhost:8080/test 人为的制造1/0的异常，异常触发事务，会发现两张表都不会新增记录。

项目地址

https://github.com/MrCoderStack/SpringBootDemo/tree/master/sb-jpa-multidb-atomikos

https://gitee.com/MrCoderStack/SpringBootDemo/tree/master/sb-jpa-multidb-atomikos

注意点

请一定注意，两张表为innodb引擎，若出现分布式事务无法触发，请优先查看表引擎。

请关注我的订阅号

订阅号.png

转载于:https://my.oschina.net/u/3066875/blog/3055190

分享到：
| 4.从零开始学SpringBoot-JPA_JDBC_Hibernat ...
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    SpringBoot+Atomikos分布式事务及多数据源动态切换，两种demo

    最后，压缩包中的"SpringBoot+Atomikos分布式事务及动态数据源"文件可能包含了具体的代码示例和配置文件，这些资源可以帮助开发者更好地理解和实践上述概念。通过分析和学习这些示例，可以快速上手Spring Boot与...

    springboot-jpa atomikos 分布式事务管理

    本文将详细讲解"springboot-jpa atomikos 分布式事务管理"这一主题，以及如何在SpringBoot 2.0.5版本中结合JPA、Hibernate和MyBatis实现多数据库事务控制。 首先，SpringBoot是一个简化Spring应用开发的框架，它...

    springboot多数据源即分布式事务解决方案

    SpringBoot作为一款轻量级的框架，提供了便捷的多数据源配置和分布式事务管理方案，使得开发者能够高效地管理和操作不同的数据库。本文将详细探讨SpringBoot如何实现多数据源以及分布式事务。 首先，我们要理解什么...

    springboot-jpa-activiti-bootstrap-master

    总结来说，"springboot-jpa-activiti-bootstrap-master"项目是一个集成了SpringBoot、JPA和Activiti的实战案例，它涵盖了后端开发的多个重要环节，对于想要提升企业级应用开发能力的开发者来说，这是一个非常有价值...

    Springboot+Atomikos+Jpa+Mysql实现JTA分布式事务

    本文将详细讲解如何利用Spring Boot、Atomikos、JPA（Java Persistence API）以及MySQL来实现JTA（Java Transaction API）分布式事务。 首先，Spring Boot是一个轻量级的框架，它简化了基于Spring的应用程序开发...

    hibernate-jpa-2.0-api-1.0.1.Final-sources.jar

    hibernate-jpa-2.0-api-1.0.1.Final-sources.jar hibernate jpa 源代码

    springboot-多数据源配置 -mybatis-jpa

    在Spring Boot应用中，多数据源配置是一项关键的技术，它允许我们连接并操作多个数据库，这对于大型企业级应用尤其有用，比如分离读写操作、实现数据冗余或满足不同业务需求。Spring Boot提供了灵活的方式来配置这些...

    计算机毕业设计-旅游网站springboot-jpa-thmleaf

    内容概要：该项目为旅游网站，主要编程语言为java，主要框架为springboot-jpa-thmleaf。 适用人群：已工作或未工作的软件开发人员。 使用场景及目标：适合研究学习使用，以及项目初期快速搭建脚手架。 其他说明：暂...

    springboot-jpa.zip_java_springboot

    在SpringBoot项目中，通过在`pom.xml`或`build.gradle`文件中添加JPA和数据源相关的依赖，可以轻松集成JPA。SpringBoot会自动检测数据源，并根据配置自动配置JPA。开发者可以通过注解如`@Entity`定义实体类，`@Table...

    使用springboot + JPA / MyBatis 实现多数据源动态切换

    在现代企业级应用开发中，数据源的动态切换是一个重要的需求，特别是在分布式系统中，可能需要连接多个数据库来实现读写分离、数据分区等策略。本教程将详细讲解如何使用Spring Boot结合JPA或MyBatis框架实现多数据...

    SpringBoot+Atomikos+动态多数据源+事务+2种切换数据源的方式

    3. **事务管理**：SpringBoot默认使用LocalContainerEntityManagerFactoryBean处理JPA事务，但在多数据源环境中，需要改为使用Atomikos的`JtaPlatformTransactionManager`。此外，确保开启@...

    使用SpringBoot-JPA进行自定义保存及批量保存功能

    在Spring Boot应用程序中，使用JPA可以简化数据访问层的开发，并提供了许多有用的功能，例如自动生成SQL语句、对象关系映射、事务管理等。在本文中，我们将介绍如何使用SpringBoot-JPA进行自定义保存及批量保存功能...

    分布式事务管理SpringBoot集成Atomikos使用Oracle数据库mybatis、jta框架.rar

    SpringBoot集成Atomikos使用Oracle数据库mybatisSpringBoot集成Atomikos使用Oracle数据库mybatisSpringBoot集成Atomikos使用Oracle数据库mybatisSpringBoot集成Atomikos使用Oracle数据库mybatis

    hibernate-jpa-2.0-api-1.0.1.Final.jar

    hibernate-jpa-2.0-api-1.0.1.Final.jar

    加深难度-对标大厂SpringBoot高级应用特训 SpringBoot开发实践与高级应用

    课程内容在以往SpringBoot案例课程之上，再次加深了难度和深度，直接对标一线大厂的高级应用实践。课程围绕着SpringBoot开发实践和SpringBoot高级应用两个主题展开，是真正意义上的大厂级开发技术，同时技术拥有很强...

    springboot-jpa-001

    本项目“springboot-jpa-001”旨在提供一个基础的Spring Boot集成JPA（Java Persistence API）的示例，后续还将进一步集成JSP（JavaServer Pages）作为前端展示层。 首先，Spring Boot简化了JPA的配置和使用。JPA是...

    springboot-jpa加上jdbctemple

    标题“springboot-jpa加上jdbctemple”指的是在Spring Boot项目中同时使用JPA（Java Persistence API）和JdbcTemplate的技术整合。这是一个常见的后端开发场景，涉及到Spring Boot的数据库访问层的构建，旨在提供...

    SpringBoot+JPA+JTA(可选)+JdbcTemplate多数据源配置源码

    本资源包含了两个子项目，分别进行了springboot+jpa+jdbcTemplate的多数据源独立事务配置和jta分布式事务配置，并针对不同的情况编写了事务配置测试接口，还演示了JPA的domain一对多自动生成数据库表且不生成数据库...

    个人博客系统（SpringBoot+jpa）.zip

    个人博客系统（SpringBoot+jpa）.zip个人博客系统（SpringBoot+jpa）.zip个人博客系统（SpringBoot+jpa）.zip个人博客系统（SpringBoot+jpa）.zip个人博客系统（SpringBoot+jpa）.zip个人博客系统（SpringBoot+jpa）...

    Spring Boot使用spring-data-jpa配置Mysql多数据源

    在Spring Boot应用中，使用`spring-data-jpa`来配置MySQL多数据源是一项常见的需求，尤其是在构建大型分布式系统时，为了实现数据隔离、负载均衡或读写分离等目的。本教程将详细介绍如何在Spring Boot项目中配置多个...

Magicbox
Global site tag (gtag.js) - Google Analytics