springdata-jpa多数据源配置

已于 2023-10-16 12:14:22 修改
阅读量871 收藏 2
点赞数
文章标签： spring boot
于 2023-10-16 12:06:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43278573/article/details/133855345
版权

项目结构


1.依赖

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.16.18</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <!-- MySQL 驱动, 注意, 这个需要与 MySQL 版本对应 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.31</version>
        <scope>runtime</scope>
    </dependency>
    <!--web-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!--fastjson-->
    <dependency>
        <groupId>com.alibaba.fastjson2</groupId>
        <artifactId>fastjson2</artifactId>
        <version>2.0.4</version>
    </dependency>
</dependencies>

2.application.yml 

server:
  port: 8900 #端口
spring:
  datasource:
    #主数据源
    primary:
      url: jdbc:mysql://192.168.64.132:3306/testdb?serverTimezone=GMT&seUnicode=true&characterEncoding=UTF-8&useSSL=false&allowMultiQueries=true&autoReconnect=true&allowPublicKeyRetrieval=true
      username: root
      password: 123456
      driver-class-name: com.mysql.jdbc.Driver
      type: com.zaxxer.hikari.HikariDataSource
    #从数据源
    secondary:
      url: jdbc:mysql://192.168.64.132:3307/testdb?serverTimezone=GMT&seUnicode=true&characterEncoding=UTF-8&useSSL=false&allowMultiQueries=true&autoReconnect=true&allowPublicKeyRetrieval=true
      username: root
      password: 123456
      driver-class-name: com.mysql.jdbc.Driver
    jpa:
      #主jpa配置
      primary:
        show-sql: true
        properties:
          hibernate:
            hbm2ddl:
              auto: update
            dialect: org.hibernate.dialect.MySQL8Dialect
      #从jpa配置
      secondary:
        show-sql: true
        properties:
          hibernate:
            hbm2ddl:
              auto: update
            dialect: org.hibernate.dialect.MySQL8Dialect

3.主数据源配置

package com.xiaoxi.demo.config.primaryconfig;

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.jdbc.core.JdbcTemplate;

import javax.sql.DataSource;

@Configuration
public class PrimaryDataSourceConfig {

    /**
     * 扫描spring.datasource.primary开头的配置信息
     *
     * @return 数据源配置信息
     */
    @Primary
    @Bean(name = "primaryDataSourceProperties")
    @ConfigurationProperties(prefix = "spring.datasource.primary")
    public DataSourceProperties dataSourceProperties() {
        return new DataSourceProperties();
    }

    /**
     * 取主库数据源对象
     *
     * @param dataSourceProperties 注入名为primaryDataSourceProperties的bean
     * @return 数据源对象
     */
    @Primary
    @Bean(name = "primaryDataSource")
    public DataSource dataSource(@Qualifier("primaryDataSourceProperties") DataSourceProperties dataSourceProperties) {
        return dataSourceProperties.initializeDataSourceBuilder().build();
    }

    /**
     * 该方法仅在需要使用JdbcTemplate对象时选用
     *
     * @param dataSource 注入名为primaryDataSource的bean
     * @return 数据源JdbcTemplate对象
     */
    @Primary
    @Bean(name = "primaryJdbcTemplate")
    public JdbcTemplate jdbcTemplate(@Qualifier("primaryDataSource") DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }
}

4.主实体类创建

package com.xiaoxi.demo.entity.primaryentity;

import lombok.Data;

import javax.persistence.*;

@Data
@Entity // jpa特有，必须加
@Table(name = "t_user")
public class PrimaryTbUserEntity {
    @Id    //主键id
    @GeneratedValue(strategy= GenerationType.IDENTITY)//主键生成策略
    @Column(name="id") //数据库字段名
    private Integer id;

    @Column(name = "uname")
    private String uname;
}

5.主repository创建

package com.xiaoxi.demo.dao.primaryrepository;

import com.xiaoxi.demo.entity.primaryentity.PrimaryTbUserEntity;
import org.springframework.context.annotation.Primary;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository("primaryUserRepository")
@Primary
public interface PrimaryUserRepository extends JpaRepository<PrimaryTbUserEntity, Integer> {
}
 

6.主jpa配置
 

