关于spring:Springbooot的多数据源配置

34次阅读

共计 19212 个字符,预计需要花费 49 分钟才能阅读完成。

JdbcTemplate

依赖配置

  • 依赖如下

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
    
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
    </dependencies>

增加多数据源的配置

  • 先在 Spring Boot 的配置文件 application.properties 中设置两个你要链接的数据库配置,比方这样:

    spring.datasource.primary.jdbc-url=jdbc:mysql://192.168.56.101:3306/test1
    spring.datasource.primary.username=test
    spring.datasource.primary.password=123456
    spring.datasource.primary.driver-class-name=com.mysql.cj.jdbc.Driver
    # 次数据源
    spring.datasource.secondary.jdbc-url=jdbc:mysql://192.168.56.101:3306/test2
    spring.datasource.secondary.username=test
    spring.datasource.secondary.password=123456
    spring.datasource.secondary.driver-class-name=com.mysql.cj.jdbc.Driver
  • 阐明与留神

    1. 多数据源配置的时候,与单数据源不同点在于 spring.datasource 之后多设置一个数据源名称 primarysecondary来辨别不同的数据源配置,这个前缀将在后续初始化数据源的时候用到。
    2. 数据源连贯配置 2.x 和 1.x 的配置项是有区别的:

      • 2.x 应用spring.datasource.secondary.jdbc-url
      • 而 1.x 版本应用spring.datasource.secondary.url
      • 如果你在配置的时候产生了这个报错java.lang.IllegalArgumentException: jdbcUrl is required with driverClassName.,那么就是这个配置项的问题。

初始化数据源和 JdbcTemplate

  • 实现多数据源的配置信息之后,就来创立个配置类来加载这些配置信息,初始化数据源,以及初始化每个数据源要用的 JdbcTemplate。你只须要在你的 Spring Boot 利用下增加上面的这个配置类即可实现!

    package tk.fulsun.demo.config;
    
    import javax.sql.DataSource;
    import org.springframework.beans.factory.annotation.Qualifier;
    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 org.springframework.jdbc.core.JdbcTemplate;
    
    /**
     * @author fsun7
     * @description: 数据源的配置信息
     * @date 6/11/2021 3:20 PM
     */
    @Configuration
    public class DataSourceConfiguration {
      @Bean
      @ConfigurationProperties(prefix = "spring.datasource.primary")
      public DataSource primaryDataSource() {return DataSourceBuilder.create().build();}
    
      @Bean
      @ConfigurationProperties(prefix = "spring.datasource.secondary")
      public DataSource secondaryDataSource() {return DataSourceBuilder.create().build();}
    
      @Bean
      public JdbcTemplate primaryJdbcTemplate(@Qualifier("primaryDataSource") DataSource primaryDataSource) {return new JdbcTemplate(primaryDataSource);
      }
    
      @Bean
      public JdbcTemplate secondaryJdbcTemplate(@Qualifier("secondaryDataSource") DataSource secondaryDataSource) {return new JdbcTemplate(secondaryDataSource);
      }
    }
  • 阐明与留神

    1. 前两个 Bean 是数据源的创立,通过 @ConfigurationProperties 能够晓得这两个数据源别离加载了 spring.datasource.primary.*spring.datasource.secondary.*的配置。
    2. @Primary注解指定了主数据源,就是当咱们不特地指定哪个数据源的时候,就会应用这个 Bean
    3. 后两个 Bean 是每个数据源对应的 JdbcTemplate。能够看到这两个JdbcTemplate 创立的时候,别离注入了 primaryDataSource 数据源和 secondaryDataSource 数据源

