### 核心技术
1、PHP分表存储

2、分布式服务器（数据库），主从复制

3、合表查询分页

### 分表存储代码
```php
<?php
namespace org;

class SubTable
{
    // 缓存表名称地址
    protected static $table_path = '';
    // 缓存表名称列表
    protected static $table_list = [];

// 表前缀
    private static $prefix  = 'tp_';
    // 表中缀：TP的分表链接只能是下划线中缀
    private static $in_prefix  = '_';
    // 表名称
    private static $table   = '';
    // 单例实例
    private static $instance;
    
	// 私有化构造函数，可以保证在类外该类不能被实例化
    private function __construct(){}
        
    // 禁止克隆单例类，防止二次new
    private function __clone()
    { 
        die('此对象不允许被克隆');
    }
    
    /**
     * 用于初始化单例类
     * @todo 无
     * @author 小黄牛
     * @version v1.0.1 + 2019.05.23
     * @deprecated 暂不弃用
     * @global 无
     * @param string $table
     * @return void
    */
    public static function init($table)
    {
        self::$table = $table;

if (!self::$instance instanceof self) {
            // 生成缓存地址
            self::$table_path = ROOT_PATH . DIRECTORY_SEPARATOR .'public'. DIRECTORY_SEPARATOR .'data'. DIRECTORY_SEPARATOR .'table_cache' . DIRECTORY_SEPARATOR . $table . '_cache.php';
            // 获得单例
            self::$instance = new self();
            // 返回单例
            return self::$instance;
        }

return self::$instance;
    }
    
    /**
     * 简单hash算法，生成表名
     * @todo 无
     * @author 小黄牛
     * @version v1.0.1 + 2019.05.20
     * @deprecated 暂不弃用
     * @global 无
     * @param string $channel 查询关键词条件ID，一定要是唯一的值
     * @return string
    */
    public function hash($channel)
    {
        $str = crc32($channel);
        if ($str < 0) {
            $hash = "0".substr(abs($str), 0, 1);
        } else {
            $hash = substr($str, 0, 2);
        }

$table = self::$table . self::$in_prefix . $hash;
        
        return $this->create_table($table);
    }

/**
     * 对所有表，包括主表进行字段(索引)新增、修改，注意：表名称也使用{table}代替
     * @todo 无
     * @author 小黄牛
     * @version v1.0.1 + 2019.05.20
     * @deprecated 暂不弃用
     * @global 无
     * @param string $sql
     * @return bool
    */
    public function update($sql) {
        // 获取缓存列表
        $this->get_table_list();
        $list = self::$table_list;
        // 也加入主表一起更新
        $list[] = self::$table;
        // 强制删除末尾;号，防止SQL不规范
        $sql = rtrim($sql, ';');

$sql_list = '';
        // 循环创建SQL
        foreach ($list as $v) {
            $sql_list .= str_replace('{table}', self::$prefix.$v, $sql).';';
        }

// 批量执行SQL
        $res = $this->exec($sql_list);
        if ($res !== true) {
            die("执行失败！\r\n<br/>SQL：{$sql_list}\r\n<br/>error：{$res}");
        }

return true;
    }

// 获得所有分表缓存名称
    private function get_table_list() {
        // 判断缓存文件是否存在
        if (file_exists(self::$table_path)) {
            self::$table_list = require self::$table_path;
            return self::$table_list;
        }

return [];
    }
    // 新增对外开放获取
    public function get_tables() {
        return $this->get_table_list();
    }

// 创建表
    private function create_table($table)
    {
        // 获取缓存列表
        $this->get_table_list();

$status = false;

// 判断缓存文件是否存在
        if (!file_exists(self::$table_path)) {
            file_put_contents(self::$table_path, "<?php \r\nreturn [];");
        } else {
        // 判断是否存在缓存中
            foreach (self::$table_list as $v) {
                if ($v == $table) {
                    $status = true;
                    break;
                }
            }
        }

// 为false则创建该表
        if (!$status) {
            $sql = 'CREATE TABLE '.self::$prefix.$table.' LIKE '.self::$prefix.self::$table.';';
            $res = $this->exec($sql);
            if ($res !== true) {
                die("{$table}：分表创建失败！\r\n<br/>SQL：{$sql}\r\n<br/>error：{$res}");
            }
            
            // 加入分表中缓存
            self::$table_list[] = $table;
            // 更新缓存
            $html = "<?php \r\nreturn [\r\n";
            foreach (self::$table_list as $v) {
                $html .= '      "'.$v.'",'."\r\n";
            }
            $html .= "];";
            file_put_contents(self::$table_path, $html);
        }

return $table;
    }

/**
     * 执行查询语句
     * @todo 无
     * @author 小黄牛
     * @version v1.0.1 + 2019.05.20
     * @deprecated 暂不弃用
     * @global 无
     * @param string $sql
     * @return mixed
    */
    private function query($sql) {
        $list = \think\Db::query($sql);
        return $list;
    }

/**
     * 执行SQL语句
     * @todo 无
     * @author 小黄牛
     * @version v1.0.1 + 2019.05.20
     * @deprecated 暂不弃用
     * @global 无
     * @param string $name 表名
     * @return bool
    */
    private function exec($sql) {
        try {
            $res = \think\Db::execute($sql);
            if ($res !== false) return true;
        } catch(\PDOException $e) {
            return $e->getMessage();
        }
    }
}
```
核心使用方法为：
```php
// 获取分表表名
$table = \org\SubTable::init('主表名')->hash(分表规则，唯一的标记);
// 获得所有分表名称，一般用于合表查询
$table_list = \org\SubTable::init('主表名')->get_tables();
// 同步更新所有表结构，例如：
// 添加字段
$obj = \org\SubTable::init('主表名')->update('alter table {table} add transactor varchar(10) not Null;');
// 添加索引
$obj = SubTable::init('主表名')->update('alter table {table} add index shop_name (shop_name);');
```
注意：

