CGI工作流程

1.如果客户端请求的是 index.html，那么Web Server会去文件系统中找到这个文件，发送给浏览器，这里分发的是静态数据。

2.当Web Server收到 index.php 这个请求后，会启动对应的 CGI 程序，这里就是PHP的解析器。接下来PHP解析器会解析php.ini文件，初始化执行环境，然后处理请求，再以CGI规定的格式返回处理后的结果，退出进程，Web server再把结果返回给浏览器。

FastCGI工作流程

1.如果客户端请求的是 index.html，那么Web Server会去文件系统中找到这个文件，发送给浏览器，这里分发的是静态数据。

2.当Web Server收到 index.php 这个请求后,FastCGI程序(FastCGI在启动时就初始化执行执行环境，每个CGI进程池各个CGI进程共享执行环境)在CGI进程池中选择一个CGI进程处理请求，再以CGI规定的格式返回处理后的结果，继续等待下一个请求。

PHP-FPM基本实现

PHP-FPM的实现就是创建一个master进程，在master进程中创建worker pool并让其监听socket，然后fork出多个子进程(work)。

这些子进程各自accept请求，子进程的处理非常简单，它在启动后阻塞在accept上，有请求到达后开始读取请求数据，读取完成后开始处理然后再返回。

在这期间是不会接收其它请求的，也就是说PHP-FPM的子进程同时只能响应一个请求，只有把这个请求处理完成后才会accept下一个请求

PHP-FPM的master进程与worker进程之间不会直接进行通信，master通过共享内存获取worker进程的信息。

比如worker进程当前状态、已处理请求数等，当master进程要杀掉一个worker进程时则通过发送信号的方式通知worker进程。

PHP-FPM可以同时监听多个端口，每个端口对应一个worker pool，而每个pool下对应多个worker进程

Worker工作流程

1.等待请求：worker进程阻塞在fcgi_accept_request()等待请求；

2.解析请求：fastcgi请求到达后被worker接收，然后开始接收并解析请求数据，直到request数据完全到达；

3.请求初始化：执行php_request_startup()，此阶段会调用每个扩展的：PHP_RINIT_FUNCTION()；

4.编译、执行：由php_execute_script()完成PHP脚本的编译、执行；

5.关闭请求：请求完成后执行php_request_shutdown()，此阶段会调用每个扩展的：PHP_RSHUTDOWN_FUNCTION()，然后进入步骤(1)等待下一个请求。

Master进程管理

1.static: 这种方式比较简单，在启动时master按照pm.max_children配置fork出相应数量的worker进程，即worker进程数是固定不变的

2.dynamic: 动态进程管理，首先在fpm启动时按照pm.start_servers初始化一定数量的worker。

运行期间如果master发现空闲worker数低于pm.min_spare_servers配置数(表示请求比较多，worker处理不过来了)则会fork worker进程，但总的worker数不能超过pm.max_children。

如果master发现空闲worker数超过了pm.max_spare_servers(表示闲着的worker太多了)则会杀掉一些worker，避免占用过多资源，master通过这4个值来控制worker数

3.ondemand: 这种方式一般很少用，在启动时不分配worker进程，等到有请求了后再通知master进程fork worker进程。

总的worker数不超过pm.max_children，处理完成后worker进程不会立即退出，当空闲时间超过pm.process_idle_timeout后再退出

PHP-FPM事件管理器

1.sp管道可读事件:这个事件是master用于处理信号的

2.fpm_pctl_perform_idle_server_maintenance_heartbeat():这是进程管理实现的主要事件。

master启动了一个定时器，每隔1s触发一次，主要用于dynamic、ondemand模式下的worker管理，master会定时检查各worker pool的worker进程数，通过此定时器实现worker数量的控制

3.fpm_pctl_heartbeat():这个事件是用于限制worker处理单个请求最大耗时的，php-fpm.conf中有一个request_terminate_timeout的配置项，如果worker处理一个请求的总时长超过了这个值那么master将会向此worker进程发送kill -TERM信号杀掉worker进程，此配置单位为秒，默认值为0表示关闭此机制

4.fpm_pctl_on_socket_accept():ondemand模式下master监听的新请求到达的事件，因为ondemand模式下fpm启动时是不会预创建worker的，有请求时才会生成子进程，所以请求到达时需要通知master进程

我们在设计签名验证的时候，请注意要满足以下几点：

• 可变性：每次的签名必须是不一样的。
• 时效性：每次请求的时效，过期作废等。
• 唯一性：每次的签名是唯一的。
• 完整性：能够对传入数据进行验证，防止篡改。

这里介绍一种方式，是目前国内互联网公司常用的一种方式，其中淘宝的支付宝支付接口、淘宝开放平台接口、腾讯开放平台等应用的一种方式。

一、签名参数sign生成的方法

第1步: 将所有参数（注意是所有参数），除去sign本身，以及值是空的参数，按参数名字母升序排序。

第2步: 然后把排序后的参数按参数1值1参数2值2…参数n值n（这里的参数和值必须是传输参数的原始值，不能是经过处理的，如不能将”转成”后再拼接）的方式拼接成一个字符串。

第3步: 把分配给接入方的验证密钥key拼接在第2步得到的字符串前面。

第2步: 在上一步得到的字符串前面加上验证密钥key(这里的密钥key是接口提供方分配给接口接入方的)，然后计算md5值，得到32位字符串，然后转成大写.

第4步: 计算第3步字符串的md5值(32位)，然后转成大写,得到的字符串作为sign的值。

举例：

假设传输的数据是/interface.php?sign=sign_value&p2=v2& p1=v1&method=cancel&p3=&pn=vn（实际情况最好是通过post方式发送），其中sign参数对应的sign_value就是签名的值。

第一步，拼接字符串，首先去除sign参数本身，然后去除值是空的参数p3，剩下p2=v2&p1=v1&method=cancel& amp;pn=vn，然后按参数名字符升序排序，method=cancel&p1=v1&p2=v2&pn=vn.

第二步，然后做参数名和值的拼接，最后得到methodcancelp1v1p2v2pnvn
第三步，在上面拼接得到的字符串前加上验证密钥key，我们假设是abc，得到新的字符串abcmethodcancelp1v1p2v2pnvn

第四步，然后将这个字符串进行md5计算，假设得到的是abcdef，然后转为大写，得到ABCDEF这个值即为sign签名值。

注意，计算md5之前请确保接口与接入方的字符串编码一致，如统一使用utf-8编码或者GBK编码，如果编码方式不一致则计算出来的签名会校验失败。

二、签名验证方法

根据前面描述的签名参数sign生成的方法规则，计算得到参数的签名值，和参数中通知过来的sign对应的参数值进行对比，如果是一致的，那么就校验通过，如果不一致，说明参数被修改过。

三、下面直接看代码

<?php

// 设置一个公钥(key)和私钥(secret)，公钥用于区分用户，私钥加密数据，不能公开
$key = "c4ca4238a0b923820dcc509a6f75849b";
$secret = "28c8edde3d61a0411511d3b1866f0636";

// 待发送的数据包
$data = array(
    'username' => 'abc@qq.com',
    'sex' => '1',
    'age' => '16',
    'addr' => 'guangzhou',
    'key' => $key,
    'timestamp' => time(),
);

// 获取sign
function getSign($secret, $data) {
    // 对数组的值按key排序
    ksort($data);
    // 生成url的形式
    $params = http_build_query($data);
    // 生成sign
    $sign = md5($params . $secret);
    return $sign;
}

// 发送的数据加上sign
$data['sign'] = getSign($secret, $data);

/**
 * 后台验证sign是否合法
 * @param  [type] $secret [description]
 * @param  [type] $data   [description]
 * @return [type]         [description]
 */
function verifySign($secret, $data) {
    // 验证参数中是否有签名
    if (!isset($data['sign']) || !$data['sign']) {
        echo '发送的数据签名不存在';
        die();
    }
    if (!isset($data['timestamp']) || !$data['timestamp']) {
        echo '发送的数据参数不合法';
        die();
    }
    // 验证请求， 10分钟失效
    if (time() - $data['timestamp'] > 600) {
        echo '验证失效， 请重新发送请求';
        die();
    }
    $sign = $data['sign'];
    unset($data['sign']);
    ksort($data);
    $params = http_build_query($data);
    // $secret是通过key在api的数据库中查询得到
    $sign2 = md5($params . $secret);
    if ($sign == $sign2) {
        die('验证通过');
    } else {
        die('请求不合法');
    }
}

它包括可以将这次主要的登录映射到其他应用中用于同一个用户的登录的机制。它是目前比较流行的企业业务整合的解决方案之一,下面我们来看看吧。

简单讲一下 SSO 单点登录系统的接入的原理，前提是系统本身有完善的用户认证功能，即基本的用户登录功能，那实现起来就很方便了。

SSO 登录请求接口往往是接口加上一个回调地址，访问这个地址会跳转到回调地址并带上一个 ticket 参数，拿着这个 ticket 参数再请求接口可以获取到用户信息，如果存在用户则自动登录，不存在就新增用户并登录。

要使用 PHP 实现单点登录（Single Sign-On，SSO），可以借助一些标准和协议，如OAuth 2.0、OpenID Connect 或 SAML（Security Assertion Markup Language）。

下面是一个使用 OAuth 2.0 实现 SSO 的简单示例：

创建认证服务器（Authorization Server）：该服务器负责处理用户认证和发放访问令牌。

// authorization_server.php

// 用户登录验证逻辑，验证用户名和密码是否正确
function validateUser($username, $password) {
    // 进行用户验证逻辑，返回验证结果
    // ...
}

// 发放访问令牌给授权成功的用户
function issueAccessToken($username) {
    // 生成访问令牌并返回
    // ...
}

// 处理用户登录请求
if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    $username = $_POST['username'];
    $password = $_POST['password'];

    // 验证用户名和密码
    if (validateUser($username, $password)) {
        // 发放访问令牌
        $accessToken = issueAccessToken($username);

        // 将访问令牌返回给客户端
        echo json_encode(['access_token' => $accessToken]);
        exit;
    } else {
        // 用户认证失败
        http_response_code(401);
        exit;
    }
}

创建客户端应用（Client Application）：该应用将使用认证服务器发放的访问令牌来验证用户身份。

// client_application.php

// 验证访问令牌是否有效
function validateAccessToken($accessToken) {
    // 进行访问令牌验证逻辑，返回验证结果
    // ...
}

// 处理用户登录请求
if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    $accessToken = $_POST['access_token'];

    // 验证访问令牌
    if (validateAccessToken($accessToken)) {
        // 用户已验证通过，执行单点登录逻辑
        // ...
        echo 'Login successful';
        exit;
    } else {
        // 访问令牌验证失败
        http_response_code(401);
        exit;
    }
}

用户登录和单点登录流程：

• 用户访问 Client Application，检查用户是否已登录。
• 如果用户未登录，则跳转到认证服务器的登录页面。
• 用户在认证服务器上提供用户名和密码进行登录认证。
• 认证服务器验证用户名和密码，并发放访问令牌。
• 用户被重定向回 Client Application，并将访问令牌发送到 Client Application。
• Client Application 验证访问令牌的有效性，确认用户已成功登录，执行相应的单点登录逻辑。

请注意，上述示例只是一个简单的演示，实际的 SSO 实现可能更复杂，涉及到会话管理、安全性等方面的考虑。您可以根据具体的需求和使用的协议，进一步完善和扩展这个基本示例。

进程是什么？

进程就是应用程序的启动实例。
例如：打开一个软件，就是开启了一个进程。
进程拥有代码和打开的文件资源，数据资源，独立的内存空间。

线程是什么？

线程属于进程，是程序的执行者。
一个进程至少包含一个主线程，也可以有更多的子线程。
线程有两种调度策略，一是：分时调度，二是：抢占式调度。

协程是什么？

协程是轻量级线程, 协程的创建、切换、挂起、销毁全部为内存操作，消耗是非常低的。
1 协程是属于线程，协程是在线程里执行的。
2 协程的调度是用户手动切换的，所以又叫用户空间线程。
3 协程的调度策略是：协作式调度。

为什么要用协程

