WordPress柔性供应链软件开发中的多租户架构实现教程

引言：柔性供应链与多租户架构的融合

在当今快速变化的商业环境中，柔性供应链系统已成为企业保持竞争力的关键。WordPress作为全球最流行的内容管理系统，其强大的插件架构和丰富的生态系统使其成为开发定制化供应链解决方案的理想平台。本文将深入探讨如何在WordPress环境中实现多租户架构的柔性供应链软件，使单个应用程序能够为多个租户（客户或业务单元）提供服务，同时保持数据隔离和个性化配置。

多租户架构的核心优势在于资源共享、成本效益和简化维护。在供应链场景中，这意味着不同企业或部门可以共享同一套核心功能，同时拥有各自独立的供应商数据、库存信息和订单流程。

多租户架构设计模式选择

在开始开发前，我们需要选择适合WordPress环境的多租户实现模式：

1. 独立数据库模式：每个租户拥有完全独立的数据库
2. 共享数据库，独立模式：共享同一数据库，但使用不同数据库模式
3. 共享数据库，共享模式：所有租户共享同一数据库和表结构，通过租户ID区分数据

考虑到WordPress的架构特点，我们选择第三种方案，因为它与WordPress的扩展性最为兼容，且维护成本最低。

<?php
/**
 * WordPress柔性供应链多租户核心类
 * 采用共享数据库、共享表结构模式
 */
class Flexible_SupplyChain_Multitenant {
    
    private $current_tenant_id;
    private $table_prefix;
    
    /**
     * 初始化多租户系统
     */
    public function __construct() {
        // 从请求中获取租户标识
        $this->detect_tenant();
        
        // 设置数据库表前缀
        $this->set_table_prefix();
        
        // 初始化租户特定配置
        $this->init_tenant_config();
    }
    
    /**
     * 检测当前请求的租户
     * 支持通过子域名、URL参数或自定义路径识别
     */
    private function detect_tenant() {
        $host = $_SERVER['HTTP_HOST'];
        
        // 示例：通过子域名识别租户 (tenant1.example.com)
        $subdomain = explode('.', $host)[0];
        
        // 租户映射表 - 实际应用中应从数据库读取
        $tenant_map = array(
            'tenant1' => 1,
            'tenant2' => 2,
            'acme'    => 3,
        );
        
        $this->current_tenant_id = isset($tenant_map[$subdomain]) 
            ? $tenant_map[$subdomain] 
            : 1; // 默认为主租户
    }
    
    /**
     * 设置动态表前缀
     * 为每个租户创建独立的数据隔离层
     */
    private function set_table_prefix() {
        global $wpdb;
        
        // 保存原始前缀
        $this->original_prefix = $wpdb->prefix;
        
        // 设置租户特定前缀
        $wpdb->prefix = 'tenant_' . $this->current_tenant_id . '_';
        
        // 更新WordPress选项表名
        $wpdb->options = $wpdb->prefix . 'options';
        $wpdb->usermeta = $wpdb->prefix . 'usermeta';
    }
    
    /**
     * 初始化租户特定配置
     */
    private function init_tenant_config() {
        // 加载租户特定的配置选项
        $tenant_settings = get_option('supplychain_tenant_settings', array());
        
        // 设置租户特定的常量
        define('CURRENT_TENANT_ID', $this->current_tenant_id);
        define('TENANT_SUPPLY_CHAIN_CONFIG', $tenant_settings);
        
        // 应用租户特定的过滤器
        $this->apply_tenant_filters();
    }
}
?>

数据库设计与数据隔离实现

在共享数据库模式下，数据隔离是关键挑战。以下是我们设计的核心表结构：

<?php
/**
 * 供应链多租户数据库安装类
 */
class SupplyChain_DB_Installer {
    