package com.xiaoxi.demo.config.primaryconfig;

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.orm.jpa.JpaProperties;
import org.springframework.boot.context.properties.ConfigurationProperties;
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.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.sql.DataSource;

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
        basePackages = PrimaryJpaConfig.REPOSITORY_PACKAGE,
        entityManagerFactoryRef = "primaryEntityManagerFactory",
        transactionManagerRef = "primaryTransactionManager"
)
public class PrimaryJpaConfig {
    static final String REPOSITORY_PACKAGE = "com.xiaoxi.demo.dao.primaryrepository";
    private static final String ENTITY_PACKAGE = "com.xiaoxi.demo.entity.primaryentity";

    /**
     * 扫描spring.jpa.primary开头的配置信息
     *
     * @return jpa配置信息
     */
    @Primary
    @Bean(name = "primaryJpaProperties")
    @ConfigurationProperties(prefix = "spring.jpa.primary")
    public JpaProperties jpaProperties() {
        return new JpaProperties();
    }

    /**
     * 获取主库实体管理工厂对象
     *
     * @param primaryDataSource 注入名为primaryDataSource的数据源
     * @param jpaProperties     注入名为primaryJpaProperties的jpa配置信息
     * @param builder           注入EntityManagerFactoryBuilder
     * @return 实体管理工厂对象
     */
    @Primary
    @Bean(name = "primaryEntityManagerFactory")
    public LocalContainerEntityManagerFactoryBean entityManagerFactoryBean(
            @Qualifier("primaryDataSource") DataSource primaryDataSource,
            @Qualifier("primaryJpaProperties") JpaProperties jpaProperties,
            EntityManagerFactoryBuilder builder
    ) {
        return builder
                // 设置数据源
                .dataSource(primaryDataSource)
                // 设置jpa配置
                .properties(jpaProperties.getProperties())
                // 设置实体包名
                .packages(ENTITY_PACKAGE)
                // 设置持久化单元名，用于@PersistenceContext注解获取EntityManager时指定数据源
                .persistenceUnit("primaryPersistenceUnit").build();
    }

    /**
     * 获取实体管理对象
     *
     * @param factory 注入名为primaryEntityManagerFactory的bean
     * @return 实体管理对象
     */
    @Primary
    @Bean(name = "primaryEntityManager")
    public EntityManager entityManager(@Qualifier("primaryEntityManagerFactory") EntityManagerFactory factory) {
        return factory.createEntityManager();
    }

    /**
     * 获取主库事务管理对象
     *
     * @param factory 注入名为primaryEntityManagerFactory的bean
     * @return 事务管理对象
     */
    @Primary
    @Bean(name = "primaryTransactionManager")
    public PlatformTransactionManager transactionManager(@Qualifier("primaryEntityManagerFactory") EntityManagerFactory factory) {
        return new JpaTransactionManager(factory);
    }
}
 

 

7.从数据源配置
 

package com.xiaoxi.demo.config.secondaryconfig;

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.JdbcTemplate;

import javax.sql.DataSource;

@Configuration
public class SecondaryDataSourceConfig {
    /**
     * 扫描spring.datasource.secondary开头的配置信息
     *
     * @return 数据源配置信息
     */
    @Bean(name = "secondaryDataSourceProperties")
    @ConfigurationProperties(prefix = "spring.datasource.secondary")
    public DataSourceProperties dataSourceProperties() {
        return new DataSourceProperties();
    }

    /**
     * 获取次数据源对象
     *
     * @param dataSourceProperties 注入名为secondaryDataSourceProperties的bean
     * @return 数据源对象
     */
    @Bean("secondaryDataSource")
    public DataSource dataSource(@Qualifier("secondaryDataSourceProperties") DataSourceProperties dataSourceProperties) {
        return dataSourceProperties.initializeDataSourceBuilder().build();
    }

    /**
     * 该方法仅在需要使用JdbcTemplate对象时选用
     *
     * @param dataSource 注入名为secondaryDataSource的bean
     * @return 数据源JdbcTemplate对象
     */
    @Bean(name = "secondaryJdbcTemplate")
    public JdbcTemplate jdbcTemplate(@Qualifier("secondaryDataSource") DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }
}
 

 

8.从jpa配置
 

