Laravel集合中的when方法

发表于 2018-09-05

Hope is a good thing and maybe the best of things. And no good thing ever dies.

Starting at v5.4.12, Laravel Collections now includes a when method that allows you to perform conditional actions on the items without breaking the chain.

Like all the other Laravel Collection methods this one can have a lot of use cases but one example that comes to mind is being able to filter based on a query string parameter.

To demonstrate that example, let’s pretend we have a list of hosts from the Laravel News Podcast:

$hosts = [
    ['name' => 'Eric Barnes', 'location' => 'USA', 'is_active' => 0],
    ['name' => 'Jack Fruh', 'location' => 'USA', 'is_active' => 0],
    ['name' => 'Jacob Bennett', 'location' => 'USA', 'is_active' => 1],
    ['name' => 'Michael Dyrynda', 'location' => 'AU', 'is_active' => 1],
];

Previously to filter based on a query string you might do something like this:

$inUsa = collect($hosts)->where('location', 'USA');
if (request('retired')) {
    $inUsa = $inUsa->filter(function($employee){
        return ! $employee['is_active'];
    });
}

With the new when method you can now do this all in one Collection chain:

$inUsa = collect($hosts)
    ->where('location', 'USA')
    ->when(request('retired'), function($collection) {
        return $collection->reject(function($employee){
            return $employee['is_active'];
        });
    });

https://laravel-news.com/laravel-collections-when-method

区块链分币项目

发表于 2018-09-05

我徒然学会了拒绝热闹，却还未透悟真正的冷清

简介

一个使用虚拟货币进行交易的项目，通过小金额的参与，获得大的收益，架构上才用Laravel和Swooole相结合，Socket消息事实推送。

功能点

首页展示

倒计时购买页面

邀请奖励页面

开奖锁定倒计时页面

中奖通知页面

自动充值页面

提现页面

swoole的平滑重启问题

发表于 2018-08-10

年轻时总以为能遇上许许多多的人。而后你就明白，所谓机缘，其实也不过那么几次。

守护进程（daemon）就是一种长期生存的进程，它不受终端的控制，可以在后台运行。其实我们之前也有了解，比如说nginx，fpm等一般都是作为守护进程在后台提供服务。

熟悉linux的同学可能知道，我们可以利用nohup命令让程序在后台跑。swoole官方也为我们提供了配置选项daemonize，默认不启用守护进程，若要开启守护进程，daemonize设置为true即可。

守护进程有优点，必然也存在缺点。我们启用守护进程后，server内所有的标准输出都会被丢弃，这样的话我们也就无法跟踪进程在运行过程中是否异常之类的错误信息了。为方便起见，swoole为我们提供了另一个配置选项log_file，我们可以指定日志路径，这样swoole在运行时就会把所有的标准输出统统记载到该文件内。

信号

我们了解到，swoole是常驻内存的，若想让修改后的代码生效，就必须Ctrl+C，然后再重启server。对于守护进程化的server呢？了解过kill命令的同学要说了，我直接把它干掉，然后终端下再重启，就可以了。

事实上，对于线上繁忙的server，如果你直接把它干掉了，可能某个进程刚好就只处理了一半的数据，对于天天来回倒腾的你来说，面对错乱的数据你不头疼，DBA也想long死你！

这个时候我们就需要考虑如何平滑重启server的问题了。所谓的平滑重启，也叫“热重启”，就是在不影响用户的情况下重启服务，更新内存中已经加载的php程序代码，从而达到对业务逻辑的更新。

swoole为我们提供了平滑重启机制，我们只需要向swoole_server的主进程发送特定的信号，即可完成对server的重启。

那什么是信号呢？

信号是软件中断，每一个信号都有一个名字。通常，信号的名字都以“SIG”开头，比如我们最熟悉的Ctrl+C就是一个名字叫“SIGINT”的信号，意味着“终端中断”。

平滑重启

在swoole中，我们可以向主进程发送各种不同的信号，主进程根据接收到的信号类型做出不同的处理。比如下面这几个

SIGTERM，一种优雅的终止信号，会待进程执行完当前程序之后中断，而不是直接干掉进程
SIGUSR1，将平稳的重启所有的Worker进程
SIGUSR2，将平稳的重启所有的Task进程