    /**
     * 为指定租户创建数据库表
     * @param int $tenant_id 租户ID
     */
    public static function create_tenant_tables($tenant_id) {
        global $wpdb;
        
        // 动态设置表前缀
        $table_prefix = 'tenant_' . $tenant_id . '_';
        
        // 供应商表
        $suppliers_table = $table_prefix . 'suppliers';
        $suppliers_sql = "CREATE TABLE IF NOT EXISTS {$suppliers_table} (
            id INT(11) NOT NULL AUTO_INCREMENT,
            name VARCHAR(255) NOT NULL,
            contact_email VARCHAR(100),
            tenant_id INT(11) NOT NULL DEFAULT {$tenant_id},
            status ENUM('active', 'inactive') DEFAULT 'active',
            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
            PRIMARY KEY (id),
            INDEX idx_tenant (tenant_id),
            INDEX idx_status (status)
        ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;";
        
        // 库存表
        $inventory_table = $table_prefix . 'inventory';
        $inventory_sql = "CREATE TABLE IF NOT EXISTS {$inventory_table} (
            id INT(11) NOT NULL AUTO_INCREMENT,
            product_id INT(11) NOT NULL,
            quantity INT(11) DEFAULT 0,
            warehouse_id INT(11),
            tenant_id INT(11) NOT NULL DEFAULT {$tenant_id},
            last_updated TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
            PRIMARY KEY (id),
            UNIQUE KEY unique_product_warehouse (product_id, warehouse_id),
            INDEX idx_tenant_product (tenant_id, product_id),
            FOREIGN KEY (product_id) REFERENCES {$table_prefix}products(id) ON DELETE CASCADE
        ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;";
        
        // 执行创建语句
        require_once(ABSPATH . 'wp-admin/includes/upgrade.php');
        dbDelta($suppliers_sql);
        dbDelta($inventory_sql);
        
        // 记录安装日志
        self::log_installation($tenant_id);
    }
    
    /**
     * 数据访问层基类
     * 确保所有查询都包含租户ID过滤
     */
    class Tenant_Aware_DAO {
        protected $tenant_id;
        protected $table_name;
        
        public function __construct($table_name) {
            $this->tenant_id = CURRENT_TENANT_ID;
            $this->table_name = $table_name;
        }
        
        /**
         * 获取租户特定的数据
         * @param array $conditions 查询条件
         * @return array 查询结果
         */
        public function get_tenant_data($conditions = array()) {
            global $wpdb;
            
            // 确保包含租户ID条件
            $conditions['tenant_id'] = $this->tenant_id;
            
            $where_clauses = array();
            $values = array();
            
            foreach ($conditions as $field => $value) {
                $where_clauses[] = "{$field} = %s";
                $values[] = $value;
            }
            
            $where_sql = implode(' AND ', $where_clauses);
            $sql = $wpdb->prepare(
                "SELECT * FROM {$this->table_name} WHERE {$where_sql}",
                $values
            );
            
            return $wpdb->get_results($sql, ARRAY_A);
        }
        
        /**
         * 插入租户特定的数据
         * @param array $data 插入数据
         * @return int 插入ID
         */
        public function insert_tenant_data($data) {
            global $wpdb;
            
            // 自动添加租户ID和时间戳
            $data['tenant_id'] = $this->tenant_id;
            $data['created_at'] = current_time('mysql');
            
            $wpdb->insert($this->table_name, $data);
            return $wpdb->insert_id;
        }
    }
}
?>

用户管理与权限隔离

在多租户系统中，用户权限管理需要特别设计，以支持跨租户用户和租户内角色的灵活配置：

<?php
/**
 * 多租户用户权限管理器
 */
class Multitenant_User_Manager {
    
    /**
     * 初始化租户特定的用户角色和能力
     */
    public static function init_tenant_roles() {
        $tenant_id = CURRENT_TENANT_ID;
        
        // 租户特定的供应链管理员角色
        add_role("supply_chain_manager_tenant_{$tenant_id}", 
                __('供应链管理员', 'flexible-supplychain'),
                array(
                    'manage_suppliers' => true,
                    'view_inventory' => true,
                    'manage_orders' => true,
                    'generate_reports' => true,
                    // 限制仅访问当前租户数据
                    'access_current_tenant_only' => true,
                ));
        
        // 租户特定的采购员角色
        add_role("procurement_officer_tenant_{$tenant_id}", 
                __('采购专员', 'flexible-supplychain'),
                array(
                    'view_suppliers' => true,
                    'create_orders' => true,
                    'view_inventory' => true,
                    'access_current_tenant_only' => true,
                ));
    }
    
    /**
     * 用户登录处理 - 确定可访问的租户
     * @param string $username 用户名
     * @param WP_User $user WordPress用户对象
     */
    public static function handle_user_login($username, $user) {
        // 获取用户有权限访问的租户列表
        $accessible_tenants = get_user_meta($user->ID, '_accessible_tenants', true);
        
        if (empty($accessible_tenants)) {
            // 默认只能访问主租户
            $accessible_tenants = array(1);
            update_user_meta($user->ID, '_accessible_tenants', $accessible_tenants);
        }
        
        // 设置会话中的租户访问权限
        $_SESSION['accessible_tenants'] = $accessible_tenants;
        
        // 如果用户只有一个可访问租户，自动重定向
        if (count($accessible_tenants) === 1) {
            $primary_tenant = $accessible_tenants[0];
            self::switch_tenant_context($primary_tenant);
        }
    }
    
