寫在前面

本篇來學習SpringBoot如何配置多數據源，所謂多數據源就是一個JAVA EE項目中采用了不同數據庫實例中的多個庫，或者是同一個數據庫實例中的多個不同庫。一般來說，采用MyCat等分布式數據庫中間件是比較好的解決方案，這樣可以把數據庫讀寫分離、分庫分表、備份等操作交給中間件去做，這樣Java代碼只需要專注于業務即可。不過這并不意味著無法使用Java代碼解決類似的問題，在Spring Famework中就可以配置多個數據源，SpringBoot作為其中的佼佼者，自然也同樣支持多數據源的配置，只是配置方式有些變化而已。

下面就分別介紹使用Jdbc Template、Mybatis和SpringData JPA等不同持久層框架時的多數據源配置。

Jdbc Template多數據源

Jdbc Template多數據源配置是最簡單的一個，因為一個Jdbc Template就對應一個DataSource，開發者只需要提供多個DataSource，再手動配置Jdbc Template即可。具體配置如下： 第一步，創建數據庫。使用下面的SQL語句來手動創建兩個數據庫和表：

drop database if exists jdbcone;
create database jdbcone;
use jdbcone;
drop table if exists book;
create table book(
id int(11) not null auto_increment comment 'id',
name varchar(128) default null comment '名稱',
author varchar(64) default null comment '作者',
primary key(id)
)ENGINE=INNODB default charset=utf8;
insert into book(id,name,author)values(1,"西游記","吳承恩");

drop database if exists jdbctwo;
create database jdbctwo;
use jdbctwo;
drop table if exists book;
create table book(
id int(11) not null auto_increment comment 'id',
name varchar(128) default null comment '名稱',
author varchar(64) default null comment '作者',
primary key(id)
)ENGINE=INNODB default charset=utf8;
insert into book(id,name,author)values(1,"紅樓夢","曹雪芹");

執行該SQL語句后，可以看出數據庫中的信息如下所示：

第二步，創建SpringBoot項目并添加依賴。使用spring Initializr構建工具構建一個SpringBoot的Web應用，名稱為jdbcmorespringboot，然后在pom.xml文件中添加如下依賴：

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--添加jdbc依賴-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <!--添加數據庫驅動依賴-->
        <dependency>
            <groupId>MySQL</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!--添加數據庫連接池依賴-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>

請注意這里添加的數據庫連接池依賴是druid-spring-boot-starter。druid-spring-boot-starter可以幫助開發者在SpringBoot項目中輕松集成Druid數據庫連接池和監控。

第三步，配置數據庫連接。在Application.properties配置文件中配置多個數據源的信息：

# 數據源1
spring.datasource.one.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.one.url=jdbc:mysql://127.0.0.1:3306/jdbcone?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
spring.datasource.one.username=root
spring.datasource.one.password=1234
# 數據源2
spring.datasource.two.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.two.url=jdbc:mysql://127.0.0.1:3306/jdbctwo?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
spring.datasource.two.username=root
spring.datasource.two.password=1234

這里配置了兩個數據源，主要區別是數據庫不同，其他都是一樣的。 第四步，配置數據源。新建一個config包，并在里面創建一個DataSourceConfig類，用于配置數據源，這樣就可以根據application.properties文件來生成對應的DataSource。里面的代碼為：

@Configuration
public class DataSourceConfig {
    
    @Bean
    @ConfigurationProperties("spring.datasource.one")
    public DataSource dsOne(){
        return DruidDataSourceBuilder.create().build();
    }

    @Bean
    @ConfigurationProperties("spring.datasource.two")
    public DataSource dsTwo(){
        return DruidDataSourceBuilder.create().build();
    }
}

簡單解釋一下上述代碼的含義：

• 請注意DataSource是javax.sql.DataSource包內的；
• DataSourceConfig類中提供了兩個數據源：dsOne和dsTwo，默認的方法名就是實例名。
• @ConfigurationProperties注解表示使用不同前綴的配置文件來創建不同的DataSource實例。

