原文出自:http://blog.csdn.net/anxpp/article/details/52274120,转载请注明出处,谢谢!

123

    在以前的常规项目中,直接XML配置文件中配置多个数据源即可,在最新推荐的做法中,我们使用配置类来设置。

 

首先配置两个数据源:

[java] view plain copy
 
 print?在CODE上查看代码片派生到我的代码片
  1. package com.anxpp.web.config;  
  2.   
  3. import javax.sql.DataSource;  
  4.   
  5. import org.springframework.beans.factory.annotation.Qualifier;  
  6. import org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder;  
  7. import org.springframework.boot.context.properties.ConfigurationProperties;  
  8. import org.springframework.context.annotation.Bean;  
  9. import org.springframework.context.annotation.Configuration;  
  10. import org.springframework.context.annotation.Primary;  
  11.   
  12. @Configuration  
  13. public class DataSourceConfig {  
  14.   
  15.     @Bean(name = "primaryDS")  
  16.     @Qualifier("primaryDS")  
  17.     @Primary  
  18.     @ConfigurationProperties(prefix="spring.primary.datasource")  
  19.     public DataSource primaryDataSource(){  
  20.         return DataSourceBuilder.create().build();  
  21.     }  
  22.   
  23.     @Bean(name = "secondaryDS")  
  24.     @Qualifier("secondaryDS")  
  25.     @ConfigurationProperties(prefix="spring.secondary.datasource")  
  26.     public DataSource secondaryDataSource(){  
  27.         return DataSourceBuilder.create().build();  
  28.     }  
  29.   
  30. }  

 

    @Primary 的意思是默认实现。

然后分别配置两个数据源的详细信息。

    配置一:

