`
liujiekasini0312
  • 浏览: 147420 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

Spring Boot多数据源配置与使用

 
阅读更多

之前在介绍使用JdbcTemplate和Spring-data-jpa时，都使用了单数据源。在单数据源的情况下，Spring Boot的配置非常简单，只需要在application.properties文件中配置连接参数即可。但是往往随着业务量发展，我们通常会进行数据库拆分或是引入其他数据库，从而我们需要配置多个数据源，下面基于之前的JdbcTemplate和Spring-data-jpa例子分别介绍两种多数据源的配置方式。

多数据源配置

创建一个Spring配置类，定义两个DataSource用来读取application.properties中的不同配置。如下例子中，主数据源配置为spring.datasource.primary开头的配置，第二数据源配置为spring.datasource.secondary开头的配置。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
@Configuration

public class DataSourceConfig {
    @Bean(name = "primaryDataSource")
    @Qualifier("primaryDataSource")
    @ConfigurationProperties(prefix="spring.datasource.primary")
    public DataSource primaryDataSource() {
        return DataSourceBuilder.create().build();
    }
    @Bean(name = "secondaryDataSource")
    @Qualifier("secondaryDataSource")
    @Primary

    @ConfigurationProperties(prefix="spring.datasource.secondary")
    public DataSource secondaryDataSource() {
        return DataSourceBuilder.create().build();
    }
}

对应的application.properties配置如下：

1
2
3
4
5
6
7
8
9
 
spring.datasource.primary.url=jdbc:mysql://localhost:3306/test1
spring.datasource.primary.username=root
spring.datasource.primary.password=root
spring.datasource.primary.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.secondary.url=jdbc:mysql://localhost:3306/test2
spring.datasource.secondary.username=root
spring.datasource.secondary.password=root
spring.datasource.secondary.driver-class-name=com.mysql.jdbc.Driver

JdbcTemplate支持

对JdbcTemplate的支持比较简单，只需要为其注入对应的datasource即可，如下例子，在创建JdbcTemplate的时候分别注入名为primaryDataSource和secondaryDataSource的数据源来区分不同的JdbcTemplate。

1
2
3
4
5
6
7
8
9
10
11
12
 

@Bean(name = "primaryJdbcTemplate")
public JdbcTemplate primaryJdbcTemplate(
        @Qualifier("primaryDataSource") DataSource dataSource) {
    return new JdbcTemplate(dataSource);
}

@Bean(name = "secondaryJdbcTemplate")
public JdbcTemplate secondaryJdbcTemplate(
        @Qualifier("secondaryDataSource") DataSource dataSource) {
    return new JdbcTemplate(dataSource);
}

接下来通过测试用例来演示如何使用这两个针对不同数据源的JdbcTemplate。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 

@RunWith(SpringJUnit4ClassRunner.class)

@SpringApplicationConfiguration(Application.class)

public class ApplicationTests {
	@Autowired

	@Qualifier("primaryJdbcTemplate")
	protected JdbcTemplate jdbcTemplate1;
	@Autowired

	@Qualifier("secondaryJdbcTemplate")
	protected JdbcTemplate jdbcTemplate2;
	@Before

	public void setUp() {
		jdbcTemplate1.update("DELETE  FROM  USER ");
		jdbcTemplate2.update("DELETE  FROM  USER ");
	}
	@Test

	public void test() throws Exception {
		// 往第一个数据源中插入两条数据

		jdbcTemplate1.update("insert into user(id,name,age) values(?, ?, ?)", 1, "aaa", 20);
		jdbcTemplate1.update("insert into user(id,name,age) values(?, ?, ?)", 2, "bbb", 30);
		// 往第二个数据源中插入一条数据，若插入的是第一个数据源，则会主键冲突报错

		jdbcTemplate2.update("insert into user(id,name,age) values(?, ?, ?)", 1, "aaa", 20);
		// 查一下第一个数据源中是否有两条数据，验证插入是否成功

		Assert.assertEquals("2", jdbcTemplate1.queryForObject("select count(1) from user", String.class));
		// 查一下第一个数据源中是否有两条数据，验证插入是否成功

		Assert.assertEquals("1", jdbcTemplate2.queryForObject("select count(1) from user", String.class));
	}
}

完整示例:Chapter3-2-3

Spring-data-jpa支持

对于数据源的配置可以沿用上例中DataSourceConfig的实现。

新增对第一数据源的JPA配置，注意两处注释的地方，用于指定数据源对应的Entity实体和Repository定义位置，用@Primary区分主数据源。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
@Configuration
@EnableTransactionManagement

@EnableJpaRepositories(
        entityManagerFactoryRef="entityManagerFactoryPrimary",
        transactionManagerRef="transactionManagerPrimary",
        basePackages= { "com.didispace.domain.p" }) //设置Repository所在位置


public class PrimaryConfig {
    @Autowired @Qualifier("primaryDataSource")
    private DataSource primaryDataSource;
    @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)
                .properties(getVendorProperties(primaryDataSource))
                .packages("com.didispace.domain.p") //设置实体类所在位置

                .persistenceUnit("primaryPersistenceUnit")
                .build();
    }
    @Autowired

    private JpaProperties jpaProperties;
    private Map<String, String> getVendorProperties(DataSource dataSource) {
        return jpaProperties.getHibernateProperties(dataSource);
    }
    @Primary

    @Bean(name = "transactionManagerPrimary")
    public PlatformTransactionManager transactionManagerPrimary(EntityManagerFactoryBuilder builder) {
        return new JpaTransactionManager(entityManagerFactoryPrimary(builder).getObject());
    }
}

新增对第二数据源的JPA配置，内容与第一数据源类似，具体如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
@Configuration
@EnableTransactionManagement

@EnableJpaRepositories(
        entityManagerFactoryRef="entityManagerFactorySecondary",
        transactionManagerRef="transactionManagerSecondary",
        basePackages= { "com.didispace.domain.s" }) //设置Repository所在位置


public class SecondaryConfig {
    @Autowired @Qualifier("secondaryDataSource")
    private DataSource secondaryDataSource;
    @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)
                .properties(getVendorProperties(secondaryDataSource))
                .packages("com.didispace.domain.s") //设置实体类所在位置

                .persistenceUnit("secondaryPersistenceUnit")
                .build();
    }
    @Autowired

    private JpaProperties jpaProperties;
    private Map<String, String> getVendorProperties(DataSource dataSource) {
        return jpaProperties.getHibernateProperties(dataSource);
    }
    @Bean(name = "transactionManagerSecondary")
    PlatformTransactionManager transactionManagerSecondary(EntityManagerFactoryBuilder builder) {
        return new JpaTransactionManager(entityManagerFactorySecondary(builder).getObject());
    }
}

完成了以上配置之后，主数据源的实体和数据访问对象位于：com.didispace.domain.p，次数据源的实体和数据访问接口位于：com.didispace.domain.s。

分别在这两个package下创建各自的实体和数据访问接口

  • 主数据源下，创建User实体和对应的Repository接口
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
@Entity

public class User {
    @Id

    @GeneratedValue

    private Long id;
    @Column(nullable = false)
    private String name;
    @Column(nullable = false)
    private Integer age;
    public User(){}
    public User(String name, Integer age) {
        this.name = name;
        this.age = age;
    }
    // 省略getter、setter

}
 
1
2
3
 

public interface UserRepository extends JpaRepository<User, Long> {
}
  • 从数据源下，创建Message实体和对应的Repository接口
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
@Entity

public class Message {
    @Id

    @GeneratedValue

    private Long id;
    @Column(nullable = false)
    private String name;
    @Column(nullable = false)
    private String content;
    public Message(){}
    public Message(String name, String content) {
        this.name = name;
        this.content = content;
    }
    // 省略getter、setter

}
 
1
2
3
 

public interface MessageRepository extends JpaRepository<Message, Long> {
}

接下来通过测试用例来验证使用这两个针对不同数据源的配置进行数据操作。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 

@RunWith(SpringJUnit4ClassRunner.class)

@SpringApplicationConfiguration(Application.class)

public class ApplicationTests {
	@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());
	}
}

完整示例:Chapter3-2-4

分享到：
| 手把手教你用Spring Cloud和Docker构建微服 ...
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    spring boot多数据源配置

    首先，我们需要在`pom.xml`或`build.gradle`文件中添加相应的Spring Boot数据源依赖，例如MySQL和Oracle： ```xml &lt;groupId&gt;org.springframework.boot &lt;artifactId&gt;spring-boot-starter-data-jpa &lt;groupId&gt;...

    Spring Boot多数据源(JdbcTemplate)配置与使用

    在本教程中，我们将深入探讨如何在Spring Boot项目中配置和使用多数据源以及JdbcTemplate。 首先，让我们了解什么是`JdbcTemplate`。它是Spring提供的一种模板类，用于执行SQL语句，通过回调机制将结果转换为Java...

    Spring Boot+Jpa多数据源配置Demo（支持不同数据库）

    总结来说，Spring Boot + JPA 的多数据源配置需要对Spring的配置机制有深入理解，包括自动配置、bean的创建、数据源的切换等。同时，合理组织实体类和数据库访问层，确保代码的可维护性和扩展性。这个名为`...

    Spring Boot多数据源配置

    本篇文章将详细介绍如何在Spring Boot中进行多数据源配置，以及与Mybatis框架的集成，包括Mybatis的通用插件和分页插件的配置。 首先，我们来看Spring Boot如何实现多数据源配置。Spring Boot的自动配置特性使得...

    spring boot 2多数据源，里面有hibernate和mybatis的多数据源代码

    在Spring Boot 2框架中，实现多数据源的配置是一项重要的任务，特别是在大型企业级应用中，可能需要连接到不同的数据库来满足不同业务的需求。在这个项目中，我们有两个主要的数据访问技术：Hibernate和MyBatis，...

    springboot多数据源配置

    在Spring Boot应用中，多数据源配置是一项重要的技术实践，特别是在大型系统中，可能需要连接到多个数据库以实现数据隔离、读写分离或是分布式事务管理。Spring Boot以其强大的自动化配置能力，使得设置多数据源变得...

    Spring Boot使用spring-data-jpa配置Mysql多数据源

    在Spring Boot应用中，使用`spring-data-jpa`来配置MySQL多数据源是一项常见的需求，尤其是在构建大型分布式系统时，为了实现数据隔离、负载均衡或读写分离等目的。本教程将详细介绍如何在Spring Boot项目中配置多个...

    spring boot多数据源(AOP注解动态切换）

    在Spring Boot应用中，多数据源的配置与管理是一项重要的任务，特别是在大型系统中，可能需要连接到不同的数据库以满足不同业务的需求。本教程将详细讲解如何在Spring Boot项目中集成Druid连接池，并利用AOP注解实现...

    spring-boot2.0多数据源

    4. **配置多数据源**: 在Spring Boot中，可以通过配置不同的`@Configuration`类来设置多个数据源。每个数据源可以有自己的`DataSourceProperties`，并通过`@Bean`注解创建对应的`DataSource`实例。 5. **切换数据源...

    spring boot 多数据源项目

    通过这个项目，开发者可以快速理解和实践Spring Boot多数据源的整合，了解如何在实际项目中实现多数据源的切换和管理，以及Thymeleaf模板引擎的使用。这将有助于提升开发效率，为复杂的企业级应用提供稳定的基础架构...

    spring boot多数据源.rar

    总的来说，Spring Boot多数据源的配置涉及了Spring Boot的自动配置、数据源的创建与切换、事务管理的定制等多个方面。掌握这些知识点有助于构建更加复杂和灵活的分布式系统。通过学习和实践提供的源码，开发者能够更...

    SpringBoot多数据源配置（方式一：配置多个mapper扫描不同的包路径实现多数据源配置）.docx

    ### Spring Boot多数据源配置详解 #### 一、引言 在实际的软件开发过程中，随着业务需求的多样化，单一的数据源已经无法满足所有场景的需求。例如，有时我们需要同时访问两个或更多的数据库来完成复杂的业务逻辑，...

    Spring Boot多数据源(支持Spring声明式事务切换和回滚).pdf

    《Spring Boot多数据源(支持Spring声明式事务切换和回滚)》 Spring Boot多数据源技术是构建高效、灵活的多租户SaaS架构的关键。在本文中，我们将深入探讨如何实现动态数据源切换，支持Spring声明式事务管理，并讨论...

    基于注解和Spring的多数据源配置和使用

    在Spring Boot中，可以通过配置文件（如application.properties或application.yml）指定当前环境，然后在数据源配置类上使用`@Profile`注解，使其在特定环境中生效。 3. **使用`@Configuration`和`@Bean`注解**：在...

    spring boot数据源切换demo

    本示例“spring boot数据源切换demo”将展示如何在Spring Boot中集成MyBatis Plus进行多数据源的配置与切换。 首先，我们需要了解Spring Boot对数据源的支持。Spring Boot默认支持多种数据库，如MySQL、Oracle等，...

    SpringBoot配置多数据源实现动态切换数据源

    本文将深入探讨如何在SpringBoot项目中配置多数据源，并实现数据源的动态切换，帮助你理解和掌握这一核心技能。 首先，我们理解"多数据源"的概念。在SpringBoot应用中，多数据源意味着系统能够连接并操作多个不同的...

    spring boot 多数据源

    Spring Boot的声明式事务管理可以轻松地与多数据源结合。通过@Transactioal注解，我们可以指定事务作用于哪个数据源。如果未明确指定，Spring会使用默认的数据源。 了解了基础配置后，深入源码有助于我们更好地理解...

    spring boot 双数据源

    Spring Boot作为流行的Java开发框架，提供了一种便捷的方式来管理和配置多数据源。本篇将深入探讨如何在Spring Boot项目中实现双数据源配置。 首先，我们需要理解什么是数据源（DataSource）。数据源是Java中用于...

    STS下spring boot、mybatis多数据源配置

    本项目是基于Spring Boot和MyBatis实现的多数据源配置示例，适合在Spring Tool Suite (STS) 开发环境中运行。 首先，我们需要理解Spring Boot的自动配置特性。Spring Boot通过`@EnableAutoConfiguration`注解简化了...

    spring boot多数据源

    spring boot多数据源

Magicbox
Global site tag (gtag.js) - Google Analytics