本文由 简悦 SimpRead 转码， 原文地址 blog.csdn.net
在现代应用程序中，多租户架构是一种非常流行的设计模式。多租户架构允许多个客户（租户）共享同一个应用程序实例，同时确保数据的隔离性和安全性。本文将详细介绍如何在 Spring Boot 应用程序中配置和实现多租户支持，并提供丰富的 Java 代码示例，帮助你更加深入地理解多租户架构的实现。
1. 什么是多租户架构？
多租户架构是一种软件架构模式，其中单个应用程序实例为多个租户（客户）提供服务。每个租户的数据和配置都是隔离的，确保不同租户之间的数据安全和隐私。多租户架构通常有三种实现方式：
- 共享数据库，独立数据表：所有租户共享同一个数据库，但每个租户有独立的数据表。
- 共享数据库，共享数据表：所有租户共享同一个数据库和数据表，通过区分租户标识来隔离数据。
- 独立数据库：每个租户有独立的数据库实例。
本文将重点介绍共享数据库，共享数据表的多租户实现方式。
2. Spring Boot 多租户配置
我们将使用 Spring Boot 和 Hibernate 来实现多租户支持。以下是实现步骤：
- 设置基本项目结构。
- 配置数据源和 Hibernate 拦截器。
- 创建租户解析器。
- 配置实体和存储库。
- 测试多租户实现。
3. 设置基本项目结构
首先，创建一个 Spring Boot 项目，并添加以下依赖：
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<scope>runtime</scope>
</dependency>
</dependencies>
4. 配置数据源和 Hibernate 拦截器
在application.properties中配置数据源：
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=password
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.H2Dialect
spring.jpa.show-sql=true
spring.jpa.hibernate.ddl-auto=update
创建一个TenantInterceptor类，用于拦截数据库操作并添加租户上下文：
import org.hibernate.EmptyInterceptor;
import org.hibernate.type.Type;
import org.springframework.stereotype.Component;
import java.io.Serializable;
@Component
public class TenantInterceptor extends EmptyInterceptor {
@Override
public boolean onSave(Object entity, Serializable id, Object[] state, String[] propertyNames, Type[] types) {
// 在保存实体时添加租户标识
for (int i = 0; i < propertyNames.length; i++) {
if ("tenantId".equals(propertyNames[i])) {
state[i] = TenantContext.getCurrentTenant();
return true;
}
}
return false;
}
@Override
public boolean onFlushDirty(Object entity, Serializable id, Object[] currentState, Object[] previousState, String[] propertyNames, Type[] types) {
// 在更新实体时添加租户标识
for (int i = 0; i < propertyNames.length; i++) {
if ("tenantId".equals(propertyNames[i])) {
currentState[i] = TenantContext.getCurrentTenant();
return true;
}
}
return false;
}
}
配置TenantContext，用于保存当前租户标识：
public class TenantContext {
private static final ThreadLocal<String> currentTenant = new ThreadLocal<>();
public static void setCurrentTenant(String tenantId) {
currentTenant.set(tenantId);
}
public static String getCurrentTenant() {
return currentTenant.get();
}
public static void clear() {
currentTenant.remove();
}
}
5. 创建租户解析器
租户解析器用于从请求中提取租户标识，并设置到TenantContext中。我们可以通过 Spring 的过滤器来实现这一功能。
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
public class TenantFilter implements Filter {
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws IOException, ServletException {
HttpServletRequest httpRequest = (HttpServletRequest) request;
String tenantId = httpRequest.getHeader("X-TenantID");
if (tenantId != null) {
TenantContext.setCurrentTenant(tenantId);
}
try {
chain.doFilter(request, response);
} finally {
TenantContext.clear();
}
}
@Override
public void init(FilterConfig filterConfig) throws ServletException {
}
@Override
public void destroy() {
}
}
在配置类中注册这个过滤器：
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class TenantConfiguration {
@Bean
public FilterRegistrationBean<TenantFilter> tenantFilter() {
FilterRegistrationBean<TenantFilter> registrationBean = new FilterRegistrationBean<>();
registrationBean.setFilter(new TenantFilter());
registrationBean.addUrlPatterns("/*");
return registrationBean;
}
}
6. 配置实体和存储库
创建一个示例实体，并在其中包含租户标识字段：
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
@Entity
public class Product {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String tenantId;
private String name;
private Double price;
// Getter和Setter方法
}
创建一个 Spring Data JPA 存储库接口：
import org.springframework.data.jpa.repository.JpaRepository;
import java.util.List;
public interface ProductRepository extends JpaRepository<Product, Long> {
List<Product> findByTenantId(String tenantId);
}
7. 测试多租户实现
创建一个简单的控制器来测试多租户功能：
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RestController
@RequestMapping("/products")
public class ProductController {
@Autowired
private ProductRepository productRepository;
@PostMapping
public Product createProduct(@RequestBody Product product) {
return productRepository.save(product);
}
@GetMapping
public List<Product> getProducts() {
String tenantId = TenantContext.getCurrentTenant();
return productRepository.findByTenantId(tenantId);
}
}
测试多租户功能可以通过以下步骤进行：
- 启动 Spring Boot 应用程序。
- 使用不同的
X-TenantID头发送请求来创建和获取产品。
例如，使用 cURL 命令创建和获取产品：
# 创建产品，租户ID为tenant1
curl -H "X-TenantID: tenant1" -X POST -d '{"name": "Product A", "price": 10.99}' -H "Content-Type: application/json" http://localhost:8080/products
# 创建产品，租户ID为tenant2
curl -H "X-TenantID: tenant2" -X POST -d '{"name": "Product B", "price": 15.99}' -H "Content-Type: application/json" http://localhost:8080/products
# 获取产品，租户ID为tenant1
curl -H "X-TenantID: tenant1" http://localhost:8080/products
# 获取产品，租户ID为tenant2
curl -H "X-TenantID: tenant2" http://localhost:8080/products
通过以上步骤，你可以看到不同租户具有自己的产品列表，实现了数据隔离的多租户架构。
8. 结论
本文详细介绍了如何在 Spring Boot 应用程序中配置和实现多租户支持。通过使用 Spring Boot、Hibernate 拦截器和自定义过滤器，我们可以实现共享数据库、共享数据表的多租户架构。希望通过本文的详细解释和代码示例，能帮助你更好地理解和实现多租户支持的 Spring Boot 应用程序。