GoFrame实现多租户隔离的最佳实践

1. 什么是多租户架构

多租户（Multi-tenancy）是一种软件架构设计模式，允许单个软件实例服务多个客户（租户）。在这种模式下，每个租户看到的应用程序似乎是独占的，但实际上是共享同一个应用实例及其底层资源。多租户架构广泛应用于SaaS（Software as a Service）平台，使服务提供商能够以更高效的方式为多个客户提供服务，同时降低维护和运营成本。

1.1 多租户架构的特点

资源共享：多个租户共享相同的应用程序实例、数据库服务器等基础设施资源
数据隔离：尽管资源共享，但每个租户的数据必须严格隔离，确保安全性和隐私性
可定制化：支持租户级别的配置和定制，满足不同租户的特定需求
规模经济：通过资源共享降低每个租户的服务成本
简化管理：统一的运维和升级流程，减少管理开销

1.2 为什么需要多租户架构

在现代软件开发中，多租户架构已成为SaaS应用的标准模式，主要基于以下原因：

成本效益：单一应用实例服务多个客户，大幅减少服务器、许可证和维护成本
资源优化：更高效地利用计算资源，避免每个租户独占资源导致的浪费
简化部署：只需维护一个版本的应用程序，简化更新和部署流程
集中管理：统一的管理和监控平台，提高运维效率
灵活扩展：能够更容易地支持更多租户，实现业务扩展

2. 多租户的业务场景

多租户架构适用于多种业务场景，特别是当应用需要服务多个相对独立的客户群体时。以下是几个典型的业务场景：

2.1 企业管理软件（ERP/CRM）

企业资源计划(ERP)或客户关系管理(CRM)系统是多租户架构的典型应用。不同公司使用相同的软件，但各自管理独立的业务数据。

场景示例：一个CRM系统服务多家销售公司，每家公司只能访问自己的客户数据、销售记录和报表，但共享相同的功能模块和基础设施。

2.2 电子商务平台

提供多商户支持的电子商务平台，每个商户（租户）有自己的商品、订单和客户管理。

场景示例：类似淘宝的平台，每个店铺是一个租户，拥有独立的商品库存、订单处理和客户管理，但共享平台的支付系统、搜索引擎和基础设施。

2.3 在线教育系统

服务多个学校或教育机构的学习管理系统，每个机构管理自己的课程、学生和教师。

场景示例：一个在线学习平台，不同培训机构作为租户使用同一套系统，各自管理课程内容、学生账号和学习进度，同时共享视频存储、直播功能等基础设施。

2.4 SaaS协作工具

团队协作工具如项目管理软件、文档共享平台等，每个组织作为独立租户使用。

场景示例：类似Notion或Asana的协作平台，不同公司团队作为租户使用相同的应用，但数据完全隔离，同时可以根据需求配置不同的工作流和权限规则。

2.5 医疗信息系统

为多家医院或诊所提供的患者管理系统，每家医疗机构管理自己的患者记录和医疗服务。

场景示例：一个云端医疗记录系统，多家诊所共享同一应用，但每家诊所只能访问其患者的医疗记录，同时满足各自的预约管理和报表需求。

3. 多租户数据隔离的策略

在实现多租户架构时，数据隔离是最核心的考量因素之一。根据安全需求、成本因素和实现复杂度，可以选择不同的数据隔离策略：

3.1 独立数据库模式

原理：每个租户使用完全独立的数据库实例。

优点：

最高级别的数据隔离和安全性
租户数据容易备份和恢复
可以为不同租户配置不同的数据库参数

缺点：

成本较高，特别是租户数量大时
数据库维护工作量大
资源利用率可能不高

适用场景：

金融、医疗等对数据安全要求极高的行业
租户数量少但数据量大的应用
需要提供高度自定义数据库配置的场景

3.2 共享数据库，独立Schema模式

原理：所有租户共享同一数据库实例，但每个租户使用独立的数据库Schema。

优点：

较好的数据隔离性
成本低于独立数据库模式
简化了备份和恢复流程

缺点：

数据库对象数量限制（如MySQL的表数量）
管理多个Schema的复杂性

适用场景：

中等规模的SaaS应用
租户数据结构相似但需要一定隔离的场景

3.3 共享数据库，共享Schema，独立表模式

原理：所有租户共享数据库和Schema，但每个租户使用独立的表集合。

优点：

较好的数据隔离
比前两种方案更节省资源