如果我们要实现重启server，只需要向主进程发送SIGUSR1信号就好了。

平滑重启的原理是当主进程收到SIGUSR1信号时，主进程就会向一个子进程发送安全退出的信号，所谓的安全退出的意思是主进程并不会直接把Worker进程杀死，而是等这个子进程处理完手上的工作之后，再让其光荣的“退休”，最后再拉起新的子进程（重新载入新的PHP程序代码）。然后再向其他子进程发送“退休”命令，就这样一个接一个的重启所有的子进程。

我们注意到，平滑重启实际上就是让旧的子进程逐个退出并重新创建新的进程。为了在平滑重启时不影响到用户，这就要求进程中不要保存用户相关的状态信息，即业务进程最好是无状态的，避免由于进程退出导致信息丢失。

在swoole中，重启只能针对Worker进程启动之后载入的文件才有效！什么意思呢，就是说只有在onWorkerStart回调之后加载的文件，重启才有意义。在Worker进程启动之前就已经加载到内存中的文件，如果想让它重新生效，还是只能乖乖的关闭server再重启。

我们看个例子看看到底怎么样向主进程发送SIGUSR1信号以便有效重启Worker进程。

<?php
class Test
{
    public function run($data)
    {
        echo $data;
    }
}

在Test::run方法中，我们第一步仅仅是echo输出swoole_server接收到的数据。

当前目录下我们创建一个swoole_server的类NoReload.php

<?php
require_once("Test.php");
class NoReload
{
    private $_serv;
    private $_test;
    /**
     * init
     */
    public function __construct()
    {
        $this->_serv = new Swoole\Server("127.0.0.1", 9501);
        $this->_serv->set([
            'worker_num' => 1,
        ]);
        $this->_serv->on('Receive', [$this, 'onReceive']);
        $this->_test = new Test;
    }
    /**
     * start server
     */
    public function start()
    {
        $this->_serv->start();
    }
    public function onReceive($serv, $fd, $fromId, $data)
    {
        $this->_test->run($data);
    }
}
$noReload = new NoReload;
$noReload->start();

特别提醒：我们在初始化swoole_server的时候的写法是命名空间的写法

1	new Swoole\Server

该种风格的写法等同于下划线写法 ,swoole对这两种风格的写法都支持

1	new swoole_server

此外我们看下server的代码逻辑：类定义之前require_once了Test.php，初始化的时候设置了一个Worker进程，注册了NoReload::onReceive方法为swoole_server的onReceive回调，在onReceive回调内接收到的数据传递给了Test::run方法处理。

接下来我们写一个client脚本测试下运行结果

<?php
$client = new swoole_client(SWOOLE_SOCK_TCP, SWOOLE_SOCK_SYNC);
$client->connect('127.0.0.1', 9501) || exit("connect failed. Error: {$client->errCode}\n");
// 向服务端发送数据
$client -> send("Just a test.\n");
$client->close();

客户端的测试代码也很简单，连接server并向server发一个字符串信息

在server不动的情况下我们修改下Test.php，代码如下

<?php
class Test
{
    public function run($data)
    {
        // echo $data;
        $data = json_decode($data, true);
        if (!is_array($data)) {
            echo "server receive \$data format error.\n";
            return ;
        } 
        var_dump($data);
    }
}

原先echo直接输出，现在我们改了下Test的代码，如果接收到的数据经过json_decode处理后不是数组，就返回一段内容并结束，否则打印receive到的数据

如果这个时候我们不对server进行重启，运行client的结果肯定还是一样的

server端新的代码未生效，如果Test.php新的代码生效了，会在server所在终端输出“server receive $data format error.”，这符合我们的认知。

下面我们通过ps命令查看下左侧server的主进程的pid，然后通过kill命令向该进程发送SIGUSR1信号，看看结果如何

结果发现即使向主进程发送了SIGUSR1信号，但是左侧server终端显示的依然是未生效的php代码，这也是对的，因为我们说过新的程序代码只针对在onWorkerStart回调之后才加载进来的php文件才能生效，我们事例中Test.php是在class定义之前就加载进来了，所以肯定不生效。

