SpringBoot中多数据源的配置与使用

在实际项目开发中，我们可能会遇到，想要不改变当前数据库结构的情况下，调用另外一个数据库，这个时候我们就需要用到多数据源了（在文章的底部有本案例有详细的代码提供下载（SpringBoot多数据源案例）），接下来开始具体实现过程的讲解。

1、首先创建一个springBoot的项目。如图：

2、在pom.xml中配置相关的JAR包

1. <project xmlns="http://maven.apache.org/POM/4.0.0"
2.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3.     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
4.     <modelVersion>4.0.0</modelVersion>
5.     <groupId>dsjy</groupId>
6.     <artifactId>dsjy</artifactId>
7.     <version>0.0.1-SNAPSHOT</version>
8.     <parent>
9.         <groupId>org.springframework.boot</groupId>
10.         <artifactId>spring-boot-starter-parent</artifactId>
11.         <version>2.0.0.RELEASE</version>
12.         <relativePath /> <!-- lookup parent from repository -->
13.     </parent>
14.     <properties>
15.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
16.         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
17.         <java.version>1.8</java.version>
18.     </properties>
19.     <dependencies>
20.         <dependency>
21.             <groupId>org.springframework.boot</groupId>
22.             <artifactId>spring-boot-starter-web</artifactId>
23.         </dependency>
24.         <!--freemarker支持 -->
25.         <dependency>
26.             <groupId>org.springframework.boot</groupId>
27.             <artifactId>spring-boot-starter-freemarker</artifactId>
28.         </dependency>
29.         <!-- mysql驱动 -->
30.         <dependency>
31.             <groupId>mysql</groupId>
32.             <artifactId>mysql-connector-java</artifactId>
33.         </dependency>
34.         <!--整合mybatis -->
35.         <dependency>
36.             <groupId>org.mybatis.spring.boot</groupId>
37.             <artifactId>mybatis-spring-boot-starter</artifactId>
38.             <version>1.1.1</version>
39.         </dependency>
40.     </dependencies>
41. </project>

3、在resource包中创建application.properties文件，并且在文件中配置相应的数据库

1. ## test1 database
2. spring.datasource.test1.jdbc-url=jdbc:mysql://localhost:3306/mybatisstudy?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC&useSSL=false
3. spring.datasource.test1.username=root
4. spring.datasource.test1.password=3edcVFR$
5. spring.datasource.test1.driverClassName=com.mysql.jdbc.Driver
6. ## test2 database
7. spring.datasource.test2.jdbc-url=jdbc:mysql://localhost:3306/mybatisstudy2?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC&useSSL=false
8. spring.datasource.test2.username=root
9. spring.datasource.test2.password=3edcVFR$
10. spring.datasource.test2.driverClassName=com.mysql.jdbc.Driver

4、做完基本配置以后，接下来就需要配置每个数据源的加载类，创建config的数据包，创建test1数据源的加载类，代码如下：

1. package com.dsjy.Config;
2. import javax.sql.DataSource;
3. import org.apache.ibatis.session.SqlSessionFactory;
4. import org.mybatis.spring.SqlSessionFactoryBean;
5. import org.mybatis.spring.SqlSessionTemplate;
6. import org.mybatis.spring.annotation.MapperScan;
7. import org.springframework.beans.factory.annotation.Qualifier;
8. import org.springframework.boot.context.properties.ConfigurationProperties;
9. import org.springframework.boot.jdbc.DataSourceBuilder;
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.jdbc.datasource.DataSourceTransactionManager;
14. //这里配置mapper所在的包
15. @Configuration
16. //配置数据源  basePackages指扫描的mapper目录
17. @MapperScan(basePackages="com.dsjy.test1",sqlSessionFactoryRef="test1SqlSessionFactory")
18. public class DataSourceConfig1 {
19.     @Bean(name="test1DataSource")
20.     @ConfigurationProperties(prefix="spring.datasource.test1")
21.     @Primary   //将数据库作为主数据库
22.     public DataSource testDataSource()
23.     {
24.         return DataSourceBuilder.create().build();
25.     }
26.     @Bean(name="test1SqlSessionFactory")
27.     @Primary
28.     public SqlSessionFactory testSqlSessionFactory
29.     (@Qualifier("test1DataSource") DataSource dataSource) throws Exception
30.     {
31.         SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
32.         bean.setDataSource(dataSource);
33.         //读取mybatis小配置文件
34.         // bean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mybatis/mapper/test1/*.xml"));
35.         return bean.getObject();
36.     }
37.     @Bean(name="test1TransactionManager")
38.     @Primary
39.     public DataSourceTransactionManager testTransactionManager
40.     (@Qualifier("test1DataSource") DataSource dataSource)
41.     {
42.         return new DataSourceTransactionManager(dataSource);
43.     }
44.     @Bean(name="test1SqlSessionTemplate")
45.     @Primary
46.     public SqlSessionTemplate testSqlSessionTemplate
47.     (@Qualifier("test1SqlSessionFactory") SqlSessionFactory sqlSessionFactory)
48.     {
49.         return new SqlSessionTemplate(sqlSessionFactory);
50.     }
51. }

注：MapperScan使用来扫描对应文件夹下的Mapper，Primary默认将该数据库作为主数据库

test1数据源加载类创建好以后，接下来需要创建test2数据源的加载类，我们可以直接复制test1数据源的加载类，然后修改相应的参数即可，代码如下：