package com.xiaoxi.demo.config.secondaryconfig;

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.orm.jpa.JpaProperties;
import org.springframework.boot.context.properties.ConfigurationProperties;
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 javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.sql.DataSource;

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
        basePackages = SecondaryJpaConfig.REPOSITORY_PACKAGE,
        entityManagerFactoryRef = "secondaryEntityManagerFactory",
        transactionManagerRef = "secondaryTransactionManager"
)
public class SecondaryJpaConfig {

    static final String REPOSITORY_PACKAGE = "com.xiaoxi.demo.dao.secondaryrepository";
    private static final String ENTITY_PACKAGE = "com.xiaoxi.demo.entity.secondaryentity";

    /**
     * 扫描spring.jpa.secondary
     *
     * @return jpa配置信息
     */
    @Bean(name = "secondaryJpaProperties")
    @ConfigurationProperties(prefix = "spring.jpa.secondary")
    public JpaProperties jpaProperties() {
        return new JpaProperties();
    }

    /**
     * 获取次库实体管理工厂对象
     *
     * @param secondaryDataSource 注入名为secondaryDataSource的数据源
     * @param jpaProperties       注入名为secondaryJpaProperties的jpa配置信息
     * @param builder             注入EntityManagerFactoryBuilder
     * @return 实体管理工厂对象
     */
    @Bean(name = "secondaryEntityManagerFactory")
    public LocalContainerEntityManagerFactoryBean entityManagerFactory(
            @Qualifier("secondaryDataSource") DataSource secondaryDataSource,
            @Qualifier("secondaryJpaProperties") JpaProperties jpaProperties,
            EntityManagerFactoryBuilder builder
    ) {
        return builder
                // 设置数据源
                .dataSource(secondaryDataSource)
                // 设置jpa配置
                .properties(jpaProperties.getProperties())
                // 设置实体包名
                .packages(ENTITY_PACKAGE)
                // 设置持久化单元名，用于@PersistenceContext注解获取EntityManager时指定数据源
                .persistenceUnit("secondaryPersistenceUnit").build();
    }

    /**
     * 获取实体管理对象
     *
     * @param factory 注入名为secondaryEntityManagerFactory的bean
     * @return 实体管理对象
     */
    @Bean(name = "secondaryEntityManager")
    public EntityManager entityManager(@Qualifier("secondaryEntityManagerFactory") EntityManagerFactory factory) {
        return factory.createEntityManager();
    }

    /**
     * 获取主库事务管理对象
     *
     * @param factory 注入名为secondaryEntityManagerFactory的bean
     * @return 事务管理对象
     */
    @Bean(name = "secondaryTransactionManager")
    public PlatformTransactionManager transactionManager(@Qualifier("secondaryEntityManagerFactory") EntityManagerFactory factory) {
        return new JpaTransactionManager(factory);
    }
}
 

9.从实体类配置
 

package com.xiaoxi.demo.entity.secondaryentity;

import lombok.Data;

import javax.persistence.*;

@Data
@Entity // jpa特有，必须加
@Table(name = "t_user")
public class SecondaryTbUserEntity {
        @Id    //主键id
        @GeneratedValue(strategy= GenerationType.IDENTITY)//主键生成策略
        @Column(name="id") //数据库字段名
        private Integer id;

        @Column(name = "uname")
        private String name;
}
 

10.从repository创建
 

package com.xiaoxi.demo.dao.secondaryrepository;

import com.xiaoxi.demo.entity.secondaryentity.SecondaryTbUserEntity;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
@Repository("secondaryUserRepository")
public interface SecondaryUserRepository extends JpaRepository<SecondaryTbUserEntity, Integer> {
}
 

11.从jpa配置
 

package com.xiaoxi.demo.config.secondaryconfig;

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.orm.jpa.JpaProperties;
import org.springframework.boot.context.properties.ConfigurationProperties;
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 javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.sql.DataSource;

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
        basePackages = SecondaryJpaConfig.REPOSITORY_PACKAGE,
        entityManagerFactoryRef = "secondaryEntityManagerFactory",
        transactionManagerRef = "secondaryTransactionManager"
)
public class SecondaryJpaConfig {

