欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识！
您现在的位置是： 首页  >  IT编程

LaravelS - 基于Swoole加速Laravel/Lumen

程序员文章站 2022-12-21 20:27:27
LaravelS LaravelS是一个胶水项目，用于快速集成Swoole到Laravel或Lumen，然后赋予它们更好的性能、更多可能性。Github 特性 内置Http/WebSocket服务器 多端口混合协议 协程 自定义进程 常驻内存 异步的事件监听 异步的任务队列 毫秒级定时任务 平滑Re ......

laravels

laravels是一个胶水项目，用于快速集成swoole到laravel或lumen，然后赋予它们更好的性能、更多可能性。github

特性

要求

依赖 说明
php >= 5.5.9 推荐php7+
swoole >= 1.7.19 从2.0.12开始不再支持php5 推荐4.2.3+
laravel/lumen >= 5.1 推荐5.6+

安装

1.通过composer安装()。有可能找不到3.0版本，解决方案移步。

composer require "hhxsv5/laravel-s:~3.5.0" -vvv
# 确保你的composer.lock文件是在版本控制中

 

2.注册service provider（以下两步二选一）。

  • laravel: 修改文件config/app.php，laravel 5.5+支持包自动发现，你应该跳过这步

    'providers' => [
    //...
    hhxsv5\laravels\illuminate\laravelsserviceprovider::class,
],

     

  • lumen: 修改文件bootstrap/app.php

    $app->register(hhxsv5\laravels\illuminate\laravelsserviceprovider::class);

     

3.发布配置和二进制文件。

每次升级laravels后，需重新publish；点击release去了解各个版本的变更记录。
php artisan laravels publish
# 配置文件：config/laravels.php
# 二进制文件：bin/laravels bin/fswatch bin/inotify

4.修改配置config/laravels.php：监听的ip、端口等，请参考配置项。

运行

php bin/laravels {start|stop|restart|reload|info|help}

在运行之前，请先仔细阅读：注意事项(非常重要)。

命令 说明
start 启动laravels，展示已启动的进程列表 "ps -ef|grep laravels"。支持选项 "-d|--daemonize" 以守护进程的方式运行，此选项将覆盖laravels.php中swoole.daemonize设置；支持选项 "-e|--env" 用来指定运行的环境，如--env=testing将会优先使用配置文件.env.testing，这个特性要求laravel 5.2+
stop 停止laravels
restart 重启laravels，支持选项 "-d|--daemonize" 和 "-e|--env"
reload 平滑重启所有task/worker/timer进程(这些进程内包含了你的业务代码)，并触发自定义进程的onreload方法，不会重启master/manger进程；修改config/laravels.php后，你只能调用restart来实现重启
info 显示组件的版本信息
help 显示帮助信息

部署

建议通过supervisord监管主进程，前提是不能加-d选项并且设置swoole.daemonize为false。
[program:laravel-s-test]
command=/user/local/bin/php /opt/www/laravel-s-test/bin/laravels start -i
numprocs=1
autostart=true
autorestart=true
startretries=3
user=www-data
redirect_stderr=true
stdout_logfile=/opt/www/laravel-s-test/storage/logs/supervisord-stdout.log

 

与nginx配合使用（推荐）

。
gzip on;
gzip_min_length 1024;
gzip_comp_level 2;
gzip_types text/plain text/css text/javascript application/json application/javascript application/x-javascript application/xml application/x-httpd-php image/jpeg image/gif image/png font/ttf font/otf image/svg+xml;
gzip_vary on;
gzip_disable "msie6";
upstream swoole {
    # 通过 ip:port 连接
    server 127.0.0.1:5200 weight=5 max_fails=3 fail_timeout=30s;
    # 通过 unixsocket stream 连接，小诀窍：将socket文件放在/dev/shm目录下，可获得更好的性能
    #server unix:/xxxpath/laravel-s-test/storage/laravels.sock weight=5 max_fails=3 fail_timeout=30s;
    #server 192.168.1.1:5200 weight=3 max_fails=3 fail_timeout=30s;
    #server 192.168.1.2:5200 backup;
    keepalive 16;
}
server {
    listen 80;
    # 别忘了绑host哟
    server_name laravels.com;
    root /xxxpath/laravel-s-test/public;
    access_log /yyypath/log/nginx/$server_name.access.log  main;
    autoindex off;
    index index.html index.htm;
    # nginx处理静态资源(建议开启gzip)，laravels处理动态资源。
    location / {
        try_files $uri @laravels;
    }
    # 当请求php文件时直接响应404，防止暴露public/*.php
    #location ~* \.php$ {
    #    return 404;
    #}
    location @laravels {
        # proxy_connect_timeout 60s;
        # proxy_send_timeout 60s;
        # proxy_read_timeout 120s;
        proxy_http_version 1.1;
        proxy_set_header connection "";
        proxy_set_header x-real-ip $remote_addr;
        proxy_set_header x-real-port $remote_port;
        proxy_set_header x-forwarded-for $proxy_add_x_forwarded_for;
        proxy_set_header host $http_host;
        proxy_set_header scheme $scheme;
        proxy_set_header server-protocol $server_protocol;
        proxy_set_header server-name $server_name;
        proxy_set_header server-addr $server_addr;
        proxy_set_header server-port $server_port;
        proxy_pass http://swoole;
    }
}

 