测试

  • 实现了下面之后,咱们就能够写个测试类来尝试一下下面的多数据源配置是否正确了,比方上面这样:

    package tk.fulsun.demo;
    
    import org.junit.Assert;
    import org.junit.Before;
    import org.junit.jupiter.api.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.jdbc.core.JdbcTemplate;
    import org.springframework.test.context.junit4.SpringRunner;
    
    /**
     * @author fsun7
     * @description: 主测试类
     * @date 6/11/2021 3:25 PM
     */
    @RunWith(SpringRunner.class)
    @SpringBootTest
    class ApplicationTest {
    
        @Autowired protected JdbcTemplate primaryJdbcTemplate;
    
        @Autowired protected JdbcTemplate secondaryJdbcTemplate;
    
        @Before
        public void setUp() {primaryJdbcTemplate.update("DELETE  FROM  user");
            secondaryJdbcTemplate.update("DELETE  FROM  user");
        }
    
        @Test
        public void test() throws Exception {
            // 往第一个数据源中插入 2 条数据
            primaryJdbcTemplate.update("insert into user(name,age) values(?, ?)", "aaa", 20);
            primaryJdbcTemplate.update("insert into user(name,age) values(?, ?)", "bbb", 30);
    
            // 往第二个数据源中插入 1 条数据,若插入的是第一个数据源,则会主键抵触报错
            secondaryJdbcTemplate.update("insert into user(name,age) values(?, ?)", "ccc", 20);
    
            // 查一下第一个数据源中是否有 2 条数据,验证插入是否胜利
            Assert.assertEquals("2", primaryJdbcTemplate.queryForObject("select count(1) from user", String.class));
    
            // 查一下第一个数据源中是否有 1 条数据,验证插入是否胜利
            Assert.assertEquals("1", secondaryJdbcTemplate.queryForObject("select count(1) from user", String.class));
        }
    }
    
  • 查询数据库

    mysql> select * from test1.user;
    +------+------+
    | name | age  |
    +------+------+
    | aaa  |   20 |
    | bbb  |   30 |
    +------+------+
    2 rows in set (0.00 sec)
    
    mysql> select * from test2.user;
    +------+------+
    | name | age  |
    +------+------+
    | ccc  |   20 |
    +------+------+
    1 row in set (0.00 sec)
    

### 阐明

  • 有两个 JdbcTemplate,为什么不必 @Qualifier 指定?

    • 这里顺带说个小知识点,当咱们不指定的时候,会采纳参数的名字来查找 Bean,存在的话就注入。
  • 这两个 JdbcTemplate 创立的时候,咱们也没指定名字,它们是如何匹配上的?

    • 这里也是一个小知识点,当咱们创立 Bean 的时候,默认会应用办法名称来作为 Bean 的名称,所以这里就对应上了。

Spring Data JPA

依赖配置

  • 增加 jpa 的依赖

    <!--    <dependency>-->
    <!--      <groupId>org.springframework.boot</groupId>-->
    <!--      <artifactId>spring-boot-starter-jdbc</artifactId>-->
    <!--    </dependency>-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>

增加多数据源的配置

  • 先在 Spring Boot 的配置文件 application.properties 中设置两个你要链接的数据库配置,比方这样:

    spring.datasource.primary.jdbc-url=jdbc:mysql://192.168.56.101:3306/test1
    spring.datasource.primary.username=test
    spring.datasource.primary.password=123456
    spring.datasource.primary.driver-class-name=com.mysql.cj.jdbc.Driver
    # 次数据源
    spring.datasource.secondary.jdbc-url=jdbc:mysql://192.168.56.101:3306/test2
    spring.datasource.secondary.username=test
    spring.datasource.secondary.password=123456
    spring.datasource.secondary.driver-class-name=com.mysql.cj.jdbc.Driver
    # 日志打印执行的 SQL
    spring.jpa.show-sql=true
    # Hibernate 的 DDL 策略
    spring.jpa.hibernate.ddl-auto=create-drop
  • 这里除了 JPA 本身相干的配置之外,与 JdbcTemplate 配置时候的数据源配置齐全是统一的

