SpringBoot整合Spring Data JPA多数据源

时间：2022-12-05 21:56:34

Springboot 整合spring data jpa多数据源

在使用Mybatis时会涉及多数据源的问题，同样，当我们使用Jpa作为持久化处理方式时，也会涉及多数据源的问题，本节我们来讲解一下Springboot如何整合Spring data Jpa多数据源。

1.创建项目

添加lomboc，web，spring data jpa, mysql依赖

SpringBoot整合Spring Data JPA多数据源

SpringBoot整合Spring Data JPA多数据源

默认Mysql驱动时8，如果本机安装的Mysql是5，需要手动修改版本 ，修改后的依赖信息如下：

<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>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.45</version> <!-- 手动添加版本号-->
        <scope>runtime</scope>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-tomcat</artifactId>
        <scope>provided</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

添加 Druid连接池依赖

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.1.10</version>
</dependency>

创建好的项目结构如下:

SpringBoot整合Spring Data JPA多数据源

2.准备两个数据库

boot1和boot2

SpringBoot整合Spring Data JPA多数据源

SpringBoot整合Spring Data JPA多数据源

3.配置数据源

application.properties中配置两个数据源

# 数据库的基本配置
spring.datasource.one.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.one.username=root
spring.datasource.one.password=root
#注意多数据源要用jdbc-url
spring.datasource.one.jdbc-url=jdbc:mysql://localhost:3306/boot1? characterEncoding=utf8&serverTimezone=GMT%2B8   
spring.datasource.one.type=com.alibaba.druid.pool.DruidDataSource

spring.datasource.two.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.two.username=root
spring.datasource.two.password=root
spring.datasource.two.jdbc-url=jdbc:mysql://localhost:3306/boot2?characterEncoding=utf8&serverTimezone=GMT%2B8
spring.datasource.two.type=com.alibaba.druid.pool.DruidDataSource

# JPA配置
spring.jpa.properties.database=mysql
spring.jpa.properties.show-sql=true
spring.jpa.properties.hibernate.ddl-auto=update
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL57Dialect
跟Mybatis多数据源一样，这里也是通过 one 和 two 对数据源进行了区分，但是加了 one 和 two 之后，这里的配置就没法被 SpringBoot 自动加载了（因为前面的 key 变了），需要我们自己去加载 DataSource 了，此时，需要自己配置一个 DataSourceConfig，用来提供两个 DataSource Bean。
另外Jpa的配置里面多了一个properties属性

4.创建DataSourceConfig文件

创建包config，在config包中创建DataSourceConfig类，添加两个返回DataSource的方法：

package com.test.multidatasourcejpa.config;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.sql.DataSource;


@Configuration
public class DataSourceConfig {
    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.one")
    //这里添加@Primary注解，一定不能少，否则在项目启动时会出错，@Primary 表示当某一个类存在多个实例时，优先使用哪个实例
    @Primary
    DataSource dsOne() {
        return DataSourceBuilder.create().build();
    }
    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.two")
    DataSource dsTwo() {
        return DataSourceBuilder.create().build();
    }
}
这里提供了两个 Bean，其中 @ConfigurationProperties 是 Spring Boot 提供的类型安全的属性绑定，以第一个Bean为例， @ConfigurationProperties(prefix = "spring.datasource.one") 表示使用 spring.datasource.one 前缀的数据库配置去创建一个 DataSource，这样配置之后，我们就有了两个不同的 DataSource

5.创建两个Jpa配置类

创建JpaConfigOne类，对应数据源dsOne：

package com.test.multidatasourcejpa.config;

import org.springframework.beans.factory.annotation.Autowired;
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;

import javax.annotation.Resource;
import javax.sql.DataSource;


@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(basePackages = "com.test.multidatasourcejpa.dao1",
        entityManagerFactoryRef = "entityManagerFactoryBeanOne",
        transactionManagerRef = "platformTransactionManagerOne")
/*
basePackages 用来指定 dao 所在的位置。
entityManagerFactoryRef 用来指定实体类管理工厂 Bean 的名称
transactionManagerRef 用来指定事务管理器的引用名称，
默认的 Bean 名称为方法名
 */
public class JpaConfigOne {

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

    @Autowired
    JpaProperties jpaProperties;

    @Bean
    @Primary
    //该 Bean 用来提供 EntityManager 实例
    LocalContainerEntityManagerFactoryBean entityManagerFactoryBeanOne(
            EntityManagerFactoryBuilder builder) {
        return builder.dataSource(dsOne) //配置数据源
                .properties(jpaProperties.getProperties())//设置 JPA 相关配置
                .packages("com.test.multidatasourcejpa.pojo")//设置实体类所在的位置
                .persistenceUnit("pu1")//配置持久化单元名。若项目中只有一个 EntityManagerFactory，则 persistenceUnit 可以省略掉，若有多个，则必须明确指定持久化单元名。
                .build();
    }

