likes
comments
collection
share

SpringBoot2.x系列教程26--SpringBoot中以分包方式实现多数据源配置

作者站长头像
站长
· 阅读数 57

前言

我们知道，一般的项目中，一个项目一般只会关联配置一个数据库。但是随着项目并发量的不断增加，如果此时所有的并发访问都集中在这一个数据库上，那么这单个数据库可能难以承受高并发所带来的巨大压力。所以此时，我们通常会对数据库进行拆分或是引入第2、第3个数据库，也就是可以在一个项目中使用多个数据库，那么我们就需要在一个项目中配置多个数据源。

这时候你可能会觉得，一个项目中配置一个数据库很简单，那要是增加一个数据库，是不是也很简单呢？需不需要做一些额外的配置呢？请跟着 壹哥 学习今天的内容吧，你会发现可能并不是你想的那么简单。

在Java中，如果要在一个项目中配置多个数据源，一般有两种方法：基于分包法和基于AOP配置法。

下面我先利用spring-data-jpa，以分包的方式在一个项目中配置多个数据库。

二. 多数据源配置实现

1. 创建Web项目

我们按照之前的经验，创建一个SpringBoot的Web程序，具体过程略。

SpringBoot2.x系列教程26--SpringBoot中以分包方式实现多数据源配置

2. 添加依赖包

在pom.xml文件中添加几个核心依赖包。

<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>com.alibaba</groupId>
   <artifactId>druid</artifactId>
   <version>1.1.10</version>
</dependency>

3. 创建application.yml配置文件

创建一个application.yml文件，在该配置文件中，要进行两个数据库的配置，本案例中我们使用的是默认的HikariDataSource数据源。

spring:
  main:
    allow-bean-definition-overriding: true
  datasource:
  	#配置第1个数据源
    ds1:
      url: jdbc:mysql://localhost:3306/db1?characterEncoding=utf-8&useSSL=false&serverTimezone=UTC
      username: root
      password: syc
      driverClassName: com.mysql.jdbc.Driver
    #配置第2个数据源  
    ds2:
      url: jdbc:mysql://localhost:3306/db4?characterEncoding=utf-8&useSSL=false&serverTimezone=UTC
      username: root
      password: syc
      driverClassName: com.mysql.jdbc.Driver
    type: com.zaxxer.hikari.HikariDataSource
    #type: com.alibaba.druid.pool.DruidDataSource
  jpa:
    database: mysql
    show-sql: true
    hibernate:
      ddl-auto: update
      naming:
        physical-strategy: org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl
    database-platform: org.hibernate.dialect.MySQL5Dialect

4. 创建数据库配置类

4.1 编写第一个数据库配置类

这里我们先编写第一个数据库配置类，读取ds1中的数据库信息。

package com.yyg.boot.config.properties;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

/**
 * @Author 一一哥Sun
 * @Date Created in 2020/4/3
 * @Description db1数据源配置类
 */
@ConfigurationProperties(prefix = "spring.datasource.ds1")
@Component("ds1Properties")
@Data
public class Ds1Properties {

    private String url;

    private String username;

    private String password;

    private String driverClassName;

}

4.2 编写第2个数据库配置类

然后再编写第2个数据库配置类，读取ds2中的数据库信息。

package com.yyg.boot.config.properties;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

/**
 * @Author 一一哥Sun
 * @Date Created in 2020/4/3
 * @Description db4数据源配置类
 */
@ConfigurationProperties(prefix = "spring.datasource.ds2")
@Component("ds2Properties")
@Data
public class Ds2Properties {

    private String url;

    private String username;

    private String password;

    private String driverClassName;

}

5. 注册数据源

接下来我们在一个类中同时注册2个数据源就可以了，注意我们就是在这个配置类中分别关联加载2个数据源。

package com.yyg.boot.config;

import com.zaxxer.hikari.HikariDataSource;
import org.springframework.beans.factory.annotation.Qualifier;
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;

import javax.sql.DataSource;

/**
 * @Author 一一哥Sun
 * @Date Created in 2020/4/3
 * @Description 数据源的配置类
 */
@Configuration
public class DataSourceConfig {

    /**
     * 关联主数据源配置 ds1数据源
     */
    @Primary
    @Bean(name = "ds1Properties")
    @ConfigurationProperties(prefix = "spring.datasource.ds1")
    public DataSourceProperties ds1DataSourceProperties() {
        
        return new DataSourceProperties();
    }