初始化数据源与 JPA 配置

  • 实现多数据源的配置信息之后,就来创立个配置类来加载这些配置信息,初始化数据源,以及初始化每个数据源要用的 JPA 配置。
  • 因为 JPA 的配置要比 JdbcTemplate 的简单很多,所以咱们可将配置拆分一下来解决
  • 在应用 JPA 的时候,须要为不同的数据源创立不同的 package 来寄存对应的 Entity 和 Repository,以便于配置类的分区扫描

    • 类名上的注解 @EnableJpaRepositories 中指定 Repository 的所在位置
    • LocalContainerEntityManagerFactoryBean创立的时候,指定 Entity 所在的地位
    • 其余次要留神在相互注入时候,不同数据源不同配置的命名,根本就没有什么大问题了

配置 DataSource 类

  • 独自建一个多数据源的配置类,比方上面这样:

    import javax.sql.DataSource;
    import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.boot.jdbc.DataSourceBuilder;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Primary;
    
    /**
     * @author fsun7
     * @description: JPA 数据源的配置类
     * @date 6/11/2021 4:08 PM
     */
    @Configuration
    public class JpaDataSourceConfiguration {
      @Primary
      @Bean
      @ConfigurationProperties(prefix = "spring.datasource.primary")
      public DataSource primaryDataSource() {return DataSourceBuilder.create().build();}
    
      @Bean
      @ConfigurationProperties(prefix = "spring.datasource.secondary")
      public DataSource secondaryDataSource() {return DataSourceBuilder.create().build();}
    }
    
  • 能够看到内容跟 JdbcTemplate 时候是截然不同的。通过 @ConfigurationProperties 能够晓得这两个数据源别离加载了 spring.datasource.primary.*spring.datasource.secondary.*的配置。
  • @Primary注解指定了主数据源,就是当咱们不特地指定哪个数据源的时候,就会应用这个 Bean 真正差别局部在上面的 JPA 配置上。

JPA 配置

  • 别离创立两个数据源的 JPA 配置。
  • primary 数据源的 JPA 配置:

    @Configuration
    @EnableTransactionManagement
    @EnableJpaRepositories(
        entityManagerFactoryRef = "entityManagerFactoryPrimary",
        transactionManagerRef = "transactionManagerPrimary",
        basePackages = {"tk.fulsun.demo.entity"}) // 设置 Repository 所在位置
    class PrimaryConfig {
    
      @Autowired
      @Qualifier("primaryDataSource")
      private DataSource primaryDataSource;
    
      @Autowired private JpaProperties jpaProperties;
      @Autowired private HibernateProperties hibernateProperties;
    
      private Map<String, Object> getVendorProperties() {
        return hibernateProperties.determineHibernateProperties(jpaProperties.getProperties(), new HibernateSettings());
      }
    
      @Primary
      @Bean(name = "entityManagerPrimary")
      public EntityManager entityManager(EntityManagerFactoryBuilder builder) {return entityManagerFactoryPrimary(builder).getObject().createEntityManager();
      }
    
      @Primary
      @Bean(name = "entityManagerFactoryPrimary")
      public LocalContainerEntityManagerFactoryBean entityManagerFactoryPrimary(EntityManagerFactoryBuilder builder) {
        return builder
            .dataSource(primaryDataSource)
            .packages("tk.fulsun.demo.entity") // 设置实体类所在位置
            .persistenceUnit("primaryPersistenceUnit")
            .properties(getVendorProperties())
            .build();}
    
      @Primary
      @Bean(name = "transactionManagerPrimary")
      public PlatformTransactionManager transactionManagerPrimary(EntityManagerFactoryBuilder builder) {return new JpaTransactionManager(entityManagerFactoryPrimary(builder).getObject());
      }
    }
  • Secondary 数据源的 JPA 配置:

    @Configuration
    @EnableTransactionManagement
    @EnableJpaRepositories(
        entityManagerFactoryRef="entityManagerFactorySecondary",
        transactionManagerRef="transactionManagerSecondary",
        basePackages= {"com.didispace.chapter38.s"}) // 设置 Repository 所在位置
    class SecondaryConfig {
    
        @Autowired
        @Qualifier("secondaryDataSource")
        private DataSource secondaryDataSource;
    
        @Autowired
        private JpaProperties jpaProperties;
        @Autowired
        private HibernateProperties hibernateProperties;
    
        private Map<String, Object> getVendorProperties() {return hibernateProperties.determineHibernateProperties(jpaProperties.getProperties(), new HibernateSettings());
        }
    
        @Bean(name = "entityManagerSecondary")
        public EntityManager entityManager(EntityManagerFactoryBuilder builder) {return entityManagerFactorySecondary(builder).getObject().createEntityManager();
        }
    
        @Bean(name = "entityManagerFactorySecondary")
        public LocalContainerEntityManagerFactoryBean entityManagerFactorySecondary (EntityManagerFactoryBuilder builder) {
            return builder
                .dataSource(secondaryDataSource)
                .packages("com.didispace.chapter38.s") // 设置实体类所在位置
                .persistenceUnit("secondaryPersistenceUnit")
                .properties(getVendorProperties())
                .build();}
    
        @Bean(name = "transactionManagerSecondary")
        PlatformTransactionManager transactionManagerSecondary(EntityManagerFactoryBuilder builder) {return new JpaTransactionManager(entityManagerFactorySecondary(builder).getObject());
        }
    
    }

