springboot+jpa多数据源配置实例

springboot+jpa配置多数据源一直都在听说，没有实际动手演练，今天动手一试，发现有一些麻烦，麻烦的地方在于，需要严格区分多种数据源带来的变化，实体需要区分，dao层需要区分，service一般来说是事务控制的入口，既然底层数据来源都不同，service层也是需要严格区分的，所以说controller,service,dao三层架构的系统来说，就需要改变service,dao相关的数据库配置。只有controller可以勉强避免修改。

这里所说的多数据源可以是同一个类型的数据库的两个实例，也可以是不同数据库的两个实例，这里以mysql和postgresql两个数据库为例，来介绍如何做多数据源配置。以及多数据源配置可能带来的问题。

构建maven工程的时候，除了springboot基础依赖，就是spring-boot-starter-data-jpa，以及mysql,postgresql驱动。

<parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-parent</artifactId>
  <version>2.0.4.RELEASE</version>
  <relativePath/>
</parent>

<dependencies>
<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <scope>test</scope>
</dependency>
<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>
</dependency>
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
   <groupId>mysql</groupId>
   <artifactId>mysql-connector-java</artifactId>
</dependency>
<dependency>
   <groupId>org.postgresql</groupId>
   <artifactId>postgresql</artifactId>
</dependency>
<dependency>
   <groupId>org.projectlombok</groupId>
   <artifactId>lombok</artifactId>
   <scope>provided</scope>
</dependency>
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-configuration-processor</artifactId>
	<optional>true</optional>
</dependency>
</dependencies>
<build>
  <plugins>
	 <plugin>
		 <groupId>org.springframework.boot</groupId>
		 <artifactId>spring-boot-maven-plugin</artifactId>
		 <configuration>
			<fork>true</fork>
			<addResources>true</addResources>
		 </configuration>
	 </plugin>
  </plugins>
</build>

我们在前面说了从service到dao，再到实体类，既然数据库来源不同，他们在创建的时候就要考虑做区分。使用jpa做数据持久化，我们需要实体管理器EntityManager，而EntityManager需要实体管理器工厂类EntityManagerFactory，而实体管理器工厂类EntityManagerFactory需要数据源DataSource，另外要做事务管理，需要JpaTransactionManager，它也需要数据源，整个配置还是我们在做xml配置的思路一样。 

这里我们将mysql配置作为默认数据源primaryDataSource，另外一个数据源我们称之为otherDataSource，使用properties配置文件，这样配置更容易理解，占用篇幅也少,application.properties内容如下：

spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/test?useSSL=false&characterEncoding=UTF-8&useUnicode=true
spring.datasource.username=root
spring.datasource.password=root
#other
spring.datasource.other.driver-class-name=org.postgresql.Driver
spring.datasource.other.url=jdbc:postgresql://localhost:5432/mydb
spring.datasource.other.username=postgres
spring.datasource.other.password=
spring.jpa.hibernate.ddl-auto=update
#spring.jpa.open-in-view=true
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.format_sql=true
spring.jpa.properties.hibernate.max_fetch_depth=1
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL57Dialect
spring.jpa.properties.hibernate.hbm2ddl=update
#spring.jpa.properties.hibernate.enable_lazy_load_no_trans=true
spring.jpa.properties.hibernate.temp.use_jdbc_metadata_defaults=false
spring.jackson.serialization.fail-on-empty-beans=false

 数据源配置类：

package com.xxx.springboot.config;
import javax.sql.DataSource;
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;
@Configuration
public class DataSourceConfig {
	@Bean(name="dataSource")
	@Primary
	@ConfigurationProperties(prefix="spring.datasource")
	public DataSource dataSource(){
		//return DataSourceBuilder.create().build();
		return dataSourceProperties().initializeDataSourceBuilder().build();
	}
	