与apache配合使用

 1 loadmodule proxy_module /yyypath/modules/mod_deflate.so
 2 <ifmodule deflate_module>
 3     setoutputfilter deflate
 4     deflatecompressionlevel 2
 5     addoutputfilterbytype deflate text/html text/plain text/css text/javascript application/json application/javascript application/x-javascript application/xml application/x-httpd-php image/jpeg image/gif image/png font/ttf font/otf image/svg+xml
 6 </ifmodule>
 7 
 8 <virtualhost *:80>
 9     # 别忘了绑host哟
10     servername www.laravels.com
11     serveradmin hhxsv5@sina.com
12 
13     documentroot /xxxpath/laravel-s-test/public;
14     directoryindex index.html index.htm
15     <directory "/">
16         allowoverride none
17         require all granted
18     </directory>
19 
20     loadmodule proxy_module /yyypath/modules/mod_proxy.so
21     loadmodule proxy_module /yyypath/modules/mod_proxy_balancer.so
22     loadmodule proxy_module /yyypath/modules/mod_lbmethod_byrequests.so.so
23     loadmodule proxy_module /yyypath/modules/mod_proxy_http.so.so
24     loadmodule proxy_module /yyypath/modules/mod_slotmem_shm.so
25     loadmodule proxy_module /yyypath/modules/mod_rewrite.so
26 
27     proxyrequests off
28     proxypreservehost on
29     <proxy balancer://laravels>  
30         balancermember http://192.168.1.1:5200 loadfactor=7
31         #balancermember http://192.168.1.2:5200 loadfactor=3
32         #balancermember http://192.168.1.3:5200 loadfactor=1 status=+h
33         proxyset lbmethod=byrequests
34     </proxy>
35     #proxypass / balancer://laravels/
36     #proxypassreverse / balancer://laravels/
37 
38     # apache处理静态资源，laravels处理动态资源。
39     rewriteengine on
40     rewritecond %{document_root}%{request_filename} !-d
41     rewritecond %{document_root}%{request_filename} !-f
42     rewriterule ^/(.*)$ balancer://laravels/%{request_uri} [p,l]
43 
44     errorlog ${apache_log_dir}/www.laravels.com.error.log
45     customlog ${apache_log_dir}/www.laravels.com.access.log combined
46 </virtualhost>

 

启用websocket服务器

websocket服务器监听的ip和端口与http服务器相同。

1.创建websocket handler类，并实现接口websockethandlerinterface。start时会自动实例化，不需要手动创建实例。

 1 namespace app\services;
 2 use hhxsv5\laravels\swoole\websockethandlerinterface;
 3 use swoole\http\request;
 4 use swoole\websocket\frame;
 5 use swoole\websocket\server;
 6 /**
 7  * @see https://wiki.swoole.com/wiki/page/400.html
 8  */
 9 class websocketservice implements websockethandlerinterface
10 {
11     // 声明没有参数的构造函数
12     public function __construct()
13     {
14     }
15     public function onopen(server $server, request $request)
16     {
17         // 在触发onopen事件之前，建立websocket的http请求已经经过了laravel的路由，
18         // 所以laravel的request、auth等信息是可读的，session是可读写的，但仅限在onopen事件中。
19         // \log::info('new websocket connection', [$request->fd, request()->all(), session()->getid(), session('xxx'), session(['yyy' => time()])]);
20         $server->push($request->fd, 'welcome to laravels');
21         // throw new \exception('an exception');// 此时抛出的异常上层会忽略，并记录到swoole日志，需要开发者try/catch捕获处理
22     }
23     public function onmessage(server $server, frame $frame)
24     {
25         // \log::info('received message', [$frame->fd, $frame->data, $frame->opcode, $frame->finish]);
26         $server->push($frame->fd, date('y-m-d h:i:s'));
27         // throw new \exception('an exception');// 此时抛出的异常上层会忽略，并记录到swoole日志，需要开发者try/catch捕获处理
28     }
29     public function onclose(server $server, $fd, $reactorid)
30     {
31         // throw new \exception('an exception');// 此时抛出的异常上层会忽略，并记录到swoole日志，需要开发者try/catch捕获处理
32     }
33 }

 

2.更改配置config/laravels.php。

 1 // ...
 2 'websocket'      => [
 3     'enable'  => true, // 看清楚，这里是true
 4     'handler' => \app\services\websocketservice::class,
 5 ],
 6 'swoole'         => [
 7     //...
 8     // dispatch_mode只能设置为2、4、5，https://wiki.swoole.com/wiki/page/277.html
 9     'dispatch_mode' => 2,
10     //...
11 ],
12 // ...

 

3.使用swooletable绑定fd与userid，可选的，swoole table示例。也可以用其他全局存储服务，例如redis/memcached/mysql，但需要注意多个swoole server实例时fd可能冲突。

4.与nginx配合使用（推荐）