目前主流语言基本上都选择了多线程作为并发设施，与线程相关的概念就是抢占式多任务（Preemptive multitasking），而与协程相关的是协作式多任务。其实不管是进程还是线程，每次阻塞、切换都需要陷入系统调用(system call)，先让CPU跑操作系统的调度程序，然后再由调度程序决定该跑哪一个进程(线程)。而且由于抢占式调度执行顺序无法确定的特点，使用线程时需要非常小心地处理同步问题，而协程完全不存在这个问题（事件驱动和异步程序也有同样的优点）。因为协程是用户自己来编写调度逻辑的，对于我们的CPU来说，协程其实是单线程，所以CPU不用去考虑怎么调度、切换上下文，这就省去了CPU的切换开销，所以协程在一定程度上又好于多线程。

协程相对于多线程的优点

多线程编程是比较困难的， 因为调度程序任何时候都能中断线程， 必须记住保留锁， 去保护程序中重要部分， 防止多线程在执行的过程中断。而协程默认会做好全方位保护， 以防止中断。我们必须显示产出才能让程序的余下部分运行。对协程来说， 无需保留锁， 而在多个线程之间同步操作， 协程自身就会同步， 因为在任意时刻， 只有一个协程运行。总结下大概下面几点：

• 无需系统内核的上下文切换，减小开销；
• 无需原子操作锁定及同步的开销，不用担心资源共享的问题；
• 单线程即可实现高并发，单核 CPU 即便支持上万的协程都不是问题，

所以很适合用于高并发处理，尤其是在应用在网络爬虫中。

二、Swoole 协程

swoole协程为什么是单线程

在swoole中，因为协程的切换是串行的，在同一个时间点只能运行一个协程，一个协程正在运行时，其他协程会停止工作，所以swoole的协程是基于单线程的。

swoole协程的调度方式是什么

线程的调度方式为系统调度,常用的调度策略有分时调度、抢占调度。说白就是线程的调度完全不受自己控制，协程的调度方式为协作式调度，不受内核控制由自由策略调度切换。上述说了协程是用户态的,所以所谓的协作式调度直接可以理解为是程序员写的调度方式,也就是我想怎么调度就怎么调度,而不用通过系统内核被调度。

Swoole 的协程客户端必须在协程的上下文环境中使用。

// 第一种情况：Request 回调本身是协程环境
$server->on('Request', function($request, $response) {
    // 创建 Mysql 协程客户端
    $mysql = new Swoole\Coroutine\MySQL();
    $mysql->connect([]);
    $mysql->query();
});

// 第二种情况：WorkerStart 回调不是协程环境
$server->on('WorkerStart', function() {
    // 需要先声明一个协程环境，才能使用协程客户端
    go(function(){
        // 创建 Mysql 协程客户端
        $mysql = new Swoole\Coroutine\MySQL();
        $mysql->connect([]);
        $mysql->query();
    });
});

Swoole 的协程是基于单线程的, 无法利用多核CPU，同一时间只有一个在调度。

// 启动 4 个协程
$n = 4;
for ($i = 0; $i < $n; $i++) {
    go(function () use ($i) {
        // 模拟 IO 等待
        Co::sleep(1);
        echo microtime(true) . ": hello $i " . PHP_EOL;
    });
};
echo "hello main \n";

// 每次输出的结果都是一样
$ php test.php 
hello main 
1558749158.0913: hello 0 
1558749158.0915: hello 3 
1558749158.0915: hello 2 
1558749158.0915: hello 1

Swoole 协程使用示例及详解

// 创建一个 Http 服务
$server = new Swoole\Http\Server('127.0.0.1', 9501, SWOOLE_BASE);

// 调用 onRequest 事件回调函数时，底层会调用 C 函数 coro_create 创建一个协程，
// 同时保存这个时间点的 CPU 寄存器状态和 ZendVM stack 信息。
$server->on('Request', function($request, $response) {
    // 创建一个 Mysql 的协程客户端
    $mysql = new Swoole\Coroutine\MySQL();

    // 调用 mysql->connect 时发生 IO 操作，底层会调用 C 函数 coro_save 保存当前协程的状态，
    // 包括 Zend VM 上下文以及协程描述的信息，并调用 coro_yield 让出程序控制权，当前的请求会挂起。
    // 当协程让出控制权之后，会继续进入 EventLoop 处理其他事件，这时 Swoole 会继续去处理其他客户端发来的 Request。
    $res = $mysql->connect([
        'host'     => '127.0.0.1',
        'user'     => 'root',
        'password' => 'root',
        'database' => 'test'
    ]);

    // IO 事件完成后，MySQL 连接成功或失败，底层调用 C 函数 coro_resume 恢复对应的协程，恢复 ZendVM 上下文，继续向下执行 PHP 代码。
    if ($res == false) {
        $response->end("MySQL connect fail");
        return;
    }

    // mysql->query 的执行过程和 mysql->connect 一致，也会进行一次协程切换调度
    $ret = $mysql->query('show tables', 2);

    // 所有操作完成后，调用 end 方法返回结果，并销毁此协程。
    $response->end('swoole response is ok, result='.var_export($ret, true));
});

// 启动服务
$server->start();

三、Go 的协程 goroutine

1. goroutine 是轻量级的线程，Go 语言从语言层面就支持原生协程。
2. Go 协程与线程相比，开销非常小。
3. Go 协程的堆栈开销只用2KB，它可以根据程序的需要增大和缩小，
而线程必须指定堆栈的大小，并且堆栈的大小都是固定的。
4. goroutine 是通过 GPM 调度模型实现的。
M: 表示内核级线程，一个 M 就是一个线程，goroutine 跑在 M 之上的。
G: 表示一个 goroutine，它有自己的栈。
P: 全称是 Processor，处理器。它主要用来执行 goroutine 的，同时它也维护了一个 goroutine 队列。Go 在 runtime、系统调用等多个方面对 goroutine 调度进行了封装和处理，当遇到长时间执行或进行系统调用时，会主动把当前协程的 CPU 转让出去，让其他协程调度执行。

Go 语言原生层面就支持协层，不需要声明协程环境。

package main

import "fmt"

func main() {
    // 直接通过 Go 关键字，就可以启动一个协程。
    go func() {
        fmt.Println("Hello Go!")
    }()
}

Go 协程是基于多线程的，可以利用多核 CPU，同一时间可能会有多个协程在执行。

package main

import (
    "fmt"
    "time"
)

func main() {
    // 设置这个参数，可以模拟单线程与 Swoole 的协程做比较
    // 如果这个参数设置成 1，则每次输出的结果都一样。
    // runtime.GOMAXPROCS(1)

    // 启动 4 个协程
    var i int64
    for i = 0; i < 4; i++ {
        go func(i int64) {
            // 模拟 IO 等待
            time.Sleep(1 * time.Second)
            fmt.Printf("hello %d \n", i)
        }(i)
    }

    fmt.Println("hello main")

    // 等待其他的协程执行完，如果不等待的话，
    // main 执行完退出后，其他的协程也会相继退出。
    time.Sleep(10 * time.Second)
}

// 第一次输出的结果
$ go run test.go
hello main
hello 2 
hello 1 
hello 0 
hello 3 

// 第二次输出的结果
$ go run test.go
hello main
hello 2 
hello 0 
hello 3 
hello 1 

// 依次类推，每次输出的结果都不一样

Go 协程使用示例及详解

package main

import (
    "fmt"
    "github.com/jinzhu/gorm"
    "net/http"
    "time"
)
import _ "github.com/go-sql-driver/mysql"

func main() {
    dsn := fmt.Sprintf("%v:%v@(%v:%v)/%v?charset=utf8&parseTime=True&loc=Local",
        "root",
        "root",
        "127.0.0.1",
        "3306",
        "fastadmin",
    )
    db, err := gorm.Open("mysql", dsn)
    if err != nil {
        fmt.Printf("mysql connection failure, error: (%v)", err.Error())
        return
    }
    db.DB().SetMaxIdleConns(10)  // 设置连接池
    db.DB().SetMaxOpenConns(100) // 设置与数据库建立连接的最大数目
    db.DB().SetConnMaxLifetime(time.Second * 7)

    http.HandleFunc("/test", func(writer http.ResponseWriter, request *http.Request) {
        // http Request 是在协程中处理的
        // 在 Go 源码 src/net/http/server.go:2851 行处 `go c.serve(ctx)` 给每个请求启动了一个协程
        var name string
        row := db.Table("fa_auth_rule").Where("id = ?", 1).Select("name").Row()
        err = row.Scan(&name)
        if err != nil {
            fmt.Printf("error: %v", err)
            return
        }
        fmt.Printf("name: %v \n", name)
    })
    http.ListenAndServe("0.0.0.0:8001", nil)
}

四、案例分析

背景：在我们的积分策略服务系统中，使用到了 mongodb 存储，但是 swoole 没有提供 mongodb 协程客户端。那么这种场景下，在连接及操作 Mongodb 时会发生同步阻塞，无法发生协程切换，导致整个进程都会阻塞。在这段时间内，进程将无法再处理新的请求，这使得系统的并发性大大降低。

使用同步的 mongodb 客户端

$server->on('Request', function($request, $response) {
    // swoole 没有提供协程客户端，那么只能使用同步客户端
    // 这种情况下，进程阻塞，无法切换协程
    $m = new MongoClient();    // 连接到mongodb
    $db = $m->test;            // 选择一个数据库
    $collection = $db->runoob; // 选择集合
    // 更新文档
    $collection->update(array("title"=>"MongoDB"), array('$set'=>array("title"=>"Swoole")));
    $cursor = $collection->find();
    foreach ($cursor as $document) {
        echo $document["title"] . "\n";
    }
}}

通过使用 Server->taskCo 来异步化对 mongodb 的操作

$server->on('Task', function (swoole_server $serv, $task_id, $worker_id, $data) {
    $m = new MongoClient();    // 连接到mongodb
    $db = $m->test;            // 选择一个数据库
    $collection = $db->runoob; // 选择集合
    // 更新文档
    $collection->update(array("title"=>"MongoDB"), array('$set'=>array("title"=>"Swoole")));
    $cursor = $collection->find();
    foreach ($cursor as $document) {
        $data = $document["title"];
    }
    return $data;
});

$server->on('Request', function ($request, $response) use ($server) {
    // 通过 $server->taskCo() 把对 mongodb 的操作，投递到异步 task 中。
    // 投递到异步 task 后，将发生协程切换，可以继续处理其他的请求，提供并发能力。
    $tasks[] = "hello world";
    $result = $server->taskCo($tasks, 0.5);
    $response->end('Test End, Result: '.var_export($result, true));
});

上面两种使用方式就是 Swoole 中常用的方法了。
那么我们在 Go 中怎么处理这种同步的问题呢 ？

实际上在 Go 语言中就不用担心这个问题了，如我们之前所说到的，
Go 在语言层面就已经支持协程了，只要是发生 IO 操作，网络请求都会发生协程切换。这也就是 Go 语言天生以来就支持高并发的原因了。

package main

import (
    "fmt"
    "gopkg.in/mgo.v2"
    "net/http"
)

func main() {
    http.HandleFunc("/test", func(writer http.ResponseWriter, request *http.Request) {
        session, err := mgo.Dial("127.0.0.1:27017")
        if err != nil {
            fmt.Printf("Error: %v \n", err)
            return
        }
        session.SetMode(mgo.Monotonic, true)
        c := session.DB("test").C("runoob")
        fmt.Printf("Connect %v \n", c)
    })
    http.ListenAndServe("0.0.0.0:8001", nil)
}

并行：同一时刻，同一个 CPU 只能执行同一个任务，要同时执行多个任务，就需要有多个 CPU。

并发：CPU 切换时间任务非常快，就会感觉到有很多任务在同时执行。

五、协程 CPU 密集场景调度

我们上面说到都是基于 IO 密集场景的调度。
那么如果是 CPU 密集型的场景，应该怎么处理呢？在 Swoole v4.3.2 版本中，已经支持了协程 CPU 密集场景的调度。想要支持 CPU 密集调度，需要在编译时增加编译选项 --enable-scheduler-tick 开启 tick 调度器。其次还需要我们手动声明 declare(tick=N) 语法功能来实现协程调度。

