LVPHP

发表于 |

简介

Zookeeper 分布式服务框架是 Apache Hadoop 的一个子项目，它主要是用来解决分布式应用中经常遇到的一些数据管理问题，如：统一命名服务、状态同步服务、集群管理、分布式应用配置项的管理等

安装和配置详解

Zookeeper的安装和配置十分简单, 既可以配置成单机模式, 也可以配置成集群模式
1.单机模式
到官方网站下载zookeeper的安装包之后, 解压到合适目录. 进入zookeeper目录下的conf子目录，复制一份zoo_sample.cfg为zoo.cfg，根据情况修改配置：

1
2
3
4
tickTime=2000  
dataDir=/home/apple/zookeeper/data  
dataLogDir=/home/apple/zookeeper/logs  
clientPort=4180

参数说明:

  • tickTime: zookeeper中使用的基本时间单位, 毫秒值.
  • dataDir: 数据目录. 可以是任意目录.
  • dataLogDir: log目录, 同样可以是任意目录. 如果没有设置该参数, 将使用和dataDir相同的设置.
  • clientPort: 监听client连接的端口号.
    至此, zookeeper的单机模式已经配置好了. 启动server只需运行脚本:
    1
    ./bin/zkServer.sh start

Server启动之后, 就可以启动client连接server了, 执行脚本:

1
./bin/zkCli.sh -server localhost:4180

2.伪集群模式
所谓伪集群, 是指在单台机器中启动多个zookeeper进程, 并组成一个集群. 以启动3个zookeeper进程为例.
将zookeeper的目录拷贝2份:

1
2
3
|--zookeeper1
|--zookeeper2
|--zookeeper3

更改各目录下的conf/zoo.cfg的配置,例如下:

1
2
3
4
5
6
7
8
9
tickTime=2000  
initLimit=5  
syncLimit=2  
dataDir=/home/apple/zookeeper0/data  
dataLogDir=/home/apple/zookeeper0/logs  
clientPort=4180
server.1=127.0.0.1:8880:7770  
server.2=127.0.0.1:8881:7771  
server.3=127.0.0.1:8882:7772

新增了几个参数, 其含义如下:

  • initLimit: zookeeper集群中的包含多台server, 其中一台为leader, 集群中其余的server为follower. initLimit参数配置初始化连接时, follower和leader之间的最长心跳时间. 此时该参数设置为5, 说明时间限制为5倍tickTime, 即5*2000=10000ms=10s.
  • syncLimit: 该参数配置leader和follower之间发送消息, 请求和应答的最大时间长度. 此时该参数设置为2, 说明时间限制为2倍tickTime, 即4000ms.
  • server.X=A:B:C 其中X是一个数字, 表示这是第几号server. A是该server所在的IP地址. B配置该server和集群中的leader交换消息所使用的端口. C配置选举leader时所使用的端口. 由于配置的是伪集群模式, 所以各个server的B, C参数必须不同.
    在之前设置的dataDir中新建myid文件, 写入一个数字, 该数字表示这是第几号server. 该数字必须和zoo.cfg文件中的server.X中的X一一对应。
    /home/apple/zookeeper1/data/myid文件中写入1, /home/apple/zookeeper2/data/myid文件中写入2, /home/apple/zookeeper3/data/myid文件中写入3.
    3.集群模式
    集群模式的配置和伪集群基本一致.由于集群模式下, 各server部署在不同的机器上, 因此各server的conf/zoo.cfg文件可以完全一样.
    下面是一个示例:
    1
    2
    3
    4
    5
    6
    7
    8
    9
    tickTime=2000  
    initLimit=5  
    syncLimit=2  
    dataDir=/home/zookeeper/data  
    dataLogDir=/home/zookeeper/logs  
    clientPort=4180
    server.43=10.1.39.43:2888:3888
    server.47=10.1.39.47:2888:3888  
    server.48=10.1.39.48:2888:3888

示例中部署了3台zookeeper server, 分别部署在10.1.39.43, 10.1.39.47, 10.1.39.48上. 需要注意的是, 各server的dataDir目录下的myid文件中的数字必须不同.
10.1.39.43 server的myid为43, 10.1.39.47 server的myid为47, 10.1.39.48 server的myid为48.

