SpringBoot+JPA框架 配置多数据源

最新推荐文章于 2024-02-20 07:57:11 发布
最新推荐文章于 2024-02-20 07:57:11 发布
阅读量1.9k 收藏 4
点赞数 2
分类专栏： java进阶 SpringBoot技术篇 文章标签： spring boot java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43078114/article/details/126667487
版权

背景

SpringBoot配置多数据源，是很常见的一个场景，为了便于测试，引入JPA框架查询数据库

pom.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.0.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>dadasource</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>dadasource</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>17</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>


        <!-- swagger2 start -->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.7.0</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.7.0</version>
        </dependency>
        <!-- jpa start -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
            <!--            <version>2.0.2.RELEASE</version>-->
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <!-- druid start -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.13</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.44</version>
        </dependency>
        <!-- druid end -->

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>

            </plugin>

            <!-- 指定maven.compiler.plugin 配置版本，解决编译问题 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.6.0</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>

        </plugins>
    </build>

</project>

2.配置文件

2.1 application.yml
server:
  servlet:
    context-path: /api
  port: 8380

spring:
  profiles:
    active: dev
2.2 application-dev.ym 【数据库连接信息已脱敏】
	spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    druid:
      driver-class-name: com.mysql.jdbc.Driver
      connectionInitSqls: set names utf8mb4
#      url: jdbc:mysql://10.0.173.220:3307/dtbk_rzt?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
      db1:
        url: jdbc:mysql://xxxx/dtbk_rzt?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
        username: xxxx
        password: xxxx
      db2:
        url: jdbc:mysql://xxxx:3307/dtbk_rzt_admin?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
        username: xxxx
        password: xxxx
      initial-size: 10
      max-active: 100
      min-idle: 10
      max-wait: 60000
      pool-prepared-statements: true
      max-pool-prepared-statement-per-connection-size: 20
      time-between-eviction-runs-millis: 60000
      min-evictable-idle-time-millis: 300000
      #Oracle需要打开注释
      validation-query: SELECT 1 FROM DUAL
      test-while-idle: true
      test-on-borrow: false
      test-on-return: false
      stat-view-servlet:
        enabled: true
        url-pattern: /druid/*
        #login-username: admin
        #login-password: admin
      filter:
        stat:
          enabled: true
          log-slow-sql: true
          slow-sql-millis: 1000
          merge-sql: false
        wall:
          config:
            multi-statement-allow: true
  jpa:
    show-sql: true
    hibernate:
      ddl-auto: update
    database: mysql

3.多数据源配置类

3.1数据源配置类1
package com.example.dadasource.config;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
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.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.persistence.EntityManagerFactory;
import javax.sql.DataSource;
import java.util.Map;


/**
 * @Author zhuyanming5@crdigital.com.cn
 * @Description
 * @Date 15:08 2022/8/31
 * @param null
 * @Return 
**/
@Configuration
@EnableJpaRepositories(entityManagerFactoryRef = "db1EntityManagerFactory", // 实体类工厂依赖
        transactionManagerRef = "db1TransactionManager", // 事务依赖
        basePackages = "com.example.dadasource.repository.db1") // repository类所在的包
@EnableTransactionManagement
@Slf4j
public class DB1Config {

    @Autowired
    private JpaProperties jpaProperties;

    @Autowired
    @Qualifier("analysisDataSource")
    private DataSource dataSource;

    @Autowired
    private HibernateProperties hibernateProperties;

    /*
     * 通过LocalContainerEntityManagerFactoryBean来获取EntityManagerFactory实例
     */
    @Bean(name = "db1EntityManagerFactoryBean")
    public LocalContainerEntityManagerFactoryBean entityManagerFactoryBean(
            EntityManagerFactoryBuilder builder) {
        Map<String, Object> properties = hibernateProperties.determineHibernateProperties(
                jpaProperties.getProperties(), new HibernateSettings());
        return builder.dataSource(dataSource).properties(properties)
                .packages("com.example.dadasource.entity").build();
    }

    /*
     * EntityManagerFactory类似于Hibernate的SessionFactory,mybatis的SqlSessionFactory
     * 总之,在执行操作之前,我们总要获取一个EntityManager,这就类似于Hibernate的Session,
     * mybatis的sqlSession.
     */
    @Bean(name = "db1EntityManagerFactory")
    @Primary
    public EntityManagerFactory entityManagerFactory(EntityManagerFactoryBuilder builder) {
        log.info("创建db1EntityManagerFactory");
        return this.entityManagerFactoryBean(builder).getObject();
    }

