spring boot 整合JPA多数据源

　　上个文章介绍了spring boot在使用Mybatis持久化技术的时候如何使用多数据源，今天再补充一个使用spring data jpa实现多数据源的使用情况，JPA是一套数据库持久化规范，或者称之为一套接口，可以类比于Java中的接口，既然有接口就有实现，Hibernate就是其中的一个实现。
　　本例为查询两个数据库test1和test2中的用户信息，可以共用一个实体类，当然如果有需要也可以操作不同的实体类。

　　1.项目的整体结构如下：

　　2.pom文件说明

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
            <version>5.1.27</version>
    </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

　　pom文件中主要是需要锁定数据库驱动的版本，因为要使用多数据源，所以需要导入druid，因为后面要使用DruidDataSourceBuilder来初始化数据源。而spring-boot默认使用的HikariCP是不支持的。

　　3.项目配置文件

spring.datasource.one.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.one.url=jdbc:mysql://localhost:3306/test1
spring.datasource.one.username=root
spring.datasource.one.password=123456

spring.datasource.two.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.two.url=jdbc:mysql://localhost:3306/test2
spring.datasource.two.username=root
spring.datasource.two.password=123456


spring.jpa.properties.hibernate.ddl-auto=update  //每次启动项目如果发现实体类类更新则对应着更新表结构
spring.jpa.properties.show-sql=true                //在控制台打印sql语句
spring.jpa.properties.database=mysql    
spring.jpa.properties.database-platform=mysql
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL57Dialect

　　注意两个数据库的配置信息的前缀不一样，后面将根据配置信息的前缀对数据源进行初始化，还有就是关于JPA的属性配置都需要在spring.jpa后面增加properties关键字，为什么这样做呢？是因为后面配置JPA的时候
不仅需要数据源还需要JpaProperties对象，看一下JpaProperties类:

    @ConfigurationProperties(prefix = "spring.jpa")
public class JpaProperties {

    /**
     * Additional native properties to set on the JPA provider.
     */
    private Map<String, String> properties = new HashMap<>();

　　我们自己定义的属性存到名为properties的HashMap中，再加上类的前缀为spring.jpa。所以想要spring boot自己读取需要按照其规则注入即为spring.jpa.properties。

　　4.用户类

    @Entity(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    private String name;
    private String address;
    省略get set 方法................
}

　　用户类比较简单，只有几个基本的属性。@Entity注解的name的值对应数据库的表名。

　　5.配置数据源

    @Configuration
public class DataSourceConfig {
    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.one")
    @Primary
    DataSource dsOne() {
        return DruidDataSourceBuilder.create().build();
    }
    //primary注解表示某个类存在多个实例时优先使用当前bean
    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.two")
    DataSource dsTwo() {
        return DruidDataSourceBuilder.create().build();
    }
}

　　既然是多数据源那么肯定需要自己配置多个数据源的情况，注意这里需要增加@Primary注解，其含义就是表示某个类存在多个实例时优先使用当前实例，如果不加项目会报错，多个bean只能加一个，意思是dsTwo同样返回的DataSource，但是dsOne加了，其他的就不能再加了。

　　6.JPA配置

　　(1)第一个JPA的配置

    @Configuration
@EnableJpaRepositories(basePackages = "com.hopec.jpa2.repository1",transactionManagerRef = "platformTransactionManager1",entityManagerFactoryRef = "localContainerEntityManagerFactoryBean1")
public class JpaConfigOne {

    @Autowired
    @Qualifier(value = "dsOne")
    DataSource dsOne;

    @Autowired
    JpaProperties jpaProperties;

    @Bean
    @Primary //相应的需要添加上此注解
    LocalContainerEntityManagerFactoryBean localContainerEntityManagerFactoryBean1(EntityManagerFactoryBuilder factoryBuilder){
        return factoryBuilder.dataSource(dsOne)   //设置数据源
                .properties(jpaProperties.getProperties()) //获取配置信息
                .packages("com.hopec.jpa2.model")  //设置扫描的实体类的包
                .persistenceUnit("name1")           //持久化单元的名称 不同的对象的名字不同就可以
                .build();
    }
    @Bean
    PlatformTransactionManager platformTransactionManager1(EntityManagerFactoryBuilder factoryBuilder){
        LocalContainerEntityManagerFactoryBean bean = localContainerEntityManagerFactoryBean1(factoryBuilder);
        return new JpaTransactionManager(bean.getObject());
    }
}

　　(2)第二个JPA的配置

    @Configuration
@EnableJpaRepositories(basePackages = "com.hopec.jpa2.repository2",transactionManagerRef = "platformTransactionManager2",entityManagerFactoryRef = "localContainerEntityManagerFactoryBean2")
public class JpaConfigTwo {
    @Autowired
    @Qualifier(value = "dsTwo")
    DataSource dsTwo;
    @Autowired
    JpaProperties jpaProperties;
    @Bean
    LocalContainerEntityManagerFactoryBean localContainerEntityManagerFactoryBean2(EntityManagerFactoryBuilder factoryBuilder){
        return factoryBuilder.dataSource(dsTwo)   //设置数据源
                .properties(jpaProperties.getProperties()) //获取配置信息
                .packages("com.hopec.jpa2.model")  //设置扫描的实体类的包
                .persistenceUnit("name2")           //持久化单元的名称 不同的对象的名字不同就可以
                .build();
    }
    @Bean
    PlatformTransactionManager platformTransactionManager2(EntityManagerFactoryBuilder factoryBuilder){
        LocalContainerEntityManagerFactoryBean bean = localContainerEntityManagerFactoryBean2(factoryBuilder);
        return new JpaTransactionManager(bean.getObject());
    }
}

　　以上两个JPA的配置主要是注意包名路径的对应一定要保持一致。

　　7.持久层
　　(1)第一个持久层

public interface UserRepository1 extends JpaRepository<User,Integer>{

    @Query(value = "select * from users where id=(select max(id) from users)",nativeQuery = true)
    User findMaxIdUser();

    //自定义的属性如何进行匹配
    @Query(value = "insert into users(name,address) values(?1,?2)",nativeQuery = true)
    @Modifying
    @Transactional
    Integer addUser1(String name,String author);

    @Query(value = "insert into users(name,address) values(:name,:address)",nativeQuery = true)
    @Modifying
    @Transactional
    Integer addUser2(@Param("name") String name, @Param("address") String address);


    //自定义的对象与sql语句进行匹配
    @Query(value = "insert into users(name,address) values(:#{#user.name},:#{#user.address})",nativeQuery = true)
    @Modifying
    @Transactional
    Integer addUser3(@Param("user") User user);

　　这里其实不需要写这么复杂的，单纯查询所有用户信息，JpaRepository里面已经实现了，这里自定义查询和保存用户方法是为了多学习一点如何在JPA中自定义查询方法以及参数对应，也就是将自定义的方法中的普通参数或者对象与@Query中原生SQL的属性对应起来。

　　(2)第二个持久层

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

　　实际上在本例中是这样的，不需要第一个那么复杂，第一个只是作为扩展的参考。

　　8.测试

        @Test
    public void test1(){
        List<User> users = userRepository1.findAll();
        System.out.println(users);
        List<User> users1 = userRepository2.findAll();
        System.out.println(users1);
    }
    @Test
    public void test2(){
        User user = new User();
        user.setName("123");
        user.setAddress("石家庄");
        Integer r = userRepository1.addUser3(user);
        System.out.println(r);
    }

　　测试结果：

　　　　最后大功告成！