第五步，配置Jdbc Template。前面提到過，只要開發者引入了spring-jdbc依賴，那么若開發者沒有提供Jdbc Template實例時，SpringBoot默認會提供一個Jdbc Template實例。但是現在是配置多數據源，因此這個Jdbc Template實例就需要開發者自己來提供了。在config包內新建一個JdbcTemplateConfig類，用于返回需要的Jdbc Template實例，相應的代碼為：

@Configuration
public class JdbcTemplateConfig {

    @Bean
    public JdbcTemplate jdbcTemplateOne(@Qualifier("dsOne")DataSource dataSource){
        return new JdbcTemplate(dataSource);
    }

    @Bean
    public JdbcTemplate jdbcTemplateTwo(@Qualifier("dsTwo")DataSource dataSource){
        return new JdbcTemplate(dataSource);
    }
}

簡單解釋一下上述代碼的含義：

• JdbcTemplateConfig類中提供了兩個JdbcTemplate實例，每一個JdbcTemplate實例都需要提供DataSource，由于Spring容器中有兩個DataSource實例，因此需要通過方法名來查找。@Qualifier注解表示查找不同名稱的DataSource實例，并注入進來。

第六步，創建Book實體類和BookController類。新建pojo包，并在里面創建Book實體類，里面的代碼為：

public class Book {
    private Integer id;
    private String name;
    private String author;
    //getter和setter方法
}

接著新建controller包，并在里面創建BookController類，里面的代碼為：

@RestController
public class BookController {

    @Resource(name="jdbcTemplateOne")
    JdbcTemplate jdbcTemplateOne;

    @Autowired
    @Qualifier(value="jdbcTemplateTwo")
    JdbcTemplate jdbcTemplateTwo;

    @GetMapping("/test")
    public void test(){
        String sql = "select * from book";
        List<Book> booksOne = jdbcTemplateOne.query(sql,new BeanPropertyRowMapper<>(Book.class));
        List<Book> booksTwo = jdbcTemplateTwo.query(sql,new BeanPropertyRowMapper<>(Book.class));
        System.out.println("booksOne>>>>>>"+booksOne);
        System.out.println("booksTwo>>>>>>"+booksTwo);
    }
}

簡單解釋一下上述代碼的含義：

• 注意這里沒有定義Repository和Service層，而是直接將JdbcTemplate注入到了Controller中。在Controller中注入兩個不同的JdbcTemplate有兩種方式：第一種，使用@Resource注解，并指明name屬性，然后按照name進行裝配，此時會根據實例名查找相應的實例進行注入。第二種，使用@Autowried注解并結合@Qualifier注解，其實這種效果等同于使用@Resource注解。

第七步，運行項目。運行項目，在瀏覽器地址欄中輸入http://localhost:8080/test，然后查看控制臺的輸出信息為：

booksOne>>>>>>[com.envy.jdbcmorespringboot.pojo.Book@166352ef]
booksTwo>>>>>>[com.envy.jdbcmorespringboot.pojo.Book@11ed31ef]

不方便查看，那就給Book實體類提供toString方法，之后再來運行一下：

booksOne>>>>>>[Book{id=1, name='西游記', author='吳承恩'}]
booksTwo>>>>>>[Book{id=1, name='紅樓夢', author='曹雪芹'}]

對比一下數據庫中的數據：

可以看到數據已經成功取出來了，這表明JdbcTemplate配置多數據源成功。

Mybatis多數據源

JdbcTemplate可以配置多數據源，同樣Mybatis也是可以的，只是步驟就稍微復雜一些。

第一步，創建數據庫。使用下面的SQL語句來手動創建兩個數據庫和表：

drop database if exists mybatisone;
create database mybatisone;
use mybatisone;
drop table if exists book;
create table book(
id int(11) not null auto_increment comment 'id',
name varchar(128) default null comment '名稱',
author varchar(64) default null comment '作者',
primary key(id)
)ENGINE=INNODB default charset=utf8;
insert into book(id,name,author)values(1,"西游記","吳承恩");

drop database if exists mybatistwo;
create database mybatistwo;
use mybatistwo;
drop table if exists book;
create table book(
id int(11) not null auto_increment comment 'id',
name varchar(128) default null comment '名稱',
author varchar(64) default null comment '作者',
primary key(id)
)ENGINE=INNODB default charset=utf8;
insert into book(id,name,author)values(1,"紅樓夢","曹雪芹");