    static final String REPOSITORY_PACKAGE = "com.xiaoxi.demo.dao.secondaryrepository";
    private static final String ENTITY_PACKAGE = "com.xiaoxi.demo.entity.secondaryentity";

    /**
     * 扫描spring.jpa.secondary
     *
     * @return jpa配置信息
     */
    @Bean(name = "secondaryJpaProperties")
    @ConfigurationProperties(prefix = "spring.jpa.secondary")
    public JpaProperties jpaProperties() {
        return new JpaProperties();
    }

    /**
     * 获取次库实体管理工厂对象
     *
     * @param secondaryDataSource 注入名为secondaryDataSource的数据源
     * @param jpaProperties       注入名为secondaryJpaProperties的jpa配置信息
     * @param builder             注入EntityManagerFactoryBuilder
     * @return 实体管理工厂对象
     */
    @Bean(name = "secondaryEntityManagerFactory")
    public LocalContainerEntityManagerFactoryBean entityManagerFactory(
            @Qualifier("secondaryDataSource") DataSource secondaryDataSource,
            @Qualifier("secondaryJpaProperties") JpaProperties jpaProperties,
            EntityManagerFactoryBuilder builder
    ) {
        return builder
                // 设置数据源
                .dataSource(secondaryDataSource)
                // 设置jpa配置
                .properties(jpaProperties.getProperties())
                // 设置实体包名
                .packages(ENTITY_PACKAGE)
                // 设置持久化单元名，用于@PersistenceContext注解获取EntityManager时指定数据源
                .persistenceUnit("secondaryPersistenceUnit").build();
    }

    /**
     * 获取实体管理对象
     *
     * @param factory 注入名为secondaryEntityManagerFactory的bean
     * @return 实体管理对象
     */
    @Bean(name = "secondaryEntityManager")
    public EntityManager entityManager(@Qualifier("secondaryEntityManagerFactory") EntityManagerFactory factory) {
        return factory.createEntityManager();
    }

    /**
     * 获取主库事务管理对象
     *
     * @param factory 注入名为secondaryEntityManagerFactory的bean
     * @return 事务管理对象
     */
    @Bean(name = "secondaryTransactionManager")
    public PlatformTransactionManager transactionManager(@Qualifier("secondaryEntityManagerFactory") EntityManagerFactory factory) {
        return new JpaTransactionManager(factory);
    }
}
 

 12.测试
 

package com.xiaoxi.demo.controllerr;

import com.alibaba.fastjson2.JSON;
import com.xiaoxi.demo.dao.primaryrepository.PrimaryUserRepository;
import com.xiaoxi.demo.dao.secondaryrepository.SecondaryUserRepository;
import com.xiaoxi.demo.entity.primaryentity.PrimaryTbUserEntity;
import com.xiaoxi.demo.entity.secondaryentity.SecondaryTbUserEntity;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.HashMap;
import java.util.Map;
import java.util.Optional;

@RestController
public class TestMutiDataSource {

    @Autowired
    PrimaryUserRepository primaryUserRepository;

    @Autowired
    @Qualifier("secondaryUserRepository")
    SecondaryUserRepository secondaryUserRepository;

    @GetMapping("/test")
    public String TestMutiDataSource() {
        Map<String, String> re = new HashMap<>();
        Optional<PrimaryTbUserEntity> byId = primaryUserRepository.findById(1);
        if(byId.isPresent()) {
            re.put("主库数据", JSON.toJSONString(byId.get()));
        }
        Optional<SecondaryTbUserEntity> byIdSecondary = secondaryUserRepository.findById(2);
        if(byIdSecondary.isPresent()) {
            re.put("从库数据", JSON.toJSONString(byIdSecondary.get()));
        }
        return JSON.toJSONString(re);
    }
}

打印：
 {
   "从库数据": "{\"id\":2,\"name\":\"lisi4\"}",
   "主库数据": "{\"id\":1,\"uname\":\"zhang3\"}"
}
 

总结：
 

        jpa配置多数据源就是配置多个repository，每个 repository对应操作不同的数据源 

                

        

        

    




    

      

        

            

              
                
                  是小淅吖
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    2
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                  1
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      










                



	

		

			

				
					