node客户端链接zookeeper

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
"use strict";
const zookeeper = require('node-zookeeper-client');
const client = zookeeper.createClient("127.0.0.1:4180,127.0.0.1:4181,127.0.0.1:4182");
function createPath(path){
    client.create(
        path,
        new Buffer('aaaaaaaa'),
        zookeeper.CreateMode.EPHEMERAL_SEQUENTIAL,
        function (error, path) {
            if (error) {
                console.log(error.stack);
                return;
            }
            console.log('Node: %s is created.', path);
        }
    );
}
function getData(path){
    client.getData(
        path,
        function (event) {
            console.log('Got event: %s.', event);
            getData(path);
        },
        function (error, data, stat) {
            if (error) {
                console.log(error.stack);
                return;
            }
            console.log('Got data: %s', data.toString('utf8'));
        }
    );
}
function listChildren(path) {
    client.getChildren(
        path,
        function (event) {
            console.log('Got watcher event: %s', event.getPath());
            listChildren(path);
        },
        function (error, children, stat) {
            if (error) {
                console.log(
                    'Failed to list children of %s due to: %s.',
                    path,
                    error
                );
                return;
            }
            console.log('Children of %s are: %j.', path, children);
        }
    );
}
client.once('connected', function () {
    console.log('Connected to ZooKeeper.');
    createPath("/test/node4");
    listChildren("/test");
});
client.connect();

node server使用zookeeper

local_address
node-zookeeper-client

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
"use strict";
const program = require("commander"),
    events = require('events'),
    fs = require("fs"),
    util = require("util"),
    debug = require('debug')("server"),
    local_address = require("./lib/local_address"),
    zookeeper = require('node-zookeeper-client'),
    net = require('net');
program
    .version('0.0.1')
    .usage('[options] <file ...>')
    .option('-e, --env [develop|test|bjac]', 'Run ENV')
    .parse(process.argv);
if(typeof program.env == "undefined" ){
    console.log("argv error");
    process.exit();
}
let _env = program.env;
let configfile = __dirname + "/config/config_" + _env + ".js";
if(!fs.existsSync(configfile)){
    console.log("no config file");
    process.exit();
}
var Config = require(configfile);
let nodename = local_address();
var Server = function(){
    let self = this;
    self.ready = false;
    self.name = nodename;
    self.connectZK();
    self.once("ready", function(){
        self.ready = true;
        self.init();
    });
};
util.inherits(Server, events.EventEmitter);
Server.prototype.connectZK = function () {
    let self = this;
    let zk = self.zk = zookeeper.createClient(Config.connectionString, Config.zkOptions);
    zk.once('connected', function () {
        console.log('Connected to ZooKeeper.');
        createPath("/test/"+self.name, new Buffer(self.name+":"+Config.port));
    });
    zk.on("error", function(error){
        console.log(error);
        self.emit("error", error);
    });
    zk.connect();
    function createPath(path, data){
        self.zk.create(
            path,
            data,
            zookeeper.CreateMode.EPHEMERAL_SEQUENTIAL,
            function (error, path) {
                if (error) {
                    console.log(error.stack);
                    self.emit("error", error);
                    return;
                }
                self.emit("ready");
            }
        );
    }
};
Server.prototype.init = function(){
    let self = this;
    self.server = net.createServer((c) => {
        // 'connection' listener
        console.log('client connected');
        c.on('end', () => {
            console.log('client disconnected');
        });
        c.write('hello\r\n');
        c.pipe(c);
    });
    self.server.on('error', (err) => {
        throw err;
    });
    self.server.listen(Config.port, () => {
        console.log('server bound');
    });
}
var sv = new Server();

列出所有节点

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
"use strict";
const zookeeper = require('node-zookeeper-client');
const client = zookeeper.createClient("127.0.0.1:4180,127.0.0.1:4181,127.0.0.1:4182");
function listChildren(path) {
    client.getChildren(
        path,
        function (event) {
            console.log('Got watcher event: %s', event.getPath());
            listChildren(path);
        },
        function (error, children, stat) {
            if (error) {
                console.log(
                    'Failed to list children of %s due to: %s.',
                    path,
                    error
                );
                return;
            }
            console.log('Children of %s are: %j.', path, children);
        }
    );
}
client.once('connected', function () {
    console.log('Connected to ZooKeeper.');
    listChildren("/test");
});
client.connect();

说明

zookeeper创建目录节点的时候有四种模式：

  • PERSISTENT：持久化目录节点，存储的数据不会丢失。
  • PERSISTENT_SEQUENTIAL：顺序自动编号的持久化目录节点，存储的数据不会丢失，并且根据当前已近存在的节点数自动加 1，然后返回给客户端已经成功创建的目录节点名。
  • EPHEMERAL：临时目录节点，一旦创建这个节点的客户端与服务器端口也就是session 超时，这种节点会被自动删除。
  • EPHEMERAL_SEQUENTIAL：临时自动编号节点，一旦创建这个节点的客户端与服务器端口也就是session 超时，这种节点会被自动删除，并且根据当前已近存在的节点数自动加 1，然后返回给客户端已经成功创建的目录节点名。
    ZooKeeper中一共由三种方法可以实现Watch，分别为getData、exists和getChildren，但这三种方法仅仅监控一次数据变化，要想永久监控，需要在对应的事件回调中继续增加watch。