[java] view plain copy
 
 print?在CODE上查看代码片派生到我的代码片
  1. package com.anxpp.web.config;  
  2.   
  3. import java.util.Map;  
  4.   
  5. import javax.persistence.EntityManager;  
  6. import javax.sql.DataSource;  
  7.   
  8. import org.springframework.beans.factory.annotation.Autowired;  
  9. import org.springframework.beans.factory.annotation.Qualifier;  
  10. import org.springframework.boot.autoconfigure.orm.jpa.JpaProperties;  
  11. import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;  
  12. import org.springframework.context.annotation.Bean;  
  13. import org.springframework.context.annotation.Configuration;  
  14. import org.springframework.context.annotation.Primary;  
  15. import org.springframework.data.jpa.repository.config.EnableJpaRepositories;  
  16. import org.springframework.orm.jpa.JpaTransactionManager;  
  17. import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;  
  18. import org.springframework.transaction.PlatformTransactionManager;  
  19. import org.springframework.transaction.annotation.EnableTransactionManagement;  
  20. /** 
  21.  * 开发环境数据库数据源配置 
  22.  * @author  
  23.  * 
  24.  */  
  25. @Configuration  
  26. @EnableTransactionManagement  
  27. @EnableJpaRepositories(  
  28.         entityManagerFactoryRef="entityManagerFactoryPrimary",  
  29.         transactionManagerRef="transactionManagerPrimary",  
  30.         basePackages= { "com.anxpp.web.core.repo.work" })//设置dao(repo)所在位置  
  31. public class RepositoryPrimaryConfig {  
  32.       
  33.     @Autowired  
  34.     private JpaProperties jpaProperties;  
  35.   
  36.     @Autowired  
  37.     @Qualifier("primaryDS")  
  38.     private DataSource primaryDS;  
  39.   
  40.     @Bean(name = "entityManagerPrimary")  
  41.     @Primary  
  42.     public EntityManager entityManager(EntityManagerFactoryBuilder builder) {  
  43.         return entityManagerFactoryPrimary(builder).getObject().createEntityManager();  
  44.     }  
  45.   
  46.     @Bean(name = "entityManagerFactoryPrimary")  
  47.     @Primary  
  48.     public LocalContainerEntityManagerFactoryBean entityManagerFactoryPrimary (EntityManagerFactoryBuilder builder) {  
  49.         return builder  
  50.                 .dataSource(primaryDS)  
  51.                 .properties(getVendorProperties(primaryDS))  
  52.                 .packages("com.anxpp.web.core.entity.po"//设置实体类所在位置  
  53.                 .persistenceUnit("primaryPersistenceUnit")  
  54.                 .build();  
  55.     }  
  56.   
  57.     private Map<String, String> getVendorProperties(DataSource dataSource) {  
  58.         return jpaProperties.getHibernateProperties(dataSource);  
  59.     }  
  60.   
  61.     @Bean(name = "transactionManagerPrimary")  
  62.     @Primary  
  63.     PlatformTransactionManager transactionManagerPrimary(EntityManagerFactoryBuilder builder) {  
  64.         return new JpaTransactionManager(entityManagerFactoryPrimary(builder).getObject());  
  65.     }  
  66.   
  67. }  

    配置二:

[java] view plain copy
 
 print?在CODE上查看代码片派生到我的代码片
  1. package com.anxpp.web.config;  
  2. import java.util.Map;  
  3.   
  4. import javax.persistence.EntityManager;  
  5. import javax.sql.DataSource;  
  6.   
  7. import org.springframework.beans.factory.annotation.Autowired;  
  8. import org.springframework.beans.factory.annotation.Qualifier;  
  9. import org.springframework.boot.autoconfigure.orm.jpa.JpaProperties;  
  10. import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;  
  11. import org.springframework.context.annotation.Bean;  
  12. import org.springframework.context.annotation.Configuration;  
  13. import org.springframework.data.jpa.repository.config.EnableJpaRepositories;  
  14. import org.springframework.orm.jpa.JpaTransactionManager;  
  15. import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;  
  16. import org.springframework.transaction.PlatformTransactionManager;  
  17. import org.springframework.transaction.annotation.EnableTransactionManagement;  
  18.   
  19. @Configuration  
  20. @EnableTransactionManagement  
  21. @EnableJpaRepositories(  
  22.         entityManagerFactoryRef="entityManagerFactorySecondary",  
  23.         transactionManagerRef="transactionManagerSecondary",  
  24.         basePackages= { "com.anxpp.web.core.repo.dev" })  
  25. public class RepositorySecondaryConfig {  
  26.     @Autowired  
  27.     private JpaProperties jpaProperties;  
  28.   
  29.     @Autowired @Qualifier("secondaryDS")  
  30.     private DataSource secondaryDS;  
  31.   
  32.     @Bean(name = "entityManagerSecondary")  
  33.     public EntityManager entityManager(EntityManagerFactoryBuilder builder) {  
  34.         return entityManagerFactorySecondary(builder).getObject().createEntityManager();  
  35.     }  
  36.   
  37.     @Bean(name = "entityManagerFactorySecondary")  
  38.     public LocalContainerEntityManagerFactoryBean entityManagerFactorySecondary (EntityManagerFactoryBuilder builder) {  
  39.         return builder  
  40.                 .dataSource(secondaryDS)  
  41.                 .properties(getVendorProperties(secondaryDS))  
  42.                 .packages("com.anxpp.web.core.entity.po")  
  43.                 .persistenceUnit("secondaryPersistenceUnit")  
  44.                 .build();  
  45.     }  
  46.   
  47.     private Map<String, String> getVendorProperties(DataSource dataSource) {  
  48.         return jpaProperties.getHibernateProperties(dataSource);  
  49.     }  
  50.   
  51.     @Bean(name = "transactionManagerSecondary")  
  52.     PlatformTransactionManager transactionManagerSecondary(EntityManagerFactoryBuilder builder) {  
  53.         return new JpaTransactionManager(entityManagerFactorySecondary(builder).getObject());  
  54.     }  
  55.   
  56. }  

    上文中 com.anxpp.web.core.repo.dev 表示数据访问接口的包,其中的repo访问数据库时,会自动使用RepositorySecondaryConfig。

 

    实体也类似。

 

数据库连接配置:

[plain] view plain copy
 
 print?在CODE上查看代码片派生到我的代码片
  1. #Work  
  2. spring.primary.datasource.url=jdbc:oracle:thin:@//ip:port/dbname  
  3. spring.primary.datasource.username=username  
  4. spring.primary.datasource.password=password  
  5. spring.primary.datasource.driver-class-name=oracle.jdbc.driver.OracleDriver  
  6. #Development  
  7. spring.secondary.datasource.url=jdbc:oracle:thin:@//ip:port/dbname  
  8. spring.secondary.datasource.username=username  
  9. spring.secondary.datasource.password=username  
  10. spring.secondary.datasource.driver-class-name=oracle.jdbc.driver.OracleDriver  
  11. #multiple Setting  
  12. spring.jpa.hibernate.ddl-auto=update  
  13. spring.jpa.show-sql=true  

    然后就可以直接使用了。

 

 

配置完成

    当然,也可以配置更多数据源。

    本人需要这种需求是因为两个数据库,需要一些细粒度的数据对比同步,在Java代码中更容易操作,所以就使用两个数据源的Java代码来完成了。