我们新建一个Reload.php文件，把server的代码修改如下

<?php
class Reload
{
    private $_serv;
    private $_test;
    /**
     * init
     */
    public function __construct()
    {
        $this->_serv = new Swoole\Server("127.0.0.1", 9501);
        $this->_serv->set([
            'worker_num' => 1,
        ]);
        $this->_serv->on('Receive', [$this, 'onReceive']);
        $this->_serv->on('WorkerStart', [$this, 'onWorkerStart']);
    }
    /**
     * start server
     */
    public function start()
    {
        $this->_serv->start();
    }
    public function onWorkerStart($serv, $workerId)
    {
        require_once("Test.php");
        $this->_test = new Test;
    }
    public function onReceive($serv, $fd, $fromId, $data)
    {
        $this->_test->run($data);
    }
}
$reload = new Reload;
$reload->start();

仔细观察，我们仅仅移除了在类定义之前引入Test.php以及在__construct中new Test的操作。

而是在__construct方法中增加了onWorkerStart回调，并在该回调内引入Test.php并初始化Test类。

Test.php的代码，我们仍然先后用上面的两处代码为例，运行client看下结果

结果我们发现，在给主进程发送SIGUSR1信号之后，Test.php的新代码生效了。这也便实现了热重启的效果。

如此，我们在Test.php中不论如何更新代码，只需要找到主进程的PID，向它发送SIGUSR1信号即可。同理，SIGUSR2信号是只针对Task进程的，后面可以自行测试下。

热重启的效果实现了，现在针对Reload.php的server，让该server进程守护化看看。

$this->_serv->set([   
    'worker_num' => 1,          
    'daemonize' => true,          
    'log_file' => __DIR__ . '/server.log',
]);

具体操作

设置进程名

1
2
3

$http->on('start', function ($server) {
    swoole_set_process_name('yangzie-test');
});

查看

1	netstat -npl\|grep 9501

shell脚本

echo "loading..."
pid=`pidof yangzie-test`
echo $pid
kill -USR1 $pid
echo "loading success"

https://wiki.swoole.com/wiki/page/p-server/reload.html

swoole异步task邮件案例

发表于 2018-08-10

有人住高楼，有人在深沟，有人光万丈，有人一身锈。世人万千种，浮云莫去求，斯人若彩虹，遇上方知有。

我们在写代码的过程中应该注意的问题：

开启数量适中的Worker进程和Task进程
守护进程化
配置运行时日志
平滑重启
避免内存泄漏
避免粘包问题

除此之外，跟swoole打交道，我们还应该注意下面这些问题：

为了避免Worker阻塞，避免使用sleep等睡眠函数
不要使用die或者exit函数，即使在你调试的时候
保持良好的代码风格，try/catch捕获异常
如果Worker进程无法预料会发生异常退出，虽然Manager进程会重新拉起新的Worker进程，但是我们可以通过register_shutdown_function方法在进程退出前“善后”

邮件案例

首先发送邮件，我们借助第三方类库 swiftmailer。有些框架可能集成了swiftmailer，比如yii2,本来准备在yii2的基础之上来讲，考虑部分人可能对这个框架不熟悉，我们这里直接根据swiftmailer代码操作，框架中一样可以使用，无任何影响。

我们执行下面的命令，把swiftmailer下载到本地，下载好之后swiftmailer会被下载到一个叫vendor文件夹的目录里面

1	composer require "swiftmailer/swiftmailer:^6.0"

然后我们封装一个简单的邮件类Mailer.php,同vendor目录同级，用于发送邮件，该类后期可自行完善，比如增加批量发送邮件或者增加发送模版邮件等操作。