LVPHP

发表于 |

介绍

swool官网网站：swool
PHP的异步、并行、高性能网络通信引擎，使用纯C语言编写，提供了PHP语言的异步多线程服务器，异步TCP/UDP网络客户端，异步MySQL，异步Redis，数据库连接池，AsyncTask，消息队列，毫秒定时器，异步文件读写，异步DNS查询。
Swoole内置了Http/WebSocket服务器端/客户端、Http2.0服务器端。
Swoole可以广泛应用于互联网、移动通信、企业软件、云计算、网络游戏、物联网（IOT）、车联网、智能家居等领域。 使用PHP+Swoole作为网络通信框架，可以使企业IT研发团队的效率大大提升，更加专注于开发创新产品。

一个简单的http server

1
2
3
4
5
6
7
8
9
10
11
12
13
$serv = new Swoole\Http\Server("127.0.0.1", 9502);
$serv->on('Request', function($request, $response) {
    var_dump($request->get);
    var_dump($request->post);
    var_dump($request->cookie);
    var_dump($request->files);
    var_dump($request->header);
    var_dump($request->server);
    $response->cookie("User", "Swoole");
    $response->header("X-Server", "Swoole");
    $response->end("<h1>Hello Swoole!</h1>");
});
$serv->start();

使用中的修改

项目结构
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
+/config--------配置文件
    |/config_develop.php
    |/config_test.php
    |/config_product.php
    |/swool.lvphp.com.conf
+/controller----控制器
    |/IndexController.php
+/process-------进程
    |/Worker.php   worker进程
    |/Tasker.php   task进程
+/libs----------类库文件
    |/Application.php
    |/RedisDB.php
+/public--------静态文件
    |/index.html
    |/favicon.ico