    /**
     * 切换租户上下文
     * @param int $tenant_id 目标租户ID
     */
    public static function switch_tenant_context($tenant_id) {
        // 验证用户是否有权限访问该租户
        if (!in_array($tenant_id, $_SESSION['accessible_tenants'])) {
            wp_die(__('您没有权限访问此租户', 'flexible-supplychain'));
        }
        
        // 更新当前租户ID
        define('CURRENT_TENANT_ID', $tenant_id);
        
        // 重新初始化租户配置
        do_action('tenant_context_switched', $tenant_id);
    }
    
    /**
     * 数据查询过滤器 - 自动添加租户限制
     * @param string $where SQL WHERE子句
     * @param WP_Query $query WordPress查询对象
     */
    public static function filter_tenant_data($where, $query) {
        global $wpdb;
        
        // 仅对供应链相关查询添加租户过滤
        if (isset($query->query_vars['post_type']) && 
            in_array($query->query_vars['post_type'], array('supplier', 'product', 'order'))) {
            
            $where .= $wpdb->prepare(" AND {$wpdb->posts}.post_author IN (
                SELECT user_id FROM {$wpdb->usermeta} 
                WHERE meta_key = '_primary_tenant' 
                AND meta_value = %d
            )", CURRENT_TENANT_ID);
        }
        
        return $where;
    }
}
add_filter('posts_where', array('Multitenant_User_Manager', 'filter_tenant_data'), 10, 2);
?>

租户配置与自定义功能

每个租户可能需要不同的供应链配置。以下是配置管理系统的实现：

<?php
/**
 * 租户配置管理器
 */
class Tenant_Configuration_Manager {
    
    private static $tenant_configs = array();
    
    /**
     * 获取租户配置
     * @param string $key 配置键
     * @param mixed $default 默认值
     * @return mixed 配置值
     */
    public static function get_config($key, $default = null) {
        $tenant_id = CURRENT_TENANT_ID;
        
        // 懒加载配置
        if (!isset(self::$tenant_configs[$tenant_id])) {
            self::load_tenant_config($tenant_id);
        }
        
        return isset(self::$tenant_configs[$tenant_id][$key]) 
            ? self::$tenant_configs[$tenant_id][$key] 
            : $default;
    }
    
    /**
     * 加载租户配置
     * @param int $tenant_id 租户ID
     */
    private static function load_tenant_config($tenant_id) {
        global $wpdb;
        
        $config_table = "tenant_{$tenant_id}_configurations";
        
        $configs = $wpdb->get_results(
            "SELECT config_key, config_value FROM {$config_table}",
            ARRAY_A
        );
        
        $parsed_configs = array();
        foreach ($configs as $config) {
            // 尝试解析JSON配置
            $value = json_decode($config['config_value'], true);
            $parsed_configs[$config['config_key']] = 
                (json_last_error() === JSON_ERROR_NONE) ? $value : $config['config_value'];
        }
        
        // 合并默认配置
        $defaults = array(
            'inventory_alert_threshold' => 10,
            'default_currency' => 'USD',
            'supplier_approval_required' => true,
            'order_fulfillment_days' => 3,
            'reporting_timezone' => 'UTC',
        );
        
        self::$tenant_configs[$tenant_id] = array_merge($defaults, $parsed_configs);
    }
    
    /**
     * 动态生成租户特定的短代码
     */
    public static function register_tenant_shortcodes() {
        $tenant_id = CURRENT_TENANT_ID;
        
        // 租户特定的库存显示短代码
        add_shortcode("tenant_{$tenant_id}_inventory", array(__CLASS__, 'render_inventory_shortcode'));
        
        // 租户特定的订单跟踪短代码
        add_shortcode("tenant_{$tenant_id}_order_tracker", array(__CLASS__, 'render_order_tracker'));
    }
    