spring 配置多数据源

				
			

			

				

					yi_12y的博客
				

				

					08-04
					
					208
					
				

			

		

		

			
				
实现spring配置多数据源，切入不到controller层添加的配置原理不是太懂，好像是springmvc代理，小菜鸟记录一下

			
		

	



                

              
                



	

		

			

				
					
Spring多数据源的配置

				
			

			

				

					彩虹柠檬水
				

				

					07-04
					
					433
					
				

			

		

		

			
				
1.业务需求在项目开发中，经常会遇到需要操作多个数据源的情况，比如数据同步，在数据库A中增加数据的同时写入数据库B。这就需要做到可以配置多个数据源，并做到动态切换数据源。2.多数据源配置首先是多数据源的配置，在applicationContext.xml文件中。 
主要配置代码如下：    <!-- 定义数据源的信息 -->  
    <bean id="parentDataSource" cla

			
		

	



                


  
              

                


	

		

			

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

				
			

			

				

					12-17
				

			

		

		

			
				
Spring Boot使用spring-data-jpa配置Mysql多数据源，可用版本

			
		

	





	

		

			

				
					
springboot-jpa多数据源

				
			

			

				

					azhegps的博客
				

				

					08-10
					
					191
					
				

			

		

		

			
				
Maven依赖
	
				1

				2

				3

				4
				
				
				<dependency>

				<groupId>org.springframework.boot</groupId>

				<artifactId>spring-boot-starter-da...

			
		

	



		

			
		



	

		

			

				
					
【源码】Spring Data JPA原理解析之Repository的自动注入（一）

					
最新发布

				
			

			

				

					JingAi_jia917的博客
				

				

					05-14
					
					1121
					
				

			

		

		

			
				
本篇从源码的角度讲解了Repository接口类如何封装成BeanDefinition，并添加到Spring IOC容器的过程。主要讲解了JpaRepositoryConfigExtension、RepositoryConfigurationExtension、RepositoryConfigurationExtensionSupport、RepositoryComponentProvider、ClassPathScanningCandidateComponentProvider、JpaRepository

			
		

	





	

		

			

				
					
Springboot JPA实现多数据源配置

				
			

			

				

					随心居
				

				

					02-20
					
					614
					
				

			

		

		

			
				
要实现一个MES系统的web-API接口，MES系统是购买的商业软件，厂商的接口报价过高，因此由内部IT团队开发实现这个接口。考虑到系统的追溯性，因此设计一个中间库，第三方报工系统传过来的数据同时存放在中间库和MES系统里。搜索查阅了很多博文及实验后，终于实现了多数据库的访问，调试时遇到了几个问题，在搜索后也找到了解决方案并修正。这样就完成了多数据源的配置，以后在相应的db目录下创建相关的entity和repository。

			
		

	





	

		

			

				
					
Spring Data JPA 之 多数据源配置

				
			

			

				

					曾小二的博客
				

				

					08-14
					
					6010
					
				

			

		

		

			
				
我们都知道 DataSource 的本质是获得数据库连接，⽽ AbstractRoutingDataSource 帮我们实现了动态获得数据源的可能性。

			
		

	





	

		

			

				
					
JPA多数据源配置

				
			

			

				

					qq_51711350的博客
				

				

					12-03
					
					2232
					
				

			

		

		

			
				
JPA多数据源配置

			
		

	





	

		

			

				
					
避坑版：springboot+JPA如何配多种数据源（postgresql+mysql）

				
			

			

				

					u013232219的博客
				

				

					09-08
					
					2711
					
				

			

		

		

			
				
注意： JPA和mybatis是不同的持久层，各自特点独特，

与mybatis相比，JPA需要考虑对数据源的映射和操作，

通常我们设置在项目启动时，JPA就会根据设置去创建或者更新表，

因此不能像mybayis那样等到调用时再去告诉方法用哪个数据源，

JPA需要一开始就设定好repository和entity所对应的数据源，

在下列文件repository里你可以看到相关设置；

坑，请注意，网上有很多的JPA配多种数据源，但是他们都缺失一点，连方言都没有设置，有的压根不知道这回事，要知道，JPA

			
		

	





	

		

			

				
					
springboot jpa 多数据源配置

				
			

			

				

					chenxing1990的专栏
				

				

					02-07
					
					6734
					
				

			

		

		

			
				