缺点：

表数量随租户增加而快速增长
维护复杂度高

适用场景：

租户数量适中且每个租户的数据模型相对简单

3.4 共享数据库，共享Schema，共享表模式

原理：所有租户共享相同的数据库、Schema和表，通过表中的租户ID字段区分不同租户的数据。

优点：

最高的资源利用率
最低的基础设施成本
维护和升级简单

缺点：

数据隔离依赖于应用层的实现
潜在的安全风险更高
需要在应用层严格控制租户访问

适用场景：

租户数量大、单租户数据量小的应用
成本敏感型应用
初创企业和快速迭代的产品

4. 使用GoFrame实现多租户隔离

接下来，我们将使用GoFrame框架实现两种常见的多租户隔离方案：多数据库隔离和表隔离。GoFrame是一个模块化、高性能、企业级的Go应用开发框架，为多租户架构实现提供了良好的支持。

4.1 基于多数据库的租户隔离实现

第一种方案是每个租户使用单独的数据库，提供最完善的数据隔离。GoFrame提供了便捷的数据库配置和访问机制，可以轻松实现多数据库管理。

4.1.1 多数据库配置

首先，我们需要在配置文件中定义多个数据库连接。在GoFrame中，可以使用config.toml或config.yaml文件进行配置。

# config.yaml
database:
  # 默认数据库配置
  default:
    link: "mysql:root:password@tcp(127.0.0.1:3306)/default"
    debug: true
  
  # 租户数据库配置
  tenant1:
    link: "mysql:root:password@tcp(127.0.0.1:3306)/tenant1"
    debug: true
  
  tenant2:
    link: "mysql:root:password@tcp(127.0.0.1:3306)/tenant2"
    debug: true
  
  tenant3:
    link: "mysql:root:password@tcp(127.0.0.1:3306)/tenant3"
    debug: true

4.1.2 租户识别中间件

我们需要一个中间件来识别当前请求的租户身份。租户身份可以通过多种方式获取，如HTTP头、路径参数、子域名等。以下代码展示了如何从自定义HTTP头X-Tenant-ID中获取租户ID。

// middleware/tenant.go
package middleware

import (
	"context"
	"github.com/gogf/gf/v2/net/ghttp"
)

type TenantContextKey string

const (
	TenantIDKey TenantContextKey = "TenantID"
)

// TenantMiddleware 识别当前租户并将租户ID添加到上下文中
func TenantMiddleware(r *ghttp.Request) {
	// 从请求头中获取租户ID
	tenantID := r.Header.Get("X-Tenant-ID")
	if tenantID == "" {
		tenantID = "default"
	}
	
	// 将租户ID添加到请求上下文中
	ctx := context.WithValue(r.Context(), TenantIDKey, tenantID)
	r.SetCtx(ctx)
	r.Middleware.Next()
}

4.1.3 定义租户数据库访问帮助函数

为了简化代码，我们创建一个帮助函数，在业务代码中获取当前租户的数据库连接。

// helper/database.go
package helper

import (
	"context"
	"github.com/gogf/gf/v2/database/gdb"
	"github.com/gogf/gf/v2/frame/g"
	"your-project/middleware"
)

// GetTenantDB 根据上下文获取当前租户的数据库连接
func GetTenantDB(ctx context.Context) gdb.DB {
	// 从上下文中获取租户ID
	tenantID, ok := ctx.Value(middleware.TenantIDKey).(string)
	if !ok || tenantID == "" {
		return g.DB()
	}
	return g.DB(tenantID)
}

4.1.4 在业务代码中使用多租户数据库

现在我们可以在业务代码中使用这个帮助函数来访问当前租户的数据库。

// api/user.go
package api

import (
	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/net/ghttp"
	"your-project/helper"
)

type UserAPI struct{}

// GetUserList 获取用户列表
func (a *UserAPI) GetUserList(r *ghttp.Request) {
	ctx := r.Context()
	
	// 获取当前租户的数据库连接并执行查询
	users, err := helper.GetTenantDB(ctx).Model("users").All()
	if err != nil {
		r.Response.WriteJson(g.Map{
			"code":    500, 
			"message": "Failed to fetch users",
			"error":   err.Error(),
		})
		return
	}
	
	r.Response.WriteJson(g.Map{
		"code":    0,
		"message": "success",
		"data":    users,
	})
}

4.1.5 注册路由和中间件