	@Primary
	@Bean(name="dataSourceProperties")
	@ConfigurationProperties(prefix="spring.datasource")
	public DataSourceProperties dataSourceProperties(){
		return new DataSourceProperties();
	}
	
	
	@Bean(name="otherDataSource")
	@ConfigurationProperties(prefix="spring.datasource.other")
	public DataSource otherDataSource(){
		//return DataSourceBuilder.create().build();
		return otherDataSourceProperties().initializeDataSourceBuilder().build();
	}
	
	
	@Bean(name="otherDataSourceProperties")
	@ConfigurationProperties(prefix="spring.datasource.other")
	public DataSourceProperties otherDataSourceProperties(){
		return new DataSourceProperties();
	}
	
}

因为application.properties中指定数据源url使用的属性是url，而不是jdbc-url，因此，这里的数据源配置类，我们没有使用默认的方式创建：

DataSourceBuilder.create().build()

而使用的是：

new DataSourceProperties().initializeDataSourceBuilder().build()

如果不是这么来做，会报错：jdbcUrl is required with driverClassName

我们还需要配置各自的EntityManager,PlatformTransactionManager：

mysql数据源对应的相关配置：

package com.xxx.springboot.config;
import java.util.HashMap;
import java.util.Map;
import javax.persistence.EntityManager;
import javax.sql.DataSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
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;

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
		entityManagerFactoryRef="entityManagerFactoryPrimary",
		transactionManagerRef="transactionManagerPrimary",
		basePackages={"com.xxx.springboot.dao.mysql"})
public class PrimaryDataSourceConfig {
	@Autowired
	@Qualifier("dataSource")
	private DataSource dataSource;
	
	@Autowired
	private JpaProperties jpaProperties;
	
	@Primary
	@Bean(name="entityManagerPrimary")
	public EntityManager entityManager(EntityManagerFactoryBuilder builder){
		return entityManagerFactoryBean(builder).getObject().createEntityManager();
	}
	
	@Primary
	@Bean(name="entityManagerFactoryPrimary")
	public LocalContainerEntityManagerFactoryBean entityManagerFactoryBean(EntityManagerFactoryBuilder builder){
		return builder
				.dataSource(dataSource)
				.properties(getProperties())
				.packages("com.xxx.springboot.domain.mysql")
				.persistenceUnit("primaryPersistentUnit")
				.build();
	}
	
	public Map<String, String> getProperties(){
		Map<String, String> map = new HashMap<String, String>();
		map.put("format_sql", "true");
		map.put("max_fetch_depth", "1");
		return map;
	}
	
	
	@Primary
	@Bean(name="transactionManagerPrimary")
	public PlatformTransactionManager transactionManager(EntityManagerFactoryBuilder builder){
		return new JpaTransactionManager(entityManagerFactoryBean(builder).getObject());
	}
}

postgresql数据源对应的相关配置： 

package com.xxx.springboot.config;
import java.util.HashMap;
import java.util.Map;

import javax.persistence.EntityManager;
import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
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.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;
@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
		entityManagerFactoryRef="entityManagerFactoryOther",
		transactionManagerRef="transactionManagerOther",
	    basePackages={"com.xxx.springboot.dao.postgresql"})
public class OtherDataSourceConfig {

	@Autowired
	@Qualifier("otherDataSource")
	private DataSource otherDataSource;
	
	@Autowired
	private JpaProperties jpaProperties;
	
	@Bean(name="entityManagerOther")
	public EntityManager entityManager(EntityManagerFactoryBuilder builder){
		return entityManagerFactoryBean(builder).getObject().createEntityManager();
	}
	
	@Bean(name="entityManagerFactoryOther")
	public LocalContainerEntityManagerFactoryBean entityManagerFactoryBean(EntityManagerFactoryBuilder builder){
		return builder
				.dataSource(otherDataSource)
				.properties(getProperties())
				.packages("com.xxx.springboot.domain.postgresql")
				.persistenceUnit("otherPersistentUnit")
				.build();
	}
	
	public Map<String, String> getProperties(){
		Map<String, String> map = new HashMap<String, String>();
		map.put("format_sql", "true");
		map.put("max_fetch_depth", "1");
		//map.put("dialect", "org.hibernate.dialect.PostgreSQL9Dialect");
		return map;
	}
	
	@Bean(name="transactionManagerOther")
	public PlatformTransactionManager transactionManager(EntityManagerFactoryBuilder builder){
		return new JpaTransactionManager(entityManagerFactoryBean(builder).getObject());
	}
}