<?php
declare(ticks=1000);

$max_msec = 10;
Swoole\Coroutine::set([
    'max_exec_msec' => $max_msec,
]);

$s = microtime(1);
echo "start\n";
$flag = 1;
go(function () use (&$flag, $max_msec){
    echo "coro 1 start to loop for $max_msec msec\n";
    $i = 0;
    while($flag) {
        $i ++;
    }
    echo "coro 1 can exit\n";
});

$t = microtime(1);
$u = $t-$s;
echo "shedule use time ".round($u * 1000, 5)." ms\n";
go(function () use (&$flag){
    echo "coro 2 set flag = false\n";
    $flag = false;
});
echo "end\n";

// 输出结果
start
coro 1 start to loop for 10 msec
shedule use time 10.2849 ms
coro 2 set flag = false
end
coro 1 can exit

Go 在 CPU 密集运算时，有可能导致协程无法抢占 CPU 会一直挂起。这时候就需要显示的调用代码 runtime.Gosched() 挂起当前协程，让出 CPU 给其他的协程。

package main

import (
    "fmt"
    "time"
)

func main() {
    // 如果设置单线程，则第一个协程无法让出时间片
    // 第二个协程一直得不到时间片，阻塞等待。
    // runtime.GOMAXPROCS(1)

    flag := true

    go func() {
        fmt.Printf("coroutine one start \n")
        i := 0
        for flag {
            i++
            // 如果加了这行代码，协程可以让时间片
            // 这个因为 fmt.Printf 是内联函数，这是种特殊情况
            // fmt.Printf("i: %d \n", i)
        }
        fmt.Printf("coroutine one exit \n")
    }()

    go func() {
        fmt.Printf("coroutine two start \n")
        flag = false
        fmt.Printf("coroutine two exit \n")
    }()

    time.Sleep(5 * time.Second)
    fmt.Printf("end \n")
}

// 输出结果
coroutine one start 
coroutine two start 
coroutine two exit 
coroutine one exit 
end

注：time.sleep() 模拟 IO 操作，for i++ 模拟 CPU 密集运算。

总结

• 协程是轻量级的线程，开销很小。
• Swoole 的协程客户端需要在协程的上下文环境中使用。
• 在 Swoole v4.3.2 版本之后，已经支持协程 CPU 密集场景调度。
• Go 语言层面就已经完全支持协程了。

解决方案
方案1 easySwoole + crontab
方案2 easySwoole定时器
方案3 Swoole table
方案4 Redis

实现
这里做的分页的场景，不包含分页的源码，只从拿到了分页的数据看定时生成json和获取json的部分

原始的方法 – 读取mysql

这是原始的方法，每个用户访问都会去数据库里面读取一次，每一次分页也会访问数据库，会造成大量的资源开销。

public function lists0(){
    $condition = [];
    if(!empty($this->params['cat_id'])){
        $condition['cat_id'] = intval($this->params['cat_id']);
    }

    try {
        $videoModel = new VideoModel();
        $data = $videoModel->getVideoData($condition, $this->params['page'], $this->params['size']);
    } catch (\Exception $e) {
        //$e->getMessage();
        return $this->writeJson(Status::CODE_BAD_REQUEST,"服务异常");
    }

    if(!empty($data['lists'])){
        foreach ($data['lists'] as &$list){
            $list['create_time'] = date("Ymd H:i:s",$list['create_time']);
            $list['video_duration'] = gmstrftime("%H:%M:%S",$list["video_duration"]);
        }
    }

    return $this->writeJson(Status::CODE_OK,'OK',$data);
}

知识点：

1 获取以秒为单位的时间长度使用gmstrftime(“%H:%M:%S”,$list[“video_duration”])
2 在做模型的时候写一个基类，把连接数据库的工作放在这个基类的构造方法当中，这样每次实例化的时候就自动连接了，提高代码的复用性

<?php


namespace App\Model;

use EasySwoole\Core\Component\Di;

class Base
{
    public $db = "";

    public function __construct()
    {
        if(empty($this->tableName)){
            throw new \Exception("table error");
        }
        $db = Di::getInstance()->get("MYSQL");
        if($db instanceof \MysqliDb){
            $this->db = $db;
        }else{
            throw new \Exception("db error");
        }
    }

    public function add($data){
        if(empty($data) || !is_array($data)){
            return false;
        }
        return $this->db->insert($this->tableName,$data);
    }

}

方案一、方案二 使用easySwoole定时器以及contab的生成静态化API

这是直接读取静态化API的方法，其实就是读文件然后返回给前端

/**
 * 第二套方法 - 直接读取静态化json数据
 * @return bool
 */
public function lists(){
    $catId = !empty($this->params['cat_id']) ? intval($this->params['cat_id']) : 0;
    $videoFile = EASYSWOOLE_ROOT."/webroot/video/json/".$catId.".json";
    $videoData = is_file($videoFile) ? file_get_contents($videoFile) : [];
    var_dump($videoData);
    $videoData = !empty($videoData) ? json_decode($videoData,true) : [];

    $count = count($videoData);
    // var_dump($videoData);
    return $this->writeJson(Status::CODE_OK,'OK',$this->getPagingData($count,$videoData));
}

这里的getPagingData使用了array_slice来切割数组来做分页。

/**
 * 获取分页信息
 * @param $count
 * @param $data
 * @return array
 */
public function getPagingData($count, $data){
    $totalPage = ceil($count / $this->params['size']);
    $data = $data ?? [];
    $data = array_slice($data, $this->params['from'], $this->params['size']);
    return [
        'total_page' => $totalPage,
        'page_size' => $this->params['page'],
        'count' => intval($count),
        'list' => $data
    ];

}

定时生成Json文件代码 – 核心部分 全局事件easySwooleEvent->mainServiceCreate中执行，这样easySwoole启动了之后就会执行，这里使用的原生的crontab，只能够精确到分

$cacheVideoObj = new VideoCache();
// 使用cronTab处理定时任务
// 这里是闭包 要use $cacheVideoObj之后才能获取,实例化不放在function中是为了防止每次都实例化浪费资源
CronTab::getInstance()
    ->addRule("test_bing_crontab", '*/1 * * * *', function () use($cacheVideoObj) {
        $cacheVideoObj->setIndexVideo();
    });

也可以使用easySwoole的定时器来实现也是放在mainServiceCreate中执行，这里的代码一定要注意要注册一个onWorkerStart。
然后指定一个进程去执行这个定时任务注意一下这里闭包里面又有一个闭包，外面的变量要use两次。
一定要注意easwoole定时器的使用，这里的坑比较多一定要注意，优势是swoole的定时器可以到毫秒级而contab只能到分级

// easySwoole自带定时器
$register->add(EventRegister::onWorkerStart,function (\swoole_server $server,$workerId)use($cacheVideoObj){
    //让第一个进程去执行,否则每个进程都会执行
    if($workerId == 0){
        Timer::loop(1000*2,function ()use ($cacheVideoObj){
            $cacheVideoObj->setIndexVideo();
        });
    }
});

方案三 Swoole table的解决方案

swoole_table一个基于共享内存和锁实现的超高性能，并发数据结构。用于解决多进程/多线程数据共享和同步加锁问题。性能十分强悍。使用起来有一点像是缓存。这里不再是生成一个json文件去读取了，读取table中数据给前端的方法，注意要use cache这个类，这里直接使用get就可以根据key获取到table中的数据，注意这个是一个单例模式，因此需要getInstance

public function lists(){
    $catId = !empty($this->params['cat_id']) ? intval($this->params['cat_id']) : 0;
    $videoFile = EASYSWOOLE_ROOT."/webroot/video/json/".$catId.".json";

    //  第三套方案 table
    $videoData = Cache::getInstance()->get("index_video_data_cat_id".$catId);
    $videoData = !empty($videoData) ? $videoData : [];

    $count = count($videoData);;
    return $this->writeJson(Status::CODE_OK,'OK',$this->getPagingData($count,$videoData));
}

设置直接set(key,data)就可以了，注意这里的代码不是很严谨，比如要判断一下是不是设置成功了，没有设置成功发短信之类的，也要处理一下空值的场景，这里只是做一个演示。

<?php

namespace App\Lib\Cache;

use App\Model\Video as VideoModel;
use EasySwoole\Config;
use EasySwoole\Core\Component\Cache\Cache;

class Video
{
    public function setIndexVideo()
    {
        $catIds = array_keys(Config::getInstance()->getConf("category"));
        array_unshift($catIds, 0);

        $modelObj = new VideoModel();

        foreach ($catIds as $catId) {
            $condition = [];
            if (!empty($catId)) {
                $condition['cat_id'] = $catId;
            }

            try {
                $data = $modelObj->getVideoCacheData($condition);
            } catch (\Exception $e) {
                // 短信报警
                $data = [];
            }
            if (empty($data)) {

            }
            foreach ($data as &$list) {
                $list['create_time'] = date("Ymd H:i:s", $list["create_time"]);
                $list["video_duration"] = gmstrftime("%H:%M:%s", $list["video_duration"]);
            }
            // 由于table存在内存所以重启服务器时数据会丢失，要将配置中的PERSISTENT_TIME设置为1进行落盘操作
            Cache::getInstance()->set("index_video_data_cat_id".$catId, $data);
        }
    }
}

注意，一定要去config里面开启

'PERSISTENT_TIME'=>1//如果需要定时数据落地，请设置对应的时间周期，单位为秒

否则会在重启服务的时候没有数据，因为每次启动的时候swoole table会清空，要等到定时去set table的时候才会有数据，因此要开启数据落盘，这样会生成两个文件：

每次启动的时候由于还没有执行定时任务，就会先读取这两个落盘的文件中的数据，防止服务启动时等待table生成造成业务中断。

方案四 Redis

用redis来做数据缓存，每次从缓存里面度读先重写一下set方法，更加严谨一点

/**
 * 重写set方法 处理一下失效时间以及数组转json
 * @param $key
 * @param $value
 * @param $time
 * @return bool|string
 */
public function set($key, $value, $time){
    if(empty($key)){
        return '';
    }
    if(is_array($value)){
        $value = json_encode($value);
    }
    if(!$time){
        return $this->redis->set($key,$value);
    }
    return $this->redis->setex($key, $time, $value);
}

使用起来很简单啦，在之前的代码中

Di::getInstance()->get("REDIS")->set("index_video_data_cat_id".$catId, $data);

然后取出的数据的部分

public function lists(){
    $catId = !empty($this->params['cat_id']) ? intval($this->params['cat_id']) : 0;
    //redis
    $videoData = Di::getInstance()->get("REDIS")->get("index_video_data_cat_id".$catId);
    $videoData = !empty($videoData) ? json_decode($videoData,true) : [];
    $count = count($videoData);
    return $this->writeJson(Status::CODE_OK,'OK',$this->getPagingData($count,$videoData));
}

高度封装

只需要在配置文件中进行配置即可选择相应方法。设置静态化API和获取静态化API的方法

<?php


namespace App\Lib\Cache;

use App\Model\Video as VideoModel;
use EasySwoole\Config;
use EasySwoole\Core\Component\Cache\Cache;
use EasySwoole\Core\Component\Di;
use EasySwoole\Core\Http\Message\Status;

class Video
{
    /**
     * 设置静态API的方法
     * @throws \Exception
     */
    public function setIndexVideo()
    {
        $catIds = array_keys(Config::getInstance()->getConf("category"));
        array_unshift($catIds, 0);

        // 获取配置
        try {
            $cacheType = Config::getInstance()->getConf("base.indexCacheType");
        } catch (\Exception $e) {
            return $this->writeJson(Status::CODE_BAD_REQUEST,"请求失败");
        }

        $modelObj = new VideoModel();

        foreach ($catIds as $catId) {
            $condition = [];
            if (!empty($catId)) {
                $condition['cat_id'] = $catId;
            }

            try {
                $data = $modelObj->getVideoCacheData($condition);
            } catch (\Exception $e) {
                // 短信报警
                $data = [];
            }
            if (empty($data)) {

            }

            foreach ($data as &$list) {
                $list['create_time'] = date("Ymd H:i:s", $list["create_time"]);
                $list["video_duration"] = gmstrftime("%H:%M:%s", $list["video_duration"]);
            }

            switch ($cacheType) {
                case 'file':
                    $res = file_put_contents($this->getVideoCatIdFile($catId), json_encode($data));
                    break;
                case 'table':
                    $res = Cache::getInstance()->set($this->getCatKey($catId), $data);
                    break;
                case 'redis':
                    $res = Di::getInstance()->get("REDIS")->set($this->getCatKey($catId), $data);
                    break;
                default:
                    throw new \Exception("请求不合法");
                    break;
            }

            if(empty($res)){
            //    记录日志
            //    报警

            }

        }

    }