最后，我们需要在路由中注册租户中间件，确保所有API请求都经过租户识别。

// router/router.go
package router

import (
	"github.com/gogf/gf/v2/net/ghttp"
	"your-project/api"
	"your-project/middleware"
)

func InitRouter(s *ghttp.Server) {
	// 注册租户中间件
	s.Use(middleware.TenantMiddleware)
	
	// 注册API路由
	userApi := new(api.UserAPI)
	s.Group("/api", func(group *ghttp.RouterGroup) {
		group.GET("/users", userApi.GetUserList)
	})
}

4.1.6 多租户数据初始化

当新的租户注册时，我们需要创建新的数据库并初始化必要的表结构。以下是一个创建新租户数据库的示例函数。

// service/tenant.go
package service

import (
	"context"
	"fmt"
	"github.com/gogf/gf/v2/database/gdb"
	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/os/gfile"
)

type TenantService struct{}

// CreateTenant 创建新租户
func (s *TenantService) CreateTenant(ctx context.Context, tenantID string) error {
	// 1. 添加租户记录
	db := g.DB()
	_, err := db.Model("tenants").Insert(g.Map{
		"tenant_id": tenantID,
		"status":    "active",
		"created_at": gdb.Raw("NOW()"),
	})
	if err != nil {
		return fmt.Errorf("failed to add tenant record: %w", err)
	}
	
	// 2. 创建租户数据库
	_, err = db.Exec(fmt.Sprintf("CREATE DATABASE IF NOT EXISTS %s", tenantID))
	if err != nil {
		return fmt.Errorf("failed to create tenant database: %w", err)
	}
	
	// 3. 初始化表结构
	sqlScript := gfile.GetContents("resource/sql/init_tenant_db.sql")
	if sqlScript == "" {
		return fmt.Errorf("init SQL script not found")
	}
	
	_, err = g.DB(tenantID).Exec(sqlScript)
	if err != nil {
		return fmt.Errorf("failed to initialize tenant database: %w", err)
	}
	
	// 4. 更新数据库配置
	dataBaseConfig := g.Config().GetJson("database")
	dataBaseConfig.Set(tenantID, g.Map{
		"link":  fmt.Sprintf("mysql:root:password@tcp(127.0.0.1:3306)/%s", tenantID),
		"debug": true,
	})
	g.Config().Set("database", dataBaseConfig)
	
	return nil
}

4.1.7 多数据库隔离方案总结

使用多数据库隔离方案的优点：

最强的数据隔离： 每个租户的数据完全独立，数据泄露风险最小
独立的数据库调优： 可以为不同的租户配置不同的数据库参数
灵活的数据库事务： 不会干扰其他租户的数据库操作
易于备份和恢复： 可以针对单个租户进行备份和恢复操作

缺点：

资源消耗较大： 每个租户需要独立的数据库实例
维护成本高： 需要管理大量的数据库实例
迁移和更新复杂： 架构或数据结构迁移时需要更新所有数据库

4.2 基于共享数据库的表隔离实现

第二种方案是所有租户共享一个数据库，通过在每个表中添加tenant_id字段实现数据隔离。这种方案资源利用率更高，适合租户数量大、单租户数据量小的应用场景。

4.2.1 定义带有租户ID的基础模型

首先，我们定义一个所有模型都需要继承的基础模型，其中包含tenant_id字段。

// model/base.go
package model

// TenantModel 多租户基础模型，所有需要租户隔离的模型都应该嵌入此结构
type TenantModel struct {
	TenantID int `orm:"tenant_id" json:"tenant_id"`
}

然后，我们在业务模型中嵌入这个基础模型：

// model/user.go
package model

import "github.com/gogf/gf/v2/os/gtime"

// User 用户模型
type User struct {
	TenantModel      // 嵌入租户基础模型
	Id        int    `orm:"id,primary" json:"id"`
	Username  string `orm:"username" json:"username"`
	Password  string `orm:"password" json:"-"`
	Nickname  string `orm:"nickname" json:"nickname"`
	Email     string `orm:"email" json:"email"`
	Status    int    `orm:"status" json:"status"`
	CreatedAt *gtime.Time `orm:"created_at" json:"created_at"`
	UpdatedAt *gtime.Time `orm:"updated_at" json:"updated_at"`
}

4.2.2 实现DAO层的租户数据隔离

