1 介绍

  • 使用JPA的配置两个数据库，配置不同的数据库。

    2 示例

    2.1 依赖引入

    1.   <parent>
    2.       <groupId>org.springframework.boot</groupId>
    3.       <artifactId>spring-boot-starter-parent</artifactId>
    4.       <version>2.1.3.RELEASE</version>
    5.       <relativePath/> <!-- lookup parent from repository -->
    6.   </parent>
    8.   <dependencies>
    9.       <dependency>
    10.           <groupId>org.springframework.boot</groupId>
    11.           <artifactId>spring-boot-starter-web</artifactId>
    12.       </dependency>
    14.       <dependency>
    15.           <groupId>org.springframework.boot</groupId>
    16.           <artifactId>spring-boot-starter-data-jpa</artifactId>
    17.       </dependency>
    19.       <dependency>
    20.           <groupId>org.springframework.boot</groupId>
    21.           <artifactId>spring-boot-starter-actuator</artifactId>
    22.       </dependency>
    24.       <dependency>
    25.           <groupId>mysql</groupId>
    26.           <artifactId>mysql-connector-java</artifactId>
    27.       </dependency>
    29.       <dependency>
    30.           <groupId>org.projectlombok</groupId>
    31.           <artifactId>lombok</artifactId>
    32.           <scope>provided</scope>
    33.       </dependency>
    35.       <dependency>
    36.           <groupId>org.springframework.boot</groupId>
    37.           <artifactId>spring-boot-starter-test</artifactId>
    38.           <scope>test</scope>
    39.       </dependency>
    40.   </dependencies>

    2.2 自定义配置两个数据库

    ``` spring.datasource.primary.jdbc-url=jdbc:mysql://localhost:3306/primary?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=GMT&allowPublicKeyRetrieval=true spring.datasource.primary.username=root spring.datasource.primary.password=123456 spring.datasource.primary.driver-class-name=com.mysql.cj.jdbc.Driver

spring.datasource.second.jdbc-url=jdbc:mysql://localhost:3306/second?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=GMT&allowPublicKeyRetrieval=true spring.datasource.second.username=root spring.datasource.second.password=123456 spring.datasource.second.driver-class-name=com.mysql.cj.jdbc.Driver

日志打印执行的SQL

spring.jpa.show-sql=true

Hibernate的DDL策略

spring.jpa.hibernate.ddl-auto=update spring.jpa.hibernate.format_sql=true spring.jpa.hibernate.primary-dialect=org.hibernate.dialect.MySQL55Dialect spring.jpa.hibernate.second-dialect=org.hibernate.dialect.MySQL55Dialect

  1. <a name="lL4ZT"></a>
  2. ## 2.3 配置默认的数据库源
  3. ```java
  4. package com.hikktn.config;
  6. import org.springframework.beans.factory.annotation.Qualifier;
  7. import org.springframework.boot.context.properties.ConfigurationProperties;
  8. import org.springframework.boot.jdbc.DataSourceBuilder;
  9. import org.springframework.context.annotation.Bean;
  10. import org.springframework.context.annotation.Configuration;
  11. import org.springframework.context.annotation.Primary;
  12. import org.springframework.stereotype.Component;
  14. import javax.sql.DataSource;
  16. @Configuration
  17. @Component
  18. public class DataSourceConfig {
  20.     /**
  21.      * 主数据连接，默认优先级最高
  22.      * @return
  23.      */
  24.     @Bean(name = "primaryDataSource")
  25.     @Qualifier("primaryDataSource")
  26.     @ConfigurationProperties(prefix="spring.datasource.primary")
  27.     public DataSource PrimaryDataSource() {
  28.         return DataSourceBuilder.create().build();
  29.     }
  31.     /**
  32.      * 从数据源
  33.      * @return
  34.      */
  35.     @Primary
  36.     @Bean(name = "secondDataSource")
  37.     @Qualifier("secondDataSource")
  38.     @ConfigurationProperties(prefix="spring.datasource.second")
  39.     public DataSource secondaryDataSource() {
  40.         return DataSourceBuilder.create().build();
  41.     }
  42. }