    /*
     * 配置事务管理器
     */
    @Bean(name = "db1TransactionManager")
    @Primary
    public PlatformTransactionManager transactionManager(EntityManagerFactoryBuilder builder) {
        log.info("创建db1TransactionManager");
        return new JpaTransactionManager(this.entityManagerFactory(builder));
    }
}
3.1数据源配置类2
package com.example.dadasource.config;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
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.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.persistence.EntityManagerFactory;
import javax.sql.DataSource;
import java.util.Map;


/**
 * @Author zhuyanming5@crdigital.com.cn
 * @Description
 * @Date 15:08 2022/8/31
 * @param null
 * @Return 
**/
@Configuration
@EnableJpaRepositories(entityManagerFactoryRef = "db2EntityManagerFactory",
        transactionManagerRef = "db2TransactionManager",
        basePackages = "com.example.dadasource.repository.db2")
@EnableTransactionManagement
@Slf4j
public class DB2Config {

    @Autowired
    private JpaProperties jpaProperties;

    @Autowired
    @Qualifier("userDataSource")
    private DataSource dataSource;

    @Autowired
    private HibernateProperties hibernateProperties;

    @Bean(name = "userEntityManagerFactoryBean")
    public LocalContainerEntityManagerFactoryBean entityManagerFactoryBean(
            EntityManagerFactoryBuilder builder) {
        Map<String, Object> properties = hibernateProperties.determineHibernateProperties(
                jpaProperties.getProperties(), new HibernateSettings());
        return builder.dataSource(dataSource).properties(properties)
                .packages("com.example.dadasource.entity").build();
    }

    @Bean(name = "db2EntityManagerFactory")
    public EntityManagerFactory entityManagerFactory(EntityManagerFactoryBuilder builder) {
        log.info("创建db2EntityManagerFactory");
        return this.entityManagerFactoryBean(builder).getObject();
    }

    @Bean(name = "db2TransactionManager")
    @Primary
    public PlatformTransactionManager transactionManager(EntityManagerFactoryBuilder builder) {
        log.info("创建db2TransactionManager");
        return new JpaTransactionManager(this.entityManagerFactory(builder));
    }
}
3.3 配置实体类
package com.example.dadasource.config;

import com.alibaba.druid.pool.DruidDataSource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

import javax.sql.DataSource;
import java.util.ArrayList;
import java.util.List;


/**
 * @Author zhuyanming5@crdigital.com.cn
 * @Description
 * @Date 11:44 2022/8/31
 * @param
 * @Return 
**/
@Configuration
@Slf4j
public class DruidDataSourceConfig {

    @Value("${spring.datasource.druid.driver-class-name}")
    private String driverClassName;

    @Value("${spring.datasource.druid.initial-size}")
    private int initialSize;

    @Value("${spring.datasource.druid.min-idle}")
    private int minIdle;

    @Value("${spring.datasource.druid.max-active}")
    private int maxActive;

    @Value("${spring.datasource.druid.max-wait}")
    private int maxWait;

    @Value("${spring.datasource.druid.connectionInitSqls}")
    private String connectionInitSqls;
//
//    @Value("${spring.datasource.druid.timeBetweenEvictionRunsMillis}")
//    private int timeBetweenEvictionRunsMillis;
//
//    @Value("${spring.datasource.druid.minEvictableIdleTimeMillis}")
//    private int minEvictableIdleTimeMillis;
//
//    @Value("${spring.datasource.druid.validationQuery}")
//    private String validationQuery;
//
//    @Value("${spring.datasource.druid.testWhileIdle}")
//    private boolean testWhileIdle;
//
//    @Value("${spring.datasource.druid.testOnBorrow}")
//    private boolean testOnBorrow;
//
//    @Value("${spring.datasource.druid.testOnReturn}")
//    private boolean testOnReturn;
//
//    @Value("${spring.datasource.druid.poolPreparedStatements}")
//    private boolean poolPreparedStatements;
//
//    @Value("${spring.datasource.druid.maxPoolPreparedStatementPerConnectionSize}")
//    private int maxPoolPreparedStatementPerConnectionSize;
//
//    @Value("${spring.datasource.druid.filters}")
//    private String filters;
//
//    @Value("{spring.datasource.druid.connectionProperties}")
//    private String connectionProperties;

    /* #####################基础公共配置##################### */