Repository 编写

  • 编写实体类

    package tk.fulsun.demo.dao.p;
    
    import javax.persistence.Entity;
    import javax.persistence.GeneratedValue;
    import javax.persistence.Id;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    /**
     * @author fsun7
     * @description: TODO
     * @date 6/11/2021 4:25 PM
     */
    @Entity
    @Data
    @NoArgsConstructor
    public class User {
      @Id @GeneratedValue private Long id;
    
      private String name;
      private Integer age;
    
      public User(String name, Integer age) {
        this.name = name;
        this.age = age;
      }
    }
  • Repository

    package tk.fulsun.demo.dao.p;
    
    import org.springframework.data.jpa.repository.JpaRepository;
    
    /**
     * @author fsun7
     * @description: UserRepository
     * @date 6/11/2021 4:26 PM
     */
    public interface UserRepository extends JpaRepository<User, Long> {}
    
  • secondary 数据库的表
  package tk.fulsun.demo.dao.s;
  
  import javax.persistence.Entity;
  import javax.persistence.GeneratedValue;
  import javax.persistence.Id;
  import lombok.Data;
  import lombok.NoArgsConstructor;
  
  /**
   * @author fsun7
   * @description: Message
   * @date 6/11/2021 4:27 PM
   */
  @Entity
  @Data
  @NoArgsConstructor
  public class Message {
  
    @Id @GeneratedValue private Long id;
  
    private String title;
    private String message;
  
    public Message(String title, String message) {
      this.title = title;
      this.message = message;
    }
  }
  
  
  package tk.fulsun.demo.dao.s;
  
  import org.springframework.data.jpa.repository.JpaRepository;
  
  /**
   * @author fsun7
   * @description: MessageRepository
   * @date 6/11/2021 4:28 PM
   */
  public interface MessageRepository extends JpaRepository<Message, Long> {}
  

