SpringBoot多租戶系統的五種架構設計方案
多租戶(Multi-tenancy)是一種軟件架構模式，允許單個應用實例服務于多個客戶(租戶)，同時保持租戶數據的隔離性和安全性。通過合理的多租戶設計，企業可以顯著降低運維成本、提升資源利用率，并實現更高效的服務交付。
多租戶(Multi-tenancy)是一種軟件架構模式，允許單個應用實例服務于多個客戶(租戶)，同時保持租戶數據的隔離性和安全性。
通過合理的多租戶設計，企業可以顯著降低運維成本、提升資源利用率，并實現更高效的服務交付。
本文將分享SpringBoot環境下實現多租戶系統的5種架構設計方案
方案一：獨立數據庫模式
原理與特點
獨立數據庫模式為每個租戶提供完全獨立的數據庫實例，是隔離級別最高的多租戶方案。在這種模式下，租戶數據完全分離，甚至可以部署在不同的服務器上。
實現步驟
1、創建多數據源配置：為每個租戶配置獨立的數據源
@Configuration
public class MultiTenantDatabaseConfig {
@Autowired
private TenantDataSourceProperties properties;
@Bean
public DataSource dataSource() {
AbstractRoutingDataSource multiTenantDataSource = new TenantAwareRoutingDataSource();
Map<Object, Object> targetDataSources = new HashMap<>();
// 為每個租戶創建數據源
for (TenantDataSourceProperties.TenantProperties tenant : properties.getTenants()) {
DataSource tenantDataSource = createDataSource(tenant);
targetDataSources.put(tenant.getTenantId(), tenantDataSource);
}
multiTenantDataSource.setTargetDataSources(targetDataSources);
return multiTenantDataSource;
}
private DataSource createDataSource(TenantDataSourceProperties.TenantProperties tenant) {
HikariDataSource dataSource = new HikariDataSource();
dataSource.setJdbcUrl(tenant.getUrl());
dataSource.setUsername(tenant.getUsername());
dataSource.setPassword(tenant.getPassword());
dataSource.setDriverClassName(tenant.getDriverClassName());
return dataSource;
}
}2、實現租戶感知的數據源路由：
public class TenantAwareRoutingDataSource extends AbstractRoutingDataSource {
@Override
protected Object determineCurrentLookupKey() {
return TenantContextHolder.getTenantId();
}
}3、租戶上下文管理：
public classTenantContextHolder {
privatestatic final ThreadLocal<String> CONTEXT = newThreadLocal<>();
publicstaticvoidsetTenantId(String tenantId) {
CONTEXT.set(tenantId);
}
publicstaticStringgetTenantId() {
returnCONTEXT.get();
}
publicstaticvoidclear() {
CONTEXT.remove();
}
}4、添加租戶識別攔截器：
@Component
publicclassTenantIdentificationInterceptorimplementsHandlerInterceptor {
@Override
publicbooleanpreHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
String tenantId = extractTenantId(request);
if (tenantId != null) {
TenantContextHolder.setTenantId(tenantId);
returntrue;
}
response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
returnfalse;
}
@Override
publicvoidafterCompletion(HttpServletRequest request, HttpServletResponse response,
Object handler, Exception ex) {
TenantContextHolder.clear();
}
privateStringextractTenantId(HttpServletRequest request) {
// 從請求頭中獲取租戶ID
String tenantId = request.getHeader("X-TenantID");
// 或者從子域名提取
if (tenantId == null) {
String host = request.getServerName();
if (host.contains(".")) {
tenantId = host.split("\.")[0];
}
}
return tenantId;
}
}5、配置攔截器：
@Configuration
publicclassWebConfigimplementsWebMvcConfigurer {
@Autowired
privateTenantIdentificationInterceptor tenantInterceptor;
@Override
publicvoidaddInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(tenantInterceptor)
.addPathPatterns("/api/**");
}
}6、實現動態租戶管理：
@Entity
@Table(name = "tenant")
publicclassTenant {
@Id
privateString id;
@Column(nullable = false)
privateString name;
@Column(nullable = false)
privateString databaseUrl;
@Column(nullable = false)
privateString username;
@Column(nullable = false)
privateString password;
@Column(nullable = false)
privateString driverClassName;
@Column
privateboolean active = true;
// getters and setters
}
@Repository
publicinterfaceTenantRepositoryextendsJpaRepository<Tenant, String> {
List<Tenant> findByActive(boolean active);
}
@Service
publicclassTenantManagementService {
@Autowired
privateTenantRepository tenantRepository;
@Autowired
privateDataSource dataSource;
@Autowired
privateApplicationContext applicationContext;
// 用ConcurrentHashMap存儲租戶數據源
private final Map<String, DataSource> tenantDataSources = newConcurrentHashMap<>();
@PostConstruct
publicvoidinitializeTenants() {
List<Tenant> activeTenants = tenantRepository.findByActive(true);
for (Tenant tenant : activeTenants) {
addTenant(tenant);
}
}
publicvoidaddTenant(Tenant tenant) {
// 創建新的數據源
HikariDataSource dataSource = newHikariDataSource();
dataSource.setJdbcUrl(tenant.getDatabaseUrl());
dataSource.setUsername(tenant.getUsername());
dataSource.setPassword(tenant.getPassword());
dataSource.setDriverClassName(tenant.getDriverClassName());
// 存儲數據源
tenantDataSources.put(tenant.getId(), dataSource);
// 更新路由數據源
updateRoutingDataSource();
// 保存租戶信息到數據庫
tenantRepository.save(tenant);
}
publicvoidremoveTenant(String tenantId) {
DataSource dataSource = tenantDataSources.remove(tenantId);
if (dataSource != null && dataSource instanceofHikariDataSource) {
((HikariDataSource) dataSource).close();
}
// 更新路由數據源
updateRoutingDataSource();
// 從數據庫移除租戶
tenantRepository.deleteById(tenantId);
}
privatevoidupdateRoutingDataSource() {
try {
TenantAwareRoutingDataSource routingDataSource = (TenantAwareRoutingDataSource) dataSource;
// 使用反射訪問AbstractRoutingDataSource的targetDataSources字段
Field targetDataSourcesField = AbstractRoutingDataSource.class.getDeclaredField("targetDataSources");
targetDataSourcesField.setAccessible(true);
Map<Object, Object> targetDataSources = newHashMap<>(tenantDataSources);
targetDataSourcesField.set(routingDataSource, targetDataSources);
// 調用afterPropertiesSet初始化數據源
routingDataSource.afterPropertiesSet();
} catch (Exception e) {
thrownewRuntimeException("Failed to update routing data source", e);
}
}
}7、提供租戶管理API：
@RestController
@RequestMapping("/admin/tenants")
public class TenantAdminController {
@Autowired
private TenantManagementService tenantService;
@GetMapping
public List<Tenant> getAllTenants() {
returntenantService.getAllTenants();
}
@PostMapping
publicResponseEntity<Tenant> createTenant(@RequestBody Tenant tenant) {
tenantService.addTenant(tenant);
returnResponseEntity.status(HttpStatus.CREATED).body(tenant);
}
@DeleteMapping("/{tenantId}")
publicResponseEntity<Void> deleteTenant(@PathVariable String tenantId) {
tenantService.removeTenant(tenantId);
returnResponseEntity.noContent().build();
}
}優缺點分析
優點：
? 數據隔離級別最高，安全性最佳
? 租戶可以使用不同的數據庫版本或類型
? 易于實現租戶特定的數據庫優化
? 故障隔離，一個租戶的數據庫問題不影響其他租戶
? 便于獨立備份、恢復和遷移
缺點：
? 資源利用率較低，成本較高
? 運維復雜度高，需要管理多個數據庫實例
? 跨租戶查詢困難
? 每增加一個租戶需要創建新的數據庫實例
? 數據庫連接池管理復雜
適用場景
? 高要求的企業級SaaS應用
? 租戶數量相對較少但數據量大的場景
? 租戶愿意支付更高費用獲得更好隔離性的場景
方案二：共享數據庫，獨立Schema模式
原理與特點
在這種模式下，所有租戶共享同一個數據庫實例，但每個租戶擁有自己獨立的Schema（在PostgreSQL中）或數據庫（在MySQL中）。這種方式在資源共享和數據隔離之間取得了平衡。
實現步驟
1、創建租戶Schema配置：
@Configuration
publicclassMultiTenantSchemaConfig {
@Autowired
privateDataSource dataSource;
@Autowired
privateTenantRepository tenantRepository;
@PostConstruct
publicvoidinitializeSchemas() {
for (Tenant tenant : tenantRepository.findByActive(true)) {
createSchemaIfNotExists(tenant.getSchemaName());
}
}
privatevoidcreateSchemaIfNotExists(String schema) {
try (Connection connection = dataSource.getConnection()) {
// PostgreSQL語法，MySQL使用CREATE DATABASE IF NOT EXISTS
String sql = "CREATE SCHEMA IF NOT EXISTS " + schema;
try (Statement stmt = connection.createStatement()) {
stmt.execute(sql);
}
} catch (SQLException e) {
thrownewRuntimeException("Failed to create schema: " + schema, e);
}
}
}2、租戶實體和存儲：
@Entity
@Table(name = "tenant")
public class Tenant {
@Id
private String id;
@Column(nullable = false)
private String name;
@Column(nullable = false, unique = true)
private String schemaName;
@Column
private boolean active = true;
// getters and setters
}
@Repository
public interface TenantRepository extends JpaRepository<Tenant, String> {
List<Tenant> findByActive(boolean active);
Optional<Tenant> findBySchemaName(String schemaName);
}3、配置Hibernate多租戶支持：
@Configuration
@EnableJpaRepositories(basePackages = "com.example.repository")
@EntityScan(basePackages = "com.example.entity")
public class JpaConfig {
@Autowired
private DataSource dataSource;
@Bean
public LocalContainerEntityManagerFactoryBean entityManagerFactory(
EntityManagerFactoryBuilder builder) {
Map<String, Object> properties = newHashMap<>();
properties.put(org.hibernate.cfg.Environment.MULTI_TENANT,
MultiTenancyStrategy.SCHEMA);
properties.put(org.hibernate.cfg.Environment.MULTI_TENANT_CONNECTION_PROVIDER,
multiTenantConnectionProvider());
properties.put(org.hibernate.cfg.Environment.MULTI_TENANT_IDENTIFIER_RESOLVER,
currentTenantIdentifierResolver());
// 其他Hibernate配置...
returnbuilder
.dataSource(dataSource)
.packages("com.example.entity")
.properties(properties)
.build();
}
@Bean
publicMultiTenantConnectionProvidermultiTenantConnectionProvider() {
returnnewSchemaBasedMultiTenantConnectionProvider();
}
@Bean
publicCurrentTenantIdentifierResolvercurrentTenantIdentifierResolver() {
returnnewTenantSchemaIdentifierResolver();
}
}4、實現多租戶連接提供者：
public classSchemaBasedMultiTenantConnectionProvider
implementsMultiTenantConnectionProvider {
privatestaticfinallongserialVersionUID=1L;
@Autowired
private DataSource dataSource;
@Override
public Connection getAnyConnection()throws SQLException {
return dataSource.getConnection();
}
@Override
publicvoidreleaseAnyConnection(Connection connection)throws SQLException {
connection.close();
}
@Override
public Connection getConnection(String tenantIdentifier)throws SQLException {
finalConnectionconnection= getAnyConnection();
try {
// PostgreSQL語法，MySQL使用USE database_name
connection.createStatement()
.execute(String.format("SET SCHEMA '%s'", tenantIdentifier));
} catch (SQLException e) {
thrownewHibernateException("Could not alter JDBC connection to schema ["
+ tenantIdentifier + "]", e);
}
return connection;
}
@Override
publicvoidreleaseConnection(String tenantIdentifier, Connection connection)
throws SQLException {
try {
// 恢復到默認Schema
connection.createStatement().execute("SET SCHEMA 'public'");
} catch (SQLException e) {
// 忽略錯誤，確保連接關閉
}
connection.close();
}
@Override
publicbooleansupportsAggressiveRelease() {
returnfalse;
}
@Override
publicbooleanisUnwrappableAs(Class unwrapType) {
returnfalse;
}
@Override
public <T> T unwrap(Class<T> unwrapType) {
returnnull;
}
}5、實現租戶標識解析器：
public classTenantSchemaIdentifierResolverimplementsCurrentTenantIdentifierResolver {
privatestatic final StringDEFAULT_TENANT = "public";
@Override
publicStringresolveCurrentTenantIdentifier() {
String tenantId = TenantContextHolder.getTenantId();
return tenantId != null ? tenantId : DEFAULT_TENANT;
}
@Override
publicbooleanvalidateExistingCurrentSessions() {
returntrue;
}
}6、動態租戶管理服務：
@Service
publicclassTenantSchemaManagementService {
@Autowired
privateTenantRepository tenantRepository;
@Autowired
privateDataSource dataSource;
@Autowired
privateEntityManagerFactory entityManagerFactory;
publicvoidcreateTenant(Tenant tenant) {
// 1. 創建Schema
createSchemaIfNotExists(tenant.getSchemaName());
// 2. 保存租戶信息
tenantRepository.save(tenant);
// 3. 初始化Schema的表結構
initializeSchema(tenant.getSchemaName());
}
publicvoiddeleteTenant(String tenantId) {
Tenant tenant = tenantRepository.findById(tenantId)
.orElseThrow(() -> newRuntimeException("Tenant not found: " + tenantId));
// 1. 刪除Schema
dropSchema(tenant.getSchemaName());
// 2. 刪除租戶信息
tenantRepository.delete(tenant);
}
privatevoidcreateSchemaIfNotExists(String schema) {
try (Connection connection = dataSource.getConnection()) {
String sql = "CREATE SCHEMA IF NOT EXISTS " + schema;
try (Statement stmt = connection.createStatement()) {
stmt.execute(sql);
}
} catch (SQLException e) {
thrownewRuntimeException("Failed to create schema: " + schema, e);
}
}
privatevoiddropSchema(String schema) {
try (Connection connection = dataSource.getConnection()) {
String sql = "DROP SCHEMA IF EXISTS " + schema + " CASCADE";
try (Statement stmt = connection.createStatement()) {
stmt.execute(sql);
}
} catch (SQLException e) {
thrownewRuntimeException("Failed to drop schema: " + schema, e);
}
}
privatevoidinitializeSchema(String schemaName) {
// 設置當前租戶上下文
String previousTenant = TenantContextHolder.getTenantId();
try {
TenantContextHolder.setTenantId(schemaName);
// 使用JPA/Hibernate工具初始化Schema
// 可以使用SchemaExport或更推薦使用Flyway/Liquibase
Session session = entityManagerFactory.createEntityManager().unwrap(Session.class);
session.doWork(connection -> {
// 執行DDL語句
});
} finally {
// 恢復之前的租戶上下文
if (previousTenant != null) {
TenantContextHolder.setTenantId(previousTenant);
} else {
TenantContextHolder.clear();
}
}
}
}7、租戶管理API：
@RestController
@RequestMapping("/admin/tenants")
public class TenantSchemaController {
@Autowired
private TenantSchemaManagementService tenantService;
@Autowired
private TenantRepository tenantRepository;
@GetMapping
public List<Tenant> getAllTenants() {
returntenantRepository.findAll();
}
@PostMapping
publicResponseEntity<Tenant> createTenant(@RequestBody Tenant tenant) {
tenantService.createTenant(tenant);
returnResponseEntity.status(HttpStatus.CREATED).body(tenant);
}
@DeleteMapping("/{tenantId}")
publicResponseEntity<Void> deleteTenant(@PathVariable String tenantId) {
tenantService.deleteTenant(tenantId);
returnResponseEntity.noContent().build();
}
}優缺點分析
優點：
? 資源利用率高于獨立數據庫模式
? 較好的數據隔離性
? 運維復雜度低于獨立數據庫模式
? 容易實現租戶特定的表結構
? 數據庫級別的權限控制
缺點：
? 數據庫管理復雜度增加
? 可能存在Schema數量限制
? 跨租戶查詢仍然困難
? 無法為不同租戶使用不同的數據庫類型
? 所有租戶共享數據庫資源，可能出現資源爭用
適用場景
? 中型SaaS應用
? 租戶數量中等但增長較快的場景
? 需要較好數據隔離但成本敏感的應用
? PostgreSQL或MySQL等支持Schema/數據庫隔離的數據庫環境
方案三：共享數據庫，共享Schema，獨立表模式
原理與特點
在這種模式下，所有租戶共享同一個數據庫和Schema，但每個租戶有自己的表集合，通常通過表名前綴或后綴區分不同租戶的表。
實現步驟
1、實現多租戶命名策略：
@Component
public class TenantTableNameStrategy extends PhysicalNamingStrategyStandardImpl {
private static final long serialVersionUID = 1L;
@Override
public Identifier toPhysicalTableName(Identifier name, JdbcEnvironment context) {
String tenantId = TenantContextHolder.getTenantId();
if (tenantId != null && !tenantId.isEmpty()) {
String tablePrefix = tenantId + "_";
returnnewIdentifier(tablePrefix + name.getText(), name.isQuoted());
}
returnsuper.toPhysicalTableName(name, context);
}
}2、配置Hibernate命名策略：
@Configuration
@EnableJpaRepositories(basePackages = "com.example.repository")
@EntityScan(basePackages = "com.example.entity")
public class JpaConfig {
@Autowired
private TenantTableNameStrategy tableNameStrategy;
@Bean
public LocalContainerEntityManagerFactoryBean entityManagerFactory(
EntityManagerFactoryBuilder builder,
DataSource dataSource) {
Map<String, Object> properties = newHashMap<>();
properties.put("hibernate.physical_naming_strategy",
tableNameStrategy);
// 其他Hibernate配置...
returnbuilder
.dataSource(dataSource)
.packages("com.example.entity")
.properties(properties)
.build();
}
}3、租戶實體和倉庫：
@Entity
@Table(name = "tenant_info") // 避免與租戶表前綴沖突
public class Tenant {
@Id
private String id;
@Column(nullable = false)
private String name;
@Column
private boolean active = true;
// getters and setters
}
@Repository
public interface TenantRepository extends JpaRepository<Tenant, String> {
List<Tenant> findByActive(boolean active);
}4、表初始化管理器：
@Component
publicclassTenantTableManager {
@Autowired
private EntityManagerFactory entityManagerFactory;
@Autowired
private TenantRepository tenantRepository;
@PersistenceContext
private EntityManager entityManager;
publicvoidinitializeTenantTables(String tenantId) {
StringpreviousTenant= TenantContextHolder.getTenantId();
try {
TenantContextHolder.setTenantId(tenantId);
// 使用JPA/Hibernate初始化表結構
// 在生產環境中，推薦使用Flyway或Liquibase進行更精細的控制
Sessionsession= entityManager.unwrap(Session.class);
session.doWork(connection -> {
// 執行建表語句
// 這里可以使用Hibernate的SchemaExport，但為簡化，直接使用SQL
// 示例：創建用戶表
StringcreateUserTable="CREATE TABLE IF NOT EXISTS " + tenantId + "_users (" +
"id BIGINT NOT NULL AUTO_INCREMENT, " +
"username VARCHAR(255) NOT NULL, " +
"email VARCHAR(255) NOT NULL, " +
"created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, " +
"PRIMARY KEY (id)" +
")";
try (Statementstmt= connection.createStatement()) {
stmt.execute(createUserTable);
// 創建其他表...
}
});
} finally {
if (previousTenant != null) {
TenantContextHolder.setTenantId(previousTenant);
} else {
TenantContextHolder.clear();
}
}
}
publicvoiddropTenantTables(String tenantId) {
// 獲取數據庫中所有表
try (Connectionconnection= entityManager.unwrap(SessionImplementor.class).connection()) {
DatabaseMetaDatametaData= connection.getMetaData();
StringtablePrefix= tenantId + "_";
try (ResultSettables= metaData.getTables(
connection.getCatalog(), connection.getSchema(), tablePrefix + "%", newString[]{"TABLE"})) {
List<String> tablesToDrop = newArrayList<>();
while (tables.next()) {
tablesToDrop.add(tables.getString("TABLE_NAME"));
}
// 刪除所有表
for (String tableName : tablesToDrop) {
try (Statementstmt= connection.createStatement()) {
stmt.execute("DROP TABLE " + tableName);
}
}
}
} catch (SQLException e) {
thrownewRuntimeException("Failed to drop tenant tables", e);
}
}
}5、租戶管理服務：
@Service
publicclassTenantTableManagementService {
@Autowired
privateTenantRepository tenantRepository;
@Autowired
privateTenantTableManager tableManager;
@PostConstruct
publicvoidinitializeAllTenants() {
for (Tenant tenant : tenantRepository.findByActive(true)) {
tableManager.initializeTenantTables(tenant.getId());
}
}
@Transactional
publicvoidcreateTenant(Tenant tenant) {
// 1. 保存租戶信息
tenantRepository.save(tenant);
// 2. 初始化租戶表
tableManager.initializeTenantTables(tenant.getId());
}
@Transactional
publicvoiddeleteTenant(String tenantId) {
// 1. 刪除租戶表
tableManager.dropTenantTables(tenantId);
// 2. 刪除租戶信息
tenantRepository.deleteById(tenantId);
}
}6、提供租戶管理API：
@RestController
@RequestMapping("/admin/tenants")
public class TenantTableController {
@Autowired
private TenantTableManagementService tenantService;
@Autowired
private TenantRepository tenantRepository;
@GetMapping
public List<Tenant> getAllTenants() {
returntenantRepository.findAll();
}
@PostMapping
publicResponseEntity<Tenant> createTenant(@RequestBody Tenant tenant) {
tenantService.createTenant(tenant);
returnResponseEntity.status(HttpStatus.CREATED).body(tenant);
}
@DeleteMapping("/{tenantId}")
publicResponseEntity<Void> deleteTenant(@PathVariable String tenantId) {
tenantService.deleteTenant(tenantId);
returnResponseEntity.noContent().build();
}
}優缺點分析
優點：
? 簡單易實現，特別是對現有應用的改造
? 資源利用率高
? 跨租戶查詢相對容易實現
? 維護成本低
? 租戶間表結構可以不同
缺點：
? 數據隔離級別較低
? 隨著租戶數量增加，表數量會急劇增長
? 數據庫對象（如表、索引）數量可能達到數據庫限制
? 備份和恢復單個租戶數據較為復雜
? 可能需要處理表名長度限制問題
適用場景
? 租戶數量適中且表結構相對簡單的SaaS應用
? 需要為不同租戶提供不同表結構的場景
? 快速原型開發或MVP(最小可行產品)
? 從單租戶向多租戶過渡的系統
方案四：共享數據庫，共享Schema，共享表模式
原理與特點
這是隔離級別最低但資源效率最高的方案。所有租戶共享相同的數據庫、Schema和表，通過在每個表中添加"租戶ID"列來區分不同租戶的數據。
實現步驟
1、創建租戶感知的實體基類：
@MappedSuperclass
@EntityListeners(AuditingEntityListener.class)
@Data
public abstract class TenantAwareEntity {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(name = "tenant_id", nullable = false)
private String tenantId;
@CreatedDate
@Column(name = "created_at", updatable = false)
private LocalDateTime createdAt;
@LastModifiedDate
@Column(name = "updated_at")
private LocalDateTime updatedAt;
@PrePersist
public void onPrePersist() {
tenantId = TenantContextHolder.getTenantId();
}
}2、租戶實體和倉庫：
@Entity
@Table(name = "tenants")
public class Tenant {
@Id
private String id;
@Column(nullable = false)
private String name;
@Column
private boolean active = true;
// getters and setters
}
@Repository
public interface TenantRepository extends JpaRepository<Tenant, String> {
List<Tenant> findByActive(boolean active);
}3、實現租戶數據過濾器：
@Component
publicclassTenantFilterInterceptorimplementsHandlerInterceptor {
@Autowired
privateEntityManager entityManager;
@Override
publicbooleanpreHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
String tenantId = TenantContextHolder.getTenantId();
if (tenantId != null) {
// 設置Hibernate過濾器
Session session = entityManager.unwrap(Session.class);
Filter filter = session.enableFilter("tenantFilter");
filter.setParameter("tenantId", tenantId);
returntrue;
}
response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
returnfalse;
}
@Override
publicvoidafterCompletion(HttpServletRequest request, HttpServletResponse response,
Object handler, Exception ex) {
Session session = entityManager.unwrap(Session.class);
session.disableFilter("tenantFilter");
}
}4、為實體添加過濾器注解：
@Entity
@Table(name = "users")
@FilterDef(name = "tenantFilter", parameters = {
@ParamDef(name = "tenantId", type = "string")
})
@Filter(name = "tenantFilter", condition = "tenant_id = :tenantId")
public class User extends TenantAwareEntity {
@Column(name = "username", nullable = false)
private String username;
@Column(name = "email", nullable = false)
private String email;
// 其他字段和方法...
}5、租戶管理服務：
@Service
publicclassSharedTableTenantService {
@Autowired
privateTenantRepository tenantRepository;
@Autowired
privateEntityManager entityManager;
@Transactional
publicvoidcreateTenant(Tenant tenant) {
// 直接保存租戶信息
tenantRepository.save(tenant);
// 初始化租戶默認數據
initializeTenantData(tenant.getId());
}
@Transactional
publicvoiddeleteTenant(String tenantId) {
// 刪除該租戶的所有數據
deleteAllTenantData(tenantId);
// 刪除租戶記錄
tenantRepository.deleteById(tenantId);
}
privatevoidinitializeTenantData(String tenantId) {
String previousTenant = TenantContextHolder.getTenantId();
try {
TenantContextHolder.setTenantId(tenantId);
// 創建默認用戶、角色等
// ...
} finally {
if (previousTenant != null) {
TenantContextHolder.setTenantId(previousTenant);
} else {
TenantContextHolder.clear();
}
}
}
privatevoiddeleteAllTenantData(String tenantId) {
// 獲取所有帶有tenant_id列的表
List<String> tables = getTablesWithTenantIdColumn();
// 從每個表中刪除該租戶的數據
for (String table : tables) {
entityManager.createNativeQuery("DELETE FROM " + table + " WHERE tenant_id = :tenantId")
.setParameter("tenantId", tenantId)
.executeUpdate();
}
}
privateList<String> getTablesWithTenantIdColumn() {
List<String> tables = newArrayList<>();
try (Connection connection = entityManager.unwrap(SessionImplementor.class).connection()) {
DatabaseMetaData metaData = connection.getMetaData();
try (ResultSet rs = metaData.getTables(
connection.getCatalog(), connection.getSchema(), "%", newString[]{"TABLE"})) {
while (rs.next()) {
String tableName = rs.getString("TABLE_NAME");
// 檢查表是否有tenant_id列
try (ResultSet columns = metaData.getColumns(
connection.getCatalog(), connection.getSchema(), tableName, "tenant_id")) {
if (columns.next()) {
tables.add(tableName);
}
}
}
}
} catch (SQLException e) {
thrownewRuntimeException("Failed to get tables with tenant_id column", e);
}
return tables;
}
}6、租戶管理API：
@RestController
@RequestMapping("/admin/tenants")
public class SharedTableTenantController {
@Autowired
private SharedTableTenantService tenantService;
@Autowired
private TenantRepository tenantRepository;
@GetMapping
public List<Tenant> getAllTenants() {
returntenantRepository.findAll();
}
@PostMapping
publicResponseEntity<Tenant> createTenant(@RequestBody Tenant tenant) {
tenantService.createTenant(tenant);
returnResponseEntity.status(HttpStatus.CREATED).body(tenant);
}
@DeleteMapping("/{tenantId}")
publicResponseEntity<Void> deleteTenant(@PathVariable String tenantId) {
tenantService.deleteTenant(tenantId);
returnResponseEntity.noContent().build();
}
}優缺點分析
優點：
? 資源利用率最高
? 維護成本最低
? 實現簡單，對現有單租戶系統改造容易
? 跨租戶查詢簡單
? 節省存儲空間，特別是當數據量小時
缺點：
? 數據隔離級別最低
? 安全風險較高，一個錯誤可能導致跨租戶數據泄露
? 所有租戶共享相同的表結構
? 需要在所有數據訪問層強制租戶過濾
適用場景
? 租戶數量多但每個租戶數據量小的場景
? 成本敏感的應用
? 原型驗證或MVP階段
方案五：混合租戶模式
原理與特點
混合租戶模式結合了多種隔離策略，根據租戶等級、重要性或特定需求為不同租戶提供不同級別的隔離。例如，免費用戶可能使用共享表模式，而付費企業用戶可能使用獨立數據庫模式。
實現步驟
1、租戶類型和存儲：
@Entity
@Table(name = "tenants")
publicclassTenant {
@Id
privateString id;
@Column(nullable = false)
privateString name;
@Enumerated(EnumType.STRING)
@Column(nullable = false)
privateTenantTypetype;
@Column
privateString databaseUrl;
@Column
privateString username;
@Column
privateString password;
@Column
privateString driverClassName;
@Column
privateString schemaName;
@Column
privateboolean active = true;
publicenumTenantType {
DEDICATED_DATABASE,
DEDICATED_SCHEMA,
DEDICATED_TABLE,
SHARED_TABLE
}
// getters and setters
}
@Repository
publicinterfaceTenantRepositoryextendsJpaRepository<Tenant, String> {
List<Tenant> findByActive(boolean active);
List<Tenant> findByType(Tenant.TenantTypetype);
}2、創建租戶分類策略：
@Component
publicclassTenantIsolationStrategy {
@Autowired
privateTenantRepository tenantRepository;
private final Map<String, Tenant> tenantCache = newConcurrentHashMap<>();
@PostConstruct
publicvoidloadTenants() {
tenantRepository.findByActive(true).forEach(tenant ->
tenantCache.put(tenant.getId(), tenant));
}
publicTenant.TenantTypegetIsolationTypeForTenant(String tenantId) {
Tenant tenant = tenantCache.get(tenantId);
if (tenant == null) {
tenant = tenantRepository.findById(tenantId)
.orElseThrow(() -> newRuntimeException("Tenant not found: " + tenantId));
tenantCache.put(tenantId, tenant);
}
return tenant.getType();
}
publicTenantgetTenant(String tenantId) {
Tenant tenant = tenantCache.get(tenantId);
if (tenant == null) {
tenant = tenantRepository.findById(tenantId)
.orElseThrow(() -> newRuntimeException("Tenant not found: " + tenantId));
tenantCache.put(tenantId, tenant);
}
return tenant;
}
publicvoidevictFromCache(String tenantId) {
tenantCache.remove(tenantId);
}
}3、實現混合數據源路由：
@Component
publicclassHybridTenantRouter {
@Autowired
privateTenantIsolationStrategy isolationStrategy;
private final Map<String, DataSource> dedicatedDataSources = newConcurrentHashMap<>();
@Autowired
privateDataSource sharedDataSource;
publicDataSourcegetDataSourceForTenant(String tenantId) {
Tenant.TenantType isolationType = isolationStrategy.getIsolationTypeForTenant(tenantId);
if (isolationType == Tenant.TenantType.DEDICATED_DATABASE) {
// 對于獨立數據庫的租戶，查找或創建專用數據源
return dedicatedDataSources.computeIfAbsent(tenantId, this::createDedicatedDataSource);
}
return sharedDataSource;
}
privateDataSourcecreateDedicatedDataSource(String tenantId) {
Tenant tenant = isolationStrategy.getTenant(tenantId);
HikariDataSource dataSource = newHikariDataSource();
dataSource.setJdbcUrl(tenant.getDatabaseUrl());
dataSource.setUsername(tenant.getUsername());
dataSource.setPassword(tenant.getPassword());
dataSource.setDriverClassName(tenant.getDriverClassName());
return dataSource;
}
publicvoidremoveDedicatedDataSource(String tenantId) {
DataSource dataSource = dedicatedDataSources.remove(tenantId);
if (dataSource instanceofHikariDataSource) {
((HikariDataSource) dataSource).close();
}
}
}4、混合租戶路由數據源：
public class HybridRoutingDataSource extends AbstractRoutingDataSource {
@Autowired
privateHybridTenantRouter tenantRouter;
@Autowired
privateTenantIsolationStrategy isolationStrategy;
@Override
protectedObject determineCurrentLookupKey() {
String tenantId = TenantContextHolder.getTenantId();
if (tenantId == null) {
return"default";
}
Tenant.TenantType isolationType = isolationStrategy.getIsolationTypeForTenant(tenantId);
if (isolationType == Tenant.TenantType.DEDICATED_DATABASE) {
return tenantId;
}
return"shared";
}
@Override
protectedDataSource determineTargetDataSource() {
String tenantId = TenantContextHolder.getTenantId();
if (tenantId == null) {
returnsuper.determineTargetDataSource();
}
return tenantRouter.getDataSourceForTenant(tenantId);
}
}5、混合租戶攔截器：
@Component
publicclassHybridTenantInterceptorimplementsHandlerInterceptor {
@Autowired
privateTenantIsolationStrategy isolationStrategy;
@Autowired
privateEntityManager entityManager;
@Override
publicbooleanpreHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
String tenantId = extractTenantId(request);
if (tenantId != null) {
TenantContextHolder.setTenantId(tenantId);
Tenant.TenantType isolationType = isolationStrategy.getIsolationTypeForTenant(tenantId);
// 根據隔離類型應用不同策略
switch (isolationType) {
caseDEDICATED_DATABASE:
// 已由數據源路由處理
break;
caseDEDICATED_SCHEMA:
setSchema(isolationStrategy.getTenant(tenantId).getSchemaName());
break;
caseDEDICATED_TABLE:
// 由命名策略處理
break;
caseSHARED_TABLE:
enableTenantFilter(tenantId);
break;
}
returntrue;
}
response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
returnfalse;
}
@Override
publicvoidafterCompletion(HttpServletRequest request, HttpServletResponse response,
Object handler, Exception ex) {
String tenantId = TenantContextHolder.getTenantId();
if (tenantId != null) {
Tenant.TenantType isolationType = isolationStrategy.getIsolationTypeForTenant(tenantId);
if (isolationType == Tenant.TenantType.SHARED_TABLE) {
disableTenantFilter();
}
}
TenantContextHolder.clear();
}
privatevoidsetSchema(String schema) {
try {
entityManager.createNativeQuery("SET SCHEMA '" + schema + "'").executeUpdate();
} catch (Exception e) {
// 處理異常
}
}
privatevoidenableTenantFilter(String tenantId) {
Session session = entityManager.unwrap(Session.class);
Filter filter = session.enableFilter("tenantFilter");
filter.setParameter("tenantId", tenantId);
}
privatevoiddisableTenantFilter() {
Session session = entityManager.unwrap(Session.class);
session.disableFilter("tenantFilter");
}
privateStringextractTenantId(HttpServletRequest request) {
// 從請求中提取租戶ID的邏輯
return request.getHeader("X-TenantID");
}
}6、綜合租戶管理服務：
@Service
publicclassHybridTenantManagementService {
@Autowired
private TenantRepository tenantRepository;
@Autowired
private TenantIsolationStrategy isolationStrategy;
@Autowired
private HybridTenantRouter tenantRouter;
@Autowired
private EntityManager entityManager;
@Autowired
private DataSource dataSource;
// 不同隔離類型的初始化策略
privatefinal Map<Tenant.TenantType, TenantInitializer> initializers = newHashMap<>();
@PostConstruct
publicvoidinit() {
initializers.put(Tenant.TenantType.DEDICATED_DATABASE, this::initializeDedicatedDatabase);
initializers.put(Tenant.TenantType.DEDICATED_SCHEMA, this::initializeDedicatedSchema);
initializers.put(Tenant.TenantType.DEDICATED_TABLE, this::initializeDedicatedTables);
initializers.put(Tenant.TenantType.SHARED_TABLE, this::initializeSharedTables);
}
@Transactional
publicvoidcreateTenant(Tenant tenant) {
// 1. 保存租戶基本信息
tenantRepository.save(tenant);
// 2. 根據隔離類型初始化
TenantInitializerinitializer= initializers.get(tenant.getType());
if (initializer != null) {
initializer.initialize(tenant);
}
// 3. 更新緩存
isolationStrategy.evictFromCache(tenant.getId());
}
@Transactional
publicvoiddeleteTenant(String tenantId) {
Tenanttenant= tenantRepository.findById(tenantId)
.orElseThrow(() -> newRuntimeException("Tenant not found: " + tenantId));
// 1. 根據隔離類型清理資源
switch (tenant.getType()) {
case DEDICATED_DATABASE:
cleanupDedicatedDatabase(tenant);
break;
case DEDICATED_SCHEMA:
cleanupDedicatedSchema(tenant);
break;
case DEDICATED_TABLE:
cleanupDedicatedTables(tenant);
break;
case SHARED_TABLE:
cleanupSharedTables(tenant);
break;
}
// 2. 刪除租戶信息
tenantRepository.delete(tenant);
// 3. 更新緩存
isolationStrategy.evictFromCache(tenantId);
}
// 獨立數據庫初始化
privatevoidinitializeDedicatedDatabase(Tenant tenant) {
// 創建數據源
DataSourcededicatedDs= tenantRouter.getDataSourceForTenant(tenant.getId());
// 初始化數據庫結構
try (Connectionconn= dedicatedDs.getConnection()) {
// 執行DDL腳本
// ...
} catch (SQLException e) {
thrownewRuntimeException("Failed to initialize database for tenant: " + tenant.getId(), e);
}
}
// Schema初始化
privatevoidinitializeDedicatedSchema(Tenant tenant) {
try (Connectionconn= dataSource.getConnection()) {
// 創建Schema
try (Statementstmt= conn.createStatement()) {
stmt.execute("CREATE SCHEMA IF NOT EXISTS " + tenant.getSchemaName());
}
// 切換到該Schema
conn.setSchema(tenant.getSchemaName());
// 創建表結構
// ...
} catch (SQLException e) {
thrownewRuntimeException("Failed to initialize schema for tenant: " + tenant.getId(), e);
}
}
// 獨立表初始化
privatevoidinitializeDedicatedTables(Tenant tenant) {
// 設置線程上下文中的租戶ID以使用正確的表名前綴
StringpreviousTenant= TenantContextHolder.getTenantId();
try {
TenantContextHolder.setTenantId(tenant.getId());
// 創建表
// ...
} finally {
if (previousTenant != null) {
TenantContextHolder.setTenantId(previousTenant);
} else {
TenantContextHolder.clear();
}
}
}
// 共享表初始化
privatevoidinitializeSharedTables(Tenant tenant) {
// 共享表模式下，只需插入租戶特定的初始數據
StringpreviousTenant= TenantContextHolder.getTenantId();
try {
TenantContextHolder.setTenantId(tenant.getId());
// 插入初始數據
// ...
} finally {
if (previousTenant != null) {
TenantContextHolder.setTenantId(previousTenant);
} else {
TenantContextHolder.clear();
}
}
}
// 清理方法
privatevoidcleanupDedicatedDatabase(Tenant tenant) {
// 關閉并移除數據源
tenantRouter.removeDedicatedDataSource(tenant.getId());
// 注意：通常不會自動刪除實際的數據庫，這需要DBA手動操作
}
privatevoidcleanupDedicatedSchema(Tenant tenant) {
try (Connectionconn= dataSource.getConnection()) {
try (Statementstmt= conn.createStatement()) {
stmt.execute("DROP SCHEMA IF EXISTS " + tenant.getSchemaName() + " CASCADE");
}
} catch (SQLException e) {
thrownewRuntimeException("Failed to drop schema for tenant: " + tenant.getId(), e);
}
}
privatevoidcleanupDedicatedTables(Tenant tenant) {
// 查找并刪除該租戶的所有表
try (Connectionconn= dataSource.getConnection()) {
DatabaseMetaDatametaData= conn.getMetaData();
StringtablePrefix= tenant.getId() + "_";
try (ResultSettables= metaData.getTables(
conn.getCatalog(), conn.getSchema(), tablePrefix + "%", newString[]{"TABLE"})) {
while (tables.next()) {
StringtableName= tables.getString("TABLE_NAME");
try (Statementstmt= conn.createStatement()) {
stmt.execute("DROP TABLE " + tableName);
}
}
}
} catch (SQLException e) {
thrownewRuntimeException("Failed to drop tables for tenant: " + tenant.getId(), e);
}
}
privatevoidcleanupSharedTables(Tenant tenant) {
// 從所有帶有tenant_id列的表中刪除該租戶的數據
entityManager.createNativeQuery(
"SELECT table_name FROM information_schema.columns " +
"WHERE column_name = 'tenant_id'")
.getResultList()
.forEach(tableName ->
entityManager.createNativeQuery(
"DELETE FROM " + tableName + " WHERE tenant_id = :tenantId")
.setParameter("tenantId", tenant.getId())
.executeUpdate()
);
}
// 租戶初始化策略接口
@FunctionalInterface
privateinterfaceTenantInitializer {
voidinitialize(Tenant tenant);
}
}7、提供租戶管理API：
@RestController
@RequestMapping("/admin/tenants")
public class HybridTenantController {
@Autowired
private HybridTenantManagementService tenantService;
@Autowired
private TenantRepository tenantRepository;
@GetMapping
public List<Tenant> getAllTenants() {
returntenantRepository.findAll();
}
@PostMapping
publicResponseEntity<Tenant> createTenant(@RequestBody Tenant tenant) {
tenantService.createTenant(tenant);
returnResponseEntity.status(HttpStatus.CREATED).body(tenant);
}
@PutMapping("/{tenantId}")
publicResponseEntity<Tenant> updateTenant(
@PathVariable String tenantId,
@RequestBody Tenant tenant) {
tenant.setId(tenantId);
tenantService.updateTenant(tenant);
returnResponseEntity.ok(tenant);
}
@DeleteMapping("/{tenantId}")
publicResponseEntity<Void> deleteTenant(@PathVariable String tenantId) {
tenantService.deleteTenant(tenantId);
returnResponseEntity.noContent().build();
}
@GetMapping("/types")
publicResponseEntity<List<Tenant.TenantType>> getTenantTypes() {
returnResponseEntity.ok(Arrays.asList(Tenant.TenantType.values()));
}
}優缺點分析
優點：
? 最大的靈活性，可根據租戶需求提供不同隔離級別
? 可以實現資源和成本的平衡
? 可以根據業務價值分配資源
? 適應不同客戶的安全和性能需求
缺點：
? 實現復雜度最高
? 維護和測試成本高
? 需要處理多種數據訪問模式
? 可能引入不一致的用戶體驗
? 錯誤處理更加復雜
適用場景
? 需要提供靈活定價模型的應用
? 資源需求差異大的租戶集合
方案對比
隔離模式 | 數據隔離級別 | 資源利用率 | 成本 | 復雜度 | 適用場景 |
獨立數據庫 | 最高 | 低 | 高 | 中 | 企業級應用、金融/醫療行業 |
獨立Schema | 高 | 中 | 中 | 中 | 中型SaaS、安全要求較高的場景 |
獨立表 | 中 | 中高 | 中低 | 低 | 中小型應用、原型驗證 |
共享表 | 低 | 最高 | 低 | 低 | 大量小租戶、成本敏感場景 |
混合模式 | 可變 | 可變 | 中高 | 高 | 多層級服務、復雜業務需求 |
總結
多租戶架構是構建現代SaaS應用的關鍵技術，選擇多租戶模式需要平衡數據隔離、資源利用、成本和復雜度等多種因素。
通過深入理解這些架構模式及其權衡，可以根據實際情況選擇適合的多租戶架構，構建可擴展、安全且經濟高效的企業級應用。
責任編輯：武曉燕
來源：
JAVA日知錄