1、表结构更新中，SQL语句中的`表名称`要使用`{table}`关键字代替，否则将报错。

2、如果服务器配置了分布式服务器，请修改`self:$table_path`变量的存储位置，指向您应用的`分布式文件同步`目录

3、如果是linux服务器，请为`self:$table_path`变量的存储位置，设置为`可读写`目录。

### 分布式服务器唯一ID生成
```php
<?php
namespace org;

class Snowflake {
    const EPOCH = 1479533469598;
    const max12bit = 4095;
    const max41bit = 1099511627775;

static $machineId = null;

public static function get_id($mId=0) {
        self::$machineId = $mId;
        /*
        * Time - 42 bits
        */
        $time = floor(microtime(true) * 1000);

/*
        * Substract custom epoch from current time
        */
        $time -= self::EPOCH;

/*
        * Create a base and add time to it
        */
        $base = decbin(self::max41bit + $time);

/*
        * Configured machine id - 10 bits - up to 1024 machines
        */
        if(!self::$machineId) {
            $machineid = self::$machineId;
        } else {
            $machineid = str_pad(decbin(self::$machineId), 10, "0", STR_PAD_LEFT);
        }
        
        /*
        * sequence number - 12 bits - up to 4096 random numbers per machine
        */
        $random = str_pad(decbin(mt_rand(0, self::max12bit)), 12, "0", STR_PAD_LEFT);

/*
        * Pack
        */
        $base = $base.$machineid.$random;

/*
        * Return unique time id no
        */
        return bindec($base);
    }

public static function timeFromParticle($particle) {
        /*
        * Return time
        */
        return bindec(substr(decbin($particle),0,41)) - self::max41bit + self::EPOCH;
    }
}
```
使用方法：
```php
// 生成唯一ID
$id = \org\Snowflake::get_id();
// 如果您的分布式服务器较多，建议在get_id中传入机器编号（不能为0），例如：
$id = \org\Snowflake::get_id(1);
```
注意：在分表存储中，主键id一定不能为空，否则将出现合表查询ID重复的问题。

### ThinkPHP5.1合表分页查询：
```php
// 管理员操作日志-分表存储
$SubTable = \org\SubTable::init('auth_admin_action');
// 获得所有子表
$table_list = $SubTable->get_tables();
$union = [];
$where = [];

// 子表构造
foreach ($table_list as $v) {
	$union[] = \think\Db::name($v)->where($where)->buildSql();
}

// 最终使用主表合并查询
$sql = \think\Db::name('auth_admin_action')->where($where)->union($union)->buildSql();
$list = \think\Db::table($sql . ' a')->order('id DESC')->page($param['page'])->limit($param['limit'])->select();
$count = \think\Db::table($sql . ' a')->count();
```
上面是我基于layui编写的ajax分页，你们也可以根据自己的需求改成view视图分页。

已有0条评论

添加新评论☺

如果认为本文对您有所帮助请赞助本站

支付宝扫一扫赞助

已有0条评论

添加新评论☺