测试

  • 测试通过不同的 Repository 往不同的数据源插入数据,而后查问一下总数是否是对的

    package tk.fulsun.demo;
    
    import lombok.extern.slf4j.Slf4j;
    import org.junit.Assert;
    import org.junit.jupiter.api.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.context.junit4.SpringRunner;
    import tk.fulsun.demo.dao.p.User;
    import tk.fulsun.demo.dao.p.UserRepository;
    import tk.fulsun.demo.dao.s.Message;
    import tk.fulsun.demo.dao.s.MessageRepository;
    
    /**
     * @author fsun7
     * @description: JPA 形式多数据源测试
     * @date 6/11/2021 4:23 PM
     */
    @Slf4j
    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class JPAApplicationTests {
      @Autowired private UserRepository userRepository;
      @Autowired private MessageRepository messageRepository;
    
      @Test
      public void test() throws Exception {userRepository.save(new User("aaa", 10));
        userRepository.save(new User("bbb", 20));
        userRepository.save(new User("ccc", 30));
        userRepository.save(new User("ddd", 40));
        userRepository.save(new User("eee", 50));
    
        Assert.assertEquals(5, userRepository.findAll().size());
    
        messageRepository.save(new Message("o1", "aaaaaaaaaa"));
        messageRepository.save(new Message("o2", "bbbbbbbbbb"));
        messageRepository.save(new Message("o3", "cccccccccc"));
    
        Assert.assertEquals(3, messageRepository.findAll().size());
      }
    }

MyBatis

依赖配置

  • 移除 jpa 的依赖

    <!--    <dependency>-->
    <!--      <groupId>org.springframework.boot</groupId>-->
    <!--      <artifactId>spring-boot-starter-jdbc</artifactId>-->
    <!--    </dependency>-->
    <!--    <dependency>-->
    <!--      <groupId>org.springframework.boot</groupId>-->
    <!--      <artifactId>spring-boot-starter-data-jpa</artifactId>-->
    <!--    </dependency>-->
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>2.1.4</version>
    </dependency>

增加多数据源的配置

  • 先在 Spring Boot 的配置文件 application.properties 中设置两个你要链接的数据库配置,比方这样:

    spring.datasource.primary.jdbc-url=jdbc:mysql://192.168.56.101:3306/test1
    spring.datasource.primary.username=test
    spring.datasource.primary.password=123456
    spring.datasource.primary.driver-class-name=com.mysql.cj.jdbc.Driver
    # 次数据源
    spring.datasource.secondary.jdbc-url=jdbc:mysql://192.168.56.101:3306/test2
    spring.datasource.secondary.username=test
    spring.datasource.secondary.password=123456
    spring.datasource.secondary.driver-class-name=com.mysql.cj.jdbc.Driver
    
    # 日志打印执行的 SQL
    #spring.jpa.show-sql=true
    # Hibernate 的 DDL 策略
    #spring.jpa.hibernate.ddl-auto=update

初始化数据源与 MyBatis 配置

  • 实现多数据源的配置信息之后,就来创立个配置类来加载这些配置信息,初始化数据源,以及初始化每个数据源要用的 MyBatis 配置。
  • 这里咱们持续将数据源与框架配置做拆分解决:

数据源配置类

  • 独自建一个多数据源的配置类,比方上面这样:

    package tk.fulsun.demo.mybatis.config;
    
    import javax.sql.DataSource;
    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 org.springframework.context.annotation.Primary;
    
    /**
     * @author fsun7
     * @description: 数据源配置
     * @date 6/11/2021 4:49 PM
     */
    @Configuration
    public class DataSourceConfiguration {
      @Primary
      @Bean
      @ConfigurationProperties(prefix = "spring.datasource.primary")
      public DataSource primaryDataSource() {return DataSourceBuilder.create().build();}
    
      @Bean
      @ConfigurationProperties(prefix = "spring.datasource.secondary")
      public DataSource secondaryDataSource() {return DataSourceBuilder.create().build();}
    }
    
  • 能够看到内容跟 JdbcTemplate、Spring Data JPA 的时候是截然不同的。通过 @ConfigurationProperties 能够晓得这两个数据源别离加载了 spring.datasource.primary.*spring.datasource.secondary.*的配置。
  • @Primary注解指定了主数据源,就是当咱们不特地指定哪个数据源的时候,就会应用这个 Bean 真正差别局部在上面的 JPA 配置上。

