如何在Java服务中实现多租户架构：数据库与代码层的实现策略

原创

省赚客开发者 2024-09-08 22:02:42 ©著作权

©著作权归作者所有：来自51CTO博客作者省赚客开发者的原创作品，请联系作者获取转载授权，否则将追究法律责任

如何在Java服务中实现多租户架构：数据库与代码层的实现策略

大家好，我是微赚淘客返利系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！在如今的SaaS应用开发中，多租户架构已经成为了一个常见的需求。多租户架构允许多个租户（客户）共享同一个应用程序，但数据隔离。本文将详细讲解如何在Java服务中实现多租户架构，包括数据库层和代码层的实现策略。我们将以cn.juwatech包为例展示具体的代码实现。

一、数据库层的多租户实现

在数据库层，多租户架构通常有以下三种实现方式：

单数据库单表（通过租户ID区分）： 所有租户的数据存储在同一个数据库的同一个表中，通过租户ID区分。
单数据库多表（每个租户独立表）： 所有租户共享一个数据库，但每个租户的数据存储在独立的表中。
多数据库（每个租户独立数据库）： 每个租户使用独立的数据库，实现最强的数据隔离。

我们以单数据库单表的方式为例，来讲解如何实现数据库层的多租户架构。

1.1 配置数据源

使用Spring Boot和Hibernate，我们首先配置一个多数据源。在application.yml中，我们配置多个数据库：

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/tenant_database
    username: root
    password: password
    driver-class-name: com.mysql.cj.jdbc.Driver
  jpa:
    hibernate:
      ddl-auto: update
    properties:
      hibernate:
        dialect: org.hibernate.dialect.MySQLDialect

1.2 动态数据源路由

创建一个DynamicDataSource，用于动态选择数据源：

package cn.juwatech.multitenancy.config;

import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

public class DynamicDataSource extends AbstractRoutingDataSource {
    @Override
    protected Object determineCurrentLookupKey() {
        return TenantContext.getCurrentTenant();
    }
}

1.3 实现TenantContext

TenantContext用于管理当前的租户ID：

package cn.juwatech.multitenancy.context;

public class TenantContext {
    private static final ThreadLocal<String> currentTenant = new ThreadLocal<>();

    public static void setCurrentTenant(String tenant) {
        currentTenant.set(tenant);
    }

    public static String getCurrentTenant() {
        return currentTenant.get();
    }

    public static void clear() {
        currentTenant.remove();
    }
}

1.4 拦截器实现

使用Spring的拦截器来实现租户ID的提取和设置：

package cn.juwatech.multitenancy.interceptor;

import cn.juwatech.multitenancy.context.TenantContext;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@Component
public class TenantInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        String tenantId = request.getHeader("X-Tenant-ID");
        TenantContext.setCurrentTenant(tenantId);
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
        TenantContext.clear();
    }
}

二、代码层的多租户实现

在代码层，最关键的部分是实现租户ID的动态传递，并根据租户ID动态调整数据源或数据库查询。在Spring Data JPA中，我们可以使用@EntityListeners来动态调整Hibernate的过滤条件。

2.1 创建租户实体监听器

首先，创建一个租户实体监听器，用于在每次数据库操作时添加租户过滤条件：

package cn.juwatech.multitenancy.entity;

import cn.juwatech.multitenancy.context.TenantContext;
import org.hibernate.engine.spi.SharedSessionContractImplementor;
import org.hibernate.event.spi.LoadEvent;
import org.hibernate.event.spi.LoadEventListener;
import org.springframework.stereotype.Component;

@Component
public class TenantEntityListener implements LoadEventListener {

    @Override
    public void onLoad(LoadEvent event, LoadType loadType) {
        String tenantId = TenantContext.getCurrentTenant();
        if (tenantId == null) {
            throw new RuntimeException("租户ID不能为空");
        }
        
        SharedSessionContractImplementor session = event.getSession();
        session.enableFilter("tenantFilter").setParameter("tenantId", tenantId);
    }
}

2.2 定义租户过滤器

接下来，定义一个租户过滤器：

package cn.juwatech.multitenancy.config;

import org.hibernate.Filter;
import org.hibernate.Session;
import org.springframework.stereotype.Component;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

@Component
public class TenantFilterConfigurer {

    @PersistenceContext
    private EntityManager entityManager;

    public void enableTenantFilter(String tenantId) {
        Session session = entityManager.unwrap(Session.class);
        Filter filter = session.enableFilter("tenantFilter");
        filter.setParameter("tenantId", tenantId);
    }
}

2.3 在实体中应用过滤器

在JPA实体上应用过滤器：

package cn.juwatech.multitenancy.entity;

import javax.persistence.*;

@Entity
@Table(name = "product")
@FilterDef(name = "tenantFilter", parameters = @ParamDef(name = "tenantId", type = "string"))
@Filters(@Filter(name = "tenantFilter", condition = "tenant_id = :tenantId"))
public class Product {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    @Column(name = "tenant_id")
    private String tenantId;

    // getters and setters
}

三、控制层和服务层的实现

3.1 控制层

在控制层中，通过请求头或其他方式获取租户ID，并传递给服务层：

package cn.juwatech.multitenancy.controller;

import cn.juwatech.multitenancy.context.TenantContext;
import cn.juwatech.multitenancy.entity.Product;
import cn.juwatech.multitenancy.service.ProductService;
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 ProductService productService;

    @GetMapping
    public List<Product> getProducts(@RequestHeader("X-Tenant-ID") String tenantId) {
        TenantContext.setCurrentTenant(tenantId);
        return productService.getProducts();
    }
}

3.2 服务层

在服务层中，利用租户上下文执行具体的业务逻辑：

package cn.juwatech.multitenancy.service;

import cn.juwatech.multitenancy.entity.Product;
import cn.juwatech.multitenancy.repository.ProductRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class ProductService {

    @Autowired
    private ProductRepository productRepository;

    public List<Product> getProducts() {
        return productRepository.findAll();
    }
}

四、总结

通过上述步骤，我们实现了一个基础的多租户架构。在数据库层，我们使用动态数据源路由，实现了租户数据的隔离；在代码层，我们通过上下文管理和拦截器实现了租户ID的传递，并在实体层通过过滤器实现了数据的隔离。这种架构能够较好地满足SaaS应用对多租户的需求。

本文著作权归聚娃科技微赚淘客系统开发者团队，转载请注明出处！