    /**
     * 渲染库存短代码
     */
    public static function render_inventory_shortcode($atts) {
        $tenant_id = CURRENT_TENANT_ID;
        $atts = shortcode_atts(array(
            'category' => '',
            'low_stock_only' => false,
        ), $atts);
        
        // 获取租户特定的库存数据
        $inventory_data = self::get_tenant_inventory($tenant_id, $atts);
        
        ob_start();
        ?>
        <div class="tenant-inventory-widget" data-tenant="<?php echo esc_attr($tenant_id); ?>">
            <h3><?php echo esc_html(self::get_config('company_name', '租户' . $tenant_id)); ?> 库存概览</h3>
            <table class="inventory-table">
                <thead>
                    <tr>
                        <th>产品名称</th>
                        <th>当前库存</th>
                        <th>预警水平</th>
                        <th>状态</th>
                    </tr>
                </thead>
                <tbody>
                    <?php foreach ($inventory_data as $item): ?>
                    <tr class="<?php echo $item['quantity'] <= $item['threshold'] ? 'low-stock' : 'adequate'; ?>">
                        <td><?php echo esc_html($item['product_name']); ?></td>
                        <td><?php echo esc_html($item['quantity']); ?></td>
                        <td><?php echo esc_html($item['threshold']); ?></td>
                        <td><?php echo $item['quantity'] <= $item['threshold'] ? '需要补货' : '充足'; ?></td>
                    </tr>
                    <?php endforeach; ?>
                </tbody>
            </table>
        </div>
        <?php
        return ob_get_clean();
    }
}
?>

性能优化与安全考虑

多租户系统的性能和安全至关重要：

<?php
/**
 * 多租户系统优化器
 */
class Multitenant_Optimizer {
    
    /**
     * 实现租户级别的对象缓存
     */
    public static function init_tenant_caching() {
        $tenant_id = CURRENT_TENANT_ID;
        
        // 租户特定的缓存组
        wp_cache_add_global_groups(array(
            "tenant_{$tenant_id}_suppliers",
            "tenant_{$tenant_id}_products",
            "tenant_{$tenant_id}_orders"
        ));
        
        // 缓存租户配置
        add_action('tenant_config_updated', function($tenant_id, $config_key) {
            wp_cache_delete("tenant_config_{$tenant_id}", "tenant_{$tenant_id}_config");
        }, 10, 2);
    }
    
    /**
     * 数据库查询优化
     */
    public static function optimize_tenant_queries() {
        global $wpdb;
        
        // 添加租户索引提示
        add_filter('query', function($sql) use ($wpdb) {
            // 识别供应链相关表查询
            $supplychain_tables = array('suppliers', 'inventory', 'orders', 'products');
            
            foreach ($supplychain_tables as $table) {
                if (strpos($sql, $table) !== false && strpos($sql, 'tenant_id') === false) {
                    // 记录未使用租户ID的查询
                    error_log("潜在的多租户安全问题: 查询缺少租户过滤 - " . substr($sql, 0, 200));
                }
            }
            
            return $sql;
        });
    }
    
    /**
     * 安全审计日志
     */
    public static function log_tenant_activity($user_id, $action, $details) {
        global $wpdb;
        
        $tenant_id = CURRENT_TENANT_ID;

_logs";

    
    $wpdb->insert($log_table, array(
        'user_id' => $user_id,
        'tenant_id' => $tenant_id,
        'action' => $action,
        'details' => json_encode($details),
        'ip_address' => $_SERVER['REMOTE_ADDR'],
        'user_agent' => $_SERVER['HTTP_USER_AGENT'],
        'created_at' => current_time('mysql')
    ));
}

/**
 * 跨租户数据访问防护
 */
public static function prevent_cross_tenant_access() {
    // 验证所有数据请求都包含正确的租户上下文
    add_action('pre_get_posts', function($query) {
        if (is_admin() && !defined('DOING_AJAX')) {
            return;
        }
        
        // 为供应链自定义帖子类型添加租户过滤
        if (isset($query->query_vars['post_type']) && 
            in_array($query->query_vars['post_type'], array('supplychain_order', 'supplychain_product'))) {
            
            $meta_query = $query->get('meta_query', array());
            $meta_query[] = array(
                'key' => '_tenant_id',
                'value' => CURRENT_TENANT_ID,
                'compare' => '='
            );
            $query->set('meta_query', $meta_query);
        }
    });
}

}
?>

## 部署与维护策略

### 自动化租户配置

<?php
/**

• 租户生命周期管理器
  */