執行該SQL語句后，可以看出數據庫中的信息如下所示：

第二步，創建SpringBoot項目并添加依賴。使用spring Initializr構建工具構建一個SpringBoot的Web應用，名稱為mybatismorespringboot，然后在pom.xml文件中添加如下依賴：

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--添加mybatis依賴-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.2</version>
        </dependency>
        <!--添加數據庫驅動依賴-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!--添加數據庫連接池依賴-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>

請注意這里添加的數據庫連接池依賴是druid-spring-boot-starter。druid-spring-boot-starter可以幫助開發者在SpringBoot項目中輕松集成Druid數據庫連接池和監控。

第三步，配置數據庫連接。在application.properties配置文件中配置多個數據源的信息：

# 數據源1
spring.datasource.one.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.one.url=jdbc:mysql://127.0.0.1:3306/mybatisone?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
spring.datasource.one.username=root
spring.datasource.one.password=1234
# 數據源2
spring.datasource.two.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.two.url=jdbc:mysql://127.0.0.1:3306/mybatistwo?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
spring.datasource.two.username=root
spring.datasource.two.password=1234

這里配置了兩個數據源，主要區別是數據庫不同，其他都是一樣的。

第四步，配置數據源。新建一個config包，并在里面創建一個DataSourceConfig類，用于配置數據源，這樣就可以根據application.properties文件來生成對應的DataSource。里面的代碼為：

@Configuration
public class DataSourceConfig {
    
    @Bean
    @ConfigurationProperties("spring.datasource.one")
    public DataSource dsOne(){
        return DruidDataSourceBuilder.create().build();
    }

    @Bean
    @ConfigurationProperties("spring.datasource.two")
    public DataSource dsTwo(){
        return DruidDataSourceBuilder.create().build();
    }
}

簡單解釋一下上述代碼的含義：

• 請注意DataSource是javax.sql.DataSource包內的；
• DataSourceConfig類中提供了兩個數據源：dsOne和dsTwo，默認的方法名就是實例名。
• @ConfigurationProperties注解表示使用不同前綴的配置文件來創建不同的DataSource實例。

第五步，創建Mybatis配置。在Jdbc Template多數據源的配置中這一步就是用來返回Jdbc Template，但是Mybatis中這一步是用來提供SqlSessionFactory實例和SqlSessionTemplate實例。在config包內新建兩個配置類：MybatisConfigOne和MybatisConfigTwo，分別用于返回對應數據源的SqlSessionFactory實例和SqlSessionTemplate實例。這里以MybatisConfigOne配置類中的代碼為例進行解釋說明：

@Configuration
@MapperScan(value = "com.envy.mybatismorespringboot.mapper1",sqlSessionFactoryRef = "sqlSessionFactoryBean1")
public class MybatisConfigOne {
    @Autowired
    @Qualifier("dsOne")
    DataSource dsOne;

    @Bean
    SqlSessionFactory sqlSessionFactoryBean1() throws Exception {
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setDataSource(dsOne);
        return factoryBean.getObject();
    }

    @Bean
    SqlSessionTemplate sqlSessionTemplate1() throws Exception {
        return new SqlSessionTemplate(sqlSessionFactoryBean1());
    }
}

@Configuration注解表明這個類是一個配置類，@MapperScan注解用于指名包的掃描路徑，即mapper接口所在的位置。同時使用sqlSessionFactoryRef來指定該位置下的mapper將使用SqlSessionFactory實例。然后定義了一個sqlSessionFactoryBean1方法用于返回一個SqlSessionFactory對象，在這個方法中通過factoryBean.setDataSource方法將DataSource給注入進去，請注意這里創建的SqlSessionFactory實例，其實也就是@MapperScan注解中sqlSessionFactoryRef參數指定的實例。最后提供了一個sqlSessionTemplate1方法，該方法用于返回一個SqlSessionTemplate實例，這是一個線程安全類，主要用來管理Mybatis中的SqlSession操作。

MybatisConfigTwo中的代碼與前面MybatisConfigOne中的差不多，這里僅僅附上代碼，就不做多解釋：

@Configuration
@MapperScan(value = "com.envy.mybatismorespringboot.mapper2",sqlSessionFactoryRef = "sqlSessionFactoryBean2")
public class MybatisConfigTwo {