    /**
     * 初始化构建主数据源ds1数据源
     */
    @Primary
    @Bean(name = "ds1DataSource")
    public DataSource ds1DataSource(@Qualifier("ds1Properties") DataSourceProperties dataSourceProperties) {
        //HikariDataSource","org.apache.tomcat.jdbc.pool.DataSource", "org.apache.commons.dbcp2.BasicDataSource
        return dataSourceProperties.initializeDataSourceBuilder().build();
    }

    /**
     * 关联第二个ds2数据源配置
     */
    @Bean(name = "ds2Properties")
    @ConfigurationProperties(prefix = "spring.datasource.ds2")
    public DataSourceProperties ds2DataSourceProperties() {
        
        return new DataSourceProperties();
    }

    /**
     * 初始化构建第二个ds2数据源
     */
    @Bean("ds2DataSource")
    public DataSource ds2DataSource(@Qualifier("ds2Properties") DataSourceProperties dataSourceProperties) {
        
        return dataSourceProperties.initializeDataSourceBuilder().build();
    }

}

6. 配置数据源、连接工厂、事务管理器、扫描dao目录

配置完2个数据源之后，我们还要利用事务管理器分别关联2个数据源。这里要注意合理的使用@Primary注解！

6.1 配置第一个数据源管理器

在这个数据源管理器中关联第1个数据源。

package com.yyg.boot.config;

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

/**
 * @Author 一一哥Sun
 * @Date Created in 2020/4/3
 * @Description 配置数据源、连接工厂、事务管理器、dao目录
 */
@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
        entityManagerFactoryRef = "managerFactory1", // 配置连接工厂
        transactionManagerRef = "transactionManager1", // 配置事物管理器
        basePackages = {"com.yyg.boot.dao.db01"} // 设置dao所在位置

)
public class ManagerFactory01Config {

    /**
     * 配置数据源,连接第1个数据源
     */
    @Autowired
    @Qualifier("ds1DataSource")
    private DataSource ds1DataSource;

    @Primary
    @Bean(name = "managerFactory1")
    public LocalContainerEntityManagerFactoryBean buildEntityManagerFactory1(EntityManagerFactoryBuilder builder) {
        return builder
                // 设置数据源
                .dataSource(ds1DataSource)
                //设置实体类所在位置.扫描所有带有 @Entity 注解的类
                .packages("com.yyg.boot.entity")
                // Spring会将EntityManagerFactory注入到Repository之中.有了 EntityManagerFactory之后,
                // Repository就能用它来创建 EntityManager 了,然后 EntityManager 就可以针对数据库执行操作
                .persistenceUnit("ds1PersistenceUnit")
                .build();

    }

    /**
     * 配置事务管理器
     */
    @Bean(name = "transactionManager1")
    public PlatformTransactionManager transactionManagerDatabase1(EntityManagerFactoryBuilder builder) {
        
        return new JpaTransactionManager(buildEntityManagerFactory1(builder).getObject());
    }

}

6.2 配置第2个数据源管理器

在这个数据源管理器中关联第2个数据源。

package com.yyg.boot.config;

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

/**
 * @Author 一一哥Sun
 * @Date Created in 2020/4/3
 * @Description 配置数据源、连接工厂、事务管理器、dao目录
 */
@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
        entityManagerFactoryRef = "managerFactory2", // 配置连接工厂
        transactionManagerRef = "transactionManager2", // 配置事物管理器
        basePackages = {"com.yyg.boot.dao.db02"} // 设置dao所在位置

)
public class ManagerFactory02Config {

    /**
     * 配置数据源,连接第2个数据源
     */
    @Autowired
    @Qualifier("ds2DataSource")
    private DataSource ds2DataSource;

    @Bean(name = "managerFactory2")
    public LocalContainerEntityManagerFactoryBean buildEntityManagerFactory2(EntityManagerFactoryBuilder builder) {
        return builder
                // 设置数据源
                .dataSource(ds2DataSource)
                //设置实体类所在位置.扫描所有带有 @Entity 注解的类
                .packages("com.yyg.boot.entity")
                // Spring会将EntityManagerFactory注入到Repository之中.有了 EntityManagerFactory之后,
                // Repository就能用它来创建 EntityManager 了,然后 EntityManager 就可以针对数据库执行操作
                .persistenceUnit("ds2PersistenceUnit")
                .build();

    }