    /**
     * 获取数据的方法
     * @param $catId
     * @return array|bool|mixed|null|string
     * @throws \Exception
     */
    public function getCache($catId){
        $cacheType = Config::getInstance()->getConf("base.indexCacheType");
        switch ($cacheType){
            case 'file':
                $videoFile = $this->getVideoCatIdFile($catId);
                $videoData = is_file($videoFile) ? file_get_contents($videoFile) : [];
                $videoData = !empty($videoData) ? json_decode($videoData,true) : [];
                break;
            case 'table':
                $videoData = Cache::getInstance()->get($this->getCatKey($catId));
                $videoData = !empty($videoData) ? $videoData : [];
                break;
            case 'redis':
                $videoData = Di::getInstance()->get("REDIS")->get($this->getCatKey($catId));
                $videoData = !empty($videoData) ? json_decode($videoData,true) : [];
                break;
            default:
                throw new \Exception("请求不合法");
                break;
        }
        return $videoData;
    }

    public function getVideoCatIdFile($catId = 0){
        return EASYSWOOLE_ROOT . "/webroot/video/json/" . $catId . ".json";
    }


    public function getCatKey($catId = 0){
        return "index_video_data_cat_id".$catId;
    }
}

只需修改配置文件

<?php

return [
    "indexCacheType" => "redis" // redis file table
];

控制器获取数据给前端

public function lists(){
    $catId = !empty($this->params['cat_id']) ? intval($this->params['cat_id']) : 0;
    $videoData = (new VideoCache())->getCache($catId);
    $count = count($videoData);
    return $this->writeJson(Status::CODE_OK,'OK',$this->getPagingData($count,$videoData));
}

在设计数据表时，可以考虑创建一个 tasks 表，用于存储所有需要推送的任务信息。该表可以包含以下字段：
id：任务ID，自增长整数类型；
name：任务名称，用于描述该任务的作用；
type：任务类型，用于区分不同类型的任务；
data：任务数据，可以存储该任务需要用到的数据信息，可以是序列化后的字符串或JSON格式的数据；
status：任务状态，用于标识该任务的状态，如待处理、已处理等；
created_at：任务创建时间，用于记录该任务的创建时间；
updated_at：任务更新时间，用于记录该任务的最后更新时间；

在添加任务时，可以向 tasks 表中插入一条记录，设置好任务的名称、类型、数据等信息。然后，在需要推送任务时，可以通过查询 tasks 表，找到需要推送的任务信息，并将其加入到消息队列中，等待消息队列服务处理。

在处理任务时，可以使用类似下面的代码：

$queue = new RedisQueue('my_queue', $redis);

// 处理队列中的任务
while ($job = $queue->pop()) {
    $task = unserialize($job->payload);

    // 执行任务处理操作
    handleTask($task);

    // 标记任务为已处理
    $task->status = Task::STATUS_COMPLETED;
    $task->save();
}

其中，RedisQueue 是一个自定义的 Redis 队列类，用于将任务加入到 Redis 队列中。handleTask 函数则是用于处理任务的函数，根据实际需求进行编写即可。

可以使用 cron 或类似的定时任务工具来定时检查 tasks 表，并将需要推送的任务加入到消息队列中。具体的实现方式可以根据实际情况选择不同的技术方案和工具。

需要注意的是，在异步任务处理过程中，需要考虑异常情况的处理，例如任务执行失败、队列服务异常等情况。因此，在编写异步任务时，需要进行充分的异常处理和错误日志记录。

下面介绍几个具体的例子：

1、 使用 Laravel 框架提供的队列和计划任务功能实现消息推送：

// 定义消息推送任务类
class PushMessage implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    protected $message;

    public function __construct($message)
    {
        $this->message = $message;
    }

    public function handle()
    {
        // 处理推送消息的逻辑
    }
}

// 在计划任务中添加消息推送任务
$schedule->call(function () {
    PushMessage::dispatch('hello')->delay(now()->addMinutes(10));
})->everyMinute();

在上面的示例代码中，我们使用 Laravel 框架提供的队列和计划任务功能，定义了一个 PushMessage 消息推送任务类，并在计划任务中添加了一个延迟 10 分钟执行的消息推送任务。

2、 使用第三方的消息队列服务实现消息推送：

// 使用 beanstalkd 消息队列
use Pheanstalk\Pheanstalk;

// 连接到 beanstalkd 服务
$pheanstalk = new Pheanstalk('127.0.0.1');

// 向队列添加消息
$pheanstalk->useTube('push_message')->put('hello', Pheanstalk::DEFAULT_PRIORITY, 60);

// 处理消息队列中的消息
while (true) {
    $job = $pheanstalk->watch('push_message')->ignore('default')->reserve();
    $message = $job->getData();
    // 处理推送消息的逻辑
    $pheanstalk->delete($job);
}

在上面的示例代码中，我们使用了第三方的消息队列服务 beanstalkd，并实现了向队列添加消息和处理消息队列中的消息的逻辑。

3、 使用 Swoole 扩展实现异步定时任务和消息推送：

// 创建 Swoole 定时器和 HTTP 服务器
$timer = swoole_timer_tick(1000, function () {
    // 处理定时任务的逻辑
});
$http = new swoole_http_server('127.0.0.1', 9501);
$http->on('request', function ($request, $response) use ($timer) {
    // 处理 HTTP 请求的逻辑
    $response->end('hello');

    // 添加异步任务
    swoole_timer_after(10000, function () use ($response) {
        $response->end('world');
    });

    // 关闭定时器
    swoole_timer_clear($timer);
});
$http->start();

在上面的示例代码中，我们使用 Swoole 扩展创建了一个定时器和 HTTP 服务器，并在定时器回调函数中处理定时任务的逻辑，在 HTTP 请求回调函数中处理 HTTP 请求的逻辑，并添加了一个 10 秒后执行的异步任务。

通过composer安装

composer require 'elasticsearch/elasticsearch'

二、使用

创建ES类

<?php

require 'vendor/autoload.php';

//如果未设置密码
$es = \Elasticsearch\ClientBuilder::create()->setHosts(['xxx.xxx.xxx.xxx'])->build();

//如果es设置了密码
$es = \Elasticsearch\ClientBuilder::create()->setHosts(['http://username:password@xxx.xxx.xxx.xxx:9200'])->build();

三、新建ES数据库

index 对应关系型数据（以下简称MySQL）里面的数据库，而不是对应MySQL里面的索引

<?php
$params = [
    'index' => 'autofelix_db', #index的名字不能是大写和下划线开头
    'body' => [
        'settings' => [
            'number_of_shards' => 5,
            'number_of_replicas' => 0
        ]
    ]
];
$es->indices()->create($params);

四、创建表

• 在MySQL里面，光有了数据库还不行，还需要建立表，ES也是一样的
• ES中的type对应MySQL里面的表
• ES6以前，一个index有多个type，就像MySQL中一个数据库有多个表一样
• 但是ES6以后，每个index只允许一个type
• 在定义字段的时候，可以看出每个字段可以定义单独的类型
• 在first_name中还自定义了 分词器 ik，这是个插件，是需要单独安装的

<?php
$params = [
    'index' => 'autofelix_db',
    'type' => 'autofelix_table',
    'body' => [
        'mytype' => [
            '_source' => [
                'enabled' => true
            ],
            'properties' => [
                'id' => [
                    'type' => 'integer'
                ],
                'first_name' => [
                    'type' => 'text',
                    'analyzer' => 'ik_max_word'
                ],
                'last_name' => [
                    'type' => 'text',
                    'analyzer' => 'ik_max_word'
                ],
                'age' => [
                    'type' => 'integer'
                ]
            ]
        ]
    ]
];
$es->indices()->putMapping($params);

五、插入数据

• 现在数据库和表都有了，可以往里面插入数据了
• 在ES里面的数据叫文档
• 可以多插入一些数据，等会可以模拟搜索功能

<?php
$params = [
    'index' => 'autofelix_db',
    'type' => 'autofelix_table',
    //'id' => 1, #可以手动指定id，也可以不指定随机生成
    'body' => [
        'first_name' => '飞',
        'last_name' => '兔',
        'age' => 26
    ]
];
$es->index($params);

六、 查询所有数据

<?php
$data = $es->search();
 
var_dump($data);

七、查询单条数据

• 如果你在插入数据的时候指定了id，就可以查询的时候加上id
• 如果你在插入的时候未指定id，系统将会自动生成id，你可以通过查询所有数据后查看其id

<?php
$params = [
    'index' => 'autofelix_db',
    'type' => 'autofelix_table',
    'id' =>  //你插入数据时候的id
];
$data = $es->get($params);

八、搜索

ES精髓的地方就在于搜索

<?php
$params = [
    'index' => 'autofelix_db',
    'type' => 'autofelix_table',
    'body' => [
        'query' => [
            'constant_score' => [ //非评分模式执行
                'filter' => [ //过滤器，不会计算相关度，速度快
                    'term' => [ //精确查找，不支持多个条件
                        'first_name' => '飞'
                    ]
                ]
            ]
        ]
    ]
];
 
$data = $es->search($params);
var_dump($data);

九、测试代码

基于Laravel环境，包含删除数据库，删除文档等操作

<?php
use Elasticsearch\ClientBuilder;
use Faker\Generator as Faker;
 
/**
 * ES 的 php 实测代码
 */
class EsDemo
{
    private $EsClient = null;
    private $faker = null;
 
    /**
     * 为了简化测试，本测试默认只操作一个Index，一个Type
     */
    private $index = 'autofelix_db';
    private $type = 'autofelix_table';
 
    public function __construct(Faker $faker)
{
        /**
         * 实例化 ES 客户端
         */
        $this->EsClient = ClientBuilder::create()->setHosts(['xxx.xxx.xxx.xxx'])->build();
        /**
         * 这是一个数据生成库
         */
        $this->faker = $faker;
    }
 
    /**
     * 批量生成文档
     * @param $num
     */
    public function generateDoc($num = 100) {
        foreach (range(1,$num) as $item) {
            $this->putDoc([
                'first_name' => $this->faker->name,
                'last_name' => $this->faker->name,
                'age' => $this->faker->numberBetween(20,80)
            ]);
        }
    }
 
    /**
     * 删除一个文档
     * @param $id
     * @return array
     */
    public function delDoc($id) {
        $params = [
            'index' => $this->index,
            'type' => $this->type,
            'id' =>$id
        ];
        return $this->EsClient->delete($params);
    }
 
    /**
     * 搜索文档，query是查询条件
     * @param array $query
     * @param int $from
     * @param int $size
     * @return array
     */
    public function search($query = [], $from = 0, $size = 5) {
//        $query = [
//            'query' => [
//                'bool' => [
//                    'must' => [
//                        'match' => [
//                            'first_name' => 'Cronin',
//                        ]
//                    ],
//                    'filter' => [
//                        'range' => [
//                            'age' => ['gt' => 76]
//                        ]
//                    ]
//                ]
//
//            ]
//        ];
        $params = [
            'index' => $this->index,
//            'index' => 'm*', #index 和 type 是可以模糊匹配的，甚至这两个参数都是可选的
            'type' => $this->type,
            '_source' => ['first_name','age'], // 请求指定的字段
            'body' => array_merge([
                'from' => $from,
                'size' => $size
            ],$query)
        ];
        return $this->EsClient->search($params);
    }
 