    @Autowired
    @Qualifier("dsTwo")
    DataSource dsTwo;

    @Bean
    public SqlSessionFactory sqlSessionFactoryBean2() throws Exception {
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setDataSource(dsTwo);
        return factoryBean.getObject();
    }

    @Bean
    public SqlSessionTemplate sqlSessionTemplate2() throws Exception {
        return new SqlSessionTemplate(sqlSessionFactoryBean2());
    }
}

第六步，創建Book實體類。新建pojo包，并在里面創建Book實體類，里面的代碼為：

public class Book {
    private Integer id;
    private String name;
    private String author;
    //getter、setter和toString方法
}

第七步，創建數據庫訪問層。新建兩個mapper包：mapper1和mapper2，并在里面新建對應的mapper接口和xml文件。其中mapper1包內的BookMapper.java文件中的代碼為：

@Component
@Mapper
public interface BookMapper {
    List<Book> getAllBooks();
}

mapper1包內的BookMapper.xml文件中的代碼為：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.envy.mybatismorespringboot.mapper1.BookMapper">
    <select id="getAllBooks" resultType="com.envy.mybatismorespringboot.pojo.Book">
        select * from book
    </select>
</mapper>

便于簡化操作和演示，此處僅僅是配置了一個方法。mapper2包內的BookMapper2.java文件和BookMapper2.xml文件中的代碼與上述非常相似，這里就不粘貼了，僅僅粘貼項目的目錄結構：

第八步，配置pom.xml文件，這一步很重要。在Maven工程中，XML配置文件建議寫在resources目錄下，但是很明顯上述的BookMapper.xml文件寫在了mapper包內，且不在resources目錄下，此時運行項目肯定會拋出mapper文件找不到的異常，因為Maven運行時會忽略包內的xml文件，因此需要在pom.xml文件中重新指明資源文件的位置：

    <build>
        <!--使用mybatis時需要手動指明xml的位置-->
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
            </resource>
        </resources>
   </build>

第九步，創建Controller層。在controller包內新建BookController類，這里同樣沒有service層，因此是直接將Mapper注入到Controller中。里面的代碼為：

@RestController
public class BookController {

    @Autowired
    BookMapper bookMapper;

    @Autowired
    BookMapper2 bookMapper2;

    @GetMapping("/test")
    public void test(){
        List<Book> bookList1 = bookMapper.getAllBooks();
        List<Book> bookList2 = bookMapper2.getAllBooks();
        System.out.println("【bookList1】>>>>>>"+bookList1);
        System.out.println("【bookList2】>>>>>>"+bookList2);
    }
}

第十步，運行項目。運行項目，在瀏覽器地址欄中輸入http://localhost:8080/test，然后查看控制臺的輸出信息為：

【bookList1】>>>>>>[Book{id=1, name='西游記', author='吳承恩'}]
【bookList2】>>>>>>[Book{id=1, name='紅樓夢', author='曹雪芹'}]

對比一下數據庫中的數據：

可以看到數據已經成功取出來了，這表明Mybatis配置多數據源成功。

Spring Data JPA多數據源

JPA和Mybatis配置多數據源非常類似，只是JPA配置時主要提供LocalContainerEntityManagerFactoryBean以及事務管理器，具體的配置如下：

第一步，創建數據庫，不創建表。使用下面的SQL語句來手動創建兩個數據庫：

drop database if exists jpaone;
create database jpaone;

drop database if exists jpatwo;
create database jpatwo;

執行該SQL語句后，可以看出數據庫中已經有這兩個數據庫了。

第二步，創建SpringBoot項目并添加依賴。使用spring Initializr構建工具構建一個SpringBoot的Web應用，名稱為jpamorespringboot，然后在pom.xml文件中添加如下依賴：

      <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--添加數據庫驅動依賴-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <!--添加數據庫連接池依賴-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>
        <!--添加Spring Data JPA依賴-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
     <!--添加lombok依賴-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

請注意這里添加的數據庫連接池依賴是druid-spring-boot-starter。druid-spring-boot-starter可以幫助開發者在SpringBoot項目中輕松集成Druid數據庫連接池和監控。