参考 websocket代理 
 1 map $http_upgrade $connection_upgrade {
 2     default upgrade;
 3     ''      close;
 4 }
 5 upstream swoole {
 6     # 通过 ip:port 连接
 7     server 127.0.0.1:5200 weight=5 max_fails=3 fail_timeout=30s;
 8     # 通过 unixsocket stream 连接，小诀窍：将socket文件放在/dev/shm目录下，可获得更好的性能
 9     #server unix:/xxxpath/laravel-s-test/storage/laravels.sock weight=5 max_fails=3 fail_timeout=30s;
10     #server 192.168.1.1:5200 weight=3 max_fails=3 fail_timeout=30s;
11     #server 192.168.1.2:5200 backup;
12     keepalive 16;
13 }
14 server {
15     listen 80;
16     # 别忘了绑host哟
17     server_name laravels.com;
18     root /xxxpath/laravel-s-test/public;
19     access_log /yyypath/log/nginx/$server_name.access.log  main;
20     autoindex off;
21     index index.html index.htm;
22     # nginx处理静态资源(建议开启gzip)，laravels处理动态资源。
23     location / {
24         try_files $uri @laravels;
25     }
26     # 当请求php文件时直接响应404，防止暴露public/*.php
27     #location ~* \.php$ {
28     #    return 404;
29     #}
30     # http和websocket共存，nginx通过location区分
31     # !!! websocket连接时路径为/ws
32     # javascript: var ws = new websocket("ws://laravels.com/ws");
33     location =/ws {
34         # proxy_connect_timeout 60s;
35         # proxy_send_timeout 60s;
36         # proxy_read_timeout：如果60秒内被代理的服务器没有响应数据给nginx，那么nginx会关闭当前连接；同时，swoole的心跳设置也会影响连接的关闭
37         # proxy_read_timeout 60s;
38         proxy_http_version 1.1;
39         proxy_set_header x-real-ip $remote_addr;
40         proxy_set_header x-real-port $remote_port;
41         proxy_set_header x-forwarded-for $proxy_add_x_forwarded_for;
42         proxy_set_header host $http_host;
43         proxy_set_header scheme $scheme;
44         proxy_set_header server-protocol $server_protocol;
45         proxy_set_header server-name $server_name;
46         proxy_set_header server-addr $server_addr;
47         proxy_set_header server-port $server_port;
48         proxy_set_header upgrade $http_upgrade;
49         proxy_set_header connection $connection_upgrade;
50         proxy_pass http://swoole;
51     }
52     location @laravels {
53         # proxy_connect_timeout 60s;
54         # proxy_send_timeout 60s;
55         # proxy_read_timeout 60s;
56         proxy_http_version 1.1;
57         proxy_set_header connection "";
58         proxy_set_header x-real-ip $remote_addr;
59         proxy_set_header x-real-port $remote_port;
60         proxy_set_header x-forwarded-for $proxy_add_x_forwarded_for;
61         proxy_set_header host $http_host;
62         proxy_set_header scheme $scheme;
63         proxy_set_header server-protocol $server_protocol;
64         proxy_set_header server-name $server_name;
65         proxy_set_header server-addr $server_addr;
66         proxy_set_header server-port $server_port;
67         proxy_pass http://swoole;
68     }
69 }

 

5.心跳配置

  • swoole的心跳配置

    1 // config/laravels.php
2 'swoole' => [
3     //...
4     // 表示每60秒遍历一次，一个连接如果600秒内未向服务器发送任何数据，此连接将被强制关闭
5     'heartbeat_idle_time'      => 600,
6     'heartbeat_check_interval' => 60,
7     //...
8 ],

     

  • nginx读取代理服务器超时的配置

    # 如果60秒内被代理的服务器没有响应数据给nginx，那么nginx会关闭当前连接
proxy_read_timeout 60s;

监听事件

系统事件

通常，你可以在这些事件中重置或销毁一些全局或静态的变量，也可以修改当前的请求和响应。

  • laravels.received_request 将swoole\http\request转成illuminate\http\request后，在laravel内核处理请求前。

    1 // 修改`app/providers/eventserviceprovider.php`, 添加下面监听代码到boot方法中
2 // 如果变量$events不存在，你也可以通过facade调用\event::listen()。
3 $events->listen('laravels.received_request', function (\illuminate\http\request $req, $app) {
4     $req->query->set('get_key', 'hhxsv5');// 修改querystring
5     $req->request->set('post_key', 'hhxsv5'); // 修改post body
6 });

     

  • laravels.generated_response 在laravel内核处理完请求后，将illuminate\http\response转成swoole\http\response之前(下一步将响应给客户端)。

    1 // 修改`app/providers/eventserviceprovider.php`, 添加下面监听代码到boot方法中
2 // 如果变量$events不存在，你也可以通过facade调用\event::listen()。
3 $events->listen('laravels.generated_response', function (\illuminate\http\request $req, \symfony\component\httpfoundation\response $rsp, $app) {
4     $rsp->headers->set('header-key', 'hhxsv5');// 修改header
5 });

     

自定义的异步事件

