Implement multi-tenant architecture based on SpringBoot: support application multi-tenant deployment and management

1. Overview

1 What is a multi-tenant architecture?

Multi-tenant architecture refers to supporting simultaneous access by multiple tenants (Tenant) in an application, each tenant has independent resources and data, and is completely isolated from each other. In layman’s terms, multi-tenancy is to “split” an application into multiple independent instances according to customer needs, and each instance does not interfere with each other.

2 Advantages of multi-tenant architecture

  • Better meet the individual needs of different tenants.

  • It can reduce operation and maintenance costs and reduce investment in infrastructure such as hardware and networks.

  • Save development costs, and quickly launch new tenant instances by reusing code.

  • The scalability and scalability of the system are enhanced, horizontal expansion is supported, and the data and resources of each tenant can be managed and controlled.

3 Technology selection for implementing multi-tenant architecture

What is not the most important thing for realizing multi-tenant architecture technology is the correct architecture idea. But choosing the right technology can lead to a faster multi-tenant architecture.

2. Design ideas

1 Architecture selection

It is recommended to use Spring Boot and Spring Cloud to develop multi-tenant applications based on Java. Spring Boot can quickly build applications and provide many mature plug-ins. Spring Cloud provides many tools and components to implement microservice architecture.

1.1 Spring Boot

Using Spring Boot can simplify the project construction process and automatically configure many common third-party libraries and components, reducing the workload of developers.

public class TenantController {