GoFrame的DAO（Data Access Object）层提供了各种钩子（Hook）函数，允许我们在数据库操作前后添加自定义逻辑。我们可以使用这些钩子函数实现透明的租户数据隔离。

// dao/user.go
package dao

import (
	"context"
	"github.com/gogf/gf/v2/database/gdb"
	"github.com/gogf/gf/v2/frame/g"
	"your-project/middleware"
	"your-project/model"
)

// UserDao 用户数据访问对象
type UserDao struct{
	Table string
	Group string
	Model *gdb.Model
}

// 创建单例对象
var User = &UserDao{
	Table: "users",
	Group: "default",
}

// Init 初始化DAO
func (dao *UserDao) Init() {
	dao.Model = g.DB(dao.Group).Model(dao.Table)
}

// 获取当前租户ID
func getTenantIDInt(ctx context.Context) int {
	tenantID, ok := ctx.Value(middleware.TenantIDKey).(string)
	if !ok || tenantID == "" {
		return 0 // 默认租户ID
	}
	
	// 实际应用中应从租户表中查询对应的数字ID
	return 1 // 示例值
}

// OnInsert 插入数据前的钩子函数
func (dao *UserDao) OnInsert(ctx context.Context, in interface{}) (interface{}, error) {
	// 对于User类型的记录，设置租户ID
	if user, ok := in.(*model.User); ok {
		user.TenantID = getTenantIDInt(ctx)
		return user, nil
	}
	return in, nil
}

// OnQuery 查询数据前的钩子函数
func (dao *UserDao) OnQuery(ctx context.Context) *gdb.Model {
	// 添加租户限制条件
	return dao.Model.Ctx(ctx).Where("tenant_id", getTenantIDInt(ctx))
}

// OnUpdate 更新数据前的钩子函数
func (dao *UserDao) OnUpdate(ctx context.Context, in interface{}) (interface{}, error) {
	// 确保不修改tenant_id字段
	if user, ok := in.(*model.User); ok {
		user.TenantID = getTenantIDInt(ctx)
		return user, nil
	}
	return in, nil
}

// OnDelete 删除数据前的钩子函数
func (dao *UserDao) OnDelete(ctx context.Context) *gdb.Model {
	// 确保只删除当前租户的数据
	return dao.Model.Ctx(ctx).Where("tenant_id", getTenantIDInt(ctx))
}

4.2.3 服务层的透明使用

当DAO层实现了租户隔离后，服务层可以透明地使用这些功能，无需关心租户隔离的实现细节。

// service/user.go
package service

import (
	"context"
	"github.com/gogf/gf/v2/errors/gerror"
	"your-project/dao"
	"your-project/model"
)

type UserService struct{}

// GetUserList 获取用户列表
func (s *UserService) GetUserList(ctx context.Context) ([]*model.User, error) {
	// DAO的OnQuery钩子会自动添加租户条件
	users, err := dao.User.Model.Ctx(ctx).All()
	if err != nil {
		return nil, gerror.Wrap(err, "failed to get user list")
	}
	
	var result []*model.User
	if err := users.Structs(&result); err != nil {
		return nil, gerror.Wrap(err, "failed to convert user data")
	}
	
	return result, nil
}

// CreateUser 创建新用户
func (s *UserService) CreateUser(ctx context.Context, user *model.User) error {
	// OnInsert钩子会自动设置租户ID
	_, err := dao.User.Model.Ctx(ctx).Data(user).Insert()
	return err
}

// UpdateUser 更新用户信息
func (s *UserService) UpdateUser(ctx context.Context, user *model.User) error {
	// OnUpdate和OnQuery钩子确保只更新当前租户数据
	_, err := dao.User.Model.Ctx(ctx).Data(user).Where("id", user.Id).Update()
	return err
}

// DeleteUser 删除用户
func (s *UserService) DeleteUser(ctx context.Context, id int) error {
	// OnDelete钩子确保只删除当前租户数据
	_, err := dao.User.Model.Ctx(ctx).Where("id", id).Delete()
	return err
}

4.2.4 API控制器实现

现在，我们可以实现API层，调用业务服务来处理请求。由于租户隔离已经在DAO层实现，所以API层也可以透明地使用这些功能。

// api/user.go

// UserAPI handles user-related API requests
type UserAPI struct{}