    //创建一个事务管理器。JpaTransactionManager 提供对单个 EntityManagerFactory 的事务支持，专门用于解决 JPA 中的事务管理
    @Bean
    PlatformTransactionManager platformTransactionManagerOne(
            EntityManagerFactoryBuilder builder) {
        LocalContainerEntityManagerFactoryBean factoryBeanOne
                = entityManagerFactoryBeanOne(builder);
        return new JpaTransactionManager(factoryBeanOne.getObject());
    }

}

创建JpaConfigTwo类，对应数据源dsTwo：

package com.test.multidatasourcejpa.config;

import org.springframework.beans.factory.annotation.Autowired;
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;

import javax.annotation.Resource;
import javax.sql.DataSource;


@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(basePackages = "com.test.multidatasourcejpa.dao2",
        entityManagerFactoryRef = "entityManagerFactoryBeanTwo",
        transactionManagerRef = "platformTransactionManagerTwo")
/*
basePackages 用来指定 dao 所在的位置。
entityManagerFactoryRef 用来指定实体类管理工厂 Bean 的名称
transactionManagerRef 用来指定事务管理器的引用名称，
默认的 Bean 名称为方法名
 */
public class JpaConfigTwo {

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

    @Autowired
    JpaProperties jpaProperties;

    @Bean
    //该 Bean 用来提供 EntityManager 实例
    LocalContainerEntityManagerFactoryBean entityManagerFactoryBeanTwo(
            EntityManagerFactoryBuilder builder) {
        return builder.dataSource(dsTwo) //配置数据源
                .properties(jpaProperties.getProperties())//设置 JPA 相关配置
                .packages("com.test.multidatasourcejpa.pojo")//设置实体类所在的位置
                .persistenceUnit("pu2")//配置持久化单元名。若项目中只有一个 EntityManagerFactory，则 persistenceUnit 可以省略掉，若有多个，则必须明确指定持久化单元名。
                .build();
    }

    //创建一个事务管理器。JpaTransactionManager 提供对单个 EntityManagerFactory 的事务支持，专门用于解决 JPA 中的事务管理
    @Bean
    PlatformTransactionManager platformTransactionManagerTwo(
            EntityManagerFactoryBuilder builder) {
        LocalContainerEntityManagerFactoryBean factoryBeanTwo
                = entityManagerFactoryBeanTwo(builder);
        return new JpaTransactionManager(factoryBeanTwo.getObject());
    }

}

6.创建实体类

创建包com.test.multidatasourcejpa.pojo,在包下创建两个实体类:

Users

package com.test.multidatasourcejpa.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import javax.persistence.*;


@Data
@NoArgsConstructor
@AllArgsConstructor
@Entity
@Table(name = "users")
public class Users {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;

    private String uname;

    private int age;


}

Goods

package com.test.multidatasourcejpa.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import javax.persistence.*;


@Data
@NoArgsConstructor
@AllArgsConstructor
@Entity
@Table(name = "goods")
public class Goods {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;

    private String name;

    private float price;

}

7.创建数据库访问层

我们分别在 com.test.multidatasourcejpa.dao1 和 com.test.multidatasourcejpa.dao2 包下创建两个 dao，分别用于操作不同的数据源。

com.test.multidatasourcejpa.dao1包下：

package com.test.multidatasourcejpa.dao1;

import com.test.multidatasourcejpa.pojo.Users;
import org.springframework.data.jpa.repository.JpaRepository;


public interface UsersDao extends JpaRepository<Users,Integer> {
}

com.test.multidatasourcejpa.dao2包下：

package com.test.multidatasourcejpa.dao2;

import com.test.multidatasourcejpa.pojo.Goods;
import org.omg.CORBA.INTERNAL;
import org.springframework.data.jpa.repository.JpaRepository;


public interface GoodsDao extends JpaRepository<Goods,Integer> {
}

8.创建控制层

创建包controller,在controller包中创建两个控制层类:

UsersController

package com.test.multidatasourcejpa.controller;

import com.test.multidatasourcejpa.dao1.UsersDao;
import com.test.multidatasourcejpa.pojo.Users;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;


@RestController
@RequestMapping("/users")
public class UsersController {

    @Autowired
    private UsersDao usersDao;


    @RequestMapping("select")
    public List<Users> selectUsers()
    {
        return usersDao.findAll();
    }

}

GoodsController

package com.test.multidatasourcejpa.controller;

import com.test.multidatasourcejpa.dao1.UsersDao;
import com.test.multidatasourcejpa.dao2.GoodsDao;
import com.test.multidatasourcejpa.pojo.Goods;
import com.test.multidatasourcejpa.pojo.Users;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;


@RestController
@RequestMapping("/goods")
public class GoodsController {

    @Autowired
    private GoodsDao goodsDao;


    @RequestMapping("select")
    public List<Goods> selectGoods()
    {
        return goodsDao.findAll();
    }
}

9.测试

SpringBoot整合Spring Data JPA多数据源

标签：

相关文章