Quarkus+saas multi tenant dynamic data source switching is simple and perfect

What I want to share with you today is quarkus Dynamic data source problem , Before we start, we can think about spring How to implement the system needs to write those codes .

First of all, you should understand what we are doing as a dynamic data source ： To handle the business requirements in different databases in one system

What projects do systems with such business requirements do ？ This may not be easy to summarize , The more common is the multi tenancy mode of independent data sources, which is known to all , There are other uses. This one is more personalized , As long as your business needs anything , For example, your system is to operate different databases and so on .

So what is the core technical principle of dynamically switching data sources ？ Personally, I think it is interception technology . To put it bluntly is to http A request must carry information that can be used to identify different database connections , Then this information is more flexible. For example, you can use header The information can even be in the form of a user name , You always have to enter the user name to log in to the system , As long as the user name can be checked in the database, a series of information about the user can occur , It's easy to understand . But in most cases, people prefer to use header To carry this information .

Today is about quarkus How to dynamically switch data sources is virtually a problem spring System comparison , After reading it, you will understand .

I have made an issue of the video ： headlines ：

https://www.ixigua.com/i7110837364703887904/

B standing ：

https://www.bilibili.com/video/BV1nA4y1d7rC?share_source=copy_web

At that time, it basically realized , Today, I think it has really solved all the technical problems , It can achieve perfect effect , Of course, I haven't done it perfectly, but the technical difficulties have been solved , You can play by yourself and do better for yourself .

First of all, say quarkus The information about multi tenancy on the official website describes the place ：

https://quarkus.io/guides/hibernate-orm#multitenancy

The dynamic data source of programming mode mentioned several interfaces we used , Of course, there is no concrete implementation . I'd also like to mention quarkus At present, there are two modes that can be implemented ： Based on the OIDC(OpenID Connect) And the traditional model we are now implementing , They are all based on header Of .

This diagram is the logic of the dynamic data source I implemented , I think everyone can understand , I won't say one by one .

I posted the key code , Source code everyone to see （

https://gitee.com/weir_admin/weirblog-quarkus/tree/master/quarkus-tanent2）

package com.weir.quarku.tanent;

import io.quarkus.arc.Unremovable;
import io.quarkus.hibernate.orm.runtime.tenant.TenantResolver;

import javax.enterprise.context.RequestScoped;
import javax.inject.Inject;
import java.util.Optional;

/**
 *  Identify dynamic tenant information ( Usually by web Of request from header Transfer tenant information )
 * @author weir
 *
 */
@RequestScoped
@Unremovable
public class InjectableTenantResolver implements TenantResolver {

 @Inject
 TenantConnections tenantConnections;

 private Optional<String> requestTenant = Optional.empty();

 public void setRequestTenant(String requestTenant) {
 this.requestTenant = Optional.of(requestTenant);
 }
 /**
 *  Default tenant
 */
 @Override
 public String getDefaultTenantId() {
 return tenantConnections.allTenants()
 .stream()
 .findAny()
 .orElseThrow(() -> new RuntimeException(&quot;No tenants known at all&quot;));
 }
 /**
 *  Current tenants
 */
 @Override
 public String resolveTenantId() {
 return requestTenant.orElseThrow(() -> new RuntimeException(&quot;No tenant specified by current request&quot;));
 }
}

package com.weir.quarku.tanent;

import io.agroal.api.AgroalDataSource;
import io.agroal.api.configuration.AgroalDataSourceConfiguration;
import io.agroal.api.configuration.supplier.AgroalDataSourceConfigurationSupplier;
import io.agroal.api.security.NamePrincipal;
import io.agroal.api.security.SimplePassword;
import io.quarkus.arc.Unremovable;
import io.quarkus.hibernate.orm.runtime.customized.QuarkusConnectionProvider;
import io.quarkus.hibernate.orm.runtime.tenant.TenantConnectionResolver;
import org.hibernate.engine.jdbc.connections.spi.ConnectionProvider;

import javax.enterprise.context.ApplicationScoped;
import javax.inject.Inject;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.*;

import static io.agroal.api.configuration.AgroalConnectionPoolConfiguration.ConnectionValidator.defaultValidator;
import static java.time.Duration.ofSeconds;

/**
 *  Dynamically generate and switch data source connections
 * @author weir
 *
 */