第三步，配置數據庫連接。在application.properties配置文件中配置多個數據源及JPA的配置信息：

# 數據源1
spring.datasource.one.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.one.url=jdbc:mysql://127.0.0.1:3306/jpaone?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
spring.datasource.one.username=root
spring.datasource.one.password=1234

# 數據源2
spring.datasource.two.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.two.url=jdbc:mysql://127.0.0.1:3306/jpatwo?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
spring.datasource.two.username=root
spring.datasource.two.password=1234

# JPA相關配置
spring.jpa.properties.hibernate.dialect.MySQL57InnoDBDialect
spring.jpa.properties.database=mysql
spring.jpa.properties.hibernate.hbm2ddl.auto=update
spring.jpa.properties.show-sql=true

這里配置了兩個數據源，主要區別是數據庫不同，其他都是一樣的。不過需要注意的是JPA多數據源配置與單獨的JPA配置有所不同，因為后續的配置要從JpaProperties中的getProperties方法中獲取所有JPA相關的配置，因此這里的屬性前綴都是spring.jpa.properties。

第四步，配置數據源。新建一個config包，并在里面創建一個DataSourceConfig類，用于配置數據源，這樣就可以根據application.properties文件來生成對應的DataSource。里面的代碼為：

@Configuration
public class DataSourceConfig {

    @Bean
    @ConfigurationProperties("spring.datasource.one")
    @Primary
    public DataSource dsOne(){
        return DruidDataSourceBuilder.create().build();
    }

    @Bean
    @ConfigurationProperties("spring.datasource.two")
    public DataSource dsTwo(){
        return DruidDataSourceBuilder.create().build();
    }
}

不知道你是否注意到，此處在dsOne方法上添加了@Primary注解。默認的@Autowired注解是依據類型進行注入，但是此處存在多個類型相同的對象，因此必須使用@Primary注解來指定優先注入哪個。

第五步，創建Book實體類。新建pojo包，并在里面創建Book實體類，里面的代碼為：

@Entity(name = "t_user")
@Data
public class User {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;

    private String name;
    
    private String gender;
    
    private Integer age;
}

這樣后續會根據實體類在數據庫中創建t_user表，表中的id字段自增長。

第六步，創建JPA配置。接下來是核心配置，根據兩個配置好的數據源來創建兩個不同的JPA配置。在config包內，新建兩個JPA的配置類：JpaOneConfig和JpaTwoConfig，用于返回LocalContainerEntityManagerFactoryBean及事務管理器對象。下面以JpaOneConfig配置類中的代碼為例進行解釋說明：

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(basePackages = "com.envy.jpamorespringboot.dao1",entityManagerFactoryRef = "entityManagerFactoryBeanOne",transactionManagerRef = "platformTransactionManagerOne")
public class JpaOneConfig {

    @Resource(name = "dsOne")
    DataSource dsOne;

    @Autowired
    JpaProperties jpaProperties;

    @Bean
    @Primary
    LocalContainerEntityManagerFactoryBean entityManagerFactoryBeanOne(EntityManagerFactoryBuilder builder){
        return builder.dataSource(dsOne)
                .properties(jpaProperties.getProperties())
                .packages("com.envy.jpamorespringboot.pojo")
                .persistenceUnit("pu1")
                .build();
    }
    
    @Bean
    PlatformTransactionManager platformTransactionManagerOne(EntityManagerFactoryBuilder builder){
        LocalContainerEntityManagerFactoryBean factoryOne = entityManagerFactoryBeanOne(builder);
        return new JpaTransactionManager(factoryOne.getObject());
    }
}

解釋一下上述代碼的含義：