MyBatis 配置

  • 别离创立两个数据源的 MyBatis 配置。
  • Primary 数据源的 JPA 配置:

    package tk.fulsun.demo.mybatis.config;
    
    import javax.sql.DataSource;
    import org.apache.ibatis.session.SqlSessionFactory;
    import org.mybatis.spring.SqlSessionFactoryBean;
    import org.mybatis.spring.SqlSessionTemplate;
    import org.mybatis.spring.annotation.MapperScan;
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    /**
     * @author fsun7
     * @description: MyBatis 配置
     * @date 6/11/2021 4:50 PM
     */
    @Configuration
    @MapperScan(
        basePackages = "tk.fulsun.demo.mybatis.mapper.p",
        sqlSessionFactoryRef = "sqlSessionFactoryPrimary",
        sqlSessionTemplateRef = "sqlSessionTemplatePrimary")
    public class PrimaryConfig {
      private DataSource primaryDataSource;
    
      public PrimaryConfig(@Qualifier("primaryDataSource") DataSource primaryDataSource) {this.primaryDataSource = primaryDataSource;}
    
      @Bean
      public SqlSessionFactory sqlSessionFactoryPrimary() throws Exception {SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(primaryDataSource);
        return bean.getObject();}
    
      @Bean
      public SqlSessionTemplate sqlSessionTemplatePrimary() throws Exception {return new SqlSessionTemplate(sqlSessionFactoryPrimary());
      }
    }
    
  • Secondary 数据源的 JPA 配置:

    package tk.fulsun.demo.mybatis.config;
    
    import javax.sql.DataSource;
    import org.apache.ibatis.session.SqlSessionFactory;
    import org.mybatis.spring.SqlSessionFactoryBean;
    import org.mybatis.spring.SqlSessionTemplate;
    import org.mybatis.spring.annotation.MapperScan;
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    /**
     * @author fsun7
     * @description: MyBatis 配置
     * @date 6/11/2021 4:50 PM
     */
    @Configuration
    @MapperScan(
        basePackages = "tk.fulsun.demo.mybatis.mapper.s",
    <<<<<<< HEAD
        sqlSessionFactoryRef = "sqlSessionFactorySecondary",
        sqlSessionTemplateRef = "sqlSessionTemplateSecondary")
    =======
        sqlSessionFactoryRef = "sqlSessionFactoryPrimary",
        sqlSessionTemplateRef = "sqlSessionTemplatePrimary")
    >>>>>>> origin/hp
    public class SecondaryConfig {
      private DataSource secondaryDataSource;
    
      public SecondaryConfig(@Qualifier("secondaryDataSource") DataSource secondaryDataSource) {this.secondaryDataSource = secondaryDataSource;}
        
      @Bean
      public SqlSessionFactory sqlSessionFactorySecondary() throws Exception {SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(secondaryDataSource);
        return bean.getObject();}
        
      @Bean
      public SqlSessionTemplate sqlSessionTemplateSecondary() throws Exception {return new SqlSessionTemplate(sqlSessionFactorySecondary());
      }
    }
    