此特性依赖swoole的asynctask，必须先设置config/laravels.php的swoole.task_worker_num。异步事件的处理能力受task进程数影响，需合理设置。

1.创建事件类。

 1 use hhxsv5\laravels\swoole\task\event;
 2 class testevent extends event
 3 {
 4     private $data;
 5     public function __construct($data)
 6     {
 7         $this->data = $data;
 8     }
 9     public function getdata()
10     {
11         return $this->data;
12     }
13 }

 

2.创建监听器类。

 1 use hhxsv5\laravels\swoole\task\task;
 2 use hhxsv5\laravels\swoole\task\event;
 3 use hhxsv5\laravels\swoole\task\listener;
 4 class testlistener1 extends listener
 5 {
 6     // 声明没有参数的构造函数
 7     public function __construct()
 8     {
 9     }
10     public function handle(event $event)
11     {
12         \log::info(__class__ . ':handle start', [$event->getdata()]);
13         sleep(2);// 模拟一些慢速的事件处理
14         // 监听器中也可以投递task，但不支持task的finish()回调。
15         // 注意：
16         // 1.参数2需传true
17         // 2.config/laravels.php中修改配置task_ipc_mode为1或2，参考 https://wiki.swoole.com/wiki/page/296.html
18         $ret = task::deliver(new testtask('task data'), true);
19         var_dump($ret);
20         // throw new \exception('an exception');// handle时抛出的异常上层会忽略，并记录到swoole日志，需要开发者try/catch捕获处理
21     }
22 }

 

3.绑定事件与监听器。

 1 // 在"config/laravels.php"中绑定事件与监听器，一个事件可以有多个监听器，多个监听器按顺序执行
 2 [
 3     // ...
 4     'events' => [
 5         \app\tasks\testevent::class => [
 6             \app\tasks\testlistener1::class,
 7             //\app\tasks\testlistener2::class,
 8         ],
 9     ],
10     // ...
11 ];

 

4.触发事件。

1 // 实例化testevent并通过fire触发，此操作是异步的，触发后立即返回，由task进程继续处理监听器中的handle逻辑
2 use hhxsv5\laravels\swoole\task\event;
3 $success = event::fire(new testevent('event data'));
4 var_dump($success);//判断是否触发成功

 

异步的任务队列

此特性依赖swoole的asynctask，必须先设置config/laravels.php的swoole.task_worker_num。异步任务的处理能力受task进程数影响，需合理设置。

1.创建任务类。

 1 use hhxsv5\laravels\swoole\task\task;
 2 class testtask extends task
 3 {
 4     private $data;
 5     private $result;
 6     public function __construct($data)
 7     {
 8         $this->data = $data;
 9     }
10     // 处理任务的逻辑，运行在task进程中，不能投递任务
11     public function handle()
12     {
13         \log::info(__class__ . ':handle start', [$this->data]);
14         sleep(2);// 模拟一些慢速的事件处理
15         // throw new \exception('an exception');// handle时抛出的异常上层会忽略，并记录到swoole日志，需要开发者try/catch捕获处理
16         $this->result = 'the result of ' . $this->data;
17     }
18     // 可选的，完成事件，任务处理完后的逻辑，运行在worker进程中，可以投递任务
19     public function finish()
20     {
21         \log::info(__class__ . ':finish start', [$this->result]);
22         task::deliver(new testtask2('task2')); // 投递其他任务
23     }
24 }

 

2.投递任务。

1 // 实例化testtask并通过deliver投递，此操作是异步的，投递后立即返回，由task进程继续处理testtask中的handle逻辑
2 use hhxsv5\laravels\swoole\task\task;
3 $task = new testtask('task data');
4 // $task->delay(3);// 延迟3秒投放任务
5 $ret = task::deliver($task);
6 var_dump($ret);//判断是否投递成功

 

毫秒级定时任务

基于swoole的毫秒定时器，封装的定时任务，取代linux的crontab。

1.创建定时任务类。

 1 namespace app\jobs\timer;
 2 use app\tasks\testtask;
 3 use swoole\coroutine;
 4 use hhxsv5\laravels\swoole\task\task;
 5 use hhxsv5\laravels\swoole\timer\cronjob;
 6 class testcronjob extends cronjob
 7 {
 8     protected $i = 0;
 9     // !!! 定时任务的`interval`和`isimmediate`有两种配置方式（二选一）：一是重载对应的方法，二是注册定时任务时传入参数。
10     // --- 重载对应的方法来返回配置：开始
11     public function interval()
12     {
13         return 1000;// 每1秒运行一次
14     }
15     public function isimmediate()
16     {
17         return false;// 是否立即执行第一次，false则等待间隔时间后执行第一次
18     }
19     // --- 重载对应的方法来返回配置：结束
20     public function run()
21     {
22         \log::info(__method__, ['start', $this->i, microtime(true)]);
23         // do something
24         // sleep(1); // swoole < 2.1
25         coroutine::sleep(1); // swoole>=2.1 run()方法已自动创建了协程。
26         $this->i++;
27         \log::info(__method__, ['end', $this->i, microtime(true)]);
28 
29         if ($this->i >= 10) { // 运行10次后不再执行
30             \log::info(__method__, ['stop', $this->i, microtime(true)]);
31             $this->stop(); // 终止此任务
32             // cronjob中也可以投递task，但不支持task的finish()回调。
33             // 注意：
34             // 1.参数2需传true
35             // 2.config/laravels.php中修改配置task_ipc_mode为1或2，参考 https://wiki.swoole.com/wiki/page/296.html
36             $ret = task::deliver(new testtask('task data'), true);
37             var_dump($ret);
38         }
39         // throw new \exception('an exception');// 此时抛出的异常上层会忽略，并记录到swoole日志，需要开发者try/catch捕获处理
40     }
41 }

 