两个配置类，除了注解不一样之外，代码几乎一样，这就是多数据源配置显得有意思的地方，其实一点也不冗余，否则，就无法彻底分离两个数据源。配置类中，通过配置属性prefix前缀来获取对应的数据源信息。另外，这里有个主配置，默认我们使用的是mysql数据库，因此在mysql相关的配置如：DataSource,EntityManager,EntityManagerFactory,TransactionManager配置上除了@Bean(name="")和@Qualifer()来指定他们的区别之外，还有一个@Primary注解，表示主配置。

 配置中我们还通过basePackages属性指定了Repository的位置，也就是dao层接口的位置，还通过packages属性指定了各自实体类的位置。这样，数据源配置清楚了，剩下就是各自数据源对应的实体和dao,service编码了。

dao层很简单，就是一个接口，然后继承JpaRepository<Entity,ID>就可以了。service层就是调用dao层的方法。为了解决hibernate懒加载的问题，我们需要在service层接口上注入@Transaction注解。如果不加注解，可以在配置文件中加入配置：

#spring.jpa.properties.hibernate.enable_lazy_load_no_trans=true

关于懒加载的问题，还想再说一下，报错一般是这样的：LazyInitializationException:could not initialize proxy [com.xxx....] - no session，原因是，我们在通过dao.getOne()这样的请求，他是返回一个代理，并不是直接查询的数据库，当真正需要使用数据的时候，才会去数据库查询，而这时候，session已经关闭。这个问题很奇怪，如果我们使用的是dao.findById(id)却不会遇到这样的懒加载异常问题，因为它直接取查了数据库，所以底层原因是懒加载导致的。解决问题的办法有以下几种方案：

1、取消懒加载，这个在实体中通过注解@Proxy(lazy=false)来实现。

2、既然session已经关闭，那么我们让session在使用期间一直开启。这就回到了openSessionInView的解决办法了，这种办法在单元测试service方法的时候却不生效，不知道为什么。无论我们配置spring.jpa.open-in-view=true还是在启动类中增加如下代码：

@Bean
public OpenEntityManagerInViewFilter openEntityManagerInViewFilter(){
	return new OpenEntityManagerInViewFilter();
}

有人说通过这种办法能够解决，但是对于dao.getOne(id)这个方法来说是不生效的。 

3、 这里涉及到两个事务，为了解决这个问题，可以让调用getOne(id)的方法在一个事务中，因此我们可以在调用get(id)->getOne(id)的方法体上加上事务@Transaction，也可以解决问题，尤其是在单元测试的时候，我们可以这么来做：

@Test
@Transactional
public void query(){
	User user  = userService.get(14);
	System.out.println(user);
}

但是这毕竟是单元测试，实际中，调用service层方法的是controller层，我们不可能将事务加载controller层上面。实际上，在真正启动项目进行测试的时候发现，即使controller层不加事务注解，我们访问controller对应的接口，也是没有任何问题的，不会出现懒加载异常，这个一直是我不太理解的地方。

 4、这个是一个终极解决办法，就是统一配置hibernate的属性，让系统所有的请求不执行懒加载，而不用在每个实体上通过@Proxy(lazy=false)来注解解决。这个属性就是spring.jpa.properties.hibernate.enable_lazy_load_no_trans=true。在多数据源配置的时候，这个配置我们配置在默认配置文件中application.properties中，只会对主数据源生效，而其他数据源不会生效，我们需要在对数据源进行单独配置。这就是我们数据源配置的部分：

@Bean(name="entityManagerFactoryOther")
public LocalContainerEntityManagerFactoryBean 
entityManagerFactoryBean(EntityManagerFactoryBuilder builder){
	return builder
			.dataSource(otherDataSource)
			.properties(getProperties())
			.packages("com.xxx.springboot.domain.postgresql")
			.persistenceUnit("otherPersistentUnit")
			.build();
}

public Map<String, String> getProperties(){
	Map<String, String> map = new HashMap<String, String>();
	map.put("hibernate.dialect", "org.hibernate.dialect.PostgreSQL9Dialect");
	map.put("hibernate.enable_lazy_load_no_trans", "true");
	return map;
}