<?php
require_once __DIR__ . '/vendor/autoload.php';
class Mailer
{
    public $transport;
    public $mailer;
    /**
     * 发送邮件类 参数 $data 需要三个必填项 包括 邮件主题`$data['subject']`、接收邮件的人`$data['to']`和邮件内容 `$data['content']`
     * @param Array $data
     * @return bool $result 发送成功 or 失败
     */
    public function send($data)
    {
        $this->transport = (new Swift_SmtpTransport('smtp.qq.com', 25))
            ->setEncryption('tls')
            ->setUsername('bailangzhan@qq.com')
            ->setPassword('xxxxxx');
        $this->mailer = new Swift_Mailer($this->transport);
        $message = (new Swift_Message($data['subject']))
            ->setFrom(array('bailangzhan@qq.com' => '白狼栈'))
            ->setTo(array($data['to']))
            ->setBody($data['content']);
            
        $result = $this->mailer->send($message);
        // 释放
        $this->destroy();
        return $result;
    }
    public function destroy()
    {
        $this->transport = null;
        $this->mailer = null;
    }
}

在这段代码中，你需要修改的地方包括 Host、Post、Encryption、Username、Password和From。

Mailer类简单的封装好之后，我们写几行代码测试下你的邮件类是否可以正确的使用

require_once __DIR__ . "/task/Mailer.php";
$data = [
    'to' => '422744***@qq.com',
    'subject' => 'just a test',
    'content' => 'This is just a test.',
];
$mailer = new Mailer;
$mailer->send($data);

to是要发送给谁，subject邮件标题，content邮件内容。

如果不可以正常发送，请检查swiftmailer相关类正确引入并且保证Mailer类的配置可用。

邮件类准备好之后，我们正式开始写swoole server，主要代码如下：

<?php
class TaskServer
{
    private $_serv;
    private $_run;
    /**
    * init
    */
    public function __construct()
    {
        $this->_serv = new Swoole\Server("127.0.0.1", 9501);
        $this->_serv->set([
            'worker_num' => 2,
            'daemonize' => false,
            'log_file' => __DIR__ . '/server.log',
            'task_worker_num' => 2,
            'max_request' => 5000,
            'task_max_request' => 5000,
            'open_eof_check' => true, //打开EOF检测
            'package_eof' => "\r\n", //设置EOF
            'open_eof_split' => true, // 自动分包
        ]);
        $this->_serv->on('Connect', [$this, 'onConnect']);
        $this->_serv->on('Receive', [$this, 'onReceive']);
        $this->_serv->on('WorkerStart', [$this, 'onWorkerStart']);
        $this->_serv->on('Task', [$this, 'onTask']);
        $this->_serv->on('Finish', [$this, 'onFinish']);
        $this->_serv->on('Close', [$this, 'onClose']);
    }
    public function onConnect($serv, $fd, $fromId)
    {
    }
    public function onWorkerStart($serv, $workerId)
    {
        require_once __DIR__ . "/TaskRun.php";
        $this->_run = new TaskRun;
    }
    public function onReceive($serv, $fd, $fromId, $data)
    {
        $data = $this->unpack($data);
        $this->_run->receive($serv, $fd, $fromId, $data);
        // 投递一个任务到task进程中
        if (!empty($data['event'])) {
            $serv->task(array_merge($data , ['fd' => $fd]));
        }
    }
    public function onTask($serv, $taskId, $fromId, $data)
    {
        $this->_run->task($serv, $taskId, $fromId, $data);
    }
    public function onFinish($serv, $taskId, $data)
    {
        $this->_run->finish($serv, $taskId, $data);
    }
    public function onClose($serv, $fd, $fromId)
    {
    }
    /**
    * 对数据包单独处理，数据包经过`json_decode`处理之后，只能是数组
    * @param $data
    * @return bool|mixed
    */
    public function unpack($data)
    {
        $data = str_replace("\r\n", '', $data);
        if (!$data) {
            return false;
        }
        $data = json_decode($data, true);
        if (!$data || !is_array($data)) {
            return false;
        }
        return $data;
    }
    public function start()
    {
        $this->_serv->start();
    }
}
$reload = new TaskServer;
$reload->start();

简单分析下:

在onWorkerStart回调内，我们引入了实际处理业务逻辑的类TaskRun.php，为什么这么说呢？因为我们在onReceive\onTask\onFinish回调内均把数据交给了TaskRun对象去处理了
我们约定，每个数据包都必须带有EOF标记\r\n，在server端为了更好的处理数据，onReceive回调内我们把数据包丢给了unpack方法处理，该方法的目的就是把数据包的EOF标记去掉，还原真实的数据包。我们还约定，server收到的数据包经过unpack处理之后只能是数组，非数组在unpack中就被直接处理掉了。
onReceive回调内，我们看到，只有数据包含有event项才会被投递给Task进程，这样做的原因是Task进程可能要处理各种任务，增加event项是为了表明投递过来的任务是要做什么的。