2.4 JPA配置主数据库

  1. package com.hikktn.config;
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.beans.factory.annotation.Qualifier;
  5. import org.springframework.boot.autoconfigure.domain.EntityScan;
  6. import org.springframework.boot.autoconfigure.orm.jpa.HibernateProperties;
  7. import org.springframework.boot.autoconfigure.orm.jpa.HibernateSettings;
  8. import org.springframework.boot.autoconfigure.orm.jpa.JpaProperties;
  9. import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
  10. import org.springframework.context.annotation.Bean;
  11. import org.springframework.context.annotation.Configuration;
  12. import org.springframework.context.annotation.Primary;
  13. import org.springframework.core.env.Environment;
  14. import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
  15. import org.springframework.orm.jpa.JpaTransactionManager;
  16. import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
  17. import org.springframework.transaction.PlatformTransactionManager;
  18. import org.springframework.transaction.annotation.EnableTransactionManagement;
  20. import javax.persistence.EntityManager;
  21. import javax.sql.DataSource;
  22. import java.util.Map;
  24. @Configuration
  25. @EnableTransactionManagement
  26. @EntityScan(basePackages = "com.hikktn.domain.primary")
  27. @EnableJpaRepositories(
  28.         entityManagerFactoryRef = "entityManagerFactoryPrimary",
  29.         transactionManagerRef = "transactionManagerPrimary",
  30.         basePackages = {"com.hikktn.dao.primary"})
  31. public class PrimaryConfig {
  33.     @Autowired
  34.     @Qualifier("primaryDataSource")
  35.     private DataSource primaryDataSource;
  37.     @Autowired
  38.     private JpaProperties jpaProperties;
  39.     @Autowired
  40.     private HibernateProperties hibernateProperties;
  42.     private Map<String, Object> getVendorProperties() {
  43.         return hibernateProperties.determineHibernateProperties(jpaProperties.getProperties(), new HibernateSettings());
  44.     }
  46.     @Primary
  47.     @Bean(name = "entityManagerPrimary")
  48.     public EntityManager entityManager(EntityManagerFactoryBuilder builder) {
  49.         return entityManagerFactoryPrimary(builder).getObject().createEntityManager();
  50.     }
  52.     @Primary
  53.     @Bean(name = "entityManagerFactoryPrimary")
  54.     public LocalContainerEntityManagerFactoryBean entityManagerFactoryPrimary(EntityManagerFactoryBuilder builder) {
  55.         return builder
  56.                 .dataSource(primaryDataSource)
  57.                 .properties(getVendorProperties())
  58.                 .packages("com.hikktn.domain.primary")
  59.                 .persistenceUnit("primaryPersistenceUnit")
  60.                 .build();
  61.     }
  63.     @Primary
  64.     @Bean(name = "transactionManagerPrimary")
  65.     public PlatformTransactionManager transactionManagerPrimary(EntityManagerFactoryBuilder builder) {
  66.         return new JpaTransactionManager(entityManagerFactoryPrimary(builder).getObject());
  67.     }
  68. }

2.5 JPA配置副数据库

  1. package com.hikktn.config;
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.beans.factory.annotation.Qualifier;
  5. import org.springframework.boot.autoconfigure.orm.jpa.HibernateProperties;
  6. import org.springframework.boot.autoconfigure.orm.jpa.HibernateSettings;
  7. import org.springframework.boot.autoconfigure.orm.jpa.JpaProperties;
  8. import org.springframework.context.annotation.Bean;
  9. import org.springframework.context.annotation.Configuration;
  10. import org.springframework.core.env.Environment;
  11. import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
  12. import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
  13. import org.springframework.orm.jpa.JpaTransactionManager;
  14. import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
  15. import org.springframework.transaction.PlatformTransactionManager;
  16. import org.springframework.transaction.annotation.EnableTransactionManagement;
  18. import javax.annotation.Resource;
  19. import javax.persistence.EntityManager;
  20. import javax.sql.DataSource;
  21. import java.util.HashMap;
  22. import java.util.Map;
  24. @Configuration
  25. @EnableTransactionManagement
  26. @EnableJpaRepositories(
  27.         //实体管理
  28.         entityManagerFactoryRef="entityManagerFactorySecond",
  29.         //事务管理
  30.         transactionManagerRef="transactionManagerSecond",
  31.         //实体扫描,设置Repository所在位置
  32.         basePackages= { "com.hikktn.dao.second" })
  33. public class SecondConfig {
  35.     @Autowired
  36.     @Qualifier("secondDataSource")
  37.     private DataSource secondDataSource;
  39.     @Autowired
  40.     private JpaProperties jpaProperties;
  41.     @Autowired
  42.     private HibernateProperties hibernateProperties;
  44.     private Map<String, Object> getVendorProperties() {
  45.         return hibernateProperties.determineHibernateProperties(jpaProperties.getProperties(), new HibernateSettings());
  46.     }
  48.     @Bean(name = "entityManagerSecond")
  49.     public EntityManager entityManager(EntityManagerFactoryBuilder builder) {
  50.         return entityManagerFactorySecond(builder).getObject().createEntityManager();
  51.     }
  53.     @Bean(name = "entityManagerFactorySecond")
  54.     public LocalContainerEntityManagerFactoryBean entityManagerFactorySecond (EntityManagerFactoryBuilder builder) {
  55.         return builder
  56.                 .dataSource(secondDataSource)
  57.                 .properties(getVendorProperties())
  58.                 .packages("com.hikktn.domain.second")
  59.                 .persistenceUnit("secondPersistenceUnit")
  60.                 .build();
  61.     }
  63.     @Bean(name = "transactionManagerSecond")
  64.     PlatformTransactionManager transactionManagerSecond(EntityManagerFactoryBuilder builder) {
  65.         return new JpaTransactionManager(entityManagerFactorySecond(builder).getObject());
  66.     }
  67. }