+server.php-----启动文件
启动程序
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
server.php
<?php
define("ROOT_PATH", dirname(__FILE__));
define("LOG_NAME", "swool.lvphp.com");
define("LOG_PATH", "/data/logs/php/");
define("API_CALLER", "swool");
//note 加载配置文件
$server_type = get_cfg_var('yaf.environ');
$conf_file = ROOT_PATH . "/config/config_{$server_type}.php";
if(!is_file($conf_file)){
    exit("no config file");
}
require(ROOT_PATH . '/libs/Application.php');
Application::load(array("dir"=>array(ROOT_PATH . "/controller", ROOT_PATH . "/libs", ROOT_PATH . "/process"), "file"=>array("Config"=>$conf_file)));
class HttpServer{
    public static $instance;
    public function __construct($conf) {
        //note 开启服务
        $http = new swoole_http_server(Config::SWOOL_ADDR, Config::SWOOL_PORT);
        $http->set($conf);
        $http->on("start", function(){ cli_set_process_title(Config::SERVER_NAME . "-master"); });
        $http->on('WorkerStart', function ($serv, $worker_id){
            if($worker_id >= $serv->setting['worker_num']) {
                cli_set_process_title(Config::SERVER_NAME . "-task-" . $worker_id);
                //note task初始化
                Tasker::start($serv, $worker_id);
            } else {
                cli_set_process_title(Config::SERVER_NAME . "-worker-" . $worker_id);
                //note worker初始化
                Worker::start($serv, $worker_id);
            }
        });
        $http->on("request", "Application::onRequest"); //note 处理请求
        $http->on("task", "Tasker::onTask"); //note 处理task
        $http->on("finish", "Worker::onFinish"); //note task finish
        $http->start();
    }
    public static function getInstance($conf) {
        if (!self::$instance) {
            self::$instance = new HttpServer($conf);
        }
        return self::$instance;
    }
}
HttpServer::getInstance(Config::$swool);
配置文件
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
config_develop.php
<?php
class Config
{
    const ENV = "beta";
    const SERVER_NAME = "swool";
    const SWOOL_ADDR = "0.0.0.0";
    const SWOOL_PORT = 9505;
    public static $swool = array(
        "max_request" => 100000,
        "heartbeat_idle_time" => 600,
        "worker_num" => 4,
        "task_worker_num" => 1,
        "heartbeat_check_interval" => 60,
        "dispatch_mode" => 1,
        "log_file" => "/data/logs/php/swool.lvphp.com.log",
        "log_level" => 4,
        "daemonize" => 0
    );
    public static $redis = array(
        "cache.read"  => array(
            "name"    => "cache.read",
            "host"    => "127.0.0.1",
            "port"    => "14000",
            "pwd"     => "lvphp",
            "timeout" => 3,
            "prefix"  => "cache:",
        )
    );
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
swool.lvphp.com.conf
server {
    listen       80;
    server_name  swool.lvphp.com;
    root /data/htdocs/swool.lvphp.com/public/;
    index index.html;
    location / {
        if (!-e $request_filename) {
            proxy_pass http://127.0.0.1:9505;
        }
    }
    #access_log  /data/logs/nginx/swool.lvphp.com.access.log main;
}

类库

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
Application.php
<?php
defined('ROOT_PATH') || exit("NO ROOT_PATH!");
defined('LOG_PATH') || exit("NO LOG_PATH!");
defined('LOG_NAME') || exit("NO LOG_NAME!");
class Application{
    public static $starttime = null;
    public static $controller = null;
    public static $method = null;
    public static $argTypes = array("p"=>"post", "g"=>"get", "c"=>"cookie");
    public static $directories = array();
    public static $files = array();
    public static $inputs = null;
    public static $server = null;
    public function __construct() {}
    public static function load($loadData){
        if(isset($loadData["dir"])){ self::$directories = $loadData["dir"];}
        if(isset($loadData["file"])){ self::$files = $loadData["file"];}
        spl_autoload_register("Application::autoLoad");
    }
    public static function autoLoad($className){
        $dsClassName = str_replace("_", "/", $className);
        if(is_array(self::$directories)){
            foreach(self::$directories as $directorie){
                $filePath = rtrim($directorie, "/") . "/" . $dsClassName . ".php";
                if(is_file($filePath)){
                    require $filePath;
                    return true;
                }
            }
        }
        if(is_array(self::$files)){
            foreach(self::$files as $key => $file){
                if($key == $className){
                    require $file;
                    return true;
                }
            }
        }
        throw new Exception("No found class " . $className, 500);
    }
    public static function writeLog($type, $data, $addTime = true){
        $data = $addTime ? (date("Y-m-d H:i:s") . "\t" . $data) : $data;
        swoole_async_writefile(LOG_PATH . "/" . LOG_NAME . "_{$type}.log", $data . "\r\n", function(){}, FILE_APPEND);
    }
    public static function display($result){
        //note 请求响应日志
        $consume = (int)round((microtime(true) - Application::$starttime) * 1000, 1);
        $logInfo = self::$inputs;
        $logInfo['client_ip'] = self::getIP();
        $logInfo['logtime'] = date("Y-m-d H:i:s", intval(Application::$starttime));
        $logInfo['consume'] = $consume;
        $logInfo['errno'] = $result['errno'];
        $logInfo['errmsg'] = $result['errmsg'];
        self::writeLog('request', json_encode($logInfo), false);
        return json_encode($result);
    }
    public static function get($name, $hash = 'get', $default = null) {
        $hash = strtolower ( $hash );
        switch ($hash) {
            case 'get' : $input = self::$inputs['get'];break;
            case 'post' : $input = self::$inputs['post'];break;
            case 'cookie' : $input = self::$inputs['cookie'];break;
            case 'files' : $input = self::$inputs['files'];break;
            case 'server' : $input = self::$server;break;
            default : $input = isset(self::$inputs[$hash]) ? self::$inputs[$hash] : NULL;break;
        }
        return (isset ($input[$name]) ? $input[$name] : $default);
    }
    public static function set($name, $hash = 'get', $value = ""){
        self::$inputs[strtolower($hash)][$name] = $value;
    }
    public static function getIP(){
        $ip = false;
        if (getenv("REMOTE_ADDR") && strcasecmp(getenv("REMOTE_ADDR"), "unknown")){
            $ip = getenv("REMOTE_ADDR");
        }else if (isset(self::$server['remote_addr']) && self::$server['remote_addr'] && strcasecmp(self::$server['remote_addr'], "unknown")){
            $ip = self::$server['remote_addr'];
        }
        return $ip;
    }
    public static function Route(){
        $method = self::get('method');
        if($method){
            $info = explode(".", $method);
            if(count($info) == 2){
                $controllerName = ucfirst($info[0]) . 'Controller';
                $actionName = strtolower($info[1]) . 'Action';
                //note 实例化控制器
                self::$controller = new $controllerName();
                if(method_exists(self::$controller, $actionName)){
                    $className = get_class(self::$controller);
                    $class = new ReflectionClass($className);
                    self::$method = $class->getMethod($actionName);
                }else{
                    throw new Exception("No method exists", 500);
                }
            }else{
                throw new Exception("Error method param", 401);
            }
        }else{
            throw new Exception("No method param", 401);
        }
    }
    public static function prepareParams(){
        $args = array();
        $params = self::$method->getParameters();
        if($params){
            foreach($params as $p){
                $input = false;
                $pargName = $p->getName();
                $tmp = explode("_", $pargName);
                if(isset(self::$argTypes[$tmp[0]])){
                    $pargType = self::argTypes[$tmp[0]];
                    $pargName = substr($pargName, 2);
                }else{
                    $pargType = "get";
                }
                $input = isset( self::$inputs[$pargType][$pargName] ) ? self::$inputs[$pargType][$pargName] : false;
                $default = $p->isDefaultValueAvailable();
                if(0 != $input && (false === $input || empty($input)) && false === $default){
                    throw new Exception("No {$pargName} {$pargType} param", 401);
                }
                $args[$pargName] = false !== $input ? $input : $p->getDefaultValue();
            }
        }
        return $args;
    }
    public static function Run() {
        self::Route();
        return self::$method->invokeArgs(self::$controller, self::prepareParams());
    }
    public static function onRequest($req, $res){
        $result = array("errno"=>0, "errmsg"=>"", "data"=>"");
        self::$starttime = microtime(true);
        self::$server = $req->server;
        self::$inputs = array(
            "get" => $req->get,
            "post" => $req->post,
            "cookie" => $req->cookie,
            "files" => $req->files,
            "input" => empty($req->post) ? $req->rawContent() : null,
        );
        try{
            //note 程序运行
            $result['data'] = self::run();
        }catch(Exception $e){
            $errno = $e->getCode();
            empty($errno) && $errno = 500;
            $result['errno'] = $errno;
            $result['errmsg'] = $e->getMessage();
        }
        //note 输出结果
        $res->header("Content-Type", "application/json; charset=UTF-8");
        $res->header("Cache-Control", "no-store");
        $res->end(self::display($result));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
RedisDB.php
<?php
class RedisDB{
    public static $pool = null;
    public static function getInstance($conf){
        if($conf){
            $name = $conf['name'];
            if(!isset(self::$pool[$name])){
                try{
                    self::$pool[$name] = new Redis();
                    $result = self::$pool[$name]->pconnect($conf['host'], $conf['port'], $conf['timeout']);
                    if(!$result){
                        throw new Exception("Redis {$name} connect error", 500);
                    }
                    if(isset($conf['pwd'])){
                        self::$pool[$name]->auth($conf["pwd"]);
                    }
                    if(isset($conf['prefix'])){
                        self::$pool[$name]->setOption(Redis::OPT_PREFIX, $conf['prefix']);
                    }
                }catch(Exception $e){
                    throw new Exception(ErrorMessage::$errmsg[ErrorMessage::INVALID_REQUEST], ErrorMessage::INVALID_REQUEST);
                }
            }
            return self::$pool[$name];
        }else{
            throw new Exception("No Redis config", 500);
        }
    }
}
进程
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
Tasker.php
<?php
class Tasker{
    public static $serv = null;
    public static $tasker_id = null;
    public static $redisClient = null;
    public static function start($serv, $tasker_id){
        self::$serv = $serv;
        self::$tasker_id = $tasker_id;
        self::$redisClient = RedisDB::getInstance(Config::$redis["cache.read"]);
    }
    public static function onTask($serv, $task_id, $src_worker_id, $data){
        self::$redisClient->incr($data);
        self::$serv->finish("finish");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
Worker.php
<?php
class Worker{
    public static $serv = null;
    public static $worker_id = null;
    public static $redisClient = null;
    public static $rand;
    public static function start($serv, $worker_id){
        self::$serv = $serv;
        self::$worker_id = $worker_id;
        self::$redisClient = RedisDB::getInstance(Config::$redis["cache.read"]);
        self::$rand = rand(0, 999999);
    }
    public static function onFinish($serv, $task_id, $data){
    }
}
控制器
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
IndexController.php
<?php
class IndexController{
    public function indexAction($name = "hehe", $type){
        if($name =="aaa"){
            sleep(3);
        }
        Worker::$serv->taskwait("wbtest", $timeout = 0.5);
        $data = Worker::$redisClient->incr("wbtest");
        return Application::get("name") . "-" . Worker::$rand . "-" . $data;
    }
}

说明

以上代码只是一个demo，做了一下简单的路由，可以自己根据实际情况使用，task worker根据自己的需要确定是否使用。

LVPHP

发表于 |

介绍

zimg是@招牌疯子开源的一个图片存储程序，主要的优点是可以根据请求实时处理图片，并且进行压缩和存储，一是方便前端用户，二来降低流量。

安装

安装依赖
1
$ sudo yum install openssl-devel cmake libevent-devel libjpeg-devel giflib-devel libpng-devel libwebp-devel ImageMagick-devel libmemcached-devel

安装zimg

1
2
3
4
5
$ git clone https://github.com/buaazp/zimg -b master --depth=1
$ cd zimg
$ make
$ cd bin
$ ./zimg conf/zimg.lua

zimg配置文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
--zimg server config
--server config
--是否后台运行
is_daemon	= 1
--绑定IP
ip              = '0.0.0.0'
--端口
port            = 4869
--运行线程数，默认值为服务器CPU数
--thread_num    = 4
backlog_num     = 1024
max_keepalives  = 1
retry           = 3
system          = io.popen('uname -sn'):read('*l')
pwd             = io.popen('pwd'):read('*l')
--header config
--返回时所带的HTTP header
headers         = 'Cache-Control:max-age=7776000'
--是否启用etag缓存
etag            = 1

默认使用4869端口，打开地址http://{ip}:4869/就可以上传图片了

图片自定义处理

http://demo.buaa.us/5f189d8ec57f5a5a0d3dcba47fa797e2?w=500&h=500&g=0&x=0&y=0&r=45&q=75&f=jpeg
说明

  • w:图片宽度
  • h:图片高度
  • g:g=1为转黑白色
  • x:裁剪的开始位置X坐标
  • y:裁剪的开始位置Y坐标
  • r:旋转角度
  • q:图片质量
  • f:输出格式
LVPHP

发表于 |

介绍

trie_filter是一个php关键词过滤扩展，用于检查一段文本中是否出现敏感词，基于Double-Array Trie 树实现。

安装步骤

安装libiconv，这个是libdatrie的依赖项
1
2
3
4
5
6
$ wget http://ftp.gnu.org/pub/gnu/libiconv/libiconv-1.14.tar.gz
$ tar zxvf libiconv-1.14.tar.gz
$ cd libiconv-1.14
$ ./configure
$ make
$ make install
安装libdatrie依赖库
1
2
3
4
$ tar zxvf libdatrie-0.2.4.tar.gz
$ cd libdatrie-0.2.4
$ make clean $ ./configure --prefix=$LIB_PATH
$ make $ make install
安装trie_filter扩展
1
2
3
4
$ $INSTALL_PHP_PATH/bin/phpize
$ ./configure --with-php-config=$INSTALL_PHP_PATH/bin/php-config --with-trie_filter=$LIB_PATH
$ make
$ make install

然后修改php.ini，增加一行：extension=trie_filter.so，然后重启PHP。

生成用语检测的词典
1
2
3
4
$ tar zxf trie_filter-2011.03.21.tar.gz
$ cd trie_filter-2011.03.21
$ gcc -o dpp dpp.c -ldatrie // 生成dpp命令用语编译词典
$ ./dpp words.txt words.dic  //将words.txt 编译成trie_filter使用的词典 words.txt中每个词占一行

PHP测试实例

1
2
3
4
5
6
7
8
9
10
11
12
13
<?php
ini_set('memory_limit', '512M');
// 载入词典，成功返回一个 Trie_Filter 资源句柄，失败返回 NULL  
$resTrie = trie_filter_load('./words.dic');
$str1 = '今天利用trie_filter做敏感词过滤示例';  
$str2 = '今天利用trie_filter做过滤示例';  
// 检测文本中是否含有词典中定义的敏感词(假设敏感词设定为：‘敏感词’)  
$res1 = trie_filter_search_all($resTrie, $str1);  // 一次把所有的敏感词都检测出来
$res2 = trie_filter_search($resTrie, $str2);// 每次只检测一个敏感词
var_dump($res1);  
echo "<br/-->";  
var_dump($res2);
trie_filter_free($resTrie); //最后别忘记调用free

注意

  • 一般情况下字典文件会比较大，如果每次都加载字典文件，性能会大打折扣，我们可以结合swool来做敏感词判断服务，避免每次加载字典；
LVPHP

发表于 |

说明

function* 声明（function关键字后跟一个星号）定义一个generator（生成器）函数，返回一个Generator对象。

语法

1
function* name([param[, param[, ... param]]]) { statements }

name
函数名

param
传入函数的参数名，一个函数至多可有255个参数。

statements
函数的主体

描述

生成器是一种可以从中退出并在之后重新进入的函数。生成器的环境（绑定的变量）会在每次执行后被保存，下次进入时可继续使用。
调用一个生成器函数并不马上执行它的主体，而是返回一个这个生成器函数的迭代器（iterator）对象。当这个迭代器的next()方法被调用时，生成器函数的主体会被执行直至第一个yield表达式，该表达式定义了迭代器返回的值，或者，被 yield*委派至另一个生成器函数。next()方法返回一个对象，该对象有一个value属性，表示产出的值，和一个done属性，表示生成器是否已经产出了它最后的值。

示例

1
2
3
4
5
6
7
8
9
10
11
"use strict"
function* idMaker(){
  var index = 0;
  while(index<3)
    yield index++;
}
var gen = idMaker();
console.log(gen.next().value); // 0
console.log(gen.next().value); // 1
console.log(gen.next().value); // 2
console.log(gen.next().value); // undefined

co的使用

在开发中，为了方便的使用generator，我们可以使用TJ大神的co库，co其实是帮我们封装了不断调用next的过程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
"use strict"
const co = require("co");
function sleep(ms){
    return function(done){
        setTimeout(done, ms)
    }
}
co(function* (){
    console.log("sleep");
    yield sleep(1000)
    console.log("sleep");
}).catch(function(e){
})

thunkify的使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
"use strict"
const fs = require("fs"),
      co = require("co"),
      thunkify = require("thunkify"),
      readfile = thunkify(fs.readFile);
co(function* (){
    let content = yield function(done){
        fs.readFile("/tmp/test.txt", done)
    }
    let text = yield readfile("/tmp/test.txt");
    console.log(content, text);
}).catch(function(e){
});
LVPHP

发表于 |

使用file_get_contents发送post请求

1
2
3
4
5
6
7
8
9
10
11
$data = ['eat'=>'2kg','run'=>'10km'];
$url = 'http://localhost';
$context = stream_context_create(array(
    'http' => array( 　　
        'method' => 'POST', 　　
        'header' => 'Content-type:application/x-www-form-urlencoded', 　　
        'content' => html_build_query($info), 　　
        'timeout' => 3
    )
));
$result = file_get_contents($url, false, $context);
LVPHP

发表于 |

引入微信JS文件

1
<script type="text/javascript" src="https://res.wx.qq.com/open/js/jweixin-1.1.0.js"></script>

获取access_token

1
$access_info = file_get_contents("https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=APPID&secret=APPSECRET");

正常情况下，微信会返回下述JSON数据包给公众号：

1
{"access_token":"ACCESS_TOKEN","expires_in":7200}

错误时微信会返回错误码等信息，JSON数据包示例如下（该示例为AppID无效错误）:

1
{"errcode":40013,"errmsg":"invalid appid"}

注意
获取access_token有频次限制，获取的access_token需要在做缓存

获取jsapi_ticket

1
$ticket_info = file_get_contents("https://api.weixin.qq.com/cgi-bin/ticket/getticket?access_token=ACCESS_TOKEN&type=jsapi");

成功返回如下JSON：

1
2
3
4
5
6
{
"errcode":0,
"errmsg":"ok",
"ticket":"bxLdikRXVbTPdHSM05e5u5sUoXNKd8-41ZO3MhKoyN5OfkWITDGgnr2fwJ0m9E8NYzWKVZvdVtaUgWvsdshFKA",
"expires_in":7200
}

注意
获取jsapi_ticket有频次限制，获取的jsapi_ticket需要在做缓存

计算签名

1
$signature = sha1("jsapi_ticket=sM4AOVdWfPE4DxkXGEs8VMCPGGVi4C3VM0P37wVUCFvkVAy_90u5h9nbSlYy3-Sl-HhTdfl2fzFy1AOcHKP7qg&noncestr=Wm3WZYTPz0wzccnW&timestamp=1414587457&url=http://mp.weixin.qq.com?params=value")
  • jsapi_ticket: 获取的jsapi_ticket
  • noncestr: 随机串
  • timestamp: 时间戳
  • url: 当前网页的URL，不包含#及其后面部分

调用SDK

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
wx.config({
    debug: true, // 开启调试模式,调用的所有api的返回值会在客户端alert出来，若要查看传入的参数，可以在pc端打开，参数信息会通过log打出，仅在pc端时才会打印。
    appId: 'wx1a1bba241ca4cce5', // 必填，公众号的唯一标识
    timestamp: 1428980719, // 必填，生成签名的时间戳
    nonceStr: 'Wm3WZYTPz0wzccnW', // 必填，生成签名的随机串
    signature: '2c3b0863b61fe7cc37961d7ce3ce71dc1d7360a8',// 必填，签名，见附录1
    jsApiList: ["previewImage"] // 必填，需要使用的JS接口列表，所有JS接口列表见附录2
});
wx.ready(function(){
    $(".img").click(function(){
        wx.previewImage({
            current: 'http://apps.sinaapp.com/app/screen.jpeg', // 当前显示的图片链接
            urls: ['http://apps.sinaapp.com/app/link.png', 'http://apps.sinaapp.com/app/search.png', 'http://apps.sinaapp.com/app/searchn.png'] // 需要预览的图片链接列表
        });
    });
});
LVPHP

发表于 |

使用拓展运算符 … 复制数组

1
2
3
4
5
6
"use strict"
const items = [1,2,3,4]
const itemscopy = [...items]
console.log(itemscopy); //note out: [ 1, 2, 3, 4 ]
itemscopy[0] = 6;
console.log(items, itemscopy); //note out: [ 1, 2, 3, 4 ] [ 6, 2, 3, 4 ]

使用解构存取和使用多属性对象

1
2
3
4
5
6
7
8
"use strict"
function getFullName(obj) {
    const { firstName, lastName } = obj;
    return `${firstName} ${lastName}`;
}
let str = getFullName({firstName:"wangbo", lastName:"bo", age:30});
console.log(str); //note out: wangbo bo

对数组使用解构赋值

1
2
3
4
"use strict"
const arr = [1, 2, 3, 4];
const [first, second] = arr;
console.log(first, second); //note out: 1 2

需要回传多个值时，使用对象解构，而不是数组解构

1
2
3
4
5
6
"use strict"
function processInput() {
    return {left: 10, right: 20, top: 30, bottom: 40};
}
const { top, left } = processInput();
console.log(top, left); //note out: 30 10

程序化生成字符串时，使用模板字符串代替字符串连接

1
2
3
4
5
6
"use strict"
function sayHi(name) {
    return `How are you, ${name}?`;
}
const str = sayHi("wangbo");
console.log(str); //note out: How are you, wangbo?

函数的参数指定默认值

1
2
3
4
"use strict"
function handleThings(opts = {}) {
}

使用箭头函数符号

1
2
3
4
5
6
"use strict"
const items = [1,2,3,4];
let tmp = items.map((x)=>{return x*x;});
console.log(tmp); //note out: [ 1, 4, 9, 16 ]
let arr = items.map(x => x * x);
console.log(arr); //note out: [ 1, 4, 9, 16 ]
LVPHP

发表于 |

应用场合

branch_A分支的工作区内容已被修改，但是并未完成。这时需要立即切换到另外一个分支branch_B上去，可是又不想提交目前的修改，因为修改没有完成。但是，不提交的话，又没有办法checkout到前面的分支。
此时用Git Stash就相当于备份工作区了。然后再Checkout到branch_B去修改，就能够达到保存当前工作区被修改过的内容，并及时恢复的作用。

用法

  • git stash 备份当前的工作区的内容，从最近的一次提交中读取相关内容，让工作区保证和上次提交的内容一致。同时，将当前的工作区内容保存到Git栈中;
  • git stash apply 把栈里面记录的内容运用到当前的版本上，这时候栈里面的记录还保存着;
  • git stash pop 从Git栈中读取最近一次保存的内容，恢复工作区的相关内容。由于可能存在多个Stash的内容，所以用栈来管理，pop会从最近的一个stash中读取内容并恢复， pop后栈中不再存在该记录;
  • git stash list 显示Git栈内的所有备份，可以利用这个列表来决定从那个地方恢复;
  • git stash clear 清空Git栈,此时使用gitg等图形化工具会发现，原来stash的哪些节点都消失了;

注意

在不同分支执行git stash 命令会将修改保存在同一个栈中，
例如

  1. 在copy_master分支执行 git stash, 这时候stash 栈中有一个stash@{0}
  2. 在sonar分支执行 git stash, 这时候stash 栈中会再放进一个stash@{1}
  3. 执行git stash list命令，输出：
    stash@{0}: WIP on copy_master: 2923b6d Merge branch ‘master’ into copy_master
    stash@{1}: WIP on sonar: c2c677b Merge branch ‘master’ into sonar
LVPHP

发表于 |

Hexo官网网站：Hexo，文档：documentation

使用命令

创建新文章

1
$ hexo new  name

本地预览

1
$ hexo server

生成静态文件

1
$ hexo generate

发布

1
$ hexo deploy