我们看TaskRun的实现

<?php
require_once ('./TaskClient.php');
require_once ('./Mailer.php');
class TaskRun
{
    public function receive($serv, $fd, $fromId, $data)
    {
    }
    public function task($serv, $taskId, $fromId, $data)
    {
        try {
            switch ($data['event']) {
                case TaskClient::EVENT_TYPE_SEND_MAIL:
                    $mailer = new Mailer;
                    $result = $mailer->send($data);
                    break;
                default:
                    break;
            }
            return $result;
        } catch (\Exception $e) {
            throw new \Exception('task exception :' . $e->getMessage());
        }
    }
    public function finish($serv, $taskId, $data)
    {
        return true;
    }
}

目前，我们主要就一个业务，“发送邮件”，所以TaskRun类的实现现在看来非常简单。

因为发邮件是一件比较耗时的任务，所以我们这里完善的是task回调。我们根据投递给Task进程的数据类型，判断投递过来的数据是要做什么。比如我们这里有一项event，等于TaskClient::EVENT_TYPE_SEND_MAIL,这一项就是发送邮件的标识，如果要投递的任务的event项等于TaskClient::EVENT_TYPE_SEND_MAIL，就表明这个任务是邮件任务，程序上就可以通过switch去处理邮件了。

TaskClient是什么呢？这是一个封装好的客户端处理类，我们来看下

<?php
class TaskClient
{
    private $client;
    const EVENT_TYPE_SEND_MAIL = 'send-mail';
    public function __construct ()
    {
        $this->client = new Swoole\Client(SWOOLE_SOCK_TCP);
        if (!$this->client->connect('127.0.0.1', 9501)) {
            $msg = 'swoole client connect failed.';
            throw new \Exception("Error: {$msg}.");
        }
    }
    /**
     * @param $data Array
     * send data
     */
    public function sendData ($data)
    {
        $data = $this->togetherDataByEof($data);
        $this->client->send($data);
    }
    /**
     * 数据末尾拼接EOF标记
     * @param Array $data 要处理的数据
     * @return String json_encode($data) . EOF
     */
    public function togetherDataByEof($data)
    {
        if (!is_array($data)) {
            return false;
        }
        return json_encode($data) . "\r\n";
    }
}

swoole之粘包问题

发表于 2018-08-09

人不知道要守住多少秘密才能安度一生。

什么是粘包问题，为什么我们要讲这个看起来比较奇怪的问题呢？
不着急解释，我们先看一个例子
创建一个server，server端代码如下

<?php
class TcpBufferServer
{
    private $_serv;
    /**
     * init
     */
    public function __construct()
    {
        $this->_serv = new Swoole\Server("127.0.0.1", 9501);
        $this->_serv->set([
            'worker_num' => 1,
        ]);
        $this->_serv->on('Receive', [$this, 'onReceive']);
    }
    public function onReceive($serv, $fd, $fromId, $data)
    {
        echo "Server received data: {$data}" . PHP_EOL;
    }
    /**
     * start server
     */
    public function start()
    {
        $this->_serv->start();
    }
}
$reload = new TcpBufferServer;
$reload->start();

server的代码很简单，仅仅是在收到客户端代码后，标准输出一句话而已，client的代码需要注意了，我们写了一个for循环，连续向server send三条信息，代码如下

<?php
$client = new swoole_client(SWOOLE_SOCK_TCP, SWOOLE_SOCK_SYNC);
$client->connect('127.0.0.1', 9501) || exit("connect failed. Error: {$client->errCode}\n");
// 向服务端发送数据
for ($i = 0; $i < 3; $i++) {
    $client->send("Just a test.\n");
}
$client->close();

在未运行测试的情况下，我们期望server所在终端输出的结果应该是这样的

1
2
3

Server received data: Just a test.
Server received data: Just a test.
Server received data: Just a test.