class Tenant_Lifecycle_Manager {

/**
 * 创建新租户
 * @param array $tenant_data 租户数据
 * @return int 租户ID
 */
public static function create_tenant($tenant_data) {
    global $wpdb;
    
    // 开始事务
    $wpdb->query('START TRANSACTION');
    
    try {
        // 1. 创建租户记录
        $wpdb->insert('tenants', array(
            'name' => $tenant_data['name'],
            'domain' => $tenant_data['domain'],
            'status' => 'active',
            'created_at' => current_time('mysql')
        ));
        
        $tenant_id = $wpdb->insert_id;
        
        // 2. 创建租户特定的数据库表
        SupplyChain_DB_Installer::create_tenant_tables($tenant_id);
        
        // 3. 初始化默认配置
        self::initialize_tenant_config($tenant_id, $tenant_data);
        
        // 4. 设置默认用户角色
        Multitenant_User_Manager::init_tenant_roles($tenant_id);
        
        // 5. 创建默认管理员用户
        self::create_tenant_admin($tenant_id, $tenant_data);
        
        $wpdb->query('COMMIT');
        
        // 触发租户创建完成钩子
        do_action('tenant_created', $tenant_id, $tenant_data);
        
        return $tenant_id;
        
    } catch (Exception $e) {
        $wpdb->query('ROLLBACK');
        error_log("租户创建失败: " . $e->getMessage());
        return false;
    }
}

/**
 * 初始化租户配置
 */
private static function initialize_tenant_config($tenant_id, $tenant_data) {
    $default_config = array(
        'company_name' => $tenant_data['name'],
        'currency' => $tenant_data['currency'] ?? 'CNY',
        'timezone' => $tenant_data['timezone'] ?? 'Asia/Shanghai',
        'inventory_threshold' => 10,
        'order_prefix' => 'ORD' . str_pad($tenant_id, 3, '0', STR_PAD_LEFT),
        'auto_approve_suppliers' => false
    );
    
    foreach ($default_config as $key => $value) {
        update_tenant_option($tenant_id, $key, $value);
    }
}

/**
 * 更新租户配置
 */
public static function update_tenant_config($tenant_id, $config_updates) {
    foreach ($config_updates as $key => $value) {
        update_tenant_option($tenant_id, $key, $value);
    }
    
    // 清除配置缓存
    wp_cache_delete("tenant_config_{$tenant_id}", "tenant_{$tenant_id}_config");
    
    do_action('tenant_config_updated', $tenant_id, $config_updates);
}

}
?>

### 监控与维护脚本

<?php
/**

• 多租户系统维护工具
  */

class Multitenant_Maintenance {

/**
 * 每日维护任务
 */
public static function daily_maintenance() {
    global $wpdb;
    
    // 1. 清理过期缓存
    self::cleanup_old_cache();
    
    // 2. 检查所有租户的数据库表完整性
    self::verify_tenant_tables();
    
    // 3. 生成系统健康报告
    $report = self::generate_health_report();
    
    // 4. 发送报告给管理员
    self::send_maintenance_report($report);
}

/**
 * 验证租户表完整性
 */
private static function verify_tenant_tables() {
    global $wpdb;
    
    // 获取所有活跃租户
    $tenants = $wpdb->get_results("SELECT id FROM tenants WHERE status = 'active'");
    
    foreach ($tenants as $tenant) {
        $tables = array(
            "tenant_{$tenant->id}_suppliers",
            "tenant_{$tenant->id}_inventory",
            "tenant_{$tenant->id}_orders",
            "tenant_{$tenant->id}_configurations"
        );
        
        foreach ($tables as $table) {
            $result = $wpdb->get_var("SHOW TABLES LIKE '{$table}'");
            if (!$result) {
                // 表缺失，尝试修复
                error_log("租户 {$tenant->id} 表 {$table} 缺失，尝试修复...");
                SupplyChain_DB_Installer::create_tenant_tables($tenant->id);
            }
        }
    }
}

/**
 * 数据备份策略
 */
public static function backup_tenant_data($tenant_id, $backup_type = 'daily') {
    $backup_dir = WP_CONTENT_DIR . '/tenant-backups/' . date('Y-m-d');
    
    if (!file_exists($backup_dir)) {
        wp_mkdir_p($backup_dir);
    }
    
    $filename = "tenant-{$tenant_id}-{$backup_type}-" . date('Y-m-d-H-i-s') . '.sql';
    $filepath = $backup_dir . '/' . $filename;
    
    // 使用mysqldump备份租户数据
    $command = sprintf(
        'mysqldump -u%s -p%s %s --tables %s > %s',
        DB_USER,
        DB_PASSWORD,
        DB_NAME,
        implode(' ', self::get_tenant_tables($tenant_id)),
        $filepath
    );
    
    exec($command, $output, $return_var);
    
    if ($return_var === 0) {
        // 记录备份日志
        self::log_backup_event($tenant_id, $filepath, $backup_type);
        return $filepath;
    }
    
    return false;
}

/**
 * 获取租户所有表名
 */
private static function get_tenant_tables($tenant_id) {
    global $wpdb;
    
    $tables = array();
    $all_tables = $wpdb->get_col("SHOW TABLES");
    
    foreach ($all_tables as $table) {
        if (strpos($table, "tenant_{$tenant_id}_") === 0) {
            $tables[] = $table;
        }
    }
    
    return $tables;
}

}
?>