    public String hello(@RequestHeader("tenant-id") String tenantId) {
        return "Hello, " + tenantId;

1.2 Spring Cloud

Spring Cloud will be more useful when architecting multi-tenant systems. Spring Cloud provides some mature solutions, such as Eureka, Zookeeper, Consul, etc., to realize microservice functions such as service discovery and load balancing.

2 Database Design

In a multi-tenant environment the database must store data separately for each tenant and ensure data isolation. We usually use the following two methods to achieve:

  • Multiple tenants share the same database, and each table contains a tenant_id column to distinguish data from different tenants.

  • Create separate databases for each tenant, each database has the same table structure, but the data is isolated from each other.

3 Application multi-tenant deployment

In order to achieve multi-tenancy in application deployment, we need to consider the following two issues.

3.1 Application isolation

In a multi-tenant environment, different tenants need to access different resources, so application isolation is required. This can be achieved by building separate containers or virtual machines, using namespaces, etc. Docker is a very popular technology for isolating containers.

3.2 Application Configuration

Since each tenant has its own configuration requirements, it is necessary to set application configuration information for each tenant, such as port number, SSL certificate, and so on. These configurations can be stored in a database or in a cloud configuration center.

4 Tenant Management

In a multi-tenant system, it is necessary to be able to manage the data and resources of different tenants, and at the same time, it is necessary to assign corresponding permissions to each tenant. Solutions usually include the following two parts.

4.1 Tenant information maintenance

The maintenance of tenant information includes operations such as adding, modifying, deleting, and querying. It is required to be able to quickly find the corresponding tenant information based on the tenant name or tenant ID.

    description VARCHAR(255),

4.2 Tenant permission control

In a multi-tenant application, access to system resources must be set separately for each tenant. For example, A tenant and B tenant cannot access each other’s data.

@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    protected void configure(HttpSecurity http) throws Exception {
        http. authorizeRequests()

    public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
        auth. userDetailsService(userDetailsService())
                .passwordEncoder(new BCryptPasswordEncoder())
                .password(new BCryptPasswordEncoder().encode("123456"))

3. Technical implementation

1 Multi-tenancy implementation in Spring Boot

In Spring Boot, multi-tenancy mechanism can be realized through multiple data sources and dynamic routing.

1.1 Implementation of multiple data sources

Multiple data sources refer to configuring different data sources for different tenants, so that each tenant can access its own independent data. The specific implementation method is as follows:

public class DataSourceConfig {
    @Bean(name = "dataSourceA")
    @ConfigurationProperties(prefix = "spring.datasource.a")
    public DataSource dataSourceA() {
        return DataSourceBuilder.create().build();

    @Bean(name = "dataSourceB")
    @ConfigurationProperties(prefix = "spring.datasource.b")
    public DataSource dataSourceB() {
        return DataSourceBuilder.create().build();

    @Bean(name = "dataSourceC")
    @ConfigurationProperties(prefix = "spring.datasource.c")
    public DataSource dataSourceC() {
        return DataSourceBuilder.create().build();

The above code is configured with three data sources corresponding to three tenants. Then when using, you can use annotations to mark the data sources that need to be connected.

public class ProductService {
    private DataSource dataSource;


1.2 Dynamic routing implementation

Dynamic routing refers to dynamically switching to the data source of the corresponding tenant according to the requested URL or parameters. The specific implementation is as follows:

public class DynamicDataSource extends AbstractRoutingDataSource {
    protected Object determineCurrentLookupKey() {
        return TenantContextHolder. getTenantId();

public class DataSourceConfig {
    @Bean(name = "dataSource")
    @ConfigurationProperties(prefix = "spring.datasource")
    public DataSource dataSource() {
        return DataSourceBuilder.create().type(DynamicDataSource.class).build();

The above is the core code of dynamic routing. DynamicDataSource inherits from AbstractRoutingDataSource, dynamically obtains the tenant ID through the determineCurrentLookupKey() method, and then switches to the corresponding data source .

2 Multi-tenancy implementation in Spring Cloud

In Spring Cloud, the multi-tenant mechanism can be realized through service registration and discovery, configuration center, load balancing, etc.

2.1 Service Registration and Discovery

Use Eureka in Spring Cloud to implement service registration and discovery. Each tenant’s service is registered with a different application name in the registry, and the client can access the service of the corresponding tenant through the service name.

2.2 Configuration Center

Use Spring Cloud Config as the configuration center. Configuration files are distinguished by tenant ID, and the client obtains configuration information by reading the configuration file of the corresponding tenant.

2.3 Load balancing

Use Spring Cloud Ribbon as a load balancer. Select the service instance corresponding to the tenant according to the requested URL or parameters to forward the request.

2.4 API

The multi-tenancy mechanism is implemented at the API gateway level to determine the tenant according to the URL or parameters of the request, and forward it to the service instance of the corresponding tenant.

4. Application scenarios

1 Private cloud environment

The private cloud environment refers to the cloud environment built by the enterprise itself, which does not provide external services and is mainly used for data storage, management, sharing and security control within the enterprise. Compared with the public cloud, the advantage of the private cloud is that it can better protect the core data of the enterprise, and it can also meet the requirements of the enterprise for data security and controllability.

2 Public cloud environment

The public cloud environment refers to the cloud environment built by cloud service providers and provides external services. Users can purchase corresponding cloud services according to their needs, such as cloud storage, cloud computing, cloud database, etc. Compared with private clouds, public clouds have the advantages of low cost, elastic scalability, and global deployment, which can better meet the needs of rapid development of enterprises.

3 Enterprise applications

Enterprise-level applications refer to applications for enterprise customers, mainly including a series of application systems such as ERP, CRM, and OA. This type of application is characterized by powerful functions, complex processes, and a large amount of data, and needs to meet the requirements of high efficiency, high reliability, high security, and easy maintenance of the enterprise. In the cloud computing environment, enterprises can deploy these applications on private clouds or public clouds, which reduces the investment and maintenance costs of hardware equipment and improves management efficiency.

5. Implementation steps

1 Build Spring Boot and Spring Cloud environment

First, the following dependencies need to be introduced into the Maven project:

<!-- Spring Boot -->

<!-- Spring Cloud -->

Then you need to configure the corresponding parameters in application.yml, as follows:

    url: jdbc:mysql://localhost:3306/appdb?useUnicode=true &characterEncoding=utf-8 &serverTimezone=Asia/Shanghai
    username: root
    password: 123456

  type-aliases-package: com.example.demo.model
  mapper-locations: classpath:mapper/*.xml

  port: 8080

      defaultZone: http://localhost:8761/eureka/

        include: "*"

Among them, datasource.url is the URL of the database connection, username and password are the account number and password of the database connection; server.port is the port started by the Spring Boot application; eureka .client.serviceUrl.defaultZone is the URL of the Eureka service registry.

2 Modify the database design

The database will then need to be modified accordingly to support multi-tenant deployments. Specifically, we need to add a tenant-related field in the database to distinguish different tenants in the application.

3 Realize application multi-tenant deployment

Then you need to implement the multi-tenant deployment function of the application in the code. Specifically, we need to instantiate the corresponding Spring Bean for each tenant, and route the request to the corresponding Bean for processing according to the tenant ID.

Here is an example of a simple implementation:

public class MultiTenantConfig {
    // Provide the data source corresponding to the tenant
    public DataSource dataSource(TenantRegistry tenantRegistry) {
        return new TenantAwareDataSource(tenantRegistry);
    // multi-tenant Session factory
    @Bean(name = "sqlSessionFactory")
    public SqlSessionFactory sqlSessionFactory(DataSource dataSource)
            throws Exception {
        SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
        return sessionFactory. getObject();
    // Dynamically switch tenants
    public MultiTenantInterceptor multiTenantInterceptor(TenantResolver tenantResolver) {
        MultiTenantInterceptor interceptor = new MultiTenantInterceptor();
        return interceptor;
    // register interceptor
    public void addInterceptors(InterceptorRegistry registry) {
    // Register tenant information
    public TenantRegistry tenantRegistry() {
        return new TenantRegistryImpl();
    // parse the tenant ID
    public TenantResolver tenantResolver() {
        return new HeaderTenantResolver();

Among them, MultiTenantConfig is the core configuration class for multi-tenant deployment, which provides functions such as corresponding tenant data source, multi-tenant Session factory, and dynamic switching of tenants.

4 Realize tenant management

Finally, a tenant management function needs to be implemented to manage different tenants in the system. Specifically, we can use Spring Cloud’s service registration and discovery component Eureka to register each tenant’s instance and perform corresponding operations in the management interface. In addition, we also need to provide an independent database for each tenant to ensure data isolation.

6. Summary review

This article details how to use Spring Boot and Spring Cloud to implement an application that supports multi-tenant deployment. It mainly includes building Spring Boot and Spring Cloud environments, modifying database design, implementing multi-tenant deployment of applications, and implementing tenant management.

Application scenarios mainly include SaaS applications, multi-tenant cloud services, etc. The advantages and disadvantages are mainly reflected in improving the scalability and maintainability of the application, but also increasing the complexity of deployment and management. Future improvement directions can consider further improving the automation of multi-tenant management to reduce manual intervention and error rates.



Back-end exclusive technology group

Build a high-quality technical exchange community, welcome to join the group who are engaged in programming development and technical recruitment HR, and also welcome everyone to share your company’s referral information, help each other, and make progress together!

Civilized speech, mainly focusing on communication technology, job referral, industry discussion

Advertisers do not enter, do not trust private chats, to prevent being cheated


Add me as a friend and pull you into the group
The knowledge points of the article match the official knowledge files, and you can further learn relevant knowledge. Java skill treeHomepageOverview 118926 people are studying systematically