// GetUserList returns the list of users for the current tenant
func (a *UserAPI) GetUserList(r *ghttp.Request) {
	ctx := r.Context()
	
	// Service layer will automatically apply tenant isolation through DAO hooks
	userService := service.UserService{}
	users, err := userService.GetUserList(ctx)
	if err != nil {
		r.Response.WriteJson(g.Map{
            "code":    500,
            "message": "Failed to fetch users",
            "error":   err.Error(),
		})
		return
	}
	
	// Return result
	r.Response.WriteJson(g.Map{
        "code":    0,
        "message": "success",
        "data":    users,
    })
}

// CreateUser creates a new user for the current tenant
func (a *UserAPI) CreateUser(r *ghttp.Request) {
	ctx := r.Context()
	
	// Parse request data
	var user model.User
	if err := r.Parse(&user); err != nil {
		r.Response.WriteJson(g.Map{
            "code":    400,
            "message": "Bad request",
            "error":   err.Error(),
			})
		return
	}
	
	// Call service to create user
	userService := service.UserService{}
	if err := userService.CreateUser(ctx, &user); err != nil {
		r.Response.WriteJson(g.Map{
            "code":    500,
            "message": "Failed to create user",
            "error":   err.Error(),
			})
		return
	}
	
	// Return success result
	r.Response.WriteJson(g.Map{
        "code":    0,
        "message": "success",
        "data":    user,
    })
}

4.2.5 创建新租户与数据初始化

对于基于表隔离的方案，创建新租户相对简单，只需要在租户表中添加记录并初始化必要的数据。

// service/tenant.go

// TenantService provides tenant management functionality
type TenantService struct{}

// CreateTenant creates a new tenant in the shared database
func (s *TenantService) CreateTenant(ctx context.Context, tenantName string) (int, error) {
	// Connect to database
	db := g.DB()
	
	// 1. Add record to tenants table
	result, err := db.Model("tenants").Insert(g.Map{
		"name":      tenantName,
		"status":    "active",
		"created_at": gdb.Raw("NOW()"),
	})
	if err != nil {
		return 0, fmt.Errorf("failed to add tenant record: %w", err)
	}
	
	// Get the newly created tenant ID
	id, err := result.LastInsertId()
	if err != nil {
		return 0, fmt.Errorf("failed to get new tenant ID: %w", err)
	}
	
	// 2. Initialize tenant data (e.g., create default admin account)
	_, err = db.Model("users").Insert(g.Map{
        "tenant_id": id,
        "username":  "admin",
        "password":  "e10adc3949ba59abbe56e057f20f883e", // md5("123456")
        "nickname":  "Administrator",
        "email":     fmt.Sprintf("admin@%s.example.com", tenantName),
        "status":    1,
        "created_at": gdb.Raw("NOW()"),
    })
	if err != nil {
		return 0, fmt.Errorf("failed to create default admin user: %w", err)
	}
	
	return int(id), nil
}

4.2.6 表隔离方案总结

使用表隔离方案的优点：

资源利用率高： 所有租户共享同一个数据库，大幅减少资源消耗
维护成本低： 只需管理一个数据库实例
灵活扩展： 很容易处理大量租户，无需创建大量数据库
简化架构： 数据库结构简化，因为不需要为每个租户创建新的数据库

缺点：

数据隔离依赖应用层： 需要在应用代码中正确实现租户隔离逻辑
潜在的安全风险： 如果应用的租户限制逻辑出现缺陷，可能导致租户数据泄露
批量操作复杂： 跨租户的统计查询和批量操作需要特殊处理
数据表可能变大： 当租户和数据量增长时，单表可能变得非常大

5. 两种方案的对比与选择

在实际项目中选择多租户隔离方案时，需要考虑多种因素。下面对两种方案进行对比，帮助你做出选择。

比较维度	多数据库隔离	共享数据库表隔离
数据隔离级别	高	中
系统资源消耗	高	低
维护成本	高	低
扩展能力	中	高
实现复杂度	中	中偏高
适用租户数量	少量	大量
适用数据量	大量	小至中量
租户定制能力	高	低
数据库升级维护	复杂	简单

5.1 选择建议

基于以上对比，我们可以给出以下选择建议：

选择多数据库隔离方案的场景：

高安全需求的应用，如金融、医疗等行业
租户数量相对较少（几十到几百）
单租户数据量大
需要为不同租户配置不同的数据库参数
必须为租户提供高度定制的数据模型

选择表隔离方案的场景：

租户数量大（几百到几千或更多）
单租户数据量小到中等
成本敏感度高的应用
所有租户使用相同的数据模型
初创阶段产品或需要快速迭代的应用