//@PersistenceUnitExtension
@ApplicationScoped
@Unremovable
public class TenantConnections implements TenantConnectionResolver {

private final Map<String, DBConnectionInfo> dbConnectionInfoMap = new HashMap<>();
// {
//  {
//  put(&quot;weir&quot;,new DBConnectionInfo(&quot;localhost&quot;, 3306, &quot;root&quot;, &quot;336393&quot;, &quot;quarkus-demo&quot;));
//  put(&quot;weir-blog&quot;,new DBConnectionInfo(&quot;localhost&quot;, 3306, &quot;root&quot;, &quot;336393&quot;, &quot;weirblog&quot;));
//  }
// };

private final Map<String, ConnectionProvider> cache = new HashMap<>();

private static AgroalDataSourceConfiguration createDataSourceConfiguration(DBConnectionInfo dbConnectionInfo) {
System.out.println(&quot;------------------createDataSourceConfiguration--------------&quot; + dbConnectionInfo);
return new AgroalDataSourceConfigurationSupplier()
.dataSourceImplementation(AgroalDataSourceConfiguration.DataSourceImplementation.AGROAL)
.metricsEnabled(false)
.connectionPoolConfiguration(cp -> cp.minSize(0).maxSize(5).initialSize(0)
.connectionValidator(defaultValidator()).acquisitionTimeout(ofSeconds(5))
.leakTimeout(ofSeconds(5)).validationTimeout(ofSeconds(50)).reapTimeout(ofSeconds(500))
.connectionFactoryConfiguration(cf -> cf
.jdbcUrl(&quot;jdbc:mysql://&quot; + dbConnectionInfo.getHost() + &quot;:&quot; + dbConnectionInfo.getPort()
+ &quot;/&quot; + dbConnectionInfo.getDb())
.connectionProviderClassName(&quot;com.mysql.cj.jdbc.Driver&quot;)
// .connectionProviderClassName(&quot;org.postgresql.Driver&quot;)
.principal(new NamePrincipal(dbConnectionInfo.getUser()))
.credential(new SimplePassword(dbConnectionInfo.getPassword()))))
.get();
}

public Set<String> allTenants() {
getTenant();
System.out.println(&quot;---------------TenantConnections--------allTenants-------&quot; + dbConnectionInfoMap.keySet());
return dbConnectionInfoMap.keySet();
}

@Inject
AgroalDataSource defaultDataSource;

private void getTenant() {
Connection connection = null;
Statement statement = null;
ResultSet resultSet = null;
try {
connection = defaultDataSource.getConnection();
statement = connection.createStatement();
resultSet = statement.executeQuery(&quot;select * from SysTenant&quot;);

while (resultSet.next()) {
dbConnectionInfoMap.put(resultSet.getString(&quot;code&quot;),
new DBConnectionInfo(resultSet.getString(&quot;host&quot;), resultSet.getInt(&quot;port&quot;),
resultSet.getString(&quot;username&quot;), resultSet.getString(&quot;password&quot;),
resultSet.getString(&quot;dbName&quot;)));
// System.out.println(&quot;--------------------------&quot;+resultSet.getString(&quot;name&quot;)+&quot;--&quot;+resultSet.getString(&quot;username&quot;));
}
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

@Override
public ConnectionProvider resolve(String tenant) {
System.out.println(&quot;---------------TenantConnections--------resolve-------&quot; + tenant);
if (!dbConnectionInfoMap.containsKey(tenant)) {
throw new IllegalStateException(&quot;Unknown tenantId: &quot; + tenant);
}

if (!cache.containsKey(tenant)) {
try {
DBConnectionInfo dbConnectionInfo = dbConnectionInfoMap.get(tenant);
AgroalDataSource agroalDataSource = AgroalDataSource
.from(createDataSourceConfiguration(dbConnectionInfo));
QuarkusConnectionProvider quarkusConnectionProvider = new QuarkusConnectionProvider(agroalDataSource);
cache.put(tenant, quarkusConnectionProvider);
return quarkusConnectionProvider;
} catch (SQLException ex) {
throw new IllegalStateException(&quot;Failed to create a new data source based on the tenantId: &quot; + tenant,
ex);
}
}
return cache.get(tenant);
}
}

package com.weir.quarku.tanent;

import javax.enterprise.context.ApplicationScoped;
import javax.inject.Inject;
import javax.ws.rs.container.ContainerRequestContext;
import javax.ws.rs.container.ContainerRequestFilter;
import javax.ws.rs.ext.Provider;
import java.io.IOException;

/**
 *  Intercept web in header And set it to TenantResolver(InjectableTenantResolver)
 * @author weir
 *
 */
@Provider
@ApplicationScoped
public class TenantRequestFilter implements ContainerRequestFilter {

 @Inject
 InjectableTenantResolver tenantResolver;

 @Override
 public void filter(ContainerRequestContext containerRequestContext) throws IOException {
 String tenantId = containerRequestContext.getHeaderString(&quot;X-tenant&quot;);
 if (tenantId != null) {
 tenantResolver.setRequestTenant(tenantId);
 }
 }
}


quarkus The package is really amazing .

How do you feel after watching , I believe you can understand , I also believe that this implementation is better than spring The system is simple , Anyway, I believe .