2.6 主数据库Bean

  1. package com.hikktn.domain.primary;
  3. import lombok.AllArgsConstructor;
  4. import lombok.Data;
  5. import lombok.NoArgsConstructor;
  7. import javax.persistence.*;
  8. import java.io.Serializable;
  10. @Data
  11. @Entity
  12. @NoArgsConstructor
  13. @AllArgsConstructor
  14. @Table(name = "t_user")
  15. public class UserPrimaryEntity implements Serializable {
  17.     @Id
  18.     @GeneratedValue(strategy = GenerationType.IDENTITY)
  19.     Long id;
  21.     /**
  22.      * 名称
  23.      */
  24.     String name;
  26.     /**
  27.      * 性别
  28.      */
  29.     String sex;
  30. }

2.7 副数据库Bean

  1. package com.hikktn.domain.second;
  3. import lombok.AllArgsConstructor;
  4. import lombok.Data;
  5. import lombok.NoArgsConstructor;
  7. import javax.persistence.*;
  8. import java.io.Serializable;
  10. @Data
  11. @Entity
  12. @NoArgsConstructor
  13. @AllArgsConstructor
  14. @Table(name = "t_user")
  15. public class UserSecondEntity implements Serializable {
  17.     @Id
  18.     @GeneratedValue(strategy = GenerationType.IDENTITY)
  19.     Long id;
  21.     /**
  22.      * 名称
  23.      */
  24.     String name;
  26.     /**
  27.      * 性别
  28.      */
  29.     String sex;
  30. }

2.8 DAO层

  1. package com.hikktn.dao.primary;
  3. import com.hikktn.domain.primary.UserPrimaryEntity;
  4. import org.springframework.data.jpa.repository.JpaRepository;
  5. import org.springframework.stereotype.Repository;
  7. @Repository
  8. public interface UserPrimaryRepository extends JpaRepository<UserPrimaryEntity, Long> {
  10. }
  1. package com.hikktn.dao.second;
  3. import com.hikktn.domain.second.UserSecondEntity;
  4. import org.springframework.data.jpa.repository.JpaRepository;
  5. import org.springframework.stereotype.Repository;
  7. @Repository
  8. public interface UserSecondRepository extends JpaRepository<UserSecondEntity, Long> {
  10. }

2.9 启动类

  1. package com.hikktn;
  3. import org.springframework.boot.SpringApplication;
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;
  6. @SpringBootApplication
  7. public class Application {
  9.     public static void main(String[] args) {
  10.         SpringApplication.run(Application.class, args);
  11.     }
  13. }

2.10 测试

  1. import com.hikktn.Application;
  2. import com.hikktn.dao.primary.UserPrimaryRepository;
  3. import com.hikktn.dao.second.UserSecondRepository;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.boot.test.context.SpringBootTest;
  6. import org.junit.Test;
  7. import org.junit.runner.RunWith;
  8. import org.springframework.test.context.junit4.SpringRunner;
  10. @RunWith(SpringRunner.class)
  11. @SpringBootTest(classes = Application.class)
  12. public class SpringbootJapDatasourceApplicationTests {
  14.     @Autowired
  15.     private UserPrimaryRepository userPrimaryRepository;
  16.     @Autowired
  17.     private UserSecondRepository userSecondRepository;
  19.     @Test
  20.     public void contextLoads() {
  21.         System.out.println(userPrimaryRepository.findAll());
  22.         System.out.println(userSecondRepository.findAll());
  23.     }
  25. }
  • 数据库里的数据

image.png

  • 结果
    1. Hibernate: select userprimar0_.id as id1_0_, userprimar0_.name as name2_0_, userprimar0_.sex as sex3_0_ from t_user userprimar0_
    2. [UserPrimaryEntity(id=1, name=zhansan, sex=男), UserPrimaryEntity(id=2, name=tom, sex=男)]
    3. 2021-08-31 00:48:12.156  INFO 22556 --- [           main] o.h.h.i.QueryTranslatorFactoryInitiator  : HHH000397: Using ASTQueryTranslatorFactory
    4. Hibernate: select usersecond0_.id as id1_0_, usersecond0_.name as name2_0_, usersecond0_.sex as sex3_0_ from t_user usersecond0_
    5. [UserSecondEntity(id=1, name=kitty, sex=女)]