    /* #####################analysisdb配置##################### */
    @Value("${spring.datasource.druid.db1.url}")
    private String analysisUrl;

    @Value("${spring.datasource.druid.db1.username}")
    private String analysisUsername;

    @Value("${spring.datasource.druid.db1.password}")
    private String analysisPassword;

    @Bean(name = "analysisDataSource")
    @Primary // 确定主数据源
    public DataSource analysisDataSource() {
        log.info("创建analysisDataSource数据源");
        return createDataSource(analysisUrl, analysisUsername, analysisPassword);
    }

    /* #####################userdb配置##################### */

    @Value("${spring.datasource.druid.db2.url}")
    private String userUrl;

    @Value("${spring.datasource.druid.db2.username}")
    private String userUsername;

    @Value("${spring.datasource.druid.db2.password}")
    private String userPassword;

    @Bean(name = "userDataSource")
    public DataSource userDataSource() {
        log.info("创建userDataSource数据源");
        return createDataSource(userUrl, userUsername, userPassword);
    }

    /* #####################DataSource配置##################### */

    private DataSource createDataSource(String url, String username, String password) {
        DruidDataSource datasource = new DruidDataSource();
        datasource.setUrl(url);
        datasource.setUsername(username);
        datasource.setPassword(password);
        datasource.setDriverClassName(driverClassName);
        // configuration
        datasource.setInitialSize(initialSize);
        datasource.setMinIdle(minIdle);
        datasource.setMaxActive(maxActive);
        datasource.setMaxWait(maxWait);
//        datasource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
//        datasource.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
//        datasource.setValidationQuery(validationQuery);
//        datasource.setTestWhileIdle(testWhileIdle);
//        datasource.setTestOnBorrow(testOnBorrow);
//        datasource.setTestOnReturn(testOnReturn);
//        datasource.setPoolPreparedStatements(poolPreparedStatements);
//        datasource.setMaxPoolPreparedStatementPerConnectionSize(maxPoolPreparedStatementPerConnectionSize);
//        try {
//            datasource.setFilters(filters);
//        } catch (SQLException e) {
//            e.printStackTrace();
//        }
//        datasource.setConnectionProperties(connectionProperties);

        List<String> connectInitSqls = new ArrayList<String>(){{
            add(connectionInitSqls);
        }};
        datasource.setConnectionInitSqls(connectInitSqls);
        return datasource;
    }

}

4.repository

4.1 db1
package com.example.dadasource.repository.db1;

import com.example.dadasource.entity.LocationEntity;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.stereotype.Repository;

import java.util.List;

/**
 * @Author zhuyanming5@crdigital.com.cn
 * @Description
 * @Date 11:32 2022/8/31
 * @param
 * @Return
**/
@Repository
public interface LocationRepository extends JpaRepository<LocationEntity,Long> {
    @Modifying
    @Query(value = "SELECT t1.* FROM t_location t1 LEFT JOIN location_authorize t2 ON t1.id=t2.t_location_id WHERE t1.parent_id is null and (t1.create_user = ?1 or t2.user_id=?1) and (?2 is null or ?2='' or t1.`status`=?2) ORDER BY t1.update_date desc LIMIT ?3,?4" ,nativeQuery = true)
    List<LocationEntity> findAllByAuthorize(String userId,Integer status,Integer pageNo, Integer pageSize);


    //当前用户不包含分页参数，计算总条数据
    @Modifying
    @Query(value = "SELECT t1.* FROM t_location t1 LEFT JOIN location_authorize t2 ON t1.id=t2.t_location_id WHERE t1.parent_id is null and (?1 is null or ?1='' or t1.create_user = ?1 or t2.user_id=?1) and (?2 is null or ?2='' or t1.`status`=?2) ORDER BY t1.update_date desc" ,nativeQuery = true)
    List<LocationEntity> findAllByAuthorizeAll(String userId,Integer status);
}
4.2 db2
package com.example.dadasource.repository.db2;

import com.example.dadasource.entity.SysUser;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.stereotype.Repository;

import java.util.List;




/**
 * @Author zhuyanming5@crdigital.com.cn
 * @Description
 * @Date 11:32 2022/8/31
 * @param
 * @Return
**/
@Repository
public interface SysUserRepository extends JpaRepository<SysUser,Long> {

    @Modifying
    @Query(value = "select * from sys_user",nativeQuery=true)
    List<SysUser> findAllUser();

    @Modifying
    @Query(value = "select t from sys_user t where t.userId=?1")
    List<SysUser> findByID(Integer userId);
}