## 扩展性与集成接口

### REST API 多租户支持

<?php
/**

• 多租户REST API控制器
  */

class Tenant_REST_API_Controller extends WP_REST_Controller {

protected $namespace = 'flexible-supplychain/v1';
protected $tenant_id;

public function __construct() {
    $this->tenant_id = CURRENT_TENANT_ID;
}

/**
 * 注册路由
 */
public function register_routes() {
    // 租户特定的库存API
    register_rest_route($this->namespace, '/tenant/(?P<tenant_id>d+)/inventory', array(
        array(
            'methods' => WP_REST_Server::READABLE,
            'callback' => array($this, 'get_inventory'),
            'permission_callback' => array($this, 'check_tenant_access'),
            'args' => array(
                'tenant_id' => array(
                    'validate_callback' => function($param) {
                        return is_numeric($param) && $param == CURRENT_TENANT_ID;
                    }
                )
            )
        )
    ));
    
    // 跨租户数据聚合API（仅限超级管理员）
    register_rest_route($this->namespace, '/analytics/summary', array(
        array(
            'methods' => WP_REST_Server::READABLE,
            'callback' => array($this, 'get_cross_tenant_analytics'),
            'permission_callback' => array($this, 'check_super_admin')
        )
    ));
}

/**
 * 获取租户库存
 */
public function get_inventory($request) {
    $tenant_id = $request['tenant_id'];
    
    // 切换租户上下文
    Multitenant_User_Manager::switch_tenant_context($tenant_id);
    
    // 获取库存数据
    $inventory_data = $this->fetch_tenant_inventory($tenant_id);
    
    return rest_ensure_response(array(
        'tenant_id' => $tenant_id,
        'data' => $inventory_data,
        'timestamp' => current_time('mysql')
    ));
}

/**
 * 检查租户访问权限
 */
public function check_tenant_access($request) {
    $requested_tenant = $request['tenant_id'];
    $user_tenants = $_SESSION['accessible_tenants'] ?? array();
    
    return in_array($requested_tenant, $user_tenants);
}

}
?>

### 第三方服务集成

<?php
/**

• 多租户支付网关集成
  */

class Multitenant_Payment_Gateway {

/**
 * 初始化租户特定的支付配置
 */
public static function init_tenant_gateways($tenant_id) {
    $payment_config = Tenant_Configuration_Manager::get_config('payment_settings', array());
    
    // 根据租户配置初始化支付网关
    add_filter('woocommerce_payment_gateways', function($gateways) use ($payment_config, $tenant_id) {
        if ($payment_config['enable_alipay']) {
            $gateways[] = new Tenant_Alipay_Gateway($tenant_id);
        }
        
        if ($payment_config['enable_wechat_pay']) {
            $gateways[] = new Tenant_WeChatPay_Gateway($tenant_id);
        }
        
        return $gateways;
    });
}

/**
 * 租户特定的支付宝网关
 */
class Tenant_Alipay_Gateway extends WC_Payment_Gateway {
    
    private $tenant_id;
    
    public function __construct($tenant_id) {
        $this->tenant_id = $tenant_id;
        $this->init_tenant_settings();
    }
    
    private function init_tenant_settings() {
        $config = Tenant_Configuration_Manager::get_config('alipay_config');
        
        $this->id = 'alipay_tenant_' . $this->tenant_id;
        $this->title = $config['gateway_title'] ?? '支付宝支付';
        $this->app_id = $config['app_id'];
        $this->merchant_private_key = $config['private_key'];
        $this->alipay_public_key = $config['public_key'];
    }
    