2.注册定时任务类。

 1 // 在"config/laravels.php"注册定时任务类
 2 [
 3     // ...
 4     'timer'          => [
 5         'enable' => true, // 启用timer
 6         'jobs'   => [ // 注册的定时任务类列表
 7             // 启用laravelschedulejob来执行`php artisan schedule:run`，每分钟一次，替代linux crontab
 8             // \hhxsv5\laravels\illuminate\laravelschedulejob::class,
 9             // 两种配置参数的方式：
10             // [\app\jobs\timer\testcronjob::class, [1000, true]], // 注册时传入参数
11             \app\jobs\timer\testcronjob::class, // 重载对应的方法来返回参数
12         ],
13         'max_wait_time' => 5, // reload时最大等待时间
14     ],
15     // ...
16 ];

 

3.注意在构建服务器集群时，会启动多个定时器，要确保只启动一个定期器，避免重复执行定时任务。

4.laravels v3.4.0开始支持热重启[reload]定时器进程，laravels 在收到sigusr1信号后会等待max_wait_time(默认5)秒再结束进程，然后manager进程会重新拉起定时器进程。

修改代码后自动reload

  • 基于inotify，仅支持linux。

    1.安装扩展。

    2.开启配置项。

    3.注意：inotify只有在linux内修改文件才能收到文件变更事件，建议使用最新版docker，vagrant解决方案。

  • 基于fswatch，支持os x、linux、windows。

    1.安装。

    2.在项目根目录下运行命令。

    # 监听当前目录
./bin/fswatch
# 监听app目录
./bin/fswatch ./app

  • 基于inotifywait，仅支持linux。

    1.安装。

    2.在项目根目录下运行命令。

    # 监听当前目录
./bin/inotify
# 监听app目录
./bin/inotify ./app

在你的项目中使用swooleserver实例

/**
 * 如果启用websocket server，$swoole是`swoole\websocket\server`的实例，否则是是`swoole\http\server`的实例
 * @var \swoole\websocket\server|\swoole\http\server $swoole
 */
$swoole = app('swoole');
var_dump($swoole->stats());// 单例

 

使用swooletable

1.定义table，支持定义多个table。

swoole启动之前会创建定义的所有table。
 1 // 在"config/laravels.php"配置
 2 [
 3     // ...
 4     'swoole_tables'  => [
 5         // 场景：websocket中userid与fd绑定
 6         'ws' => [// key为table名称，使用时会自动添加table后缀，避免重名。这里定义名为wstable的table
 7             'size'   => 102400,//table的最大行数
 8             'column' => [// table的列定义
 9                 ['name' => 'value', 'type' => \swoole\table::type_int, 'size' => 8],
10             ],
11         ],
12         //...继续定义其他table
13     ],
14     // ...
15 ];

 

2.访问table：所有的table实例均绑定在swooleserver上，通过app('swoole')->xxxtable访问。

 1 namespace app\services;
 2 use hhxsv5\laravels\swoole\websockethandlerinterface;
 3 use swoole\http\request;
 4 use swoole\websocket\frame;
 5 use swoole\websocket\server;
 6 class websocketservice implements websockethandlerinterface
 7 {
 8     /**@var \swoole\table $wstable */
 9     private $wstable;
10     public function __construct()
11     {
12         $this->wstable = app('swoole')->wstable;
13     }
14     // 场景：websocket中userid与fd绑定
15     public function onopen(server $server, request $request)
16     {
17         // var_dump(app('swoole') === $server);// 同一实例
18         /**
19          * 获取当前登录的用户
20          * 此特性要求建立websocket连接的路径要经过authenticate之类的中间件。
21          * 例如：
22          * 浏览器端：var ws = new websocket("ws://127.0.0.1:5200/ws");
23          * 那么laravel中/ws路由就需要加上类似authenticate的中间件。
24          */
25         // $user = auth::user();
26         // $userid = $user ? $user->id : 0; // 0 表示未登录的访客用户
27         $userid = mt_rand(1000, 10000);
28         $this->wstable->set('uid:' . $userid, ['value' => $request->fd]);// 绑定uid到fd的映射
29         $this->wstable->set('fd:' . $request->fd, ['value' => $userid]);// 绑定fd到uid的映射
30         $server->push($request->fd, "welcome to laravels #{$request->fd}");
31     }
32     public function onmessage(server $server, frame $frame)
33     {
34         // 广播
35         foreach ($this->wstable as $key => $row) {
36             if (strpos($key, 'uid:') === 0 && $server->isestablished($row['value'])) {
37                 $content = sprintf('broadcast: new message "%s" from #%d', $frame->data, $frame->fd);
38                 $server->push($row['value'], $content);
39             }
40         }
41     }
42     public function onclose(server $server, $fd, $reactorid)
43     {
44         $uid = $this->wstable->get('fd:' . $fd);
45         if ($uid !== false) {
46             $this->wstable->del('uid:' . $uid['value']); // 解绑uid映射
47         }
48         $this->wstable->del('fd:' . $fd);// 解绑fd映射
49         $server->push($fd, "goodbye #{$fd}");
50     }
51 }

 