5.测试类

测试类-第一个数据源
package com.example.dadasource.service.impl;

import com.example.dadasource.DadasourceApplication;
import com.example.dadasource.entity.LocationEntity;
import com.example.dadasource.entity.ResponseResult;
import com.example.dadasource.repository.db1.LocationRepository;
import com.example.dadasource.service.LocationService;
import junit.framework.TestCase;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.domain.Page;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.Map;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = DadasourceApplication.class)
public class LocationServiceImplTest extends TestCase {
    @Autowired
    private LocationService locationService;

    @Autowired
    private LocationRepository locationRepository;


    @Test
    public void testFindAllByAuthorize(){
        ResponseResult<Map<String,LocationEntity>> allByAuthorize = locationService.findAllByAuthorize("6", 1, 1, 10);
        System.out.println("allByAuthorize:"+allByAuthorize);
    }
}
测试类-第二个数据源
package com.example.dadasource.service.impl;


import com.example.dadasource.DadasourceApplication;
import com.example.dadasource.entity.ResponseResult;
import com.example.dadasource.repository.db2.SysUserRepository;
import com.example.dadasource.service.SysUserService;
import junit.framework.TestCase;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = DadasourceApplication.class)
@ComponentScan("crc.bi.dtbk")
public class SysUserServiceImplTest extends TestCase {

    @Autowired
    private SysUserService sysUserService;

    @Autowired
    private SysUserRepository repository;

    @Test
    public void testSysUserList() {
        ResponseResult result = sysUserService.sysUserList();
        System.out.println("result:"+result);
    }

    @Test
    public void testGetSysUserByID(){
        ResponseResult responseResult = sysUserService.getSysUserByID(6);
        System.out.println("responseResult:"+responseResult);
    }
}
补充：demo整体结构，标记的为重要的类

在这里插入图片描述