    /**
     * 一次获取多个文档
     * @param $ids
     * @return array
     */
    public function getDocs($ids) {
        $params = [
            'index' => $this->index,
            'type' => $this->type,
            'body' => ['ids' => $ids]
        ];
        return $this->EsClient->mget($params);
    }
 
    /**
     * 获取单个文档
     * @param $id
     * @return array
     */
    public function getDoc($id) {
        $params = [
            'index' => $this->index,
            'type' => $this->type,
            'id' =>$id
        ];
        return $this->EsClient->get($params);
    }
 
    /**
     * 更新一个文档
     * @param $id
     * @return array
     */
    public function updateDoc($id) {
        $params = [
            'index' => $this->index,
            'type' => $this->type,
            'id' =>$id,
            'body' => [
                'doc' => [
                    'first_name' => '张',
                    'last_name' => '三',
                    'age' => 99
                ]
            ]
        ];
        return $this->EsClient->update($params);
    }
 
    /**
     * 添加一个文档到 Index 的Type中
     * @param array $body
     * @return void
     */
    public function putDoc($body = []) {
        $params = [
            'index' => $this->index,
            'type' => $this->type,
            // 'id' => 1, #可以手动指定id，也可以不指定随机生成
            'body' => $body
        ];
        $this->EsClient->index($params);
    }
 
    /**
     * 删除所有的 Index
     */
    public function delAllIndex() {
        $indexList = $this->esStatus()['indices'];
        foreach ($indexList as $item => $index) {
            $this->delIndex();
        }
    }
 
    /**
     * 获取 ES 的状态信息，包括index 列表
     * @return array
     */
    public function esStatus() {
        return $this->EsClient->indices()->stats();
    }
 
    /**
     * 创建一个索引 Index （非关系型数据库里面那个索引，而是关系型数据里面的数据库的意思）
     * @return void
     */
    public function createIndex() {
        $this->delIndex();
        $params = [
            'index' => $this->index,
            'body' => [
                'settings' => [
                    'number_of_shards' => 2,
                    'number_of_replicas' => 0
                ]
            ]
        ];
        $this->EsClient->indices()->create($params);
    }
 
    /**
     * 检查Index 是否存在
     * @return bool
     */
    public function checkIndexExists() {
        $params = [
            'index' => $this->index
        ];
        return $this->EsClient->indices()->exists($params);
    }
 
    /**
     * 删除一个Index
     * @return void
     */
    public function delIndex() {
        $params = [
            'index' => $this->index
        ];
        if ($this->checkIndexExists()) {
            $this->EsClient->indices()->delete($params);
        }
    }
 
    /**
     * 获取Index的文档模板信息
     * @return array
     */
    public function getMapping() {
        $params = [
            'index' => $this->index
        ];
        return $this->EsClient->indices()->getMapping($params);
    }
 
    /**
     * 创建文档模板
     * @return void
     */
    public function createMapping() {
        $this->createIndex();
        $params = [
            'index' => $this->index,
            'type' => $this->type,
            'body' => [
                $this->type => [
                    '_source' => [
                        'enabled' => true
                    ],
                    'properties' => [
                        'id' => [
                            'type' => 'integer'
                        ],
                        'first_name' => [
                            'type' => 'text',
                            'analyzer' => 'ik_max_word'
                        ],
                        'last_name' => [
                            'type' => 'text',
                            'analyzer' => 'ik_max_word'
                        ],
                        'age' => [
                            'type' => 'integer'
                        ]
                    ]
                ]
            ]
        ];
        $this->EsClient->indices()->putMapping($params);
        $this->generateDoc();
    }
}

PHP swoole 扩展下载地址

Github：https://github.com/swoole/swoole-src/tags

php官方扩展库：http://pecl.php.net/package/swoole

开源中国：http://git.oschina.net/swoole/swoole/tags

1、自定义安装

# 下载

wget https://pecl.php.net/get/swoole-4.3.3.tgz

# 解压

tar zxf swoole-4.3.3.tgz

# 编译安装扩展

# 进入目录

cd swoole-4.3.3 

# 执行phpize命令，产生出configure可执行文件
# 如果不知道phpize路径在哪里 可以使用which phpize查看相应路径

/usr/bin/phpize   

# 进行配置  如果不知道php-config路径在哪里 可以使用which php-config   查看相应路径

./configure --with-php-config=/usr/bin/php-config   

# 编译和安装

make && make install 

vi /etc/php.ini

复制如下代码

extension=swoole.so

放到你所打开或新建的文件中即可，无需重启任何服务

# 查看扩展是否安装成功

php -m|grep swoole

2、宝塔面板安装PHP swoole扩展

如果感觉上述安装较为复杂，可以使用宝塔面板实现一键安装

二、配置nginx反向代理

1、使用xshell连接远程阿里云服务器

2、使用命令（find / -name nginx.conf）查找nginx.conf所在的配置文件

find / -name nginx.conf

3、使用命令（vim /etc/nginx/nginx.conf）查找进入到vim编辑器

vim /etc/nginx/nginx.conf

查看到可以引入/etc/nginx/conf.d/下的配置文件信息

4、使用命令（cd /etc/nginx/conf.d/）进入到该路径下，并新建配置文件：study.lishuo.net.conf

5、配置nginx反向代理,实现访问study.lishuo.net域名转发端口号到127.0.0.1:9511也就是转发到webscoket运行的端口号

# 反向代理的规则 study 这个名字自己随便起
upstream study{
  server 127.0.0.1:9511;
}
server {
        listen       80;
        server_name  study.lishuo.net;
        error_page 404 /404.html;
        location = /404.html {
        }
        location / {
          index index.php index.html index.htm;
          if (!-e $request_filename) {
                rewrite  ^(.*)$  /index.php?s=/$1  last;
          }
        #wss配置
        client_max_body_size 100m;
        proxy_redirect off;
        proxy_set_header Host $host;# http请求的主机域名
        proxy_set_header X-Real-IP $remote_addr;# 远程真实IP地址
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;#反向代理之后转发之前的IP地址
        proxy_read_timeout 604800s;#websocket心跳时间，默认是60s
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "Upgrade";
        proxy_pass http://study;
       }
        error_page 500 502 503 504 /50x.html;
        location = /50x.html {
        }
         #添加下列信息，配置Nginx通过fastcgi方式处理您的PHP请求。
        location ~ .php$ {
            fastcgi_pass 127.0.0.1:9001;   #Nginx通过本机的9000端口将PHP请求转发给PHP-FPM进行处理。
            fastcgi_index index.php;
            fastcgi_param  SCRIPT_FILENAME  $document_root$fastcgi_script_name;
            include fastcgi_params;   #Nginx调用fastcgi接口处理PHP请求。
        }
    }

三、微信小程序socket合法域名配置

1、登录到微信开放平台https://mp.weixin.qq.com/

2、开发=>开发管理=>开发设置，完成合法域名设置

3、到此配置已经完成了，接下来就是功能实现了，微信小程序+PHP代码

四、效果演示和代码

1、小程序端代码

小程序页面代码所在路径 /pages/contact/contact.wxml

<!--pages/contact/contact.wxml-->

<view>

<scroll-view scroll-y scroll-into-view='{{toView}}' style='height: {{scrollHeight}};'>
  <!-- <view class='scrollMsg'> -->
  <block wx:key wx:for='{{msgList}}' wx:for-index="index">

    <!-- 单个消息1 客服发出（左） -->
    <view wx:if='{{item.speaker=="server"}}' id='msg-{{index}}' style='display: flex; padding: 2vw 11vw 2vw 2vw;'>
      <view style='width: 11vw; height: 11vw;'>
        <image style='width: 11vw; height: 11vw; border-radius: 10rpx;' src='https://cdn.pixabay.com/photo/2020/02/10/12/47/girl-4836394__340.jpg'></image>
      </view>
      <view style='width: 4vw; height: 11vw; margin-left: 0.5vw; display: flex; align-items: center; z-index: 9;'>
        <view class="triangle_border_left"></view>
      </view>
      <view class='leftMsg'>{{item.content}}</view>
    </view>

    <!-- 单个消息2 用户发出（右） -->
    <view wx:else id='msg-{{index}}' style='display: flex; justify-content: flex-end; padding: 2vw 2vw 2vw 11vw;'>
      <view class='rightMsg'>{{item.content}}</view>
      <view style='width: 4vw; height: 11vw; margin-right: 0.5vw; display: flex; align-items: center; z-index: 9;'>
        <view class="triangle_border_right"></view>
      </view>
      <view style='width: 11vw; height: 11vw;'>
        <image style='width: 11vw; height: 11vw; border-radius: 10rpx;' src='https://cdn.pixabay.com/photo/2021/09/24/10/00/chick-6652163__340.jpg'></image>
      </view>
    </view>

  </block>
  <!-- </view> -->

  <!-- 占位 -->
  <view style='width: 100%; height: 18vw;'></view>
</scroll-view>

<view class='inputRoom' style='bottom: {{inputBottom}}'>
  <image style='width: 7vw; margin-left: 3.2vw;' src='https://img95.699pic.com/element/40030/6429.png_300.png' mode='widthFix'></image>
  <input bindconfirm='sendClick' adjust-position='{{false}}' value='{{inputVal}}' confirm-type='send' bindfocus='focus' bindblur='blur'></input>
</view>
</view>

小程序页面样式代码所在路径 /pages/contact/contact.wxss

/* pages/contact/contact.wxss */

page {
  background-color: #f1f1f1;
}

.inputRoom {
  width: 100vw;
  height: 16vw;
  border-top: 1px solid #cdcdcd;
  background-color: #f1f1f1;
  position: fixed;
  bottom: 0;
  display: flex;
  align-items: center;
  z-index: 20;
}

input {
  width: 76vw;
  height: 9.33vw;
  background-color: #fff;
  border-radius: 40rpx;
  margin-left: 2vw;
  padding: 0 3vw;
  font-size: 28rpx;
  color: #444;
}

.leftMsg {
  font-size: 35rpx;
  color: #444;
  line-height: 7vw;
  padding: 2vw 2.5vw;
  background-color: #fff;
  margin-left: -1.6vw;
  border-radius: 10rpx;
  z-index: 10;
}

.rightMsg {
  font-size: 35rpx;
  color: #444;
  line-height: 7vw;
  padding: 2vw 2.5vw;
  background-color: #96EB6A;
  margin-right: -1.6vw;
  border-radius: 10rpx;
  z-index: 10;
}

 /*向左*/
 .triangle_border_left {
  width: 0;
  height: 0;
  border-width: 10px 30px 30px 0;
  border-style: solid;
  border-color: transparent #fff transparent transparent;
          /*透明       黄   透明        透明 */
  margin: 40px auto;
  position: relative;
}


        /*向右*/
        .triangle_border_right {
          width: 0;
          height: 0;
          border-width: 0px 30px 20px 13px;
          border-style: solid;
          border-color: transparent transparent transparent #96EB6A;
                  /*透明       透明        透明         黄*/
          margin: 40px auto;
          position: relative;
      }

小程序配置文件代码所在路径 /pages/contact/contact.json

{
  "navigationBarTitleText":"柯作客服",
  "usingComponents": {
  
  }
}

小程序业务逻辑代码所在路径 /pages/contact/contact.js

// pages/contact/contact.js
const app = getApp();
var inputVal = '';
var msgList = [];
var windowWidth = wx.getSystemInfoSync().windowWidth;
var windowHeight = wx.getSystemInfoSync().windowHeight;
var keyHeight = 0;

/**
 * 初始化数据
 */
function initData(that) {
  //输入框的内容
  inputVal = '';
  //消息列表，包含客服和用户的聊天内容
  msgList = [{
      speaker: 'server',
      contentType: 'text',
      content: 'Hi，亲爱的小主，终于等到您啦！欢迎来到柯作店铺，很荣幸为您服务。'
    },
    {
      speaker: 'customer',
      contentType: 'text',
      content: '你高兴的太早了'
    }
  ]
  that.setData({
    msgList,
    inputVal
  })
}