多端口混合协议

更多的信息，请参考swoole增加监听的端口与

为了使我们的主服务器能支持除http和websocket外的更多协议，我们引入了swoole的多端口混合协议特性，在laravels中称为socket。现在，可以很方便地在laravel上构建tcp/udp应用。

  1. 创建socket处理类，继承hhxsv5\laravels\swoole\socket\{tcpsocket|udpsocket|http|websocket}

     1 namespace app\sockets;
 2 use hhxsv5\laravels\swoole\socket\tcpsocket;
 3 use swoole\server;
 4 class testtcpsocket extends tcpsocket
 5 {
 6     public function onconnect(server $server, $fd, $reactorid)
 7     {
 8         \log::info('new tcp connection', [$fd]);
 9         $server->send($fd, 'welcome to laravels.');
10     }
11     public function onreceive(server $server, $fd, $reactorid, $data)
12     {
13         \log::info('received data', [$fd, $data]);
14         $server->send($fd, 'laravels: ' . $data);
15         if ($data === "quit\r\n") {
16             $server->send($fd, 'laravels: bye' . php_eol);
17             $server->close($fd);
18         }
19     }
20     public function onclose(server $server, $fd, $reactorid)
21     {
22         \log::info('close tcp connection', [$fd]);
23         $server->send($fd, 'goodbye');
24     }
25 }

     

    这些连接和主服务器上的http/websocket连接共享worker进程，因此可以在这些事件操作中使用laravels提供的异步任务投递、swooletable、laravel提供的组件如db、eloquent等。同时，如果需要使用该协议端口的swoole\server\port对象，只需要像如下代码一样访问socket类的成员swooleport即可。

    public function onreceive(server $server, $fd, $reactorid, $data)
{
    $port = $this->swooleport; //获得`swoole\server\port`对象
}

     

  2. 注册套接字。

     1 // 修改文件 config/laravels.php
 2 // ...
 3 'sockets' => [
 4     [
 5         'host'     => '127.0.0.1',
 6         'port'     => 5291,
 7         'type'     => swoole_sock_tcp,// 支持的嵌套字类型：https://wiki.swoole.com/wiki/page/16.html#entry_h2_0
 8         'settings' => [// swoole可用的配置项：https://wiki.swoole.com/wiki/page/526.html
 9             'open_eof_check' => true,
10             'package_eof'    => "\r\n",
11         ],
12         'handler'  => \app\sockets\testtcpsocket::class,
13     ],
14 ],

     

    关于心跳配置，只能设置在主服务器上，不能配置在套接字上，但套接字会继承主服务器的心跳配置。

    对于tcp协议，dispatch_mode选项设为1/3时，底层会屏蔽onconnect/onclose事件，原因是这两种模式下无法保证onconnect/onclose/onreceive的顺序。如果需要用到这两个事件，请将dispatch_mode改为2/4/5，。

    'swoole' => [
    //...
    'dispatch_mode' => 2,
    //...
];

     

  3. 测试。
  • tcp：telnet 127.0.0.1 5291
  • udp：linux下 echo "hello laravels" > /dev/udp/127.0.0.1/5292

  1. 其他协议的注册示例。

    • udp
    'sockets' => [
    [
        'host'     => '0.0.0.0',
        'port'     => 5292,
        'type'     => swoole_sock_udp,
        'settings' => [
            'open_eof_check' => true,
            'package_eof'    => "\r\n",
        ],
        'handler'  => \app\sockets\testudpsocket::class,
    ],
],

     

    • http
     1 'sockets' => [
 2     [
 3         'host'     => '0.0.0.0',
 4         'port'     => 5293,
 5         'type'     => swoole_sock_tcp,
 6         'settings' => [
 7             'open_http_protocol' => true,
 8         ],
 9         'handler'  => \app\sockets\testhttp::class,
10     ],
11 ],

     

    • websocket：主服务器必须开启websocket，即需要将websocket.enable置为true。
     1 'sockets' => [
 2     [
 3         'host'     => '0.0.0.0',
 4         'port'     => 5294,
 5         'type'     => swoole_sock_tcp,
 6         'settings' => [
 7             'open_http_protocol'      => true,
 8             'open_websocket_protocol' => true,
 9         ],
10         'handler'  => \app\sockets\testwebsocket::class,
11     ],
12 ],
13 协程

     