注意哦，我们期望的结果是server被回调了3次，才有上述期望的结果值
实际运行的结果呢?

上图左边是server输出的信息。
我们看到，左侧显示的结果是server一次性输出的结果，按理论来说，client发起了3次请求，server应该跟我们期望的结果一致，会执行3次呀，这怎么回事呢？
这个问题，便是我们今天要说的粘包问题。
为了说清楚这个问题，我们先来看下client/server之间数据传递的过程

客户端->发送数据
服务端->接收数据

通常我们直觉性的认为，客户端直接向网络中传输数据，对端从网络中读取数据，但是这是不正确的。
socket有缓冲区buffer的概念，每个TCP socket在内核中都有一个发送缓冲区和一个接收缓冲区。客户端send操作仅仅是把数据拷贝到buffer中，也就是说send完成了，数据并不代表已经发送到服务端了，之后才由TCP协议从buffer中发送到服务端。此时服务端的接收缓冲区被TCP缓存网络上来的数据，而后server才从buffer中读取数据。
所以，在onReceive中我们拿到的数据并没有办法保证数据包的完整性，swoole_server可能会同时收到多个请求包，也可能只收到一个请求包的一部分数据。
这就是一个大问题呀，如此TCP协议不行呀，这货虽然能保证我们能正确的接收到数据但是数据不对呀，这麻烦不容小觑。
既然是个问题，那我们自然也就有解决问题的方法，不然我下面说啥呢，对吧。

swoole给我们提供了两种解决方案:

EOF结束协议

EOF，end of file，意思是我们在每一个数据包的结尾加一个eof标记，表示这就是一个完整的数据包，但是如果你的数据本身含有EOF标记，那就会造成收到的数据包不完整，所以开启EOF支持后，应避免数据中含有EOF标记。

在swoole_server中，我们可以配置open_eof_check为true，打开EOF检测，配置package_eof来指定EOF标记。

swoole_server收到一个数据包时，会检测数据包的结尾是否是我们设置的EOF标记，如果不是就会一直拼接数据包，直到超出buffer或者超时才会终止，一旦认定是一个完整的数据包，就会投递给Worker进程，这时候我们才可以在回调内处理数据。

这样server就能保证接收到一个完整的数据包了？不能保证，这样只能保证server能收到一个或者多个完整的数据包。

为啥是多个呢？

我们说了开启EOF检测，即open_eof_check设置为true，server只会检测数据包的末尾是否有EOF标记，如果向我们开篇的案例连发3个EOF的数据，server可能还是会一次性收到，这样我们只能在回调内对数据包进行拆分处理。

我们拿开篇的案例为例

server开启eof检测并指定eof标记是\r\n，代码如下

$this->_serv->set([ 
    'worker_num' => 1, 
    'open_eof_check' => true, //打开EOF检测 
    'package_eof' => "\r\n", //设置EOF 
]);

客户端设置发送的数据末尾是\r\n符号，代码如下

1
2
3

for ($i = 0; $i < 3; $i++) { 
    $client->send("Just a test.\r\n"); 
}

按照我们刚才的分析，server的效果可能会一次性收到多个完整的包，我们运行看看结果

因此我们还需要在onReceive回调内对收到的数据进行拆分处理

public function onReceive($serv, $fd, $fromId, $data)
{
    // echo "Server received data: {$data}" . PHP_EOL;
    $datas = explode("\r\n", $data);
    foreach ($datas as $data)
    {
        if(!$data)
            continue;
        echo "Server received data: {$data}" . PHP_EOL;
    }
}

此时我们再看下运行结果

自行分包的效果便实现了，考虑到自行分包稍微麻烦，swoole提供了open_eof_split配置参数，启用该参数后，server会从左到右对数据进行逐字节对比，查找数据中的EOF标记进行分包，效果跟我们刚刚自行拆包是一样的，性能较差。
在案例的基础上我们看看open_eof_split配置

$this->_serv->set([
    'worker_num' => 1,
    'open_eof_check' => true, //打开EOF检测
    'package_eof' => "\r\n", //设置EOF
    'open_eof_split' => true,
]);

onReceive的回调，我们不需要自行拆包