Page({
  /**
   * 页面的初始数据
   */
  data: {
    scrollHeight: '100vh',
    inputBottom: 0
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad: function(options) {
    //初始化websocket连接
    this.chat();
    //监听心跳的方法
    this.webSocketXin();
    //聊天方法
    initData(this);

    //监听消息
    wx.onSocketMessage(res=>{
         //追加到消息列表里
        msgList.push(JSON.parse(res.data))
        inputVal = '';
        this.setData({
          msgList,
          inputVal
        });
    })


  },
  //页面卸载时间
  onUnload(){
    wx.closeSocket();
  },
  /**
   * 获取聚焦
   */
  focus: function(e) {
    keyHeight = e.detail.height;
    this.setData({
      scrollHeight: (windowHeight - keyHeight) + 'px'
    });
    this.setData({
      toView: 'msg-' + (msgList.length - 1),
      inputBottom: keyHeight + 'px'
    })
    //计算msg高度
    // calScrollHeight(this, keyHeight);

  },

  //失去聚焦(软键盘消失)
  blur: function(e) {
    this.setData({
      scrollHeight: '100vh',
      inputBottom: 0
    })
    this.setData({
      toView: 'msg-' + (msgList.length - 1)
    })
  },

  /**
   * 发送点击监听
   */
  sendClick: function(e) {
    //客户发的信息
    let customerMsg = {
      uid: 10,
      speaker: 'customer',
      contentType: 'text',
      content: e.detail.value
    };

     //关闭心跳包
     this.webSocketXin(60000, false)
    //发送给websocket
    wx.sendSocketMessage({
      data: JSON.stringify(customerMsg),
      success:res=>{
        //重启心跳包
        this.webSocketXin(40000, true)
      }  
    })

    //追加到消息列表里
    msgList.push(customerMsg)
    inputVal = '';
    this.setData({
      msgList,
      inputVal
    });
  },
  /**
   * 退回上一页
   */
  toBackClick: function() {
    wx.navigateBack({})
  },
  /**
   * websocket
   */
  chat(){
     //进行连接php的socket
     wx.connectSocket({
       //wss 协议相当于你要有一个ssl证书，https
       //ws  就相当于不实用证书  http
      url: 'ws://study.lishuo.net',
      success: function () {
        console.log('websocket连接成功~')
      },
      fail: function () {
        console.log('websocket连接失败~')
      }
    })
  },


  /**
   * 监听websocket心跳连接的方法
   */
  webSocketXin(time=60000,status=true){
    var timing;
    if(status == true){
      timing = setInterval(function () {
        console.log("当前心跳已重新连接");
        //循环执行代码
        wx.sendSocketMessage({
          data: JSON.stringify({
            type: 'active'
          }),
          fail(res) {
            //关闭连接
            wx.closeSocket();
            //提示
            wx.showToast({
              title: '当前聊天已断开',
              icon:'none'
            })
            clearInterval(timing);
            console.log("当前心跳已关闭");
          }
        });
      }, time) //循环时间，注意不要超过1分钟  
    } else {
      //关闭定时器
      clearInterval(timing);
      console.log("当前心跳已关闭");
    }
  

  }



})

2、服务端代码（PHP代码）

wechat_websocket.php

<?php

//创建WebSocket Server对象，监听0.0.0.0:9502端口
$ws = new Swoole\WebSocket\Server('0.0.0.0', 9511);

//监听WebSocket连接打开事件
$ws->on('Open', function ($ws, $request) {
    echo $request->fd . '我连接上了';
});

//监听WebSocket消息事件
$ws->on('Message', function ($ws, $frame) {
    //把前台传过来的json字符串转成数组
    $params = json_decode($frame->data, true);
    //判断是否是心跳消息,如果是心跳消息
    if (isset($params['type']) && isset($params['type'])=='active'){
        echo '这是心跳监听消息';
    }else{
        //先判断当前用户有没有正在连接
        if (isset($params['uid']) && !empty($params['uid'] == 666)) {
            //去用户表查询当前用户  fd
            $fd = 2;
        } else {
            $fd = 1;
        }
        //客服id
        $ws->push($fd, json_encode($params, JSON_UNESCAPED_UNICODE));
    }
});

//监听WebSocket连接关闭事件
$ws->on('Close', function ($ws, $fd) {
    echo "client-{$fd} is closed\n";
});

$ws->start();

五、部署

1、把服务端代码上传到Linux操作系统里

2、然后切到该目录下进行运行php wechat_websocket.php

php wechat_websocket.php

插入数据

普通插入：

1. 采用批量插入（一次插入的数据不建议超过1000条）
2. 手动提交事务
3. 主键顺序插入

大批量插入：

如果一次性需要插入大批量数据，使用insert语句插入性能较低，此时可以使用MySQL数据库提供的load指令插入。

# 客户端连接服务端时，加上参数 --local-infile（这一行在bash/cmd界面输入）
mysql --local-infile -u root -p
# 设置全局参数local_infile为1，开启从本地加载文件导入数据的开关
set global local_infile = 1;
select @@local_infile;
# 执行load指令将准备好的数据，加载到表结构中
load data local infile '/root/sql1.log' into table 'tb_user' fields terminated by ',' lines terminated by '\n';

主键优化

数据组织方式：在InnoDB存储引擎中，表数据都是根据主键顺序组织存放的，这种存储方式的表称为索引组织表（Index organized table, IOT）

页分裂：页可以为空，也可以填充一半，也可以填充100%，每个页包含了2-N行数据（如果一行数据过大，会行溢出），根据主键排列。
页合并：当删除一行记录时，实际上记录并没有被物理删除，只是记录被标记（flaged）为删除并且它的空间变得允许被其他记录声明使用。当页中删除的记录到达 MERGE_THRESHOLD（默认为页的50%），InnoDB会开始寻找最靠近的页（前后）看看是否可以将这两个页合并以优化空间使用。

MERGE_THRESHOLD：合并页的阈值，可以自己设置，在创建表或创建索引时指定

主键设计原则：

• 满足业务需求的情况下，尽量降低主键的长度
• 插入数据时，尽量选择顺序插入，选择使用 AUTO_INCREMENT 自增主键
• 尽量不要使用 UUID 做主键或者是其他的自然主键，如身份证号
• 业务操作时，避免对主键的修改

order by优化

1. Using filesort：通过表的索引或全表扫描，读取满足条件的数据行，然后在排序缓冲区 sort buffer 中完成排序操作，所有不是通过索引直接返回排序结果的排序都叫 FileSort 排序
2. Using index：通过有序索引顺序扫描直接返回有序数据，这种情况即为 using index，不需要额外排序，操作效率高

如果order by字段全部使用升序排序或者降序排序，则都会走索引，但是如果一个字段升序排序，另一个字段降序排序，则不会走索引，explain的extra信息显示的是Using index, Using filesort，如果要优化掉Using filesort，则需要另外再创建一个索引，如：create index idx_user_age_phone_ad on tb_user(age asc, phone desc);，此时使用select id, age, phone from tb_user order by age asc, phone desc;会全部走索引

总结：

• 根据排序字段建立合适的索引，多字段排序时，也遵循最左前缀法则
• 尽量使用覆盖索引
• 多字段排序，一个升序一个降序，此时需要注意联合索引在创建时的规则（ASC/DESC）
• 如果不可避免出现filesort，大数据量排序时，可以适当增大排序缓冲区大小 sort_buffer_size（默认256k）

group by优化

• 在分组操作时，可以通过索引来提高效率
• 分组操作时，索引的使用也是满足最左前缀法则的

如索引为idx_user_pro_age_stat，则句式可以是select ... where profession order by age，这样也符合最左前缀法则

limit优化

常见的问题如limit 2000000, 10，此时需要 MySQL 排序前2000000条记录，但仅仅返回2000000 – 2000010的记录，其他记录丢弃，查询排序的代价非常大。
优化方案：一般分页查询时，通过创建覆盖索引能够比较好地提高性能，可以通过覆盖索引加子查询形式进行优化

例如：

-- 此语句耗时很长
select * from tb_sku limit 9000000, 10;
-- 通过覆盖索引加快速度，直接通过主键索引进行排序及查询
select id from tb_sku order by id limit 9000000, 10;
-- 下面的语句是错误的，因为 MySQL 不支持 in 里面使用 limit
-- select * from tb_sku where id in (select id from tb_sku order by id limit 9000000, 10);
-- 通过连表查询即可实现第一句的效果，并且能达到第二句的速度
select * from tb_sku as s, (select id from tb_sku order by id limit 9000000, 10) as a where s.id = a.id;

count优化

MyISAM 引擎把一个表的总行数存在了磁盘上，因此执行 count(*) 的时候会直接返回这个数，效率很高（前提是不适用where）；
InnoDB 在执行 count(*) 时，需要把数据一行一行地从引擎里面读出来，然后累计计数。
优化方案：自己计数，如创建key-value表存储在内存或硬盘，或者是用redis

count的几种用法：

• 如果count函数的参数（count里面写的那个字段）不是NULL（字段值不为NULL），累计值就加一，最后返回累计值
• 用法：count(*)、count(主键)、count(字段)、count(1)
• count(主键)跟count(*)一样，因为主键不能为空；count(字段)只计算字段值不为NULL的行；count(1)引擎会为每行添加一个1，然后就count这个1，返回结果也跟count(*)一样；count(null)返回0

各种用法的性能：

• count(主键)：InnoDB引擎会遍历整张表，把每行的主键id值都取出来，返回给服务层，服务层拿到主键后，直接按行进行累加（主键不可能为空）
• count(字段)：没有not null约束的话，InnoDB引擎会遍历整张表把每一行的字段值都取出来，返回给服务层，服务层判断是否为null，不为null，计数累加；有not null约束的话，InnoDB引擎会遍历整张表把每一行的字段值都取出来，返回给服务层，直接按行进行累加
• count(1)：InnoDB 引擎遍历整张表，但不取值。服务层对于返回的每一层，放一个数字 1 进去，直接按行进行累加
• count(*)：InnoDB 引擎并不会把全部字段取出来，而是专门做了优化，不取值，服务层直接按行进行累加

按效率排序：count(字段) < count(主键) < count(1) < count(*)，所以尽量使用 count(*)

update优化

避免行锁升级为表锁。InnoDB 的行锁是针对索引加的锁，不是针对记录加的锁，并且该索引不能失效，否则会从行锁升级为表锁。

如以下两条语句：
update student set no = '123' where id = 1;，这句由于id有主键索引，所以只会锁这一行；
update student set no = '123' where name = 'test';，这句由于name没有索引，所以会把整张表都锁住进行数据更新，解决方法是给name字段添加索引

视图

视图（View）是一种虚拟存在的表。视图中的数据并不在数据库中实际存在，行和列数据来自定义视图的查询中使用的表，并且是在使用视图时动态生成的。
通俗的讲，视图只保存了查询的SQL逻辑，不保存查询结果。所以我们在创建视图的时候，主要的工作就落在创建这条SQL查询语句上。

创建视图

CREATE [ OR REPLACE ] VIEW 视图名称[（列名列表）] AS SELECT 语句 [ WITH [ CASCADED | LOCAL ] CHECK OPTION ]
例子： create or replace view stu_v_1 as select id,name from student where id<=10;

查询视图

查看创建视图语句： SHOW CREATE VIEW 视图名称;

show create view stu_v_1;

查看视图数据：SELECT * FROM 视图名称;

修改视图

方式一：CREATE[OR REPLACE] VIEW 视图名称[（列名列表)）] AS SELECT 语句[ WITH[ CASCADED | LOCAL ] CHECK OPTION ]

方式二：ALTER VIEW 视图名称 [（列名列表)] AS SELECT语句 [WITH [CASCADED | LOCAL] CHECK OPTION]

删除视图

DROP VIEW [IF EXISTS] 视图名称 [视图名称]

视图检查选项

当使用WITH CHECK OPTION子句创建视图时，MySQL会通过视图检查正在更改的每个行，例如插入，更新，删除，以使其符合视图的定义。MySQL允许基于另一个视图创建视图，它还会检查依赖视图中的规则以保持一致性。为了确定检查的范围，mysql提供了两个选项：CASCADED 和 LOCAL ，默认值为 CASCADED。

（1）CASCADED