    public function process_payment($order_id) {
        // 租户特定的支付处理逻辑
        $order = wc_get_order($order_id);
        
        // 添加租户标识到支付参数
        $payment_params = array(
            'out_trade_no' => $this->tenant_id . '_' . $order_id . '_' . time(),
            'total_amount' => $order->get_total(),
            'subject' => '订单支付 - 租户' . $this->tenant_id,
            'tenant_id' => $this->tenant_id
        );
        
        // 调用支付宝API
        return $this->call_alipay_api($payment_params);
    }
}

}
?>

## 故障排除与调试

### 调试工具类

<?php
/**

• 多租户调试工具
  */

class Multitenant_Debugger {

/**
 * 显示当前租户上下文信息
 */
public static function debug_tenant_context() {
    if (!current_user_can('manage_options')) {
        return;
    }
    
    add_action('admin_bar_menu', function($wp_admin_bar) {
        $tenant_id = defined('CURRENT_TENANT_ID') ? CURRENT_TENANT_ID : '未设置';
        
        $wp_admin_bar->add_node(array(
            'id' => 'tenant-debug',
            'title' => sprintf('租户: %s | ID: %d', 
                Tenant_Configuration_Manager::get_config('company_name', '未知'),
                $tenant_id
            ),
            'parent' => 'top-secondary',
            'meta' => array('class' => 'tenant-debug-info')
        ));
    }, 999);
}

/**
 * 租户数据隔离检查
 */
public static function check_data_isolation() {
    global $wpdb;
    
    $report = array();
    $current_tenant = CURRENT_TENANT_ID;
    
    // 检查所有供应链相关查询
    $queries = $wpdb->queries ?? array();
    
    foreach ($queries as $query) {
        $sql = $query[0];
        
        // 检查是否缺少租户过滤
        if (preg_match('/FROMs+tenant_d+_/', $sql) && 
            !preg_match('/WHERE.*tenant_ids*=s*' . $current_tenant . '/i', $sql)) {
            
            $report[] = array(
                'query' => substr($sql, 0, 200) . '...',
                'issue' => '可能缺少租户过滤',
                'severity' => 'high'
            );
        }
    }
    
    return $report;
}

/**
 * 性能分析
 */
public static function analyze_performance() {
    $stats = array();
    
    // 检查每个租户的缓存命中率
    $tenants = get_all_active_tenants();
    
    foreach ($tenants as $tenant) {
        $cache_group = "tenant_{$tenant->id}_";
        $stats[$tenant->id] = array(
            'cache_hits' => wp_cache_get('hits', $cache_group . 'stats'),
            'cache_misses' => wp_cache_get('misses', $cache_group . 'stats'),
            'query_count' => self::get_tenant_query_count($tenant->id),
            'avg_query_time' => self::get_avg_query_time($tenant->id)
        );
    }
    
    return $stats;
}

}
?>

## 总结与最佳实践

通过本文的详细教程，我们实现了WordPress环境下柔性供应链软件的多租户架构。以下是关键总结和最佳实践：

### 核心实现要点
1. **数据隔离**：通过动态表前缀和自动化的租户ID过滤确保数据安全
2. **配置管理**：每个租户拥有独立的配置系统，支持个性化设置
3. **用户权限**：精细化的角色管理和跨租户访问控制
4. **性能优化**：租户级别的缓存策略和查询优化

### 部署建议
1. **分阶段部署**：先在小规模租户中测试，逐步扩大规模
2. **监控系统**：建立全面的性能监控和告警机制
3. **备份策略**：实施租户级别的数据备份和恢复方案
4. **容量规划**：根据租户增长预测进行基础设施规划

### 扩展性考虑
1. **微服务架构**：随着系统复杂度的增加，考虑将核心功能拆分为微服务
2. **多语言支持**：为国际化的供应链需求准备多语言架构
3. **API生态系统**：构建开放的API接口，支持第三方系统集成

### 安全建议
1. **定期审计**：实施定期的安全审计和代码审查
2. **数据加密**：对敏感数据实施端到端加密
3. **访问日志**：详细记录所有数据访问和修改操作

本教程提供的代码和架构方案为WordPress柔性供应链系统的多租户实现提供了完整的基础框架。开发者可以根据具体业务需求进行扩展和优化，构建出强大、灵活且安全的供应链管理解决方案。