swoole原始文档
  • 警告：协程下代码执行顺序是乱序的，请求级的数据应该以协程id隔离，但laravel/lumen中存在很多单例、静态属性，不同请求间的数据会相互影响，这是不安全的。比如数据库连接就是单例，同一个数据库连接共享同一个pdo资源，这在同步阻塞模式下是没问题的，但在异步协程下是不行的，每次查询需要创建不同的连接，维护不同的io状态，这就需要用到连接池。所以不要打开协程，仅自定义进程中可使用协程。

  • 启用协程，默认是关闭的。

    1 // 修改文件 `config/laravels.php`
2 [
3     //...
4     'swoole' => [
5         //...
6         'enable_coroutine' => true
7      ],
8 ]

     

  • ：需swoole>=2.0。

  • ：需swoole>=4.1.0，同时启用下面的配置。

    // 修改文件 `config/laravels.php`
[
    //...
    'enable_coroutine_runtime' => true
]

     

自定义进程

支持开发者创建一些特殊的工作进程，用于监控、上报或者其他特殊的任务，参考addprocess。

  1. 创建proccess类，实现customprocessinterface接口。

     1 namespace app\processes;
 2 use app\tasks\testtask;
 3 use hhxsv5\laravels\swoole\process\customprocessinterface;
 4 use hhxsv5\laravels\swoole\task\task;
 5 use swoole\coroutine;
 6 use swoole\http\server;
 7 use swoole\process;
 8 class testprocess implements customprocessinterface
 9 {
10     public static function getname()
11     {
12         // 进程名称
13         return 'test';
14     }
15     public static function callback(server $swoole, process $process)
16     {
17         // 进程运行的代码，不能退出，一旦退出manager进程会自动再次创建该进程。
18         \log::info(__method__, [posix_getpid(), $swoole->stats()]);
19         while (true) {
20             \log::info('do something');
21             // sleep(1); // swoole < 2.1
22             coroutine::sleep(1); // swoole>=2.1 callback()方法已自动创建了协程。
23             // 自定义进程中也可以投递task，但不支持task的finish()回调。
24             // 注意：
25             // 1.参数2需传true
26             // 2.config/laravels.php中修改配置task_ipc_mode为1或2，参考 https://wiki.swoole.com/wiki/page/296.html
27             $ret = task::deliver(new testtask('task data'), true);
28             var_dump($ret);
29             // 上层会捕获callback中抛出的异常，并记录到swoole日志，如果异常数达到10次，此进程会退出，manager进程会重新创建进程，所以建议开发者自行try/catch捕获，避免创建进程过于频繁。
30             // throw new \exception('an exception');
31         }
32     }
33     // 要求：laravels >= v3.4.0 并且 callback() 必须是异步非阻塞程序。
34     public static function onreload(server $swoole, process $process)
35     {
36         // stop the process...
37         // then end process
38         $process->exit(0);
39     }
40 }

     

  2. 注册testprocess。

     1 // 修改文件 config/laravels.php
 2 // ...
 3 'processes' => [
 4     [
 5         'class'    => \app\processes\testprocess::class,
 6         'redirect' => false, // 是否重定向输入输出
 7         'pipe'     => 0 // 管道类型：0不创建管道，1创建sock_stream类型管道，2创建sock_dgram类型管道
 8         'enable'   => true // 是否启用，默认true
 9     ],
10 ],

     

  3. 注意：testprocess::callback()方法不能退出，如果退出次数达到10次，manager进程将会重新创建进程。

其他特性

配置swoole的事件回调函数

支持的事件列表：

事件 需实现的接口 发生时机
serverstart hhxsv5laravelsswooleeventsserverstartinterface 发生在master进程启动时，此事件中不应处理复杂的业务逻辑，只能做一些初始化的简单工作
serverstop hhxsv5laravelsswooleeventsserverstopinterface 发生在server正常退出时，此事件中不能使用异步或协程相关的api
workerstart hhxsv5laravelsswooleeventsworkerstartinterface 发生在worker/task进程启动完成后
workerstop hhxsv5laravelsswooleeventsworkerstopinterface 发生在worker/task进程正常退出后
workererror hhxsv5laravelsswooleeventsworkererrorinterface 发生在worker/task进程发生异常或致命错误时

1.创建事件处理类，实现相应的接口。

 1 namespace app\events;
 2 use hhxsv5\laravels\swoole\events\serverstartinterface;
 3 use swoole\atomic;
 4 use swoole\http\server;
 5 class serverstartevent implements serverstartinterface
 6 {
 7     public function __construct()
 8     {
 9     }
10     public function handle(server $server)
11     {
12         // 初始化一个全局计数器(跨进程的可用)
13         $server->atomiccount = new atomic(2233);
14 
15         // 控制器中调用：app('swoole')->atomiccount->get();
16     }
17 }
18 namespace app\events;
19 use hhxsv5\laravels\swoole\events\workerstartinterface;
20 use swoole\http\server;
21 class workerstartevent implements workerstartinterface
22 {
23     public function __construct()
24     {
25     }
26     public function handle(server $server, $workerid)
27     {
28         // 初始化一个数据库连接池对象
29         // databaseconnectionpool::init();
30     }
31 }

 