6. 最佳实践与注意事项

无论选择哪种多租户隔离方案，都应该遵循以下最佳实践：

设计时考虑未来变化
- 预留从一种隔离方案切换到另一种的可能性
- 使用隔离的数据访问层，不要让租户隔离逐层渗透到业务逻辑
安全第一
- 对所有数据访问都必须添加租户隔离限制
- 验证用户请求的租户身份权限
- 定期审计租户数据访问日志
性能优化
- 使用适当的索引来提高多租户查询性能
- 在表隔离模式中，确保tenant_id字段有索引
- 对大表考虑分区策略，按租户ID分区
依赖注入与测试
- 将租户上下文作为依赖注入，便于测试
- 编写单元测试来确保租户隔离机制正确
运维考虑
- 实现租户数据备份和恢复机制
- 实现租户实例迁移工具
- 实现租户资源监控和限制功能

7. 总结

多租户架构是SaaS应用的核心特性，为服务提供商提供了成本效益和便捷的管理。在实际应用中，需要根据业务需求、成本预算和技术框架选择最适合的多租户隔离方案。

GoFrame框架极大地简化了多租户架构的实现，无论是选择多数据库隔离还是表隔离方案，都能够快速高效地实现。其丰富的数据库抽象、钩子机制和上下文管理功能使得实现多租户系统变得更加简单且优雅。

当然，设计多租户系统仍需要谨慎考虑安全性和性能问题，确保租户数据完全隔离，并且在大规模下保持良好的系统性能。

通过本文提供的方案和技术实现，您可以基于GoFrame框架快速构建一个安全、高效的多租户SaaS应用系统。

1. 什么是多租户架构​

1.1 多租户架构的特点​

1.2 为什么需要多租户架构​

2. 多租户的业务场景​

2.1 企业管理软件（ERP/CRM）​

2.2 电子商务平台​

2.3 在线教育系统​

2.4 SaaS协作工具​

2.5 医疗信息系统​

3. 多租户数据隔离的策略​

3.1 独立数据库模式​

3.2 共享数据库，独立Schema模式​

3.3 共享数据库，共享Schema，独立表模式​

3.4 共享数据库，共享Schema，共享表模式​

4. 使用GoFrame实现多租户隔离​

4.1 基于多数据库的租户隔离实现​

4.1.1 多数据库配置​

4.1.2 租户识别中间件​

4.1.3 定义租户数据库访问帮助函数​

4.1.4 在业务代码中使用多租户数据库​

4.1.5 注册路由和中间件​

4.1.6 多租户数据初始化​

4.1.7 多数据库隔离方案总结​

4.2 基于共享数据库的表隔离实现​

4.2.1 定义带有租户ID的基础模型​

4.2.2 实现DAO层的租户数据隔离​

4.2.3 服务层的透明使用​

4.2.4 API控制器实现​

4.2.5 创建新租户与数据初始化​

4.2.6 表隔离方案总结​

5. 两种方案的对比与选择​

5.1 选择建议​

6. 最佳实践与注意事项​

7. 总结​

1. 什么是多租户架构

1.1 多租户架构的特点

1.2 为什么需要多租户架构

2. 多租户的业务场景

2.1 企业管理软件（ERP/CRM）

2.2 电子商务平台

2.3 在线教育系统

2.4 SaaS协作工具

2.5 医疗信息系统

3. 多租户数据隔离的策略

3.1 独立数据库模式

3.2 共享数据库，独立Schema模式

3.3 共享数据库，共享Schema，独立表模式

3.4 共享数据库，共享Schema，共享表模式

4. 使用GoFrame实现多租户隔离

4.1 基于多数据库的租户隔离实现

4.1.1 多数据库配置

4.1.2 租户识别中间件

4.1.3 定义租户数据库访问帮助函数

4.1.4 在业务代码中使用多租户数据库

4.1.5 注册路由和中间件

4.1.6 多租户数据初始化

4.1.7 多数据库隔离方案总结

4.2 基于共享数据库的表隔离实现

4.2.1 定义带有租户ID的基础模型

4.2.2 实现DAO层的租户数据隔离

4.2.3 服务层的透明使用

4.2.4 API控制器实现

4.2.5 创建新租户与数据初始化

4.2.6 表隔离方案总结

5. 两种方案的对比与选择

5.1 选择建议

6. 最佳实践与注意事项

7. 总结