亲测可用！！！
deelless
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring Boot多数据源配置与使用
2401_83412172的博客
05-02 932
在清楚了各个大厂的面试重点之后，就能很好的提高你刷题以及面试准备的效率，接下来小编也为大家准备了最新的互联网大厂资料。《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》点击传送门，即可获取！在清楚了各个大厂的面试重点之后，就能很好的提高你刷题以及面试准备的效率，接下来小编也为大家准备了最新的互联网大厂资料。[外链图片转存中…(img-bulPMfzb-1714658264777)][外链图片转存中…(img-lNiyiTeC-1714658264777)]
JPA框架基本用法-SpringBoot框架（一）
qq_41177135的博客
06-06 1085
JPA框架基本用法-SpringBoot框架（一）
Spring Boot+Jpa多数据源配置的完整步骤
08-26
主要给大家介绍了关于Spring Boot+Jpa多数据源配置的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
【SpringBoot】Spring data JPA的多数据源实现
Robin的博客
03-21 2554
表，message数据能正确的插入testdb2的message表，则JPA的多数据源实现正确。下面的实体对象和Repository，并使用primary数据源。仿造这段代码再写一套。配置实体扫描以及事务管理,注意看@Primary和带注释的地方。的Bean对象创建并注入Spring上下文，分别对应。的配置使用secondary数据源。如果article数据能正确插入。里面的两套数据源配置。
SpringBoot—JPA和Mybatis多数据源配置和使用
qq_32015565的博客
04-18 1972
后续有新的学习，继续补充上来。
SpringBoot-JPA多数据源
月弦YueXian
06-02 3938
SpringBoot-JPA多数据源
Springboot JPA实现多数据源配置
最新发布
随心居
02-20 624
要实现一个MES系统的web-API接口，MES系统是购买的商业软件，厂商的接口报价过高，因此由内部IT团队开发实现这个接口。考虑到系统的追溯性，因此设计一个中间库，第三方报工系统传过来的数据同时存放在中间库和MES系统里。搜索查阅了很多博文及实验后，终于实现了多数据库的访问，调试时遇到了几个问题，在搜索后也找到了解决方案并修正。这样就完成了多数据源的配置，以后在相应的db目录下创建相关的entity和repository。
避坑版：springboot+JPA如何配多种数据源（postgresql+mysql）
u013232219的博客
09-08 2772
注意： JPA和mybatis是不同的持久层，各自特点独特， 与mybatis相比，JPA需要考虑对数据源的映射和操作， 通常我们设置在项目启动时，JPA就会根据设置去创建或者更新表， 因此不能像mybayis那样等到调用时再去告诉方法用哪个数据源， JPA需要一开始就设定好repository和entity所对应的数据源， 在下列文件repository里你可以看到相关设置； 坑，请注意，网上有很多的JPA配多种数据源，但是他们都缺失一点，连方言都没有设置，有的压根不知道这回事，要知道，JPA
springboot jpa 多数据源配置
chenxing1990的专栏
02-07 6735
springboot 多数据源切换。
SpringBoot+Jpa多数据源配置
huang_wei_cai的专栏
09-18 343
关于 有时候，随着业务的发展，项目关联的数据来源会变得越来越复杂，使用的数据库会比较分散，这个时候就会采用多数据源的方式来获取数据。另外，多数据源也有其他好处，例如分布式数据库的读写分离，集成多种数据库等等。下面分享我在实际项目中配置多数据源的案例。 步骤 1.application.yml文件中，配置数据库源。这里primary是主库，secondary是从库。 server: p...
springBoot + Hikari 配置多数据源连接数据库
m0_67402731的博客
07-29 1571
多数据源场景中，如果你用到了SqlSession统一提交，那么你在获取SqlSession是因为默认用的是主数据源的，获取的是主数据源的SqlSession，如果你用它调用别的数据源的mapper接口，肯定报错找不到啊！如何解决？等我抽时间写一篇《Mybatis多数据源下，SqlSessionFactory的动态切换》先自我介绍一下，小编13年上师交大毕业，曾经在小公司待过，去过华为OPPO等大厂，18年进入阿里，直到现在。...
Spring Boot+Jpa多数据源配置Demo（支持不同数据库）
04-11
Spring Boot+Jpa多数据源配置Demo，可同时支持多种数据库，不同数据库，同时支持不同数据库的JdbcTemplate
使用springboot + JPA / MyBatis 实现多数据源动态切换
04-17
本教程将详细讲解如何使用Spring Boot结合JPA或MyBatis框架实现多数据源的动态切换。 **一、Spring Boot与JPA** 1. **Spring Boot简介**：Spring Boot是Spring Framework的一个模块，旨在简化Spring应用的初始搭建...
SpringBoot+JPA.zip
10-29
SpringBoot应用中，JPA的相关配置通常在`application.properties`或`application.yml`文件中完成，包括数据源设置、JPA供应商选择（如Hibernate）、实体扫描路径等。 8. **运行与测试**： 项目中可能包含了`main`...
SpringBoot+gradle+mybatis多数据源动态配置
06-06
本项目结合了SpringBoot、Gradle和MyBatis，旨在实现多数据源的动态配置，这对于处理多个数据库或者分库分表的场景尤其有用。以下是对这个项目的详细解析： **SpringBoot** SpringBoot是由Pivotal团队提供的全新...
SpringBoot+Atomikos+动态多数据源+事务+2种切换数据源的方式
09-24
3. **事务管理**：SpringBoot默认使用LocalContainerEntityManagerFactoryBean处理JPA事务，但在多数据源环境中，需要改为使用Atomikos的`JtaPlatformTransactionManager`。此外，确保开启@...
基于SpringBoot+JPA的信息管理系统
05-31
它集成了大量的常用组件，如数据源、定时任务、缓存等，使得开发者能够快速地创建一个独立运行的、生产级别的基于Spring的应用。 【JPA简介】 Java Persistence API（JPA）是Java平台上的一个标准，用于管理关系...
7.springboot中整合Jpa多数据源
daimenglaoshi的博客
12-05 853
在使用Mybatis时会涉及多数据源的问题，同样，当我们使用Jpa作为持久化处理方式时，也会涉及多数据源的问题，本节我们来讲解一下Springboot如何整合Spring data Jpa多数据源。添加lomboc，web，spring data jpa, mysql依赖默认Mysql驱动时8，如果本机安装的Mysql是5，需要手动修改版本 ，修改后的依赖信息如下： 添加 Druid连接池依赖 创建好的项目结构如下:boot1和boot2application.properties中配置两个数据源 4.创
springboot2+JPA 配置多数据源（不同类型数据库）
qq_43082438的博客
06-24 6699
springboot2+JPA配置多数据源（不同数据库）
springboot+jpa+druid多数据源配置
12-01
2. 配置数据源：在application.properties或application.yml文件中配置多个数据源的连接信息，并指定每个数据源的名称和相关属性。 3. 配置数据源连接池：使用@ConfigurationProperties注解创建多个数据源的连接池...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值