级联，一旦选择了这个选项，除了会检查创建视图时候的条件，还会检查所依赖视图的条件。

比如下面的例子：

创建stu_v_1 视图，id是小于等于 20的。
create or replace view stu_V_l as select id,name from student where id <=20;
再创建 stu_v_2 视图，20 >= id >=10。
create or replace view stu_v_2 as select id,name from stu_v_1 where id >=10 with cascaded check option;
再创建 stu_v_3 视图。
create or replace view stu_v_3 as select id,name from stu_v_2 where id<=15;

这条数据能够成功，stu_v_3 没有开检查选项所以不会 去判断 id 是否小于等于15, 直接检查 是否满足 stu_v_2。
insert into stu_v_3 values(17,'Tom');

（2）LOCAL

本地的条件也会检查，还会向上检查。在向上找的时候，就要看是否上面开了检查选项，如果没开就不检查。和 CASCADED 的区别就是 CASCADED 不管上面开没开检查选项都会进行检查。

更新及作用

要使视图可更新，视图中的行与基础表中的行之间必须存在一对一的关系。如果视图包含以下任何一项，则该视图不可更新

1. 聚合函数或窗口函数 ( SUM()、MIN()、MAX()、COUNT() 等 )
2. DISTINCT
3. GROUP BY
4. HAVING
5. UNION 或者UNION ALL

例子： 使用了聚合函数，插入会失败。
create view stu_v_count as select count(*) from student;
insert into stu_v_count values(10); #插入失败

作用

• 简单
  视图不仅可以简化用户对数据的理解，也可以简化他们的操作。那些被经常使用的查询可以被定义为视图，从而使得用户不必为以后的操作每次指定全部的条件。
• 安全
  数据库可以授权，但不能授权到数据库特定行和特定的列上。通过视图用户只能查询和修改他们所能见到的数据。
• 数据独立
  视图可帮助用户屏蔽真实表结构变化带来的影响。

总而言之 类似于给表加上了一个外壳，通过这个外壳访问表的时候，只能按照所设计的方式进行访问与更新。

存储过程

存储过程是事先经过编译并存储在数据库中的一段SQL 语句的集合，调用存储过程可以简化应用开发人员的很多工作，减少数据在数据库和应用服务器之间的传输，对于提高数据处理的效率是有好处的。 存储过程思想上很简单，就是数据库SQL 语言层面的代码封装与重用。

特点

• 封装，复用
• 可以接收参数，也可以返回数据
• 减少网络交互，效率提升

创建

CREATE PROCEDURE 存储过程名称( [参数列表] ) 

BEGIN

	 SQL 语句 

END;

注意：在命令行中，执行创建存储过程的SQL时，需要通过关键字delimiter 指定SQL语句的结束符。默认是分号作为结束符。例如：输入 delimiter $$ ，则 $$ 符作为结束符。

调用

CALL 名称 ([参数]);

查看

查询指定数据库的存储过程及状态信息
SELECT * FROM INFORMATION_SCHEMA.ROUTINES WHERE ROUTINE_SCHEMA = 'xxx(数据库名字)'

查询某个存储过程的定义
SHOW CREATE PROCEDURE 存储过程名称;

删除

DROP PROCEDURE [ IFEXISTS ] 存储过程名称

变量

（1）系统变量

系统变量是MySQL服务器提供，不是用户定义的，属于服务器层面。分为全局变量（GLOBAL）、会话变量（SESSION）。

查看系统变量

1. 查看所有系统变量
   SHOW [SESSION | GLOBAL] VARIABLES;
2. 可以通过LIKE模糊匹配方式查找变量
   SHOW [SESSION | GLOBAL] VARIABLES LIKE '......';
3. 查看指定变量的值
   SELECT @@[SESSION. | GLOBAL.]系统变量名;

设置系统变量

SET [SESSION | GLOBAL] 系统变量名 = 值;
SET @@[SESSION. | GLOBAL.]系统变量名 = 值;

注意：
如果没有指定SESSION/GLOBAL，默认是SESSION，会话变量。
mysql服务重新启动之后，所设置的全局参数会失效，要想不失效，可以在 /etc/my.cnf 中配置。

（2）用户自定义变量

用户自定义变量是用户根据需要自己定义的变量，用户变量不用提前声明，在用的时候直接用”@变量名”使用即可。其作用域为当前连接（当前会话）。

赋值

SET @var_name = expr[, @var_name = expr]...;
或
SET @var_name := expr[, @var_name := expr]...;

SELECT @var_name := expr [, @var_name := expr]...;
或
SELECT 字段名 INTO @var_name FROM 表名;

使用

SELECT @var_name;

注意：
用户定义的变量无需对其进行声明或初始化，只不过获取到的值为NULL。

（3）局部变量

局部变量是根据需要定义的在局部生效的变量，访问之前，需要DECLARE声明。可用作存储过程内的局部变量和输入参数，局部变量的范围是在其内声明的BEGIN ... END块。

声明

DECLARE 变量名 变量类型 [DEFAULT ...];

赋值

SET 变量名 = 值;
或
SET 变量名 := 值；
或
SELECT 字段名 INTO 变量名 FROM 表名 ...;
-- 例如：
create procedure p2()
begin
	declare stu_count int default 0;
	select count(*) from student;
	select stu_count;
end;

if 判断

语法：

IF 条件1 THEN
	...
ELSEIF 条件2 THEN
	...
ELSE
	...
END IF;

判断当前分数对应的分数等级
create procedure p3()
begin
	declare score int default 58;
	declare result varchar(10);
	
	if score >= 85 then
		set result := '优秀';
	elseif score >= 60 then
		set result := '及格';
	else
		set result := '不及格';
	end if;
	
	select result;
end;

参数（IN, OUT, INOUT）

用法：

CREATE PROCEDURE 存储过程名称([IN/OUT/INOUT 参数名 参数类型]) 

BEGIN

	 SQL 语句 

END;

1、根据传入的分数，判定对应等级，并返回

create procedure p4(in score int, out result varchar(20))
begin
	if score >= 85 then
		set result := '优秀'
	elseif score >= 60 then
		set result := '及格';
	else
		set result := '不及格';
	end if;
end;

call p4(68, @result); --调用，结果返回到自定义参数 @result 上

2、将传入200分制的分数，换算为百分制分数返回

create procedure p5(inout score double)
begin
	set score := score * 0.5;
end;

# 使用
set @score = 198; -- @score即作为输入传入数据，也作为输出接收数据
call p5(@score);
select @score;

case

语法一：

CASE case_value

	WHEN when_value1 THEN statement_list1
	[WHEN when_value2 THEN statement_list2] ...
	[ELSE statement_list]
	
END CASE;

语法二：

CASE
WHEN search_condition1 THEN statement_list1
[WHEN search_condition2 THEN statement_list2] …
[ELSE statemtent_list]
END CASE;

循环（while, repeat, loop）

（1）while

while循环是有条件的循环控制语句。满足条件后，再执行循环体中的SQL语句。具体语法为：

WHILE 条件 DO
	SQL逻辑...
END WHILE;

计算 1 累加到 n 的值，n 为输入的值

create procedure p7(in n int)
begin
	declare total int default 0;
  
	while n > 0 do
		set total := total + n;
		set n := n - 1;
	end while;

	select total;
end;

（2）repeat

repeat是有条件的循环控制语句，当满足条件的时候退出循环。具体语法为：

REPEAT
	SQL逻辑...
	UNTIL 条件
END REPEAT;

计算 1 累加到 n 的值，n 为输入的值

create procedure p8(in n int)
begin
   declare total int default 0;

   repeat
       set total := total + n;
       set n := n - 1;
       
       until n <= 0
   end repeat;
   
   select total;
end;

（3）loop

loop实现简单的循环，如果不在SQL逻辑中增加退出循环的条件，可以用其来实现死循环。loop 可以配合以下两个语句使用：

• LEAVE：配合循环使用，退出循环。（类似 break）
• ITERATE：必须用在循环中，作用是跳过当前循环剩下的语句，直接进入下一次循环。（类似 continue）

语法：

[begin_label:] LOOP
	SQL逻辑...
END LOOP [end_label];

LEAVE label;	-- 退出指定标记的循环体
ITERATE label;	-- 直接进入下一次循环

计算 1 到 n 之间的偶数累加和，n 为传入参数

create procedure p10(in n int)
begin
   declare total int default 0;

   sum: loop
       if n <= 0 then
           leave sum;
       end if;

       if n%2 = 1 then
           set n := n - 1;
           iterate sum;
       end if;

       set total := total + n;
       set n := n - 1;
   end loop sum;

   select total;
end;

游标

游标（CURSOR）是用来存储查询结果集的数据类型，在存储过程和函数中可以使用游标对结果集进行循环的处理。游标的使用包括游标的声明、OPEN、FETCH和CLOSE，其语法分别如下。

• 声明游标： DECLARE 游标名称 CURSOR FOR 查询语句;
• 打开游标： OPEN 游标名称;
• 获取游标记录： FETCH 游标名称 INTO 变量[,变量];
• 关闭游标：CLOSE 游标名称;

条件处理程序

条件处理程序（Handler）可以用来定义在流程控制结构执行过程中遇到问题时相应的处理步骤。具体语法为：
DECLARE handler_action HANDLER FOR condition_value [, condition_value]... statement;

handler_action:

CONTINUE：继续执行当前程序
EXIT：终止执行当前程序

condition_value:

SQLSTATE sqlstate_value：状态码，如02000
SQLWARNING：所有以01开头的SQLSTATE代码的简写
NOT FOUND：所有以02开头的SQLSTATE代码的简写
SQLEXCEPTION：所有没有被SQLWARNING或NOT FOUND捕获的SQLSTATE代码的简写

注意：要先声明普通变量，再申请游标。

要求：根据传入的参数uage，来查询用户表tb_user中，所有的用户年龄小于等于uage的用户姓名（name）和专业（profession），并将用户的姓名和专业插入到所创建的一张新表（id，name，profession）中。

create procedure p11(in uage int)
begin
	declare uname varchar(100); 
	decLare upro varchar(100);
	declare u_cursor cursor for select name,profession from tb_user where age <= uage; 

	# 当条件处理程序的处理的状态码为02000的时候，就会退出。
	declare exit handler for SQLSTATE '02000' close u_cursor;

	drop table if exists tb_user_pro; 

	create table if not exists tb_user_pro(
		id int primary key auto_increment, 
		name varchar(100), 
		profession varchar(100)
	);

	open u_cursor; 

	while true do 
		fetch u_cursor into uname, upro; 
		insert into tb_user_pro values(null, uname, upro); 
	end while;

	close u_cursor; 
end;

存储函数

存储函数是有返回值的存储过程，存储函数的参数只能是 IN 类型的。具体语法如下：

CREATE FUNCTION 存储函数名称([参数列表])
RETURNS type [characteristic ...]
BEGIN
	SQL语句
	RETURN ...;
END;	

characteristic 说明：

DETERMINISTIC：相同的输入参数总是产生相同的结果。
NO SQL：不包括SQL语句。
READS SQL DATA：包含读取数据的语句，但不包含写入数据的语句。

计算 1 累加到 n 的值，n 为输入的值

create function fun1(n int)
returns int deterministic
begin
    declare total int default 0;

    while n > 0 do
        set total := total + n;
        set n := n - 1;
    end while;

    return total;
end;

select fun1(10);	-- 查看函数返回值

触发器

触发器是与表有关的数据库对象，指在 insert/update/delete 之前或之后，触发并执行触发器中定义的SQL语句集合。触发器的这种特性可以协助应用在数据库端确保数据的完整性，日志记录，数据校验等操作。

使用别名 OLD 和 NEW 来引用触发器中发生变化的记录内容，这与其他的数据库是相似的。现在触发器还只支持行级触发（比如说 一条语句影响了 5 行 则会被触发 5 次），不支持语句级触发（比如说 一条语句影响了 5 行 则会被触发 1 次）。

创建触发器

CREATE TRIGGER trigger_name
BEFORE/AFTER INSERT/UPDATE/DELETE
ON table_name FOR EACH ROW	--行级触发器
BEGIN
	触发器的逻辑;
END;

查看触发器