阐明与留神

  1. 配置类上应用 @MapperScan 注解来指定以后数据源下定义的 Entity 和 Mapper 的包门路;另外须要指定 sqlSessionFactory 和 sqlSessionTemplate,这两个具体实现在该配置类中类中初始化。
  2. 配置类的构造函数中,通过 @Qualifier 注解来指定具体要用哪个数据源,其名字对应在 DataSourceConfiguration 配置类中的数据源定义的函数名。
  3. 配置类中定义 SqlSessionFactory 和 SqlSessionTemplate 的实现,留神具体应用的数据源正确(

Mapper 层编写

  • 依据下面 Primary 数据源的定义,在 tk.fulsun.demo.mybatis.mapper.p 包下,定义 Primary 数据源要用的实体和数据拜访对象,比方上面这样:

    @Data
    @NoArgsConstructor
    public class UserPrimary {
    
        private Long id;
    
        private String name;
        private Integer age;
    
        public UserPrimary(String name, Integer age) {
            this.name = name;
            this.age = age;
        }
    }
    
    public interface UserMapperPrimary {@Select("SELECT * FROM USER WHERE NAME = #{name}")
        UserPrimary findByName(@Param("name") String name);
    
        @Insert("INSERT INTO USER(NAME, AGE) VALUES(#{name}, #{age})")
        int insert(@Param("name") String name, @Param("age") Integer age);
    
        @Delete("DELETE FROM USER")
        int deleteAll();}
  • 依据下面 Secondary 数据源的定义,在 tk.fulsun.demo.mybatis.mapper.s 包下,定义 Secondary 数据源要用的实体和数据拜访对象,比方上面这样:

    @Data
    @NoArgsConstructor
    public class UserSecondary {
    
        private Long id;
    
        private String name;
        private Integer age;
    
        public UserSecondary(String name, Integer age) {
            this.name = name;
            this.age = age;
        }
    }
    
    public interface UserMapperSecondary {@Select("SELECT * FROM USER WHERE NAME = #{name}")
        UserSecondary findByName(@Param("name") String name);
    
        @Insert("INSERT INTO USER(NAME, AGE) VALUES(#{name}, #{age})")
        int insert(@Param("name") String name, @Param("age") Integer age);
    
        @Delete("DELETE FROM USER")
        int deleteAll();}

测试验证

  • 实现了下面之后,咱们就能够写个测试类来尝试一下下面的多数据源配置是否正确了,先来设计一下验证思路:
  1. 往 Primary 数据源插入一条数据
  2. 从 Primary 数据源查问方才插入的数据,配置正确就能够查问到
  3. 从 Secondary 数据源查问方才插入的数据,配置正确应该是查问不到的
  4. 往 Secondary 数据源插入一条数据
  5. 从 Primary 数据源查问方才插入的数据,配置正确应该是查问不到的
  6. 从 Secondary 数据源查问方才插入的数据,配置正确就能够查问到
  • 具体实现如下:

    @Slf4j
    @RunWith(SpringRunner.class)
    @SpringBootTest
    @Transactional
    public class Chapter39ApplicationTests {
    
        @Autowired
        private UserMapperPrimary userMapperPrimary;
        @Autowired
        private UserMapperSecondary userMapperSecondary;
    
        @Before
        public void setUp() {
            // 清空测试表,保障每次后果一样
            userMapperPrimary.deleteAll();
            userMapperSecondary.deleteAll();}
    
        @Test
        public void test() throws Exception {
            // 往 Primary 数据源插入一条数据
            userMapperPrimary.insert("AAA", 20);
    
            // 从 Primary 数据源查问方才插入的数据,配置正确就能够查问到
            UserPrimary userPrimary = userMapperPrimary.findByName("AAA");
            Assert.assertEquals(20, userPrimary.getAge().intValue());
    
            // 从 Secondary 数据源查问方才插入的数据,配置正确应该是查问不到的
            UserSecondary userSecondary = userMapperSecondary.findByName("AAA");
            Assert.assertNull(userSecondary);
    
            // 往 Secondary 数据源插入一条数据
            userMapperSecondary.insert("BBB", 20);
    
            // 从 Primary 数据源查问方才插入的数据,配置正确应该是查问不到的
            userPrimary = userMapperPrimary.findByName("BBB");
            Assert.assertNull(userPrimary);
    
            // 从 Secondary 数据源查问方才插入的数据,配置正确就能够查问到
            userSecondary = userMapperSecondary.findByName("BBB");
            Assert.assertEquals(20, userSecondary.getAge().intValue());
        }
    
    }

本文由博客一文多发平台 OpenWrite 公布!

正文完
 0