2.配置。

1 // 修改文件 config/laravels.php
2 'event_handlers' => [
3     'serverstart' => \app\events\serverstartevent::class,
4     'workerstart' => \app\events\workerstartevent::class,
5 ],

 

注意事项

  • 单例问题

    • 传统fpm下，单例模式的对象的生命周期仅在每次请求中，请求开始=>实例化单例=>请求结束后=>单例对象资源回收。
    • swoole server下，所有单例对象会常驻于内存，这个时候单例对象的生命周期与fpm不同，请求开始=>实例化单例=>请求结束=>单例对象依旧保留，需要开发者自己维护单例的状态。

    • 常见的解决方案：

      1. 写一个xxxcleaner类来清理单例对象状态，此类需实现接口hhxsv5\laravels\illuminate\cleaners\cleanerinterface，然后注册到laravels.php的cleaners中。
      2. 用一个中间件来重置单例对象的状态。
      3. 如果是以serviceprovider注册的单例对象，可添加该serviceprovider到laravels.php的register_providers中，这样每次请求会重新注册该serviceprovider，重新实例化单例对象，参考。
    • laravels 已经内置了一些cleaner。
  • 常见问题：一揽子的已知问题和解决方案。
  • 调试方式：记录日志、laravel dump server（laravel 5.7已默认集成）

  • 应通过illuminate\http\request对象来获取请求信息，是可读取的，_server是部分可读的，不能使用、_post、、_cookie、、_session、$globals。

     1 public function form(\illuminate\http\request $request)
 2 {
 3     $name = $request->input('name');
 4     $all = $request->all();
 5     $sessionid = $request->cookie('sessionid');
 6     $photo = $request->file('photo');
 7     // 调用getcontent()来获取原始的post body，而不能用file_get_contents('php://input')
 8     $rawcontent = $request->getcontent();
 9     //...
10 }

     

  • 推荐通过返回illuminate\http\response对象来响应请求，兼容echo、vardump()、print_r()，不能使用函数 dd()、exit()、die()、header()、setcookie()、http_response_code()。

    public function json()
{
    return response()->json(['time' => time()])->header('header1', 'value1')->withcookie('c1', 'v1');
}

     

  • 各种单例的连接将被常驻内存，建议开启持久连接。

  1. 数据库连接，连接断开后会自动重连

     1 // config/database.php
 2 'connections' => [
 3     'my_conn' => [
 4         'driver'    => 'mysql',
 5         'host'      => env('db_my_conn_host', 'localhost'),
 6         'port'      => env('db_my_conn_port', 3306),
 7         'database'  => env('db_my_conn_database', 'forge'),
 8         'username'  => env('db_my_conn_username', 'forge'),
 9         'password'  => env('db_my_conn_password', ''),
10         'charset'   => 'utf8mb4',
11         'collation' => 'utf8mb4_unicode_ci',
12         'prefix'    => '',
13         'strict'    => false,
14         'options'   => [
15             // 开启持久连接
16             \pdo::attr_persistent => true,
17         ],
18     ],
19     //...
20 ],
21 //...

     

  2. redis连接，连接断开后不会立即自动重连，会抛出一个关于连接断开的异常，下次会自动重连。需确保每次操作redis前正确的select db。

     1 // config/database.php
 2 'redis' => [
 3         'client' => env('redis_client', 'phpredis'), // 推荐使用phpredis，以获得更好的性能
 4         'default' => [
 5             'host'       => env('redis_host', 'localhost'),
 6             'password'   => env('redis_password', null),
 7             'port'       => env('redis_port', 6379),
 8             'database'   => 0,
 9             'persistent' => true, // 开启持久连接
10         ],
11     ],
12 //...

     

  • 你声明的全局、静态变量必须手动清理或重置。

  • 无限追加元素到静态或全局变量中，将导致内存爆满。

     1 // 某类
 2 class test
 3 {
 4     public static $array = [];
 5     public static $string = '';
 6 }
 7 
 8 // 某控制器
 9 public function test(request $req)
10 {
11     // 内存爆满
12     test::$array[] = $req->input('param1');
13     test::$string .= $req->input('param2');
14 }

     

  • linux内核参数调整

用户与案例

  • kucoin
  • ：web站、m站、app、小程序的账户体系服务。
  • itok在线客服平台：用户it工单的处理跟踪及在线实时沟通。
  • 微信公众号-广州塔：活动、商城
  • 企鹅游戏盒子、明星新*、以及小程序广告服务
  • 小程序-修机匠手机上门维修服务：手机维修服务，提供上门服务，支持在线维修。
  • 亿健app

 

推荐阅读：

实现websocket 主动消息推送，用laravel+swoole

php laravel+thrift+swoole打造微服务框架

用swoole+react 实现的聊天室

swoole和redis实现的并发队列处理系统

php swoole实现毫秒级定时任务
 
 

上一篇： 给定一个整数，输出这个整数所有的可能加和，按从小到大排序

下一篇： Redis的面试问题总结，面试跳槽必备

推荐阅读