1. package com.dsjy.Config;
2. import javax.sql.DataSource;
3. import org.apache.ibatis.session.SqlSessionFactory;
4. import org.mybatis.spring.SqlSessionFactoryBean;
5. import org.mybatis.spring.SqlSessionTemplate;
6. import org.mybatis.spring.annotation.MapperScan;
7. import org.springframework.beans.factory.annotation.Qualifier;
8. import org.springframework.boot.context.properties.ConfigurationProperties;
9. import org.springframework.boot.jdbc.DataSourceBuilder;
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.jdbc.datasource.DataSourceTransactionManager;
14. //这里配置mapper所在的包
15. @Configuration
16. //配置数据源  basePackages指扫描的mapper目录
17. @MapperScan(basePackages="com.dsjy.test2",sqlSessionFactoryRef="test2SqlSessionFactory")
18. public class DataSourceConfig2 {
19.     @Bean(name="test2DataSource")
20.     @ConfigurationProperties(prefix="spring.datasource.test2")
21.     public DataSource testDataSource()
22.     {
23.         return DataSourceBuilder.create().build();
24.     }
25.     @Bean(name="test2SqlSessionFactory")
26.     public SqlSessionFactory testSqlSessionFactory
27.     (@Qualifier("test2DataSource") DataSource dataSource) throws Exception
28.     {
29.         SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
30.         bean.setDataSource(dataSource);
31.         //读取mybatis小配置文件
32.         // bean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mybatis/mapper/test1/*.xml"));
33.         return bean.getObject();
34.     }
35.     @Bean(name="test2TransactionManager")
36.     public DataSourceTransactionManager testTransactionManager
37.     (@Qualifier("test2DataSource") DataSource dataSource)
38.     {
39.         return new DataSourceTransactionManager(dataSource);
40.     }
41.     @Bean(name="test2SqlSessionTemplate")
42.     public SqlSessionTemplate testSqlSessionTemplate
43.     (@Qualifier("test2SqlSessionFactory") SqlSessionFactory sqlSessionFactory)
44.     {
45.         return new SqlSessionTemplate(sqlSessionFactory);
46.     }
47. }
     

注：此加载类中需要去掉primary

5、创建表的数据模型，首先创建一个包名称为entity，然后创建User的模型类（此类可以根据数据库的数据模型来创建，在此就不再贴代码了）

6、创建test1和test2的包，分别将数据源1的mapper和数据源2的mapper创建在对应的包中，代码如下：

1. package com.dsjy.test1.dao;
2. import java.util.List;
3. import org.apache.ibatis.annotations.Delete;
4. import org.apache.ibatis.annotations.Insert;
5. import org.apache.ibatis.annotations.Mapper;
6. import org.apache.ibatis.annotations.Param;
7. import org.apache.ibatis.annotations.Select;
8. import org.apache.ibatis.annotations.Update;
9. import com.dsjy.entity.User;
10. @Mapper
11. public interface UserMapper1 {
12.     @Select("select * from mybatis_user where id=${id}")
13.     public User getUserById(@Param("id") Integer id);
14.     
15.     @Insert("insert into mybatis_user(userName)values(#{userName})")
16.     public void insertData(@Param("userName") String userName);
17.     
18.     @Select("select * from mybatis_user")
19.     public List<User> getUser();
20.     
21.     @Delete("delete from mybatis_user where ${id}")
22.     public void delUser(@Param("id") Integer id);
23.     
24.     @Update("update mybatis_user set userName=#{userName} where id=${id}")
25.     public void updUserById(@Param("userName") String userName,@Param("id") Integer id);
26. }
     

注：数据源2的mapper的代码和数据源2的代码一样，这里就不再贴具体的代码，如果对 mybatis不太了解的朋友可以参考的我的另外一条博客springBoot中mybatis的使用，在这条博客中有对mybatis的具体讲解。

7、mapper创建完成以后，多数据源的配置就完成了，然后我们就可以创建一个对应的controller来测试一下效果，创建controller的包，然后在包中创建一个UserController的类，代码如下：

1. package com.dsjy.Controller;
2. import org.springframework.beans.factory.annotation.Autowired;
3. import org.springframework.web.bind.annotation.RequestMapping;
4. import org.springframework.web.bind.annotation.RestController;
5. import com.dsjy.test1.dao.UserMapper1;
6. import com.dsjy.test2.dao.UserMapper2;
7. @RestController
8. public class UserController {
9.     @Autowired
10.     private UserMapper1 userMapper1;
11.     @Autowired
12.     private UserMapper2 userMapper2;
13.     @RequestMapping("/insertUser1")
14.     public String insertUser1(String userName)
15.     {
16.         userMapper1.insertData(userName);
17.         return "success";
18.     }
19.     @RequestMapping("/getUser1")
20.     public Object getUser1(int id)
21.     {
22.         return userMapper1.getUserById(id);
23.     }
24.     @RequestMapping("/getAllUser1")
25.     public Object getAllUser1()
26.     {
27.         return userMapper1.getUser();
28.     }
29.     
30.     
31.     @RequestMapping("/insertUser2")
32.     public String insertUser2(String userName)
33.     {
34.         userMapper2.insertData(userName);
35.         return "success";
36.     }
37.     @RequestMapping("/getUser2")
38.     public Object getUser2(int id)
39.     {
40.         return userMapper2.getUserById(id);
41.     }
42.     @RequestMapping("/getAllUser2")
43.     public Object getAllUser2()
44.     {
45.         return userMapper2.getUser();
46.     }
47. }
     

8、最后创建springBoot的启动类，类名Application，代码如下：

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

最后启动项目，调用相应的接口就可以看到效果了。

SpringBoot多数据源案例        https://download.youkuaiyun.com/download/feritylamb/11390922