    /**
     * 配置事务管理器
     */
    @Bean(name = "transactionManager2")
    public PlatformTransactionManager transactionManagerDatabase1(EntityManagerFactoryBuilder builder) {
        return new JpaTransactionManager(buildEntityManagerFactory2(builder).getObject());
    }

}

7. 创建Entity实体类

创建与数据库对应的实体类。

7.1 Goods商品类

封装一个商品信息的实体类。

package com.yyg.boot.entity;

import lombok.Data;

import javax.persistence.*;

/**
 * @Author 一一哥Sun
 * @Date Created in 2020/4/3
 * @Description db1中的商品表
 */
@Entity
@Table(name = "goods")
@Data
public class Goods {

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

    private String name;

}

7.2 User用户类

封装用户信息的实体类。

package com.yyg.boot.entity;

import lombok.Data;

import javax.persistence.*;

/**
 * @Author 一一哥Sun
 * @Date Created in 2020/4/3
 * @Description db4中的用户表
 */
@Entity
@Table(name = "user")
@Data
public class User {

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

    private String username;

    private String birthday;

    private String sex;

    private String address;

}

8. 创建Dao层代码

8.1 GoodsRepository类

编写操作Goods商品信息的数据库Dao层接口。

package com.yyg.boot.dao.db01;

import com.yyg.boot.entity.Goods;
import com.yyg.boot.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.stereotype.Repository;

/**
 * @Author 一一哥Sun
 * @Date Created in 2020/4/3
 * @Description Description
 */
@Repository
public interface GoodsRepository extends JpaRepository<Goods, Long>,JpaSpecificationExecutor<User> {
}

8.2 UserRepository类

编写操作User用户信息的数据库Dao层接口。

package com.yyg.boot.dao.db02;

import com.yyg.boot.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.stereotype.Repository;

/**
 * @Author 一一哥Sun
 * @Date Created in 2020/4/3
 * @Description Description
 */
@Repository
public interface UserRepository extends JpaRepository<User, Long>,JpaSpecificationExecutor<User> {
}

9. 创建Controller接口

然后我们再创建一个Controller类，在这里定义几个接口，方便后面进行测试。

package com.yyg.boot.web;

import com.yyg.boot.dao.db01.GoodsRepository;
import com.yyg.boot.dao.db02.UserRepository;
import com.yyg.boot.entity.Goods;
import com.yyg.boot.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

/**
 * @Author 一一哥Sun
 * @Date Created in 2020/4/3
 * @Description Description
 */
@RestController
public class GoodsController {

    @Autowired
    private UserRepository userRepository;

    @Autowired
    private GoodsRepository goodsRepository;

    @GetMapping(value = "/users")
    public List<User> users() {
        return userRepository.findAll();
    }

    @GetMapping(value = "/goods")
    public List<Goods> goods() {
        return goodsRepository.findAll();
    }

}

10. 创建入口类

最后编写一个项目入口类，启动项目。

package com.yyg.boot;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * @Author 一一哥Sun
 * @Date Created in 2020/4/3
 * @Description Description
 */
@SpringBootApplication
public class DataSourceApplication {

    public static void main(String[] args){
        SpringApplication.run(DataSourceApplication.class,args);
    }

}

11. 项目结构

最后我们可以看看项目的代码结构，各位可以参考下图创建。

SpringBoot2.x系列教程26--SpringBoot中以分包方式实现多数据源配置

12. 启动项目进行测试

12.1 测试商品数据库

我们把项目启动起来，先测试一下goods接口，这里查询的是db1数据库里的数据。 SpringBoot2.x系列教程26--SpringBoot中以分包方式实现多数据源配置 对应的db1数据库里的数据。 SpringBoot2.x系列教程26--SpringBoot中以分包方式实现多数据源配置

12.2 测试用户数据库

然后我们再测试一下users接口，这里查询的是db4数据库里的数据。 SpringBoot2.x系列教程26--SpringBoot中以分包方式实现多数据源配置

对应数据库里的数据。 SpringBoot2.x系列教程26--SpringBoot中以分包方式实现多数据源配置

结语

至此，壹哥 就带各位实现了在Spring Boot项目中，利用JPA同时配置了两个数据源，其实大家也可以以此类推，同时配置3个，4个乃至更多的数据源！

今天的内容其实很常用，我们开发时经常会遇到一个项目中配置多个数据源的场景，请大家一定要好好练习今天的内容。

今日小作业：

在学生管理系统中，同时配置一个学生数据库，再配置另一个别的数据库，实现数据的操作。

转载自:https://juejin.cn/post/7168607663339601951
评论
请登录