public function onReceive($serv, $fd, $fromId, $data)
{
     echo "Server received data: {$data}" . PHP_EOL;
}

client的测试代码使用\r\n（同server端package_eof标记一致），我们看下运行效果

EOF标记解决粘包就说这么多，下面我们再看看另一种解决方案

固定包头+包体协议

下面我们要说的，对于部分同学可能有点难度，对于不理解的，建议多看多操作多问多查，不躲避不畏惧，这样才能有所提高。
固定包头是一种非常通用的协议，它的含义就是在你要发送的数据包的前面，添加一段信息，这段信息了包含了你要发送的数据包的长度，长度一般是2个或者4个字节的整数。
在这种协议下，我们的数据包的组成就是包头+包体。其中包头就是包体长度的二进制形式。比如我们本来想向服务端发送一段数据 “Just a test.” 共12个字符，现在我们要发送的数据就应该是这样的

1	pack('N', strlen("Just a test.")) . "Just a test."

其中php的pack函数是把数据打包成二进制字符串。
为什么这样就能保证Worker进程收到的是一个完整的数据包呢？我来解释一下：
当server收到一个数据包（可能是多个完整的数据包）之后，会先解出包头指定的数据长度，然后按照这个长度取出后面的数据，如果一次性收到多个数据包，依次循环，如此就能保证Worker进程可以一次性收到一个完整的数据包。
估计好多人都看蒙了，这都是神马玩意？我们以案例来分析
server代码

<?php
class ServerPack
{
    private $_serv;
    /**
     * init
     */
    public function __construct()
    {
        $this->_serv = new Swoole\Server("127.0.0.1", 9501);
        $this->_serv->set([
            'worker_num' => 1,
            'open_length_check'     => true,      // 开启协议解析
            'package_length_type'   => 'N',     // 长度字段的类型
            'package_length_offset' => 0,       //第几个字节是包长度的值
            'package_body_offset'   => 4,       //第几个字节开始计算长度
            'package_max_length'    => 81920,  //协议最大长度
        ]);
        $this->_serv->on('Receive', [$this, 'onReceive']);
    }
    public function onReceive($serv, $fd, $fromId, $data)
    {
        $info = unpack('N', $data);
        $len = $info[1];
        $body = substr($data, - $len);
        echo "server received data: {$body}\n";
    }
    /**
     * start server
     */
    public function start()
    {
        $this->_serv->start();
    }
}
$reload = new ServerPack;
$reload->start();

客户端的代码

<?php
$client = new swoole_client(SWOOLE_SOCK_TCP, SWOOLE_SOCK_SYNC);
$client->connect('127.0.0.1', 9501) || exit("connect failed. Error: {$client->errCode}\n");
// 向服务端发送数据
for ($i = 0; $i < 3; $i++) {
    $data = "Just a test.";
    $data = pack('N', strlen($data)) . $data;
    $client->send($data);
}
$client->close();

运行的结果

结果没错，是我们期望的结果。

我们来分析下这是为什么

1、首先，在server端我们配置了open_length_check，该参数表明我们要开启固定包头协议解析

2、package_length_type配置，表明包头长度的类型，这个类型跟客户端使用pack打包包头的类型一致，一般设置为N或者n，N表示4个字节，n表示2个字节

3、我们看下客户端的代码 pack(‘N’, strlen($data)) . $data，这句话就是包头+包体的意思，包头是pack函数打包的二进制数据，内容便是真实数据的长度 strlen($data)。

在内存中，整数一般占用4个字节，所以我们看到，在这段数据中0-4字节表示的是包头，剩余的就是真实的数据。但是server不知道呀，怎么告诉server这一事实呢？

看配置package_length_offset和package_body_offset，前者就是告诉server，从第几个字节开始是长度，后者就是从第几个字节开始计算长度。

4、既然如此，我们就可以在onReceive回调对数据解包，然后从包头中取出包体长度，再从接收到的数据中截取真正的包体。

$info = unpack('N', $data);
$len = $info[1];
$body = substr($data, - $len);
echo "server received data: {$body}\n";

lnmput@gmail.com

一个记录PHP, Laravel, MySQL, Linux, Redis, ElasticSearch等web开发实践经验的博客

GitHub