• 使用@Configuration注解來標識這是一個配置類，接著使用@EnableJpaRepositories注解來進行JPA的配置，該注解中主要配置三個屬性：basePackages、entityManagerFactoryRef和transactionManagerRef。其中basePackages屬性用于指定Repository的所在位置，entityManagerFactoryRef屬性用于指定實體類管理工廠Bean的名稱，transactionManagerRef屬性則用來指定事務管理器的引用名稱，這里的引用名稱就是JpaOneConfig類中注冊的Bean的名稱（默認的Bean名稱為方法名）。
• 然后創建entityManagerFactoryBeanOne方法，用于生成一個LocalContainerEntityManagerFactoryBean對象，而該對象用來提供EntityManager實例，在該類的創建過程中，首先配置數據源，然后設置JPA相關配置(JpaProperties由系統自動加載)，再設置實體類所在的位置，最后配置持久化單元名，若項目中只有一個EntityManagerFactory，則persistenceUnit可以省略掉，若有多個，則必須明確指定持久化單元名。
• 由于項目中會提供兩個LocalContainerEntityManagerFactoryBean實例，故需要在entityManagerFactoryBeanOne方法上添加@Primary注釋，用于告訴Spring容器時優先使用該實例。
• platformTransactionManagerOne方法用于返回一個PlatformTransactionManager對象，實際上返回的是一個JpaTransactionManager對象，它提供對單個EntityManagerFactory的事務支持，專門用于解決JPA中的事務管理。

上面是第一個JPA的配置信息，第二個JPA的配置與之相似，故這里僅僅只粘貼代碼(需要注意的是第二個JPA類中的entityManagerFactoryBeanOne方法上不能添加@Primary注解)：

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(basePackages = "com.envy.jpamorespringboot.dao2",entityManagerFactoryRef = "entityManagerFactoryBeanTwo",transactionManagerRef = "platformTransactionManagerTwo")
public class JpaTwoConfig {

    @Resource(name = "dsTwo")
    DataSource dsTwo;

    @Autowired
    JpaProperties jpaProperties;

    @Bean
    LocalContainerEntityManagerFactoryBean entityManagerFactoryBeanTwo(EntityManagerFactoryBuilder builder){
        return builder.dataSource(dsTwo)
                .properties(jpaProperties.getProperties())
                .packages("com.envy.jpamorespringboot.pojo")
                .persistenceUnit("pu2")
                .build();
    }

    @Bean
    PlatformTransactionManager platformTransactionManagerTwo(EntityManagerFactoryBuilder builder){
        LocalContainerEntityManagerFactoryBean factoryOne = entityManagerFactoryBeanTwo(builder);
        return new JpaTransactionManager(factoryOne.getObject());
    }
}

第七步，創建Repository。新建dao1和dao2包，并分別在其中新建UserDao和UserDao2接口文件。其中UserDao.java中的代碼為：

package com.envy.jpamorespringboot.dao1;

import com.envy.jpamorespringboot.pojo.User;
import org.springframework.data.jpa.repository.JpaRepository;

public interface UserDao extends JpaRepository<User,Integer> {
}

其中UserDao2.java中的代碼為：

package com.envy.jpamorespringboot.dao2;

import com.envy.jpamorespringboot.pojo.User;
import org.springframework.data.jpa.repository.JpaRepository;

public interface UserDao2 extends JpaRepository<User,Integer> {
}

其中UserDao和UserDao2分別用于操作不同的數據源。這里粘貼一下此時的目錄結構：

第八步，創建Controller。便于演示和簡便，這里就省略Service層，將UserDao直接注入Controller層。新建controller包，并在里面新建UserController.java文件，里面的代碼為：

@RestController
public class UserController {

    @Autowired
    private UserDao userDao;

    @Autowired
    private UserDao2 userDao2;

    @GetMapping("/test")
    public void test(){
        User user1 = new User();
        user1.setName("小明");
        user1.setAge(20);
        user1.setGender("男");
        userDao.save(user1);

        User user2 = new User();
        user2.setName("小美");
        user2.setAge(18);
        user2.setGender("女");
        userDao2.save(user2);
    }
}

第九步，運行項目。運行項目，在瀏覽器地址欄中輸入http://localhost:8080/test，然后查看數據庫是否已經有了這兩條記錄：

總結

本篇學習了如何在SpringBoot中整合Jdbc Template、Mybatis和Spring Data JPA的多數據源配置，其中Jdbc Template用的不是很多，基本上不會使用了；而Mybatis由于其靈活性較好，能進行SQL優化，因此如果開發者需要考慮SQL的性能，建議選用這個。Spring Data JPA使用起來較為方便，幾乎不需要書寫SQL語句，特別適合快速開發一個RESTful風格的應用，這一點在實際工作中深有體會。