springboot 多数据源切换。

			
		

	





	

		

			

				
					
SpringBoot—JPA和Mybatis多数据源配置和使用

				
			

			

				

					qq_32015565的博客
				

				

					04-18
					
					1966
					
				

			

		

		

			
				
后续有新的学习，继续补充上来。

			
		

	





	

		

			

				
					
详解基于Spring Boot与Spring Data JPA的多数据源配置

				
			

			

				

					08-30
				

			

		

		

			
				
基于Spring Boot与Spring Data JPA的多数据源配置  Spring Boot作为当前最流行的Java Web框架之一，提供了许多实用的功能和配置项，然而，在实际项目中，我们经常会遇到多数据源配置的问题，例如在一个项目中需要...

			
		

	





	

		

			

				
					
Spring Boot+Jpa多数据源配置Demo（支持不同数据库）

				
			

			

				

					04-11
				

			

		

		

			
				
Spring Boot结合JPA（Java Persistence API）和JdbcTemplate，为开发者提供了灵活且强大的多数据源配置能力。本示例将详细介绍如何在Spring Boot项目中实现这样的配置，以支持不同类型的数据库。  首先，我们要理解...

			
		

	





	

		

			

				
					
spring+Jpa多数据源配置的方法示例

				
			

			

				

					08-27
				

			

		

		

			
				
Spring+JPA多数据源配置方法示例  Spring+JPA多数据源配置是指在 Spring 框架中使用 JPA（Java Persistence API）来访问多个数据源的配置方法。该配置方法允许开发者在一个应用程序中访问多个数据库，实现数据的集成...

			
		

	





	

		

			

				
					
spring-data-jpa-examples-master.rar_spring data jpa

				
			

			

				

					09-19
				

			

		

		

			
				
【标题】"spring-data-jpa-examples-master.rar_spring data jpa" 提供了一个关于Spring Data JPA的实际应用示例，这是一个广泛使用的Java框架，它简化了与数据库的交互，特别是通过JPA（Java Persistence API）进行...

			
		

	





	

		

			

				
					
springboot2+JPA 配置多数据源（不同类型数据库）

				
			

			

				

					qq_43082438的博客
				

				

					06-24
					
					6673
					
				

			

		

		

			
				
springboot2+JPA配置多数据源（不同数据库）

			
		

	





	

		

			

				
					
SpringBoot+JPA框架 配置多数据源

				
			

			

				

					weixin_43078114的博客
				

				

					09-02
					
					1902
					
				

			

		

		

			
				
【代码】SpringBoot+JPA框架 配置多数据源。

			
		

	





	

		

			

				
					
SpringBoot-JPA多数据源

				
			

			

				

					月弦YueXian
				

				

					06-02
					
					3934
					
				

			

		

		

			
				
SpringBoot-JPA多数据源

			
		

	





	

		

			

				
					
引入spring-boot-starter-data-jpa之后配置数据源找不到

				
			

			

				

					05-10
				

			

		

		

			
				
当引入 `spring-boot-starter-data-jpa` 之后，需要配置数据源的信息才能正常使用。你可以在 `application.properties`（或 `application.yml`）文件中添加以下配置：

```properties
spring.datasource.url=jdbc:mysql://localhost:3306/db_name
spring.datasource.username=username
spring.datasource.password=password
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
```

其中，`url` 配置为你的数据库地址和端口号，`username` 和 `password` 分别为连接数据库的用户名和密码，`driver-class-name` 是数据库驱动的类名，这里是 MySQL 数据库的驱动。

如果你使用的是其它数据库，可以将上面的配置信息进行相应的修改。如果你的数据库驱动已经在 classpath 中，那么 `driver-class-name` 可以省略。

此外，还需要在你的应用程序中注入 `DataSource` 对象。你可以使用 `@Autowired` 注解来注入：

```java
@Autowired
private DataSource dataSource;
```

这样，你就可以在代码中使用 `dataSource` 来访问数据库了。如果需要使用 JPA，还需要定义实体类和仓库接口。具体的使用方法可以参考 Spring Data JPA 的官方文档。

			
		

	



              



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

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		
评论 1

	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值