SHOW TRIGGERS;

删除触发器

DROP TRIGGER [schema_name.]trigger_name; -- 如果没有指定 schema_name，默认为当前数据库

案例

需求： 通过触发器记录 user 表的数据变更日志(user_logs) , 包含增加, 修改 , 删除 ;

准备工作： 创建日志表 user_logs

create table user_logs (
	 id int(11) not null auto_increment,
	 operation varchar(20) not null comment '操作类型, insert/update/delete',
	 operate_time datetime not null comment '操作时间',
	 operate_id int(11) not null comment '操作的ID',
	 operate_params varchar(500) comment '操作参数',
	 primary key(`id`)
) engine=innodb default charset=utf8;

（1）insert 型

-- 插入数据触发器
create trigger tb_user_insert_trigger
    after insert on tb_user for each row
begin
    insert into user_logs(id, operation, operate_time, operate_id, operate_params) VALUES
    (null, 'insert', now(), new.id, concat('插入的数据内容为: id=',new.id,',name=',new.name, ', phone=', NEW.phone, ', email=', NEW.email, ', profession=', NEW.profession));
end;

（2）update 型

-- 修改数据触发器
create trigger tb_user_update_trigger
    after update on tb_user for each row
begin
    insert into user_logs(id, operation, operate_time, operate_id, operate_params) VALUES
    (null, 'update', now(), new.id,
        concat('更新之前的数据: id=',old.id,',name=',old.name, ', phone=', old.phone, ', email=', old.email, ', profession=', old.profession,
            ' | 更新之后的数据: id=',new.id,',name=',new.name, ', phone=', NEW.phone, ', email=', NEW.email, ', profession=', NEW.profession));
end;

（3）delete 型

-- 删除数据触发器
create trigger tb_user_delete_trigger
    after delete on tb_user for each row
begin
    insert into user_logs(id, operation, operate_time, operate_id, operate_params) VALUES
    (null, 'delete', now(), old.id,
        concat('删除之前的数据: id=',old.id,',name=',old.name, ', phone=', old.phone, ', email=', old.email, ', profession=', old.profession));
end;

锁

锁是计算机协调多个进程或线程并发访问某一资源的机制。在数据库中，除传统的计算资源（CPU、RAM、I/O）的争用以外，数据也是一种供许多用户共享的资源。如何保证数据并发访问的一致性、有效性是所有数据库必须解决的一个问题，锁冲突也是影响数据库并发访问性能的一个重要因素。从这个角度来说，锁对数据库而言显得尤其重要，也更加复杂。

分类：MySQL中的锁，按照锁的粒度分，分为以下三类：

1. 全局锁：锁定数据库中的所有表。
2. 表级锁：每次操作锁住整张表。
3. 行级锁：每次操作锁住对应的行数据。

全局锁

全局锁就是对整个数据库实例加锁，加锁后整个实例就处于只读状态，后续的DML的写语句，DDL语句，以及更新操作的事务提交语句都将被阻塞。

其典型的使用场景是做全库的逻辑备份，对所有的表进行锁定，从而获取一致性视图，保证数据的完整性。

数据库加全局锁，是一个比较重的操作，存在以下问题：
1、如果在主库上备份，那么在备份期间都不能执行更新，业务基本上就得停摆。
2、如果在从库上备份，那么在备份期间从库不能执行主库同步过来的二进制日志（binlog），会导致主从延迟。

在 InnoDB 引擎中，我们可以在备份时加上参数 --single-transaction 来完成不加锁的一致性数据备份。

表级锁

表级锁每次操作锁住整张表。锁定粒度大，发生锁冲突的概率最高，并发度最低。应用在MyISAM、InnoDB、BDB等存储引擎中。

对于表级锁，主要分为以下三类：

表锁： 对于表锁，分为两类：
– 1. 表共享读锁（read lock）所有的事务都只能读（当前加锁的客户端也只能读，不能写），不能写
– 2. 表独占写锁（write lock），对当前加锁的客户端，可读可写，对于其他的客户端，不可读也不可写。
读锁不会阻塞其他客户端的读，但是会阻塞写。写锁既会阻塞其他客户端的读，又会阻塞其他客户端的写。
语法：
1.加锁：lock tables 表名... read/write。
2.释放锁：unlock tables 或 客户端断开连接。

元数据锁:（meta data lock，MDL），MDL加锁过程是系统自动控制，无需显式使用，在访问一张表的时候会自动加上。MDL锁主要作用是维护表元数据的数据一致性，在表上有活动事务的时候，不可以对元数据进行写入操作。为了避免DML与DDL冲突，保证读写的正确性。
在MySQL5.5中引入了MDL，当对一张表进行增删改查的时候，加MDL读锁（共享）;当对表结构进行变更操作的时候，加MDL写锁（排他）。

查看元数据锁：
select object_type, object_schema, object_name, lock_type, lock_duration from performance_schema.metadata_locks;

意向锁: 为了避免DML在执行时，加的行锁与表锁的冲突，在InnoDB中引入了意向锁，使得表锁不用检查每行数据是否加锁，使用意向锁来减少表锁的检查。
一个客户端对某一行加上了行锁，那么系统也会对其加上一个意向锁，当别的客户端来想要对其加上表锁时，便会检查意向锁是否兼容，若是不兼容，便会阻塞直到意向锁释放。
分类：
– 1. 意向共享锁（IS）：由语句 select … lock in share mode 添加。
– 2. 意向排他锁（lX）：由 insert、update、delete、select … for update 添加。

意向锁兼容性：
– 1. 意向共享锁（IS）：与表锁共享锁（read）兼容，与表锁排它锁（write）互斥。
– 2. 意向排他锁（lX）：与表锁共享锁（read）及排它锁（write）都互斥。意向锁之间不会互斥。

查看意向锁和行级锁的加锁情况：

select object_schema, object_name, index_name, lock_type, lock_mode, lock_data from performance_schema.data_locks;

行级锁

行级锁每次操作锁住对应的行数据。锁定粒度最小，发生锁冲突的概率最低，并发度最高。应用在InnoDB存储引擎中。

InnoDB的数据是基于索引组织的，行锁是通过对索引上的索引项加锁来实现的，而不是对记录加的锁。对于行级锁，主要分为以下三类：

• 行锁（Record Lock）：锁定单个行记录的锁，防止其他事务对此行进行update和delete。在RC（read commit ）、RR（repeat read）隔离级别下都支持。
  
• 间隙锁（GapLock）：锁定索引记录间隙（不含该记录），确保索引记录间隙不变，防止其他事务在这个间隙进行insert，产生幻读。在RR隔离级别下都支持。比如说两个临近叶子节点为 12 16，那么间隙就是指 (12, 16)，锁的是这个间隙。
  
• 临键锁（Next-Key Lock）：行锁和间隙锁组合，同时锁住数据，并锁住数据前面的间隙Gap。在RR隔离级别下支持。

查看行级锁的加锁情况：

select object_schema, object_name, index_name, lock_type, lock_mode, lock_data from performance_schema.data_locks;

InnoDB实现了以下两种类型的行锁：

• 共享锁（S）：允许一个事务去读一行，阻止其他事务获得相同数据集的排它锁。
• 排他锁（X）：允许获取排他锁的事务更新数据，阻止其他事务获得相同数据集的共享锁和排他锁。

行锁说明：

默认情况下，InnoDB在REPEATABLE READ事务隔离级别运行，InnoDB使用 next-key 锁进行搜索和索引扫描，以防止幻读。

1. 针对唯一索引进行检索时，对已存在的记录进行等值匹配时，将会自动优化为行锁。
2. InnoDB的行锁是针对于索引加的锁，不通过索引条件检索数据，那么InnoDB将对表中的所有记录加锁，此时就会升级为表锁。

间隙锁/临键锁说明：

默认情况下，InnoDB在REPEATABLE READ事务隔离级别运行，InnoDB使用 next-key 锁进行搜索和索引扫描，以防止幻读。

1. 索引上的等值查询（唯一索引），给不存在的记录加锁时，优化为间隙锁。
2. 索引上的等值查询（普通索引），向右遍历时最后一个值不满足查询需求时，next-key lock 退化为间隙锁。
3. 索引上的范围查询（唯一索引）–会访问到不满足条件的第一个值为止。

注意：间隙锁唯一目的是防止其他事务插入间隙。间隙锁可以共存，一个事务采用的间隙锁不会阻止另一个事务在同一间隙上采用间隙锁。

为了深入研究 NativePHP，我决定将一个 Laravel 应用程序转换为桌面应用程序。为了让您更好地理解，让我们从基本设置开始。以下是应用程序的基本设置：后端由 Laravel 提供，前端由 React 提供，数据库由 MySQL 提供。

安装NativePHP

首先，我们使用 Composer 安装 NativePHP：

composer require nativephp/electron

这会将 NativePHP 添加到您的 Laravel 应用程序中，并通过一组新的 NativePHP 特定命令扩展 Laravel 的 artisan 工具。例如，您可以使用 php artisan native 命令来查看用于构建和管理本机应用程序的命令列表。

接下来，运行 php artisan native:install 命令会建立基本结构。

其中两个文件特别值得注意：

• config/nativephp.php 用于应用程序配置。
• app/Providers/NativeAppServiceProvider.php 用于启动顺序和注册本机组件。

开发构建

设置应用程序后，我们就可以开始开发构建了。

php artisan native:serve &
npm run dev &

这将启动 PHP 和 UI 的开发服务器。在本例中，npm 使用 Vite 构建 UI 组件并将其提供给 Electron 窗口。

NativePHP 将应用程序与 Electron 捆绑在一起，并嵌入了 PHP 解释器。在开发过程中，它将后端切换到本地 SQLite 数据库。因此，我们需要运行迁移命令 php artisan native:migrate 来设置新数据库。

添加本机功能

为了增强桌面体验，NativePHP 支持集成本机元素，例如通知、菜单栏和热键。您可以在文档页面中查看完整的元素列表。

我通过编辑 app/Providers/NativeAppServiceProvider.php，在应用程序启动时添加了一个简单的通知。这有助于我们为应用程序提供原生感觉。

首先，我们添加通知外观：

use Native\Laravel\Facades\Notification;

然后，在 boot() 函数中，我添加以下行，在窗口打开后显示通知：

Notification::title('Application Started')
    ->message('This message is coming from NativePHP running on Electron')
    ->show();

保存后，热重载功能应该重新启动应用程序并显示通知。如果您没有看到通知，请检查您是否已启用来自 Electron 的通知。

构建发布

对于生产环境的构建，您需要在 config/nativephp.php 文件中填写发布详细信息。请注意，环境文件 (.env) 将被捆绑在构建中，因此您需要使用 cleanup_env_keys 方法来清理敏感数据。

要为您的操作系统构建版本，请运行以下命令：

php artisan native:build

此过程将生成各种捆绑包，包括 DMG、Zip 文件和应用程序的二进制文件。

我们还可以使用以下命令来构建 Windows 和 Linux 捆绑包：

php artisan native:build win
php artisan native:build linux

构建过程完成后，您将获得以下文件：

• setup.exe（Windows 安装程序）
• AppImage（Linux 应用程序）
• .deb（Linux 软件包）

NativePHP 的注意事项

在深入研究 NativePHP 之前，请注意以下事项：

• Alpha 阶段：NativePHP 仍处于 alpha 阶段，因此可能存在缺陷或不稳定性。
• Laravel 框架：NativePHP 专为 Laravel 设计，虽然与其他 PHP 框架兼容，但可能存在兼容性问题。
• 数据库限制：NativePHP 仅支持本地 SQLite 数据库，在构建时将替换现有的数据库设置。
• 交叉编译限制：NativePHP 支持针对不同操作系统进行构建，但不支持跨架构构建。例如，在 Apple M1上构建的二进制文件无法在大多数 Linux 和 – Windows 机器上运行。解决方法是使用不同的机器或 CI/CD 管道进行构建。

NativePHP 是一款新兴的框架，可帮助 PHP 开发人员构建原生桌面应用程序。它仍处于 alpha 阶段，但具有很大的潜力。如果您热衷于 PHP 开发，NativePHP 值得您关注。