Detailed explanation of distributed deployment examples of ThinkPHP project

In ordinary Web development, the common mode is that after the user logs in, the login status information is stored in the Session, some of the user's commonly used hot data is stored in the file cache, and the attachment information uploaded by the user is stored in a directory on the Web server. . This method is very convenient to use and fully capable for general Web applications. But for high-concurrency enterprise-level websites, it cannot handle it. Web clusters need to be used to achieve load balancing.

After deploying using the Web cluster method, the first thing to adjust is the user status information and attachment information. User status can no longer be saved to the Session, the cache cannot use the file cache of the local Web server, and attachments cannot be saved on the Web server. Because it is necessary to ensure that the status of each web server in the cluster is completely consistent. Therefore, user status, cache, etc. need to be saved to a dedicated cache server, such as Memcache. Attachments need to be saved to cloud storage, such as Qiniu Cloud Storage, Alibaba Cloud Storage, Tencent Cloud Storage, etc.

This article takes the ThinkPHP development framework as an example to explain how to set up and save Session, cache, etc. to the Memcache cache server.

Download the cached Memcache processing class and place it in the Thinkphp\Extend\Driver\Cache directory; download the Session Memcache processing class and place it in the Thinkphp\Extend\Driver\Session directory. As shown in the figure below:

Modify the configuration file, adjust the Session and cache, and record them to the Memcache server. Open ThinkPHP\Conf\convention.php, add configuration items:

    /* Memcache缓存设置 */
    'MEMCACHE_HOST'         => '192.168.202.20',
    'MEMCACHE_PORT'         => 11211,

Modify the data cache to Memcache:

    'DATA_CACHE_TYPE'       => 'Memcache',

Modify the Session to Memcache:

    'SESSION_TYPE'          => 'Memcache',

As shown in the figure below:

# Because there are many types of cloud storage, attachments are stored on cloud storage, so I won’t go into details. Just parameterize the SDK provided by each cloud storage. After the above modifications, the Web server can be deployed in a distributed manner.

Attachment 1: CacheMemcache.class.php

// +----------------------------------------------------------------------

defined('THINK_PATH') or exit();
/**
 * Memcache缓存驱动
 * @category   Extend
 * @package  Extend
 * @subpackage  Driver.Cache
 * @author    liu21st 
 */
class CacheMemcache extends Cache {

    /**
     * 架构函数
     * @param array $options 缓存参数
     * @access public
     */
    function __construct($options=array()) {
        if ( !extension_loaded('memcache') ) {
            throw_exception(L('_NOT_SUPPERT_').':memcache');
        }

        $options = array_merge(array (
            'host'        =>  C('MEMCACHE_HOST') ? C('MEMCACHE_HOST') : '127.0.0.1',
            'port'        =>  C('MEMCACHE_PORT') ? C('MEMCACHE_PORT') : 11211,
            'timeout'     =>  C('DATA_CACHE_TIMEOUT') ? C('DATA_CACHE_TIMEOUT') : false,
            'persistent'  =>  false,
        ),$options);

        $this->options      =   $options;
        $this->options['expire'] =  isset($options['expire'])?  $options['expire']  :   C('DATA_CACHE_TIME');
        $this->options['prefix'] =  isset($options['prefix'])?  $options['prefix']  :   C('DATA_CACHE_PREFIX');        
        $this->options['length'] =  isset($options['length'])?  $options['length']  :   0;        
        $func               =   $options['persistent'] ? 'pconnect' : 'connect';
        $this->handler      =   new Memcache;
        $options['timeout'] === false ?
            $this->handler->$func($options['host'], $options['port']) :
            $this->handler->$func($options['host'], $options['port'], $options['timeout']);
    }

    /**
     * 读取缓存
     * @access public
     * @param string $name 缓存变量名
     * @return mixed
     */
    public function get($name) {
        N('cache_read',1);
        return $this->handler->get($this->options['prefix'].$name);
    }

    /**
     * 写入缓存
     * @access public
     * @param string $name 缓存变量名
     * @param mixed $value  存储数据
     * @param integer $expire  有效时间（秒）
     * @return boolen
     */
    public function set($name, $value, $expire = null) {
        N('cache_write',1);
        if(is_null($expire)) {
            $expire  =  $this->options['expire'];
        }
        $name   =   $this->options['prefix'].$name;
        if($this->handler->set($name, $value, 0, $expire)) {
            if($this->options['length']>0) {
                // 记录缓存队列
                $this->queue($name);
            }
            return true;
        }
        return false;
    }

    /**
     * 删除缓存
     * @access public
     * @param string $name 缓存变量名
     * @return boolen
     */
    public function rm($name, $ttl = false) {
        $name   =   $this->options['prefix'].$name;
        return $ttl === false ?
            $this->handler->delete($name) :
            $this->handler->delete($name, $ttl);
    }

    /**
     * 清除缓存
     * @access public
     * @return boolen
     */
    public function clear() {
        return $this->handler->flush();
    }
}

Attachment 2: SessionMemcache.class.php

// +----------------------------------------------------------------------
    /**
     * 自定义Memcache来保存session
     */
Class SessionMemcache{
    //memcache对象
    private $mem;
    //SESSION有效时间
    private $expire;
    //外部调用的函数
    public function execute(){
        session_set_save_handler(
            array(&$this,'open'), 
            array(&$this,'close'), 
            array(&$this,'read'), 
            array(&$this,'write'), 
            array(&$this,'destroy'), 
            array(&$this,'gc')
            );
    }
    //连接memcached和初始化一些数据
    public function open($path,$name){
        $this->expire = C('SESSION_EXPIRE') ? C('SESSION_EXPIRE') :ini_get('session.gc_maxlifetime');
        $this->mem = new Memcache;
        return $this->mem->connect(C('MEMCACHE_HOST'), C('MEMCACHE_PORT'));
    }
    //关闭memcache服务器
    public function close(){
        return $this->mem->close();
    }
    //读取数据
    public function read($id){
        $id = C('SESSION_PREFIX').$id;
        $data = $this->mem->get($id);
        return $data ? $data :'';
    }
    //存入数据
    public function write($id,$data){
        $id = C('SESSION_PREFIX').$id;
        //$data = addslashes($data);
        return $this->mem->set($id,$data,0,$this->expire);
    }
    //销毁数据
    public function destroy($id){
        $id = C('SESSION_PREFIX').$id;
        return $this->mem->delete($id);
    }
    //垃圾销毁
    public function gc(){
        return true;
    }
}
?>

After the above configuration, user status information and cache information can be saved into Memcache. You can use load balancing servers to build websites in large-scale clusters.

Related recommendations:

Talk in detail about PHP distributed deployment

##MongoDB stand-alone, master-slave, distributed deployment

PHP extended Memcache distributed deployment solution_PHP

The above is the detailed content of Detailed explanation of distributed deployment examples of ThinkPHP project. For more information, please follow other related articles on the PHP Chinese website!