编程 on Yison's Blog

何以服务熔断及负载均衡

Sun, 29 Aug 2021 00:00:00 +0000

本文是个人在学习书籍《Go 语言高并发与微服务实战》第10章内容过程中，动手做的小实验，涉及 Hystrix 相关知识，仅供参考。

服务熔断机制

三种状态

┌─────────────────────────────────────────────────────────────┐
│ 熔断器状态机 │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────┐ 失败率超过阈值 ┌──────────┐ │
│ │ CLOSED │ ───────────────────────▶│ OPEN │ │
│ │ 关闭 │ │ 打开 │ │
│ └──────────┘ └────┬─────┘ │
│ ▲ │ │
│ │ │ 超时后 │
│ │ 检测成功 │ 半开 │
│ │ ▼ │
│ │ ┌──────────┐ │
│ └──────────────────────────────│HALF-OPEN │ │
│ 恢复关闭 │ 半开 │ │
│ └──────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘

状态	说明
Closed（关闭）	正常状态，请求正常通过；失败达到阈值时切换到 Open
Open（打开）	熔断状态，所有请求直接失败，快速返回
Half-Open（半开）	尝试恢复状态，放行部分请求；成功则关闭，失败则重新打开

Hystrix 配置参数

参数	默认值	说明
`sleepWindow`	5000ms	熔断打开后多久尝试半开
`requestVolumeThreshold`	20	熔断器打开的最小请求数
`errorPercentThreshold`	50%	错误百分比阈值
`maxConcurrentRequests`	10	最大并发请求数

负载均衡算法

常见算法

算法	说明	适用场景
随机	随机选择服务实例	请求较少、无状态服务
轮询（Round Robin）	依次选择每个实例	请求均匀、实例性能相近
加权轮询	按权重比例分配请求	实例性能不均
Hash	根据请求特征 Hash	会话保持、缓存友好
一致性 Hash	环状 Hash 分布	分布式缓存
最小连接数	选择连接数最少的	长连接服务

一致性 Hash 原理

 ┌─────────────┐
 │ 节点 A │◀── Hash(A)
 ┌───────────│ 192.168.1.1│
 │ └─────────────┘
 │ ▲
 │ │ 顺时针找
 Hash环 │ 最近的节点
 │ │
 ▼ │
┌───────────────┐ │
│ 节点 C │───────────┘
│ 192.168.1.3 │◀── Hash(C)
└───────────────┘
 ▲
 │
 │
┌───────────────┐
│ 节点 B │
│ 192.168.1.2 │◀── Hash(B)
└───────────────┘

Hystrix Go 使用

安装

go get github.com/afex/hystrix-go/hystrix

基本用法

package main

import (
 "fmt"
 "time"
 
 "github.com/afex/hystrix-go/hystrix"
)

func main() {
 // 配置 Command
 hystrix.ConfigureCommand("my_command", hystrix.CommandConfig{
 Timeout: 1000, // 超时时间 ms
 MaxConcurrentRequests: 10, // 最大并发数
 SleepWindow: 5000, // 熔断后尝试恢复的时间
 RequestVolumeThreshold: 20, // 熔断器打开的最小请求数
 ErrorPercentThreshold: 50, // 错误百分比阈值
 })
 
 // 使用熔断器执行
 err := hystrix.Do("my_command", func() error {
 // 这里是实际要执行的业务逻辑
 return callService()
 }, func(err error) error {
 // 这里是降级处理
 fmt.Println("服务调用失败，执行降级逻辑")
 return fallback()
 })
 
 if err != nil {
 fmt.Println("请求失败:", err)
 }
}

func callService() error {
 // 模拟服务调用
 time.Sleep(100 * time.Millisecond)
 return nil
}

func fallback() error {
 // 降级逻辑
 fmt.Println("执行降级返回")
 return nil
}

异步调用

// 返回 chan
resultChan := make(chan string, 1)
errorChan := hystrix.Go("my_command", func() error {
 // 异步执行
 go func() {
 result, _ := callServiceAsync()
 resultChan <- result
 }()
 return nil
}, nil)

// 等待结果
select {
case result := <-resultChan:
 fmt.Println("结果:", result)
case <-time.After(time.Second * 5):
 fmt.Println("超时")
}

监控

import "github.com/afex/hystrix-go/hystrix/metric_collector"

func init() {
 // 开启监控
 hystrix.RegisterReporter("console", &HystrixConsoleReporter{})
}

完整示例：微服务调用

服务端（string-service）

// service/main.go
package main

import (
 "flag"
 "fmt"
 "log"
 "net/http"
 "time"
)

var port = flag.Int("port", 10086, "service port")

func main() {
 flag.Parse()
 
 http.HandleFunc("/echo", func(w http.ResponseWriter, r *http.Request) {
 msg := r.URL.Query().Get("msg")
 fmt.Printf("收到请求: %s\n", msg)
 time.Sleep(time.Millisecond * 100)
 w.Write([]byte("响应: " + msg))
 })
 
 log.Printf("服务启动，端口: %d", *port)
 log.Fatal(http.ListenAndServe(fmt.Sprintf(":%d", *port), nil))
}

客户端（带熔断）

// client/main.go
package main

import (
 "flag"
 "fmt"
 "io/ioutil"
 "log"
 "net/http"
 "strings"
 "time"
 
 "github.com/afex/hystrix-go/hystrix"
)

var (
 servicePort = flag.Int("port", 10086, "service port")
 serviceHost = flag.String("host", "localhost", "service host")
)

func main() {
 flag.Parse()
 
 // 配置熔断器
 hystrix.ConfigureCommand("string_service", hystrix.CommandConfig{
 Timeout: 1000,
 MaxConcurrentRequests: 10,
 SleepWindow: 5000,
 RequestVolumeThreshold: 5,
 ErrorPercentThreshold: 40,
 })
 
 // 模拟多次请求
 for i := 0; i < 20; i++ {
 err := hystrix.Do("string_service", func() error {
 return callService(fmt.Sprintf("请求 %d", i))
 }, func(err error) error {
 fmt.Printf("降级处理: %v\n", err)
 return nil
 })
 
 if err != nil {
 fmt.Printf("第 %d 次请求失败: %v\n", i, err)
 }
 
 time.Sleep(200 * time.Millisecond)
 }
}

func callService(msg string) error {
 url := fmt.Sprintf("http://%s:%d/echo?msg=%s", 
 *serviceHost, *servicePort, strings.TrimSpace(msg))
 
 resp, err := http.Get(url)
 if err != nil {
 return err
 }
 defer resp.Body.Close()
 
 body, _ := ioutil.ReadAll(resp.Body)
 log.Printf("响应: %s", string(body))
 return nil
}

运行示例

# 1. 启动 Consul（服务发现）
consul agent -dev

# 2. 启动多个服务实例
go run service/main.go -port 10086
go run service/main.go -port 10089

# 3. 启动客户端
go run client/main.go

# 4. 人为制造失败（例如停掉下游服务）观察熔断打开与降级日志，再恢复服务确认 Half-Open 恢复

熔断与负载均衡往往一起出现：负载均衡决定请求打到哪台实例，熔断在实例不健康时快速失败并触发降级，避免线程与连接池被拖垮。结合服务发现（Consul / K8s Endpoints）可在实例上下线时自动更新负载均衡目标。

跟我一起玩微服务网关

Thu, 26 Aug 2021 00:00:00 +0000

本文是个人在学习书籍《Go 语言高并发与微服务实战》第9章内容过程中，动手做的小实验，涉及 Consul、go-kit、Kong、JWT、Zipkin 相关知识。

微服务网关概述

┌─────────────────────────────────────────────────────────────┐
│ 微服务网关架构 │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ API Gateway │ │
│ ├──────────────────────────────────────────────────────┤ │
│ │ 路由转发 │ 负载均衡 │ 限流熔断 │ 认证鉴权 │ 监控日志 │ │
│ └──────────────────────────────────────────────────────┘ │
│ │ │
│ ┌──────────┬───────────┼───────────┬──────────┐ │
│ │ │ │ │ │ │
│ ▼ ▼ ▼ ▼ ▼ │
│ ┌─────────┐┌─────────┐┌─────────┐┌─────────┐┌─────────┐ │
│ │User Svc ││Order Svc││Product ││Payment ││Search │ │
│ │ ││ ││Service ││Service ││Service │ │
│ └─────────┘└─────────┘└─────────┘└─────────┘└─────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘

网关核心功能

功能	说明
路由转发	根据请求路径转发到后端服务
负载均衡	多实例流量分发
限流熔断	保护后端服务
认证鉴权	JWT/Session 验证
监控日志	请求追踪和日志记录

简易网关 Go 实现

项目结构

gateway/
├── main.go # 主程序
├── proxy.go # 反向代理
├── discovery.go # 服务发现
├── limiter.go # 限流器
├── circuitbreaker.go # 熔断器
└── auth.go # 认证中间件

主程序

// gateway/main.go
package main

import (
 "flag"
 "fmt"
 "log"
 "math/rand"
 "net/http"
 "net/http/httputil"
 "os"
 "os/signal"
 "strings"
 "syscall"
 "time"
 
 "github.com/go-kit/kit/log"
 "github.com/hashicorp/consul/api"
)

func main() {
 // 解析命令行参数
 var (
 consulHost = flag.String("consul.host", "127.0.0.1", "consul server host")
 consulPort = flag.String("consul.port", "8500", "consul server port")
 gatewayPort = flag.String("gateway.port", "9090", "gateway port")
 )
 flag.Parse()
 
 // 创建日志组件
 var logger log.Logger
 {
 logger = log.NewLogfmtLogger(os.Stderr)
 logger = log.With(logger, "ts", log.DefaultTimestampUTC)
 logger = log.With(logger, "caller", log.DefaultCaller)
 }
 
 // 创建 Consul 客户端
 consulConfig := api.DefaultConfig()
 consulConfig.Address = fmt.Sprintf("http://%s:%s", *consulHost, *consulPort)
 consulClient, err := api.NewClient(consulConfig)
 if err != nil {
 logger.Log("err", err)
 os.Exit(1)
 }
 
 // 创建处理器
 discovery := NewDiscovery(consulClient, logger)
 handler := NewProxyHandler(discovery, logger)
 
 // 创建 HTTP 服务器
 server := &http.Server{
 Addr: fmt.Sprintf(":%s", *gatewayPort),
 Handler: handler,
 }
 
 // 启动服务器
 go func() {
 logger.Log("gateway", "starting", "port", *gatewayPort)
 if err := server.ListenAndServe(); err != nil {
 logger.Log("gateway", "exit", "err", err)
 }
 }()
 
 // 优雅退出
 ch := make(chan os.Signal, 1)
 signal.Notify(ch, syscall.SIGINT, syscall.SIGTERM)
 logger.Log("signal", <-ch)
 
 ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 defer cancel()
 
 if err := server.Shutdown(ctx); err != nil {
 logger.Log("shutdown", err)
 }
}

服务发现

// gateway/discovery.go
package main

import (
 "context"
 "github.com/go-kit/kit/log"
 "github.com/hashicorp/consul/api"
 "math/rand"
)

type Discovery struct {
 client consul.Client
 logger log.Logger
}

func NewDiscovery(client consul.Client, logger log.Logger) *Discovery {
 return &Discovery{
 client: client,
 logger: logger,
 }
}

// GetService 获取服务实例
func (d *Discovery) GetService(ctx context.Context, serviceName string) (*api.ServiceEntry, error) {
 entries, _, err := d.client.Health().Service(serviceName, "", true, nil)
 if err != nil {
 return nil, err
 }
 
 if len(entries) == 0 {
 return nil, fmt.Errorf("no available instances for %s", serviceName)
 }
 
 // 负载均衡：随机选择
 index := rand.Intn(len(entries))
 return &entries[index], nil
}

// GetServices 获取所有服务实例
func (d *Discovery) GetServices(ctx context.Context, serviceName string) ([]*api.ServiceEntry, error) {
 entries, _, err := d.client.Health().Service(serviceName, "", true, nil)
 if err != nil {
 return nil, err
 }
 return entries, nil
}

反向代理

// gateway/proxy.go
package main

import (
 "context"
 "fmt"
 "github.com/go-kit/kit/log"
 "net/http"
 "net/http/httputil"
 "strings"
)

type ProxyHandler struct {
 discovery *Discovery
 logger log.Logger
}

func NewProxyHandler(discovery *Discovery, logger log.Logger) *ProxyHandler {
 return &ProxyHandler{
 discovery: discovery,
 logger: logger,
 }
}

func (h *ProxyHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 // 解析请求路径：/service-name/path
 path := r.URL.Path
 parts := strings.SplitN(path, "/", 3)
 if len(parts) < 3 {
 http.Error(w, "invalid path", http.StatusBadRequest)
 return
 }
 
 serviceName := parts[1]
 targetPath := "/" + parts[2]
 
 // 获取服务实例
 instance, err := h.discovery.GetService(r.Context(), serviceName)
 if err != nil {
 h.logger.Log("service", serviceName, "err", err)
 http.Error(w, "service unavailable", http.StatusServiceUnavailable)
 return
 }
 
 // 构建代理请求
 targetURL := fmt.Sprintf("http://%s:%d%s", 
 instance.Service.Address, 
 instance.Service.Port, 
 targetPath)
 
 proxyReq, err := http.NewRequest(r.Method, targetURL, r.Body)
 if err != nil {
 http.Error(w, "proxy error", http.StatusInternalServerError)
 return
 }
 
 // 复制请求头
 for key, values := range r.Header {
 for _, value := range values {
 proxyReq.Header.Add(key, value)
 }
 }
 
 // 执行代理
 client := &http.Client{}
 resp, err := client.Do(proxyReq)
 if err != nil {
 h.logger.Log("proxy", err)
 http.Error(w, "proxy error", http.StatusBadGateway)
 return
 }
 defer resp.Body.Close()
 
 // 复制响应
 for key, values := range resp.Header {
 for _, value := range values {
 w.Header().Add(key, value)
 }
 }
 w.WriteHeader(resp.StatusCode)
 w.Write([]byte(fmt.Sprintf("Proxy to: %s", targetURL)))
}

// 反向代理实现
func newSingleHostReverseProxy(target string) *httputil.ReverseProxy {
 return httputil.NewSingleHostReverseProxy(target)
}

Kong 网关

Kong 简介

Kong 是一个云原生、可扩展、统一 API 层（API Gateway）。

Docker 部署

下面给出「单机演示」的常见步骤：创建网络 → 启动数据库 → （按所用 Kong 镜像文档执行）数据库迁移 → 启动 Kong。具体镜像名与启动参数请以你选用的 Kong 发行版 README 为准，不同主版本 CLI 与环境变量略有差异。

docker network create kong-net

docker run -d --name kong-db \
 --network kong-net \
 -p 5432:5432 \
 -e POSTGRES_USER=kong \
 -e POSTGRES_PASSWORD=kong \
 -e POSTGRES_DB=kong \
 postgres:13

# 数据库就绪后，在同一网络内执行 kong migrations bootstrap（命令随镜像而异），再启动 kong 网关与管理端口。
# 典型端口：8000（代理）、8443（HTTPS）、8001（Admin API）。正式环境请改用编排模板并开启 TLS / RBAC。

本地体验也可使用 Kong Ingress Controller（Kubernetes）或云端托管网关服务；本节重点在于：网关前面负责 TLS、路由、插件（鉴权、限流、熔断），后面的微服务仍可沿用前文自定义代理或 Istio Linkerd 等服务网格。

小结

网关层把「路由、观测、防护」收口在一处：开发阶段可用 Nginx / 手写反向代理入门，业务量上升后再引入 Kong / APISIX / Envoy 等平台化能力。

GO与Websocket

Sun, 25 Jul 2021 00:00:00 +0000

本文介绍 WebSocket 协议的原理，以及如何使用 Go 语言实现 WebSocket 实时通信功能。

解决什么问题

WebSocket 是 HTML5 下一种新的协议。它实现了浏览器与服务器全双工通信，能更好的节省服务器资源和带宽并达到实时通讯的目的。

WebSocket 使得客户端和服务器之间的数据交换变得更加简单，允许服务端主动向客户端推送数据。在 WebSocket API 中，浏览器和服务器只需要完成一次握手，两者之间就直接可以创建持久性的连接，并进行双向数据传输。

现在，很多网站为了实现推送技术，所用的技术都是 Ajax 轮询。轮询是在特定的的时间间隔（如每1秒），由浏览器对服务器发出 HTTP 请求，然后由服务器返回最新的数据给客户端的浏览器。这种传统的模式带来很明显的缺点，即浏览器需要不断的向服务器发出请求，然而 HTTP 请求可能包含较长的头部，其中真正有效的数据可能只是很小的一部分，显然这样会浪费很多的带宽等资源。

HTML5 定义的 WebSocket 协议，能更好的节省服务器资源和带宽，并且能够更实时地进行通讯。

WebSocket 与 TCP、HTTP 的关系

WebSocket 与 HTTP 协议一样都是基于 TCP 的，所以他们都是可靠的协议。WebSocket 和 HTTP 协议一样都属于应用层的协议，WebSocket 在建立握手连接时，数据是通过 HTTP 协议传输的，但是在建立连接之后，真正的数据传输阶段是不需要 HTTP 协议参与的。

┌─────────────────────────────────────────────────────────┐
│ 应用层 │
│ ┌─────────────┐ ┌─────────────┐ │
│ │ HTTP │ │ WebSocket │ │
│ └──────┬──────┘ └──────┬──────┘ │
│ │ │ │
│ ┌──────▼──────┐ ┌──────▼──────┐ │
│ │ TLS/SSL │ │ TLS │ │
│ └──────┬──────┘ └──────┬──────┘ │
│ │ │ │
│ ┌──────▼────────────────────────────▼──────┐ │
│ │ TCP │ │
│ └─────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────┘

分层架构

┌────────────────────────────────────────┐
│ WebSocket 协议 │
│ ├── 握手层（HTTP Upgrade） │
│ ├── 帧解析层（Frame Parsing） │
│ └── 数据传输层（Message Handling） │
├────────────────────────────────────────┤
│ Go 标准库 / Gorilla │
│ ├── gorilla/websocket │
│ └── golang.org/x/net/websocket │
└────────────────────────────────────────┘

了解 Socket 原理

WebSocket 握手过程

客户端发送握手请求

GET /ws HTTP/1.1
Host: localhost:8080
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
Sec-WebSocket-Version: 13

服务器响应握手

HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=

握手完成后开始双向通信

Go 中使用 gorilla/websocket

package main

import (
 "fmt"
 "log"
 "net/http"
 "github.com/gorilla/websocket"
)

var upgrader = websocket.Upgrader{
 ReadBufferSize: 1024,
 WriteBufferSize: 1024,
 CheckOrigin: func(r *http.Request) bool {
 return true // 生产环境应做 origin 检查
 },
}

func wsHandler(w http.ResponseWriter, r *http.Request) {
 // 升级 HTTP 连接为 WebSocket
 conn, err := upgrader.Upgrade(w, r, nil)
 if err != nil {
 log.Println("upgrade failed:", err)
 return
 }
 defer conn.Close()

 // 读取消息
 for {
 messageType, msg, err := conn.ReadMessage()
 if err != nil {
 log.Println("read failed:", err)
 break
 }
 log.Printf("received: %s", msg)

 // 发送消息
 err = conn.WriteMessage(messageType, msg)
 if err != nil {
 log.Println("write failed:", err)
 break
 }
 }
}

func main() {
 http.HandleFunc("/ws", wsHandler)
 fmt.Println("WebSocket server started at :8080")
 log.Fatal(http.ListenAndServe(":8080", nil))
}

最基本的 Demo

前端代码

<!DOCTYPE html>
<html>
<head>
 <title>WebSocket Demo</title>
</head>
<body>
 <h2>WebSocket Client</h2>
 <input type="text" id="message" placeholder="输入消息">
 <button onclick="sendMessage()">发送</button>
 <div id="output"></div>

 <script>
 const ws = new WebSocket("ws://localhost:8080/ws");

 ws.onopen = () => {
 console.log("Connected to WebSocket");
 addMessage("已连接服务器");
 };

 ws.onmessage = (event) => {
 addMessage("收到: " + event.data);
 };

 ws.onclose = () => {
 addMessage("连接已关闭");
 };

 function sendMessage() {
 const msg = document.getElementById("message").value;
 ws.send(msg);
 addMessage("发送: " + msg);
 }

 function addMessage(msg) {
 document.getElementById("output").innerHTML += 
 "<p>" + msg + "</p>";
 }
 </script>
</body>
</html>

运行步骤

# 1. 安装依赖
go get github.com/gorilla/websocket

# 2. 运行服务器
go run server.go

# 3. 浏览器打开 index.html

功能升级你需要了解的

1. 心跳机制

保持连接活跃，防止被中间设备断开：

// 心跳 Ping-Pong
type Hub struct {
 clients map[*websocket.Conn]bool
 broadcast chan []byte
 register chan *websocket.Conn
 unregister chan *websocket.Conn
}

func (h *Hub) readPump(conn *websocket.Conn) {
 defer func() {
 h.unregister <- conn
 conn.Close()
 }()
 
 conn.SetReadDeadline(time.Now().Add(60 * time.Second))
 conn.SetPongHandler(func(string) error {
 conn.SetReadDeadline(time.Now().Add(60 * time.Second))
 return nil
 })
 
 for {
 _, msg, err := conn.ReadMessage()
 if err != nil {
 break
 }
 h.broadcast <- msg
 }
}

func (h *Hub) writePump(conn *websocket.Conn) {
 ticker := time.NewTicker(30 * time.Second)
 defer func() {
 ticker.Stop()
 conn.Close()
 }()
 
 for {
 select {
 case <-ticker.C:
 conn.SetWriteDeadline(time.Now().Add(10 * time.Second))
 if err := conn.WriteMessage(websocket.PingMessage, nil); err != nil {
 return
 }
 }
 }
}

2. 断线重连

function connect() {
 ws = new WebSocket("ws://localhost:8080/ws");
 
 ws.onclose = () => {
 console.log("Connection closed, reconnecting...");
 setTimeout(connect, 3000); // 3秒后重连
 };
}

3. 消息类型

// 文本消息
websocket.TextMessage

// 二进制消息
websocket.BinaryMessage

// Ping 消息
websocket.PingMessage

// Pong 消息
websocket.PongMessage

// 关闭消息
websocket.CloseMessage

总结

WebSocket 实现了真正的全双工通信
基于 HTTP 握手协议建立连接
Go 语言通过 gorilla/websocket 库可以轻松实现 WebSocket 服务
生产环境需要考虑：心跳机制、断线重连、安全认证等

参考资料

微服务配置中心小实验

Sun, 25 Jul 2021 00:00:00 +0000

本文是个人在学习书籍《Go 语言高并发与微服务实战》第8章内容过程中，动手做的小实验，涉及 Spring Cloud Config 和 YAML 相关知识。

配置中心概念

┌─────────────────────────────────────────────────────────────┐
│ 配置中心架构 │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────────┐ │
│ │ 配置中心 │ │
│ │ Config Server│◀──── Git/SVN/Nacos │
│ └──────┬───────┘ │
│ │ │
│ │ 拉取/推送 │
│ ▼ │
│ ┌─────────────────────────────────────────┐ │
│ │ 微服务集群 │ │
│ │ ┌─────────┐ ┌─────────┐ ┌─────────┐│ │
│ │ │Service A│ │Service B│ │Service C││ │
│ │ └─────────┘ └─────────┘ └─────────┘│ │
│ └─────────────────────────────────────────┘ │
│ │
│ 特性： │
│ • 配置集中管理 │
│ • 配置热更新 │
│ • 环境隔离（dev/staging/prod） │
│ • 版本控制 │
│ │
└─────────────────────────────────────────────────────────────┘

Spring Cloud Config 简介

Spring Cloud Config 为分布式系统的外部配置提供了服务端和客户端支持。

核心特性

特性	说明
配置集中管理	所有配置存储在 Git 仓库
环境隔离	dev、test、prod 环境分离
配置加密	支持敏感配置加密存储
动态刷新	无需重启即可更新配置
高可用	支持集群部署

准备 Spring Boot 环境

macOS 安装

# 使用 Homebrew 安装
brew tap spring-io/tap
brew install spring-boot

# 或安装 Spring CLI
brew install springboot

快速开始

创建 app.groovy：

@RestController
class ThisWillActuallyRun {
 @RequestMapping("/")
 String home() {
 "Hello World!"
 }
}

运行：

spring run app.groovy

创建配置中心服务端

项目结构

config-server/
├── pom.xml
├── src/main/java/com/example/configserver/
│ └── ConfigServerApplication.java
└── config/
 └── application.yml

Maven 依赖 (pom.xml)

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 <modelVersion>4.0.0</modelVersion>
 
 <parent>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-parent</artifactId>
 <version>2.5.2</version>
 </parent>
 
 <dependencies>
 <!-- Spring Cloud Config Server -->
 <dependency>
 <groupId>org.springframework.cloud</groupId>
 <artifactId>spring-cloud-config-server</artifactId>
 </dependency>
 
 <!-- Eureka 服务发现（可选）-->
 <dependency>
 <groupId>org.springframework.cloud</groupId>
 <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
 </dependency>
 </dependencies>
 
 <dependencyManagement>
 <dependencies>
 <dependency>
 <groupId>org.springframework.cloud</groupId>
 <artifactId>spring-cloud-dependencies</artifactId>
 <version>2020.0.2</version>
 <type>pom</type>
 <scope>import</scope>
 </dependency>
 </dependencies>
 </dependencyManagement>
</project>

启动类

@SpringBootApplication
@EnableConfigServer
public class ConfigServerApplication {
 public static void main(String[] args) {
 SpringApplication.run(ConfigServerApplication.class, args);
 }
}

配置文件

# application.yml
server:
 port: 8888

spring:
 application:
 name: config-server
 cloud:
 config:
 server:
 git:
 uri: https://github.com/your-org/config-repo
 search-paths: config/{application}
 username: your-github-username
 default-label: main

配置仓库结构

config-repo/
├── config/
│ ├── user-service/
│ │ ├── application.yml # 默认配置
│ │ ├── application-dev.yml # 开发环境
│ │ ├── application-test.yml # 测试环境
│ │ └── application-prod.yml # 生产环境
│ └── order-service/
│ └── application.yml
└── README.md

示例配置

# user-service/application.yml
server:
 port: ${PORT:8080}

spring:
 application:
 name: user-service
 datasource:
 url: jdbc:mysql://localhost:3306/user_db
 username: root
 password: ${DB_PASSWORD}
 redis:
 host: ${REDIS_HOST:localhost}
 port: ${REDIS_PORT:6379}

# 用户服务配置
user:
 cache:
 ttl: 3600
 max-size: 1000
 rate-limit:
 qps: 100

# user-service/application-dev.yml
spring:
 datasource:
 url: jdbc:mysql://localhost:3306/user_db_dev
 password: dev_password
 redis:
 host: localhost

user:
 rate-limit:
 qps: 10 # 开发环境限流放宽

Go 客户端接入

安装依赖

go get github.com/spf13/viper
go get github.com/go-laoji/go-config

Viper 配置

// config/config.go
package config

import (
 "fmt"
 "github.com/spf13/viper"
)

type Config struct {
 App AppConfig `mapstructure:"app"`
 Database DatabaseConfig `mapstructure:"database"`
 Redis RedisConfig `mapstructure:"redis"`
 User UserConfig `mapstructure:"user"`
}

type AppConfig struct {
 Name string `mapstructure:"name"`
 Port int `mapstructure:"port"`
}

type DatabaseConfig struct {
 Host string `mapstructure:"host"`
 Port int `mapstructure:"port"`
 Username string `mapstructure:"username"`
 Password string `mapstructure:"password"`
 Name string `mapstructure:"name"`
}

type RedisConfig struct {
 Host string `mapstructure:"host"`
 Port int `mapstructure:"port"`
 Password string `mapstructure:"password"`
 DB int `mapstructure:"db"`
}

type UserConfig struct {
 Cache CacheConfig `mapstructure:"cache"`
 RateLimit RateLimitConfig `mapstructure:"rate-limit"`
}

type CacheConfig struct {
 TTL int `mapstructure:"ttl"`
 MaxSize int `mapstructure:"max-size"`
}

type RateLimitConfig struct {
 QPS int `mapstructure:"qps"`
}

var GlobalConfig *Config

func LoadConfig(configServer, appName, profile string) (*Config, error) {
 v := viper.New()
 
 // 设置配置中心地址
 configURL := fmt.Sprintf("http://%s/%s/%s", configServer, appName, profile)
 v.SetConfigType("yaml")
 
 // 从配置中心获取配置
 if err := v.SafeGetConfigFile(configURL); err != nil {
 // 尝试直接读取
 v.SetConfigFile(fmt.Sprintf("config/%s.yml", profile))
 if err := v.ReadInConfig(); err != nil {
 return nil, err
 }
 }
 
 var cfg Config
 if err := v.Unmarshal(&cfg); err != nil {
 return nil, err
 }
 
 GlobalConfig = &cfg
 return &cfg, nil
}

// 本地配置（备用）
func LoadLocalConfig() (*Config, error) {
 v := viper.New()
 
 v.SetConfigName("config")
 v.SetConfigType("yaml")
 v.AddConfigPath("./config")
 
 if err := v.ReadInConfig(); err != nil {
 return nil, err
 }
 
 var cfg Config
 if err := v.Unmarshal(&cfg); err != nil {
 return nil, err
 }
 
 GlobalConfig = &cfg
 return &cfg, nil
}

若配置中心不可用，LoadLocalConfig() 可作为本地开发与灾备兜底；关键是保证 profile、密钥与 环境变量注入 在流水线与运行时一致。

微服务注册发现小实验

Tue, 20 Jul 2021 00:00:00 +0000

本文是个人在学习书籍《Go 语言高并发与微服务实战》第6章内容过程中，动手做的小实验，涉及 Consul 和 go-kit 相关知识。

Consul 简介

┌─────────────────────────────────────────────────────────────┐
│ Consul 架构 │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │ Consul │ │ Consul │ │ Consul │ │
│ │ Server │ │ Server │ │ Server │ │
│ │ (Leader)│ │(Follow) │ │(Follow) │ │
│ └────┬────┘ └────┬────┘ └────┬────┘ │
│ └───────────┴───────────┘ │
│ │ │
│ ┌─────────┴─────────┐ │
│ │ │ │
│ ┌────▼────┐ ┌────▼────┐ │
│ │ Consul │ │ Consul │ │
│ │ Agent │ │ Agent │ │
│ │ (Node1) │ │ (Node2) │ │
│ └────┬────┘ └────┬────┘ │
│ │ │ │
│ ┌────▼────┐ ┌────▼────┐ │
│ │ Service │ │ Service │ │
│ └─────────┘ └─────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘

安装 Consul

下载安装

# macOS
brew install consul

# Linux
curl -fsSL https://apt.releases.hashicorp.com/gpg | sudo apt-key add -
sudo apt-add-repository "deb [arch=amd64] https://apt.releases.hashicorp.com $(lsb_release -cs) main"
sudo apt-get update && sudo apt-get install consul

# Docker
docker run -d --name=consul consul agent -dev -client=0.0.0.0

验证安装

consul --version
# Consul v1.10.0

Consul 基本操作

单机启动

# 开发模式启动
consul agent -dev

# 访问 UI
# http://127.0.0.1:8500/ui

集群启动

# 机器 1：主节点
consul agent -server \n -bootstrap-expect=1 \n -data-dir=/tmp/consul \n -node=consul-server-1 \n -bind=10.0.0.52 \n -ui

# 机器 2：加入集群
consul agent \n -data-dir=/tmp/consul \n -node=consul-server-2 \n -bind=10.0.0.53

# 在机器 2 执行加入
consul join 10.0.0.52

注册服务

# 注册服务（通过 HTTP API）
curl -X PUT -d '{
 "ID": "user-service-1",
 "Name": "user-service",
 "Tags": ["v1", "go"],
 "Address": "127.0.0.1",
 "Port": 8080,
 "Check": {
 "HTTP": "http://127.0.0.1:8080/health",
 "Interval": "10s",
 "Timeout": "5s"
 }
}' http://127.0.0.1:8500/v1/agent/service/register

# 注销服务
curl -X PUT http://127.0.0.1:8500/v1/agent/service/deregister/user-service-1

服务发现

# 查找服务
curl http://127.0.0.1:8500/v1/catalog/service/user-service

# DNS 查询
# user-service.service.consul

# 健康检查
curl http://127.0.0.1:8500/v1/health/service/user-service?passing=true

Go 微服务注册发现

项目结构

consul-demo/
├── main.go # 主程序
├── user/ # 用户服务
│ └── user.go
├── discovery/ # 服务发现封装
│ └── consul.go
└── go.mod

安装依赖

go get github.com/go-kit/kit/sd/consul
go get github.com/hashicorp/consul

Consul 客户端封装

// discovery/consul.go
package discovery

import (
 "fmt"
 "time"
 
 "github.com/go-kit/kit/sd"
 "github.com/go-kit/kit/sd/consul"
 "github.com/go-kit/kit/sd/lazy"
 "github.com/go-kit/kit/endpoint"
 "github.com/hashicorp/consul/api"
)

type Client struct {
 client consul.Client
 instancer *consul.Instancer
}

func NewConsulClient(consulAddr string) (*Client, error) {
 // 创建 Consul 客户端
 config := api.DefaultConfig()
 config.Address = consulAddr
 
 consulClient, err := api.NewClient(config)
 if err != nil {
 return nil, err
 }
 
 // 创建服务注册实例化工具
 client, err := consul.NewClient(consulClient)
 if err != nil {
 return nil, err
 }
 
 return &Client{client: client}, nil
}

// 注册服务
func (c *Client) Register(serviceName, serviceID string, addr string, port int) error {
 // 健康检查
 check := api.AgentServiceCheck{
 HTTP: fmt.Sprintf("http://%s:%d/health", addr, port),
 Interval: "10s",
 Timeout: "5s",
 Notes: "Health check for " + serviceName,
 }
 
 // 服务注册信息
 registration := api.AgentServiceRegistration{
 ID: serviceID,
 Name: serviceName,
 Tags: []string{"v1"},
 Address: addr,
 Port: port,
 EnableTagOverride: false,
 Check: &check,
 }
 
 return c.client.Register(&registration)
}

// 注销服务
func (c *Client) Deregister(serviceName, serviceID string) error {
 return c.client.Deregister(&api.AgentServiceRegistration{
 ID: serviceID,
 Name: serviceName,
 })
}

// 创建服务实例化工具
func (c *Client) GetInstancer(serviceName string) sd.Instancer {
 return consul.NewInstancer(c.client, nil, serviceName, []string{}, true)
}

// 工厂函数创建 endpoint
func instanceFactory(serviceURL string) endpoint.Endpoint {
 return func(ctx context.Context, request interface{}) (interface{}, error) {
 // 调用远程服务
 return nil, nil
 }
}

// 创建端点订阅器
func (c *Client) GetEndpointer(serviceName string) sd.Endpointer {
 instancer := c.GetInstancer(serviceName)
 return lazy.NewEndpointer(instancer, instanceFactory, nil)
}

服务端实现

// user/server.go（演示：注册到 Consul + 提供 /health）
package main

import (
 "context"
 "encoding/json"
 "fmt"
 stdlog "log"
 "net"
 "net/http"
 "os"
 "os/signal"
 "syscall"
 "time"

 kitlog "github.com/go-kit/kit/log"
 "github.com/hashicorp/consul/api"
)

const (
 ServiceName = "user-service"
 ServicePort = 8080
)

type UserService struct{}

func (s *UserService) GetUser(ctx context.Context, id int64) (*User, error) {
 return &User{
 ID: id,
 Name: fmt.Sprintf("User-%d", id),
 Age: 20 + int(id%30),
 }, nil
}

type User struct {
 ID int64 `json:"id"`
 Name string `json:"name"`
 Age int `json:"age"`
}

func pickAdvertiseIP() string {
 addrs, err := net.InterfaceAddrs()
 if err != nil {
 return "127.0.0.1"
 }
 for _, a := range addrs {
 ipnet, ok := a.(*net.IPNet)
 if !ok || ipnet.IP.IsLoopback() {
 continue
 }
 if v4 := ipnet.IP.To4(); v4 != nil {
 return v4.String()
 }
 }
 return "127.0.0.1"
}

func main() {
 logger := kitlog.NewLogfmtLogger(os.Stderr)
 logger = kitlog.With(logger, "ts", kitlog.DefaultTimestampUTC)

 cfg := api.DefaultConfig()
 cfg.Address = "127.0.0.1:8500"

 client, err := api.NewClient(cfg)
 if err != nil {
 stdlog.Fatalf("consul client: %v", err)
 }

 addr := pickAdvertiseIP()
 serviceID := fmt.Sprintf("%s-%d", ServiceName, ServicePort)

 reg := &api.AgentServiceRegistration{
 ID: serviceID,
 Name: ServiceName,
 Address: addr,
 Port: ServicePort,
 Check: &api.AgentServiceCheck{
 HTTP: fmt.Sprintf("http://%s:%d/health", addr, ServicePort),
 Interval: "10s",
 },
 }

 if err := client.Agent().ServiceRegister(reg); err != nil {
 stdlog.Fatalf("register: %v", err)
 }

 svc := &UserService{}
 mux := http.NewServeMux()
 mux.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
 w.WriteHeader(http.StatusOK)
 _, _ = w.Write([]byte("ok"))
 })
 mux.HandleFunc("/user/", func(w http.ResponseWriter, r *http.Request) {
 u, err := svc.GetUser(r.Context(), 1)
 if err != nil {
 http.Error(w, err.Error(), http.StatusInternalServerError)
 return
 }
 w.Header().Set("Content-Type", "application/json")
 _ = json.NewEncoder(w).Encode(u)
 })

 srv := &http.Server{
 Addr: fmt.Sprintf(":%d", ServicePort),
 Handler: mux,
 }

 go func() {
 _ = logger.Log("msg", "listening", "port", ServicePort)
 if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
 stdlog.Fatal(err)
 }
 }()

 quit := make(chan os.Signal, 1)
 signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
 <-quit

 ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 defer cancel()
 _ = srv.Shutdown(ctx)
 _ = client.Agent().ServiceDeregister(serviceID)
}

进程退出前注销服务，可避免 Consul 里留下僵尸实例；生产环境还需配置正确的 健康检查 URL、ACL Token 与 多实例 ID。

GRPC一点通

Sat, 17 Jul 2021 00:00:00 +0000

gRPC 是一个高性能、开源和通用的 RPC 框架，面向移动和 HTTP/2 设计。带来双向流、流控、头部压缩、单 TCP 连接上的多复用请求等特性。

什么是 gRPC

┌─────────────────────────────────────────────────────────────┐
│ gRPC 架构 │
├─────────────────────────────────────────────────────────────┤
│ │
│ Client Server │
│ │ │ │
│ │ ─────── HTTP/2 ───────────▶ │ │
│ │ Protobuf 序列化 │ │
│ │ │ │
│ │◀─────── Protobuf ───────────│ │
│ │ │ │
│ │
│ 特性： │
│ • HTTP/2 传输 │
│ • Protobuf 序列化 │
│ • 多语言支持 │
│ • 双向流 │
│ • 强类型定义 │
│ │
└─────────────────────────────────────────────────────────────┘

环境准备

安装 Protobuf 编译器

# macOS
brew install protobuf

# Linux
apt install protobuf-compiler

# Windows
# 下载 https://github.com/protocolbuffers/protobuf/releases

安装 Go 工具

# gRPC 核心库
go get -u google.golang.org/grpc

# Protobuf 插件
go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest

# gRPC Gateway（HTTP 转 gRPC）
go install github.com/grpc-ecosystem/grpc-gateway/v2/cmd/protoc-gen-grpc-gateway@latest

# 添加到 PATH
export PATH="$PATH:$(go env GOPATH)/bin"

定义服务

创建项目

mkdir grpc-demo && cd grpc-demo
go mod init grpc-demo
mkdir helloworld

编写 Proto 文件

// helloworld/simple.proto
syntax = "proto3";

option go_package = "grpc-demo/helloworld";

package helloworld;

// Greeting 服务定义
service Greeter {
 // 简单 RPC
 rpc SayHello (HelloRequest) returns (HelloReply) {}
 
 // 服务端流式 RPC
 rpc SayHelloServerStream (HelloRequest) returns (stream HelloReply) {}
 
 // 客户端流式 RPC
 rpc SayHelloClientStream (stream HelloRequest) returns (HelloReply) {}
 
 // 双向流式 RPC
 rpc SayHelloBidirectionalStream (stream HelloRequest) returns (stream HelloReply) {}
}

// 请求消息
message HelloRequest {
 string name = 1;
 int32 age = 2;
}

// 响应消息
message HelloReply {
 string message = 1;
 string timestamp = 2;
}

生成 Go 代码

# 生成 gRPC 代码
protoc --go_out=. --go_opt=paths=source_relative \n --go-grpc_out=. --go-grpc_opt=paths=source_relative \n helloworld/simple.proto

# 查看生成的文件
ls -la helloworld/
# simple.pb.go - Protobuf 消息定义
# simple_grpc.pb.go - gRPC 服务定义

实现 gRPC 服务

// helloworld/server.go
package main

import (
 "context"
 "fmt"
 "log"
 "net"
 
 "google.golang.org/grpc"
 pb "grpc-demo/helloworld"
)

type server struct {
 pb.UnimplementedGreeterServer
}

// 简单 RPC 实现
func (s *server) SayHello(ctx context.Context, req *pb.HelloRequest) (*pb.HelloReply, error) {
 return &pb.HelloReply{
 Message: fmt.Sprintf("Hello, %s! You are %d years old.", req.Name, req.Age),
 Timestamp: fmt.Sprintf("%d", time.Now().Unix()),
 }, nil
}

// 服务端流式 RPC 实现
func (s *server) SayHelloServerStream(req *pb.HelloRequest, stream pb.Greeter_SayHelloServerStreamServer) error {
 for i := 0; i < 5; i++ {
 msg := fmt.Sprintf("Hello %s (stream %d)", req.Name, i+1)
 if err := stream.Send(&pb.HelloReply{Message: msg}); err != nil {
 return err
 }
 time.Sleep(500 * time.Millisecond)
 }
 return nil
}

// 客户端流式 RPC 实现
func (s *server) SayHelloClientStream(stream pb.Greeter_SayHelloClientStreamServer) error {
 var names []string
 for {
 req, err := stream.Recv()
 if err == io.EOF {
 return stream.SendAndClose(&pb.HelloReply{
 Message: fmt.Sprintf("Hello %v!", names),
 })
 }
 if err != nil {
 return err
 }
 names = append(names, req.Name)
 }
}

// 双向流式 RPC 实现
func (s *server) SayHelloBidirectionalStream(stream pb.Greeter_SayHelloBidirectionalStreamServer) error {
 for {
 req, err := stream.Recv()
 if err == io.EOF {
 return nil
 }
 if err != nil {
 return err
 }
 
 msg := fmt.Sprintf("Hello %s!", req.Name)
 if err := stream.Send(&pb.HelloReply{Message: msg}); err != nil {
 return err
 }
 }
}

func main() {
 lis, err := net.Listen("tcp", ":50051")
 if err != nil {
 log.Fatalf("failed to listen: %v", err)
 }
 
 s := grpc.NewServer()
 pb.RegisterGreeterServer(s, &server{})
 
 log.Println("gRPC server started on :50051")
 if err := s.Serve(lis); err != nil {
 log.Fatalf("failed to serve: %v", err)
 }
}

实现 gRPC 客户端

// helloworld/client.go
package main

import (
 "context"
 "fmt"
 "log"
 "time"
 
 "google.golang.org/grpc"
 "google.golang.org/grpc/credentials/insecure"
 pb "grpc-demo/helloworld"
)

func main() {
 // 连接 gRPC 服务器
 conn, err := grpc.Dial(":50051", grpc.WithTransportCredentials(insecure.NewCredentials()))
 if err != nil {
 log.Fatalf("did not connect: %v", err)
 }
 defer conn.Close()
 
 client := pb.NewGreeterClient(conn)
 
 // 调用简单 RPC
 ctx, cancel := context.WithTimeout(context.Background(), time.Second)
 defer cancel()
 
 r, err := client.SayHello(ctx, &pb.HelloRequest{Name: "World", Age: 25})
 if err != nil {
 log.Fatalf("could not greet: %v", err)
 }
 log.Printf("Greeting: %s", r.GetMessage())
}

添加 HTTP Gateway

安装依赖

go get google.golang.org/grpc/proto

Gateway 服务

// gateway/main.go
package main

import (
 "context"
 "fmt"
 "net/http"
 
 "github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
 "google.golang.org/grpc"
 "google.golang.org/grpc/credentials/insecure"
 pb "grpc-demo/helloworld"
)

func main() {
 ctx := context.Background()
 ctx, cancel := context.WithCancel(ctx)
 defer cancel()
 
 mux := runtime.NewServeMux()
 opts := []grpc.DialOption{
 grpc.WithTransportCredentials(insecure.NewCredentials()),
 }
 
 err := pb.RegisterGreeterHandlerFromEndpoint(ctx, mux, ":50051", opts)
 if err != nil {
 log.Fatalf("failed to register gateway: %v", err)
 }
 
 http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
 mux.ServeHTTP(w, r)
 })
 
 log.Println("HTTP Gateway started on :8080")
 http.ListenAndServe(":8080", nil)
}

启动服务

# 终端 1: 启动 gRPC 服务
go run helloworld/server.go

# 终端 2: 启动 HTTP Gateway
go run gateway/main.go

# 测试 HTTP 接口
curl -X POST http://localhost:8080/helloworld.Greeter/SayHello \n -H "Content-Type: application/json" \n -d '{"name": "World", "age": 25}'

四种 RPC 模式

模式	说明
Unary（一元）	客户端发起一次请求，服务端返回一次响应；最常见，类似普通 HTTP JSON。
Server streaming（服务端流）	客户端一次请求，服务端以流多次推送数据；适合大列表、订阅通知。
Client streaming（客户端流）	客户端多次写入流，服务端最终一次汇总响应；适合批量上传、日志汇总。
Bidirectional streaming（双向流）	两端可同时读写流；适合聊天、协作编辑、实时推送等对「管道」建模的场景。

选型上：能用 Unary 就不用流式；若业务本身是「按需拉取一块块数据」，优先考虑 Server streaming；必须在单连接上交织多条请求/响应时（如 HTTP/2 多路复用语义），再结合双向流评估。

小结

掌握四种模式后，阅读 .proto 里的 rpc 定义会更直观：stream 关键字出现在请求侧、响应侧或两侧，分别对应上述三种流式形态。

Go依赖管理工具

Sat, 09 May 2020 00:00:00 +0000

最早的时候，Go 所依赖的所有第三方库都放在 GOPATH 目录下。随着 Go 语言的发展，从 v1.5 开始引入 vendor 模式。本文介绍两个 Golang 官方依赖管理工具。

依赖管理演进

┌─────────────────────────────────────────────────────────────┐
│ Go 依赖管理演进 │
├─────────────────────────────────────────────────────────────┤
│ │
│ GOPATH 时代 ──▶ Vendor 时代 ──▶ dep 时代 ──▶ go mod 时代 │
│ (2012) (2014) (2017) (2018) │
│ │
└─────────────────────────────────────────────────────────────┘

dep（已过时）

⚠️ 提示：dep 已停止维护，建议使用 go modules。

安装

# macOS
brew install dep

# Linux
curl https://raw.githubusercontent.com/golang/dep/master/install.sh | sh

# Windows
go get -u github.com/golang/dep/cmd/dep

常用命令

命令	说明
`dep init`	初始化项目，生成 Gopkg.toml 和 Gopkg.lock
`dep status`	查看依赖状态
`dep ensure`	确保依赖已安装
`dep ensure -add`	添加新依赖
`dep ensure -update`	更新依赖版本
`dep check`	检查导入是否同步

使用示例

# 初始化项目
dep init

# 添加依赖
dep ensure -add github.com/spf13/viper

# 更新所有依赖
dep ensure -update

# 查看状态
dep status

配置文件

# Gopkg.toml
[[constraint]]
 name = "github.com/spf13/viper"
 version = "^1.6.0"

[[constraint]]
 name = "github.com/go-sql-driver/mysql"
 version = "^1.5.0"

go modules（推荐）

go modules 是 Go 1.11 引入的官方依赖管理方案，现在已是主流。

核心概念

概念	说明
Module	相关 Go 包的集合，是版本控制的单元
go.mod	模块定义文件，记录依赖关系
go.sum	依赖校验文件，确保构建一致性
GOPROXY	依赖代理服务器，加速下载

启用方式

# Go 1.11+ 默认启用
export GO111MODULE=on # 显式启用
export GO111MODULE=off # 禁用（使用 GOPATH）
export GO111MODULE=auto # 自动检测（默认）

常用命令

命令	说明
`go mod init`	初始化模块，生成 go.mod
`go mod tidy`	整理依赖（添加缺失，移除未用）
`go mod download`	下载依赖到本地缓存
`go mod vendor`	将依赖复制到 vendor 目录
`go mod graph`	打印依赖图
`go mod verify`	验证依赖是否正确
`go mod why`	解释为什么需要某依赖

初始化项目

# 在项目目录执行
go mod init github.com/username/project

# 或指定模块名
go mod init mymodule

go.mod 示例

module github.com/username/project

go 1.21

require (
 github.com/gin-gonic/gin v1.9.1
 github.com/go-sql-driver/mysql v1.7.1
 github.com/spf13/viper v1.16.0
)

require (
 github.com/bytedance/sonic v1.9.1 // indirect
 github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311 // indirect
 github.com/gabriel-vasile/mimetype v1.4.2 // indirect
)

go.sum 示例

github.com/gin-gonic/gin v1.9.1 h1:4idEAncQnU5cB7BeOkPtxjfCSye0AAm1R0RVIqJ+Jmg=
github.com/gin-gonic/gin v1.9.1/go.mod h1:hPrL7YrpYKXt5YIdfeAwnHoK0S2RThAQPz7AH81q6Us=
github.com/go-sql-driver/mysql v1.7.1 h1:lUIinVbN1DY0xBg0eMOzmmtGoHwWBbvnWubQUrtU8EI=
github.com/go-sql-driver/mysql v1.7.1/go.mod h1:OXbVy3sEdcQ2Doequ6Z5BW6fXNQTmx+9S1MCJN5yJMI=

完整使用流程

1. 创建新项目

# 创建项目目录
mkdir myproject && cd myproject

# 初始化模块
go mod init github.com/username/myproject

# 创建主文件
cat > main.go << 'EOF'
package main

import (
 "fmt"
 "github.com/gin-gonic/gin"
)

func main() {
 r := gin.Default()
 r.GET("/ping", func(c *gin.Context) {
 c.JSON(200, gin.H{"message": "pong"})
 })
 r.Run()
}
EOF

# 下载依赖并整理
go mod tidy

2. 添加依赖

# 方式一：go get
go get github.com/spf13/viper

# 指定版本
go get github.com/spf13/viper@v1.16.0

# 最新版本
go get github.com/spf13/viper@latest

# 指定分支
go get github.com/spf13/viper@master

# 指定 commit
go get github.com/spf13/viper@e3861e3

# 方式二：直接编辑 go.mod
echo 'github.com/redis/go-redis/v9 v9.0.0' >> go.mod
go mod tidy

3. 升级/降级依赖

# 升级到最新版本
go get -u github.com/gin-gonic/gin

# 升级到指定版本
go get github.com/gin-gonic/gin@v1.9.0

# 清理未使用的依赖
go mod tidy

4. 使用 vendor

# 将依赖复制到 vendor 目录
go mod vendor

# 查看 vendor 内容
ls vendor/

# 使用 vendor 构建
go build -mod=vendor

代理配置

设置 GOPROXY

# 阿里云代理（推荐国内使用）
go env -w GOPROXY=https://mirrors.aliyun.com/goproxy/,direct

# 官方代理
go env -w GOPROXY=https://proxy.golang.org,direct

# 七牛云
go env -w GOPROXY=https://goproxy.cn,direct

# 多个代理（逗号分隔）
go env -w GOPROXY=https://goproxy.cn,https://proxy.golang.org,direct

代理参数

参数	说明
`direct`	直连源站
`off`	禁用代理
`=https://proxy.golang.org`	官方代理

私有模块

设置 GONOSUMDB

# 跳过校验的域名
go env -w GONOSUMDB="gitlab.com/mycompany/*"

设置 GOPRIVATE

# 私有模块不走代理
go env -w GOPRIVATE="gitlab.com/mycompany,github.com/myteam"

配置 netrc

# ~/.netrc
machine github.com
login your-username
password your-token

常见问题

Q: 依赖下载失败

# 清理缓存
go clean -modcache

# 设置国内镜像
go env -w GOPROXY=https://goproxy.cn,direct

Q: go.mod 和 go.sum 不同步

go mod tidy

Q: vendor 和 mod 冲突

# 删除 vendor，使用 go mod
rm -rf vendor
go mod tidy

Q: 循环导入

# 检查依赖图
go mod graph | grep ":"

最佳实践

始终使用 go mod tidy 保持依赖整洁
使用 vendor 确保构建可重复
使用国内镜像 加速下载
定期升级依赖 获取安全补丁
提交 go.sum 锁校验和到版本库，CI 使用 go mod verify 防止依赖被篡改。

微信消息编辑器 - Laravel Admin扩展

Sat, 07 Dec 2019 00:00:00 +0000

本文介绍 wxmsg，一个 Laravel Admin 的扩展工具。可视化地编辑待回复的微信消息，最终输出 JSON 格式。

简介

这是一个基于 laravel-admin 后台框架开发的扩展，可在 Form 表单中进行可视化编辑微信消息。

功能特点：

支持多种消息类型（文本、图片、图文、链接、小程序卡片）
消息类型切换自动更新编辑界面
支持多公众号关联
输出标准微信客服消息 JSON 格式

截图

可访问 GitHub 仓库查看完整截图

安装

使用 Composer 安装

composer require yisonli/wxmsg

发布资源

php artisan vendor:publish --tag=wxmsg-assets

基础用法

<?php

namespace App\\Admin\\Controllers;

use Encore\\Admin\\Controllers\\AdminController;
use App\\Models\\WechatReply;

class WechatReplyController extends AdminController
{
 protected function grid()
 {
 $grid = new Grid(new WechatReply());
 
 $grid->id('ID');
 $grid->app_id('公众号');
 $grid->msgtype('消息类型');
 $grid->content('回复内容');
 $grid->created_at('创建时间');
 $grid->updated_at('更新时间');
 
 return $grid;
 }
 
 protected function form()
 {
 $form = new Form(new WechatReply());
 
 // 选择公众号
 $form->select('app_id', '公众号')
 ->options(WechatApp::pluck('name', 'id'))
 ->rules('required');
 
 // 消息类型
 $form->select('msgtype', '回复消息类型')
 ->options([
 'text' => '文本',
 'image' => '图片',
 'news' => '图文',
 'link' => '链接',
 'miniprogrampage' => '小程序卡片',
 ])
 ->rules('required');
 
 // 微信消息编辑器
 $form->wxmsg('content', '回复内容');
 
 return $form;
 }
}

高级用法

关联消息类型

当消息类型字段使用自定义定义方式时，可用 relateTo 函数进行关联：

$form->select('app_id', '公众号')
 ->options($app_list)
 ->rules('required');

$form->select('msgtype', '回复消息类型')
 ->options([
 'text' => '文本',
 'image' => '图片',
 'news' => '图文',
 'link' => '链接',
 'miniprogrampage' => '小程序卡片',
 ])
 ->rules('required');

$form->wxmsg('content', '回复内容')
 ->relateTo('msgtype', 'app_id');

关联多公众号

支持多公众号场景，通过 selectMedia 函数选择素材：

$form->select('app_id', '公众号')
 ->options($app_list)
 ->rules('required');

$form->select('msgtype', '回复消息类型')
 ->options([...])
 ->rules('required');

$form->wxmsg('content', '回复内容')
 ->relateTo('msgtype', 'app_id')
 ->selectMedia('/wechat/reply/medias');

实现素材查询 API

在控制器中添加 API 方法：

<?php

namespace App\\Http\\Controllers\\Admin;

use Illuminate\\Http\\Request;
use App\\Models\\WechatMedia;

class ReplyController extends Controller
{
 /**
 * 查询素材列表
 */
 public function medias(Request $request)
 {
 $app_id = $request->get('a');
 $name = $request->get('q');
 $type = $request->get('t');
 
 $query = WechatMedia::query();
 
 if ($app_id) {
 $query->where('app_id', $app_id);
 }
 
 if ($type) {
 $query->where('type', $type);
 }
 
 if ($name) {
 $query->where('name', 'like', "%{$name}%");
 }
 
 $result = $query->paginate(20, ['media_id', 'name', 'url']);
 
 $data = $result->map(function ($item) {
 return [
 'id' => $item->media_id,
 'text' => sprintf(
 '<img style="max-width:40px;max-height:40px;" src="%s" /> %s',
 $item->url,
 $item->name
 ),
 ];
 });
 
 return response()->json($data);
 }
}

添加路由：

// routes/admin.php
$router->get('/wechat/reply/medias', 'Wechat\\ReplyController@medias');

支持的消息类型

类型	说明	JSON 格式
text	文本消息	`{"msgtype":"text","text":{"content":"..."}}`
image	图片消息	`{"msgtype":"image","image":{"media_id":"..."}}`
news	图文消息	`{"msgtype":"news","news":{"articles":[...]}}`
link	链接消息	`{"msgtype":"link","link":{"title":"...","description":"...","url":"...","thumb_url":"..."}}`
miniprogrampage	小程序卡片	`{"msgtype":"miniprogrampage","miniprogrampage":{"title":"...","appid":"...","pagepath":"...","thumb_media_id":"..."}}`

生成的 JSON 示例

文本消息

{
 "msgtype": "text",
 "text": {
 "content": "欢迎关注我们的公众号！"
 }
}

图片消息

{
 "msgtype": "image",
 "image": {
 "media_id": "MEDIA_ID"
 }
}

图文消息

{
 "msgtype": "news",
 "news": {
 "articles": [
 {
 "title": "文章标题",
 "description": "文章描述",
 "url": "https://example.com/article",
 "picurl": "https://example.com/image.jpg"
 }
 ]
 }
}

数据库表结构

CREATE TABLE `wechat_replies` (
 `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT,
 `app_id` bigint(20) unsigned NOT NULL COMMENT '公众号ID',
 `msgtype` varchar(20) NOT NULL COMMENT '消息类型',
 `content` text NOT NULL COMMENT '消息内容(JSON)',
 `created_at` timestamp NULL DEFAULT NULL,
 `updated_at` timestamp NULL DEFAULT NULL,
 PRIMARY KEY (`id`),
 KEY `idx_app_id` (`app_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

待开发功能

支持更多消息类型（video、music、msgmenu 等）
美化操作界面
提供实时效果预览
支持消息模板

参考链接

Go深入了解sync库的锁和信号量

Tue, 15 Oct 2019 00:00:00 +0000

sync 包提供了 Go 语言的基本同步基元，如互斥锁。除了 Once 和 WaitGroup 类型，大部分都适用于低水平程序线程，高水平的同步使用 channel 通信更好。

并发与同步

Go 并发基础

package main

import (
 "fmt"
 "time"
)

func main() {
 // 创建 goroutine
 go sayHello()
 
 // 主 goroutine 继续执行
 for i := 0; i < 5; i++ {
 fmt.Println("Main:", i)
 time.Sleep(time.Millisecond * 100)
 }
}

func sayHello() {
 for i := 0; i < 5; i++ {
 fmt.Println("Hello:", i)
 time.Sleep(time.Millisecond * 100)
 }
}

同步问题

// 竞态条件示例
var counter int

func increment() {
 counter++ // 非原子操作
}

func main() {
 // 1000 个 goroutine 同时修改 counter
 for i := 0; i < 1000; i++ {
 go increment()
 }
 time.Sleep(time.Second)
 // 预期: 1000，实际可能: 900-1000 之间
 fmt.Println(counter) // 存在竞态条件！
}

sync.Mutex 互斥锁

基本用法

package main

import (
 "fmt"
 "sync"
 "time"
)

type Counter struct {
 mu sync.Mutex
 count int
}

func (c *Counter) Incr() {
 c.mu.Lock()
 defer c.mu.Unlock()
 c.count++
}

func (c *Counter) Value() int {
 c.mu.Lock()
 defer c.mu.Unlock()
 return c.count
}

func main() {
 var counter Counter
 
 // 1000 个 goroutine 安全递增
 for i := 0; i < 1000; i++ {
 go counter.Incr()
 }
 
 time.Sleep(time.Second)
 fmt.Println(counter.Value()) // 输出: 1000
}

注意事项

✅ 使用 defer 确保锁一定会释放
✅ 锁的粒度要尽可能小
❌ 不要在持有锁时调用用户代码
❌ 不要忘记解锁

sync.RWMutex 读写锁

适用场景

场景	锁类型	说明
读多写少	RWMutex	多个读锁可并存
写操作	Mutex	独占访问

基本用法

package main

import (
 "fmt"
 "sync"
 "time"
)

type SafeMap struct {
 mu sync.RWMutex
 m map[string]int
}

func (sm *SafeMap) Set(key string, value int) {
 sm.mu.Lock()
 defer sm.mu.Unlock()
 sm.m[key] = value
}

func (sm *SafeMap) Get(key string) (int, bool) {
 sm.mu.RLock() // 读锁
 defer sm.mu.RUnlock()
 val, ok := sm.m[key]
 return val, ok
}

func main() {
 sm := SafeMap{m: make(map[string]int)}
 
 // 多个读 goroutine
 for i := 0; i < 10; i++ {
 go func(id int) {
 for j := 0; j < 100; j++ {
 sm.Set(fmt.Sprintf("key-%d", j%5), j)
 }
 }(i)
 }
 
 // 一个写 goroutine
 go func() {
 for i := 0; i < 100; i++ {
 sm.Set("write", i)
 }
 }()
 
 time.Sleep(time.Second)
 
 // 读取结果
 for i := 0; i < 5; i++ {
 fmt.Printf("key-%d: %d\n", i, sm.Get(fmt.Sprintf("key-%d", i)))
 }
}

sync.Cond 条件变量

适用场景

等待某个条件成立
线程等待/唤醒模式
生产者-消费者模型

基本用法

package main

import (
 "fmt"
 "sync"
 "time"
)

type Queue struct {
 mu sync.Mutex
 cond *sync.Cond
 items []int
 max int
}

func NewQueue(max int) *Queue {
 q := &Queue{
 items: make([]int, 0, max),
 max: max,
 }
 q.cond = sync.NewCond(&q.mu)
 return q
}

func (q *Queue) Put(item int) {
 q.mu.Lock()
 defer q.mu.Unlock()
 
 // 队列满，等待
 for len(q.items) >= q.max {
 q.cond.Wait() // 解锁并等待
 }
 
 q.items = append(q.items, item)
 fmt.Printf("Put: %d, Queue: %v\n", item, q.items)
 
 // 唤醒一个等待的消费者
 q.cond.Signal()
}

func (q *Queue) Get() int {
 q.mu.Lock()
 defer q.mu.Unlock()
 
 // 队列空，等待
 for len(q.items) == 0 {
 q.cond.Wait()
 }
 
 item := q.items[0]
 q.items = q.items[1:]
 fmt.Printf("Get: %d, Queue: %v\n", item, q.items)
 
 // 唤醒一个等待的生产者
 q.cond.Signal()
 
 return item
}

func main() {
 q := NewQueue(3)
 
 // 生产者
 go func() {
 for i := 0; i < 10; i++ {
 q.Put(i)
 time.Sleep(100 * time.Millisecond)
 }
 }()
 
 // 消费者
 go func() {
 for i := 0; i < 10; i++ {
 q.Get()
 time.Sleep(150 * time.Millisecond)
 }
 }()
 
 time.Sleep(3 * time.Second)
}

Broadcast vs Signal

方法	说明
`Signal()`	唤醒一个等待的 goroutine
`Broadcast()`	唤醒所有等待的 goroutine

sync.WaitGroup 等待组

基本用法

package main

import (
 "fmt"
 "sync"
 "time"
)

func main() {
 var wg sync.WaitGroup
 
 // 添加 3 个任务
 wg.Add(3)
 
 for i := 0; i < 3; i++ {
 go func(id int) {
 defer wg.Done() // 完成后计数减 1
 fmt.Printf("Task %d started\n", id)
 time.Sleep(time.Second)
 fmt.Printf("Task %d completed\n", id)
 }(i)
 }
 
 // 等待所有任务完成
 wg.Wait()
 fmt.Println("All tasks completed!")
}

常见模式

// 1. 并行爬虫
func crawlUrls(urls []string) []string {
 var wg sync.WaitGroup
 results := make(chan string, len(urls))
 
 for _, url := range urls {
 wg.Add(1)
 go func(u string) {
 defer wg.Done()
 if body, err := fetch(u); err == nil {
 results <- body
 }
 }(url)
 }
 
 // 等待完成并关闭通道
 go func() {
 wg.Wait()
 close(results)
 }()
 
 var bodies []string
 for body := range results {
 bodies = append(bodies, body)
 }
 return bodies
}

// 2. 错误处理
type Task struct {
 ID int
 URL string
 Err error
}

func processTasks(tasks []Task) []Task {
 var wg sync.WaitGroup
 for i := range tasks {
 wg.Add(1)
 go func(idx int) {
 defer wg.Done()
 tasks[idx].Err = process(tasks[idx].URL)
 }(i)
 }
 wg.Wait()
 return tasks
}

sync.Once 一次性执行

基本用法

package main

import (
 "fmt"
 "sync"
)

type Config struct {
 Data string
}

var (
 config *Config
 once sync.Once
)

func getConfig() *Config {
 once.Do(func() {
 fmt.Println("Loading config...")
 config = &Config{
 Data: "loaded-once",
 }
 })
 return config
}

func main() {
 c1 := getConfig()
 c2 := getConfig()
 fmt.Println(c1 == c2, c1.Data) // true, 同一实例
}

注意事项

once.Do 内的函数若 panic，仍视为「已执行」，再次调用不会重试；需要在内部自行 recover 或保证可恢复。
不要在 once.Do 里再嵌套依赖同一 Once 的死锁路径。

Go应用的灵活配置Viper

Thu, 10 Oct 2019 00:00:00 +0000

Viper 是一个完整的 Go 应用程序配置解决方案，它可以处理所有类型的配置需求和格式。

Viper 功能特性

功能	说明
多格式支持	Yaml、Json、TOML、HCL、ENV、Java Properties
多来源读取	文件、环境变量、命令行参数、远程配置
热加载	支持监听配置文件变化自动重载
类型转换	自动转换配置值为 Go 类型
远程配置	支持从 etcd、Consul、NATS 等读取配置
默认值	支持设置默认值

安装

go get -u github.com/spf13/viper

基础用法

config.yaml 配置文件

app:
 name: "my-app"
 version: "1.0.0"
 port: 8080

database:
 host: "localhost"
 port: 3306
 username: "root"
 password: "secret"
 name: "test_db"

redis:
 host: "127.0.0.1"
 port: 6379
 password: ""
 db: 0

information:
 list:
 - "One"
 - "Two"
 - "Three"
 lucky_number: 7

timestamp: "2019-10-10 14:15:16"
author: "Yisonli"

初始化配置

package main

import (
 "fmt"
 "github.com/spf13/viper"
)

func main() {
 // 创建 Viper 实例
 v := viper.New()

 // 设置配置文件名（不含扩展名）
 v.SetConfigName("config")

 // 添加配置文件搜索路径
 v.AddConfigPath("./config/")
 v.AddConfigPath("$HOME/.app/")
 v.AddConfigPath("/etc/app/")

 // 设置配置文件类型
 v.SetConfigType("yaml")

 // 读取配置
 if err := v.ReadInConfig(); err != nil {
 panic(fmt.Errorf("配置读取失败: %w", err))
 }

 // 获取配置值
 fmt.Printf("应用名称: %s\n", v.GetString("app.name"))
 fmt.Printf("数据库主机: %s\n", v.GetString("database.host"))
 fmt.Printf("列表: %v\n", v.GetStringSlice("information.list"))
}

全局 Viper 实例

var VP *viper.Viper

func AutoLoadConfig() error {
 VP = viper.New()

 // 设置配置文件名
 VP.SetConfigName("config")

 // 添加配置文件路径
 VP.AddConfigPath("./config/")

 // 设置配置文件类型
 VP.SetConfigType("yaml")

 if err := VP.ReadInConfig(); err != nil {
 return fmt.Errorf("配置读取失败: %w", err)
 }

 // 绑定环境变量
 VP.BindEnv("GOPATH")

 fmt.Printf("list: %+v, gopath: %s\n", VP.Get("information.list"), VP.Get("GOPATH"))
 return nil
}

高级用法

读取环境变量

// 自动绑定环境变量
v.AutomaticEnv()
v.SetEnvPrefix("APP") // 环境变量前缀：APP_DATABASE_HOST
v.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))

// 手动绑定
v.BindEnv("database.host", "DB_HOST") // 绑定到 DB_HOST 环境变量

读取命令行参数

v.SetConfigFile("./config.yaml") // 指定配置文件路径
v.SetConfigType("yaml") // 明确配置文件类型

// 绑定 Pflags
v.BindPFlag("database.host", flag.Lookup("db-host"))

设置默认值

v := viper.New()

v.SetDefault("app.port", 8080)
v.SetDefault("database.host", "localhost")
v.SetDefault("database.port", 3306)
v.SetDefault("cache.enabled", true)

类型安全获取

// 字符串
name := v.GetString("app.name")

// 整数
port := v.GetInt("app.port")

// 布尔
enabled := v.GetBool("cache.enabled")

// 浮点数
rate := v.GetFloat64("api.rate_limit")

// 切片
list := v.GetStringSlice("information.list")

// Map
dbConfig := v.GetStringMap("database")
// dbConfig["host"], dbConfig["port"], etc.

// 嵌套获取
host := v.GetString("database.host")
listItem := v.GetString("information.list.0") // "One"

Unmarshal 到结构体

type Config struct {
 App AppConfig `mapstructure:"app"`
 Database DatabaseConfig `mapstructure:"database"`
 Redis RedisConfig `mapstructure:"redis"`
}

type AppConfig struct {
 Name string `mapstructure:"name"`
 Version string `mapstructure:"version"`
 Port int `mapstructure:"port"`
}

type DatabaseConfig struct {
 Host string `mapstructure:"host"`
 Port int `mapstructure:"port"`
 Username string `mapstructure:"username"`
 Password string `mapstructure:"password"`
 Name string `mapstructure:"name"`
}

type RedisConfig struct {
 Host string `mapstructure:"host"`
 Port int `mapstructure:"port"`
 Password string `mapstructure:"password"`
 DB int `mapstructure:"db"`
}

func main() {
 v := viper.New()
 v.SetConfigFile("config.yaml")
 v.SetConfigType("yaml")
 v.ReadInConfig()

 var config Config
 if err := v.Unmarshal(&config); err != nil {
 panic(err)
 }

 fmt.Printf("App: %s:%d\n", config.App.Name, config.App.Port)
 fmt.Printf("DB: %s:%d\n", config.Database.Host, config.Database.Port)
}

监听配置文件变化

v := viper.New()
v.SetConfigName("config")
v.SetConfigType("yaml")
v.ReadInConfig()

// 监听配置变化
v.WatchConfig()
v.OnConfigChange(func(e fsnotify.Event) {
 fmt.Printf("配置文件已更新: %s\n", e.Name)
 // 重新读取配置
 v.ReadInConfig()
})

远程配置

etcd 配置

import (
 "github.com/spf13/viper/remote"
 "github.com/hashicorp/vault/api"
)

func initRemoteConfig() error {
 v := viper.New()

 // 设置远程源
 err := remote.AddProvider("etcd", "http://127.0.0.1:4001", "/config.yaml")
 if err != nil {
 return err
 }

 // 或者使用 Consul
 err = remote.AddProvider("consul", "http://127.0.0.1:8500", "/config.yaml", "my-consul-token")

 // 启用远程配置
 err = v.AddRemoteProvider("etcd", "http://127.0.0.1:4001", "/config.yaml")
 v.SetConfigType("yaml")
 
 return v.ReadRemoteConfig()
}

多环境配置

// 根据环境加载不同配置
func loadConfig(env string) (*viper.Viper, error) {
 v := viper.New()

 // 基础配置
 v.SetConfigName("config")
 v.SetConfigType("yaml")
 v.AddConfigPath("./config/")

 // 环境特定配置
 if env != "" {
 v.SetConfigName("config." + env) // config.dev.yaml, config.prod.yaml
 }

 if err := v.ReadInConfig(); err != nil {
 return nil, err
 }

 return v, nil
}

// 使用
v, err := loadConfig("dev") // 加载 config.dev.yaml

最佳实践

项目结构

project/
├── config/
│ ├── config.yaml # 默认配置
│ ├── config.dev.yaml # 开发环境
│ ├── config.prod.yaml # 生产环境
│ └── config.test.yaml # 测试环境
├── config.yaml
└── main.go

环境变量配置

# .env 文件
APP_NAME=my-app
APP_ENV=production
DATABASE_HOST=localhost
DATABASE_PORT=3306

// 加载 .env 文件
go get github.com/joho/godotenv

func main() {
 // 加载 .env 文件
 godotenv.Load()

 v := viper.New()
 v.AutomaticEnv()
 
 // 或者手动映射（键名建议使用点分层级，对应 yaml 嵌套字段）
 v.BindEnv("database.host", "DATABASE_HOST")
 v.BindEnv("database.port", "DATABASE_PORT")

 // 读取：优先配置文件，再以环境变量覆盖 AutomaticEnv / BindEnv 的值
 host := v.GetString("database.host")
 _ = host
}

.env 只适合开发机本地密钥；线上请使用容器/编排注入的环境变量或密钥管理服务，BindEnv 只是把环境变量桥接到同一套键名。

常用正则表达式收集

Sun, 30 Jun 2019 00:00:00 +0000

正则表达式是繁琐的，但它是强大的。学会之后的应用会让你除了提高效率外，会给你带来绝对的成就感。

一、校验数字的表达式

场景	正则表达式
纯数字	`^[0-9]*$`
n位数字	`^\d{n}$`
至少n位数字	`^\d{n,}$`
m-n位数字	`^\d{m,n}$`
零和非零开头	`^(0
非零开头最多2位小数	`^([1-9][0-9]*)+(.[0-9]{1,2})?$`
带1-2位小数的数	`^(\-)?\d+(\.\d{1,2})?$`
正数、负数、小数	`^(-
2位小数正实数	`^[0-9]+(.[0-9]{2})?$`
1-3位小数正实数	`^[0-9]+(.[0-9]{1,3})?$`
非零正整数	`^[1-9]\d$` 或 `^\+?[1-9][0-9]$`
非零负整数	`^-[1-9]\d*$`
非负整数	`^\d+$` 或 `^[1-9]\d*
非正整数	`^-[1-9]\d*
非负浮点数	`^\d+(\.\d+)?$`
非正浮点数	`^((-\d+(.\d+)?)
正浮点数	`^[1-9]\d.\d
负浮点数	`^-([1-9]\d.\d
浮点数	`^(-?\d+)(\.\d+)?$`

二、校验字符的表达式

场景	正则表达式
汉字	`^[\u4e00-\u9fa5]{0,}$`
英文和数字	`^[A-Za-z0-9]+$`
4-40位字符	`^[A-Za-z0-9]{4,40}$`
3-20位字符	`^.{3,20}$`
26个英文字母	`^[A-Za-z]+$`
26个大写字母	`^[A-Z]+$`
26个小写字母	`^[a-z]+$`
数字和字母	`^[A-Za-z0-9]+$`
字母、数字、下划线	`^\w+$` 或 `^\w{3,20}$`
中文、英文、数字、下划线	`^[\u4E00-\u9FA5A-Za-z0-9_]+$`
中文、英文、数字	`^[\u4E00-\u9FA5A-Za-z0-9]+$`
禁止特殊字符	`[^%&',;=?$\x22]+`

三、特殊需求表达式

1. Email 邮箱

^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$

// PHP 示例
$email = 'test@example.com';
$pattern = '/^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$/';
if (preg_match($pattern, $email)) {
 echo "邮箱格式正确";
}

2. URL 网址

[a-zA-z]+://[^\s]* 或 ^http://([\w-]+\.)+[\w-]+(/[\w-./?%&=]*)?

3. 手机号码（中国大陆）

^(13[0-9]|14[5|7]|15[0|1|2|3|5|6|7|8|9]|16[2|6]|17[0-8]|18[0-9]|19[0-9])d{8}$

// 宽松匹配 11 位手机号
function isValidPhone($phone) {
 return preg_match('/^1[3-9]\d{9}$/', $phone);
}

4. 电话号码

^(\(\d{3,4}-)|\d{3.4}-)?\d{7,8}$

5. 身份证号码

// 15位或18位
^\d{15}|\d{18}$

// 18位（严格）
/^[1-9]\d{5}(18|19|20)\d{2}(0[1-9]|1[0-2])(0[1-9]|[12]\d|3[01])\d{3}[\dXx]$/

function isValidIdCard($id) {
 if (strlen($id) == 18) {
 return preg_match('/^[1-9]\d{5}(18|19|20)\d{2}(0[1-9]|1[0-2])(0[1-9]|[12]\d|3[01])\d{3}[\dXx]$/', $id);
 } elseif (strlen($id) == 15) {
 return preg_match('/^[1-9]\d{5}\d{2}(0[1-9]|1[0-2])(0[1-9]|[12]\d|3[01])\d{3}$/', $id);
 }
 return false;
}

6. 账号（字母开头）

^[a-zA-Z][a-zA-Z0-9_]{4,15}$ // 5-16位

7. 密码强度

// 弱密码（字母开头，6-18位）
^[a-zA-Z]\w{5,17}$

// 强密码（大小写字母+数字，8-10位）
^(?=.*\d)(?=.*[a-z])(?=.*[A-Z]).{8,10}$

8. 日期格式

^\d{4}-\d{1,2}-\d{1,2}

9. 日期范围

// 12个月：01～09 和 1～12
^(0?[1-9]|1[0-2])$

// 31天：01～09 和 1～31
^((0?[1-9])|((1|2)[0-9])|30|31)$

10. 货币金额

// 10000.00 或 10,000.00
^[1-9][0-9]*$

// 不以0开头
^(0|[1-9][0-9]*)$

// 可选小数（必须2位）
^[0-9]+(.[0-9]{2})?$

// 允许千分位
^([0-9]+|[0-9]{1,3}(,[0-9]{3})*)(.[0-9]{1,2})?$

四、常用场景正则

1. IP 地址

// 简单版
\d+\.\d+\.\d+\.\d+

// 严格版
((?:(?:25[0-5]|2[0-4]\d|[01]?\d?\d)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d?\d))

2. 腾讯 QQ 号

[1-9][0-9]{4,}

3. 中国邮政编码

[1-9]\d{5}(?!\d)

4. XML 文件

^([a-zA-Z]+-?)+[a-zA-Z0-9]+\.[x|X][m|M][l|L]$

5. 中文字符

[\u4e00-\u9fa5]

6. 双字节字符

[^\x00-\xff]

这一类「非 ASCII」写法常用来粗略匹配中文等宽字符；若要严格限定中日韓统一表意文字，可再配合 [\u4e00-\u9fff] 等 Unicode 区间。PHP 等对 UTF-8 文本建议使用带 u 修饰的正则。

7. 小结

以上条目均为常见写法模板，上线前务必用真实样本与边界数据回归测试；不同语言的正则方言（回溯、分支、贪婪性）会有差异，移植时请以目标引擎文档为准。

Laravel框架下的PHP辅助函数

Fri, 22 Mar 2019 00:00:00 +0000

Laravel 框架自带了一系列 PHP 辅助函数，很多被框架自身使用。了解这些函数方便我们在代码中善用它们。

数组函数

array_add()

添加给定键值对到数组（如果给定键不存在）：

// 如果键不存在则添加
$array = array_add(['name' => 'Desk'], 'price', 100);
// ['name' => 'Desk', 'price' => 100]

// 如果键已存在则不添加
$array = array_add(['name' => 'Desk', 'price' => 50], 'price', 100);
// ['name' => 'Desk', 'price' => 50] 价格保持 50

array_collapse()

将多个数组合并成一个：

$array = array_collapse([[1, 2, 3], [4, 5, 6], [7, 8, 9]]);
// [1, 2, 3, 4, 5, 6, 7, 8, 9]

// 实际应用：分组数据合并
$postsByCategory = [
 'tech' => [['title' => 'Post 1'], ['title' => 'Post 2']],
 'life' => [['title' => 'Post 3']],
];
$allPosts = array_collapse($postsByCategory);
// [['title' => 'Post 1'], ['title' => 'Post 2'], ['title' => 'Post 3']]

array_divide()

分离数组的键和值：

[$keys, $values] = array_divide(['name' => 'Desk', 'price' => 100]);
// $keys = ['name', 'price']
// $values = ['Desk', 100]

array_dot()

将多维数组转为一维（使用点号分隔键）：

$array = [
 'products' => [
 'desk' => [
 'price' => 100,
 ],
 ],
];

$flattened = array_dot($array);
// [
// 'products.desk.price' => 100,
// ]

array_except() / array_only()

// 排除指定键
$array = ['name' => 'Desk', 'price' => 100, 'orders' => 10];
$except = array_except($array, ['price']);
// ['name' => 'Desk', 'orders' => 10]

// 只保留指定键
$array = ['name' => 'Desk', 'price' => 100, 'orders' => 10];
$only = array_only($array, ['name', 'price']);
// ['name' => 'Desk', 'price' => 100]

array_first() / array_last()

$array = [100, 200, 300];

// 返回第一个匹配的元素
$first = array_first($array, function ($value) {
 return $value >= 150;
});
// 200

// 返回最后一个匹配的元素
$last = array_last($array, function ($value) {
 return $value >= 150;
});
// 300

// 支持默认值
$first = array_first($array, function ($value) {
 return $value >= 500;
}, 'default');
// 'default'

array_flatten()

多维数组转一维：

$array = [['id' => 1], ['id' => 2], [['id' => 3]]];
$flattened = array_flatten($array);
// [1, 2, 3]

array_forget()

使用点号语法删除数组元素：

$array = ['products' => ['desk' => ['price' => 100]]];
array_forget($array, 'products.desk.price');

// $array = ['products' => ['desk' => []]]

array_get()

使用点号语法获取数组值：

$array = [
 'products' => [
 'desk' => ['price' => 100],
 ],
];

$price = array_get($array, 'products.desk.price');
// 100

// 支持默认值
$price = array_get($array, 'products.chair.price', 200);
// 200

array_has()

检查数组是否有指定键：

$array = ['products' => ['desk' => ['price' => 100]]];

array_has($array, 'products.desk');
// true

array_has($array, 'products.chair');
// false

// 支持检查多个键
array_has($array, ['products.desk', 'products.chair']);
// false

array_pluck()

提取数组中指定键的值：

$array = [
 ['product' => 'Desk', 'price' => 100],
 ['product' => 'Chair', 'price' => 50],
];

$products = array_pluck($array, 'product');
// ['Desk', 'Chair']

// 带键
$products = array_pluck($array, 'product', 'price');
// [100 => 'Desk', 50 => 'Chair']

array_pull()

弹出数组元素并删除：

$array = ['name' => 'Desk', 'price' => 100];

$name = array_pull($array, 'name');
// $name = 'Desk'
// $array = ['price' => 100]

array_set()

使用点号语法设置数组值：

$array = [];
array_set($array, 'products.desk.price', 100);

// $array = ['products' => ['desk' => ['price' => 100]]]

array_sort()

按值排序：

$array = [
 ['name' => 'Desk', 'price' => 100],
 ['name' => 'Chair', 'price' => 50],
 ['name' => 'Table', 'price' => 75],
];

$sorted = array_values(array_sort($array, function ($item) {
 return $item['price'];
}));
// [
// ['name' => 'Chair', 'price' => 50],
// ['name' => 'Table', 'price' => 75],
// ['name' => 'Desk', 'price' => 100],
// ]

array_where()

条件过滤数组：

$array = [100, 200, 300, 400, 500];

$filtered = array_where($array, function ($value, $key) {
 return $value >= 200;
});
// [1 => 200, 2 => 300, 3 => 400, 4 => 500]

head() / last()

$array = [100, 200, 300];

head($array); // 100 - 返回第一个元素
last($array); // 300 - 返回最后一个元素

字符串函数

str_contains()

检查字符串是否包含指定内容：

str_contains('Hello World', 'World');
// true

str_contains('Hello World', ['World', 'PHP']);
// true

str_contains('Hello World', ['World', 'PHP']);
// true - 任一匹配即返回 true

str_start()

确保字符串以指定内容开头：

str_start('World', 'Hello ');
// 'Hello World'

str_start('Hello World', 'Hello ');
// 'Hello World' - 已经是则不变

str_finish()

确保字符串以指定内容结尾：

str_finish('Hello', ' World');
// 'Hello World'

str_finish('Hello World', ' World');
// 'Hello World' - 已经是则不变

str_limit()

截断字符串：

str_limit('The quick brown fox jumps over the lazy dog', 20);
// 'The quick brown fox...'

str_limit('The quick brown fox', 20, ' (...)');
// 'The quick brown (...)'

str_plural() / str_singular()

单复数转换：

str_plural('child');
// 'children'

str_plural('child', 1);
// 'child'

str_plural('children');
// 'children'

str_singular('children');
// 'child'

str_slug()

生成 URL 友好的字符串：

str_slug('Hello World');
// 'hello-world'

str_slug('Hello World!', '_');
// 'hello_world'

str_slug('日本語');
// 'ri-ben-yu'

str_replace_array()

批量替换字符串：

$string = 'The framework has :count widgets';

str_replace_array(':count', [5], $string);
// 'The framework has 5 widgets'

str_replace_first() / str_replace_last()

str_replace_first('the', 'a', 'the quick the fox');
// 'a quick the fox'

str_replace_last('the', 'a', 'the quick the fox');
// 'the quick a fox'

// 对应门面（文件顶部需：use Illuminate\Support\Str;）
// Str::replaceLast('world', 'PHP', 'Hello world'); // Hello PHP

str_replace_* 系列常用于日志脱敏、路径规范化等场景；新版本 Laravel 亦可使用 Illuminate\Support\Str 门面，请以当前版本文档为准。

你应该了解的PHP缓存技术

Wed, 09 Jan 2019 00:00:00 +0000

缓存是现代系统中必不可少的模块，已经成为高并发高性能架构的关键组件。

缓存概念

什么是缓存

缓存是将程序或系统经常要调用的对象存在内存中，以便快速调用，不必重复创建实例。这样可以减少系统开销，提高系统效率。

缓存分类

类型	说明	示例
文件缓存	数据存储在磁盘上	XML、JSON、序列化文件
内存缓存	存储在静态内存区域	Application、静态 Map
分布式缓存	跨进程、跨域访问	Redis、Memcached

PHP 缓存类型

PHP 编译缓存

PHP 是解释型语言，执行过程包括：

编译过程：读取文件，编译成中间码
执行过程：直接执行中间码

问题：

即使代码文件未改变，也会被重新编译
引用文件也需要重新编译

解决方案：PHP 编译缓存工具

工具	说明
APC	Alternative PHP Cache
OPcache	PHP 内置（PHP 5.5+）
XCache	国产高性能编译器

启用 OPcache

; php.ini
zend_extension=opcache.so

; 基本配置
opcache.enable=1
opcache.memory_consumption=128
opcache.max_accelerated_files=10000
opcache.revalidate_freq=2

PHP 数据缓存

类型	缓存内容	工具
数据库缓存	查询结果	Memcached、Redis
模板缓存	页面模板	Smarty、Twig

缓存优势

1. 提升性能

减少数据库查询
加速远程调用
降低响应时间

2. 缓解数据库压力

┌─────────┐ 请求 ┌─────────┐
│ 用户 │ ───────▶ │ Nginx │
└─────────┘ └────┬────┘
 │
 ┌─────▼─────┐
 │ 缓存层 │ ◀──────┐ 命中
 └─────┬─────┘ │
 │ 未命中 │
 ┌─────▼─────┐ │
 │ 数据库 │ ──────┘ 写入
 └───────────┘

常用缓存方案

1. 文件缓存

<?php

/**
 * 简单文件缓存类
 */
class FileCache
{
 private $cacheDir;
 private $expire = 3600;

 public function __construct(string $cacheDir = './cache', int $expire = 3600)
 {
 $this->cacheDir = rtrim($cacheDir, '/');
 $this->expire = $expire;
 
 if (!is_dir($this->cacheDir)) {
 mkdir($this->cacheDir, 0755, true);
 }
 }

 /**
 * 设置缓存
 */
 public function set(string $key, $value, ?int $expire = null): bool
 {
 $file = $this->getFilePath($key);
 $data = [
 'value' => $value,
 'expire' => time() + ($expire ?? $this->expire),
 ];
 
 return file_put_contents(
 $file,
 serialize($data),
 LOCK_EX
 ) !== false;
 }

 /**
 * 获取缓存
 */
 public function get(string $key, $default = null)
 {
 $file = $this->getFilePath($key);
 
 if (!file_exists($file)) {
 return $default;
 }
 
 $content = file_get_contents($file);
 $data = unserialize($content);
 
 if ($data['expire'] < time()) {
 unlink($file);
 return $default;
 }
 
 return $data['value'];
 }

 /**
 * 删除缓存
 */
 public function delete(string $key): bool
 {
 $file = $this->getFilePath($key);
 return file_exists($file) ? unlink($file) : true;
 }

 /**
 * 清除所有缓存
 */
 public function clear(): bool
 {
 $files = glob($this->cacheDir . '/*');
 foreach ($files as $file) {
 if (is_file($file)) {
 unlink($file);
 }
 }
 return true;
 }

 private function getFilePath(string $key): string
 {
 return $this->cacheDir . '/' . md5($key) . '.cache';
 }
}

// 使用示例
$cache = new FileCache('./cache', 3600);

// 设置缓存
$cache->set('user_1', ['name' => 'John', 'email' => 'john@example.com']);

// 获取缓存
$user = $cache->get('user_1');
if ($user) {
 echo "缓存命中: " . json_encode($user);
} else {
 // 从数据库获取
 $user = fetchUserFromDB(1);
 $cache->set('user_1', $user);
}

2. Memcached

<?php

/**
 * Memcached 缓存封装
 */
class MemcachedCache
{
 private $memcached;

 public function __construct(array $servers = [])
 {
 $this->memcached = new Memcached();
 
 if (empty($servers)) {
 $servers = [
 ['127.0.0.1', 11211, 100],
 ];
 }
 
 $this->memcached->addServers($servers);
 }

 /**
 * 设置缓存
 */
 public function set(string $key, $value, int $ttl = 0): bool
 {
 return $this->memcached->set($key, $value, $ttl);
 }

 /**
 * 获取缓存
 */
 public function get(string $key)
 {
 return $this->memcached->get($key);
 }

 /**
 * 删除缓存
 */
 public function delete(string $key): bool
 {
 return $this->memcached->delete($key);
 }

 /**
 * 增加数值
 */
 public function increment(string $key, int $offset = 1)
 {
 return $this->memcached->increment($key, $offset);
 }

 /**
 * 清除所有缓存
 */
 public function flush(): bool
 {
 return $this->memcached->flush();
 }

 /**
 * 获取多条缓存
 */
 public function getMulti(array $keys): array
 {
 return $this->memcached->getMulti($keys);
 }

 /**
 * 批量设置
 */
 public function setMulti(array $items, int $ttl = 0): bool
 {
 return $this->memcached->setMulti($items, $ttl);
 }
}

// 使用示例
$cache = new MemcachedCache([
 ['127.0.0.1', 11211],
]);

// 设置缓存
$cache->set('user_1', ['name' => 'John'], 3600);

// 获取缓存
$user = $cache->get('user_1');

// 计数器
$cache->set('page_views', 0);
$cache->increment('page_views');

3. Redis

<?php

/**
 * Redis 缓存封装
 */
class RedisCache
{
 private $redis;

 public function __construct(string $host = '127.0.0.1', int $port = 6379)
 {
 $this->redis = new Redis();
 $this->redis->connect($host, $port);
 }

 /**
 * 设置缓存
 */
 public function set(string $key, $value, ?int $ttl = null): bool
 {
 $value = is_array($value) ? json_encode($value) : $value;
 
 if ($ttl === null) {
 return $this->redis->set($key, $value);
 }
 
 return $this->redis->setex($key, $ttl, $value);
 }

 /**
 * 获取缓存
 */
 public function get(string $key)
 {
 $value = $this->redis->get($key);
 
 if ($value === null) {
 return null;
 }
 
 // 尝试 JSON 解码
 $decoded = json_decode($value, true);
 return json_last_error() === JSON_ERROR_NONE ? $decoded : $value;
 }

 /**
 * 删除缓存
 */
 public function delete(string $key): int
 {
 return (int) $this->redis->del($key);
 }

 /**
 * 判断键是否存在
 */
 public function exists(string $key): bool
 {
 return $this->redis->exists($key) > 0;
 }

 /**
 * 设置过期时间（秒）
 */
 public function expire(string $key, int $seconds): bool
 {
 return $this->redis->expire($key, $seconds);
 }
}

// 使用示例
$redis = new RedisCache();
$redis->set('foo', 'bar', 60);
var_dump($redis->get('foo'));
$redis->delete('foo');

提示：生产环境建议加连接池、统一 Key 前缀、超时与熔断，并结合业务决定哪些数据适合落在 Redis。

选型小结

场景	建议
单机小规模、持久化不重要	文件缓存 / APCu
多节点共享会话、计数	Memcached
丰富数据结构 + 持久化	Redis

结合 OPcache 减少 PHP 脚本重复编译，再配合数据缓存，通常能在成本可控的前提下显著提升站点响应速度。

分库分表de那些事【理论篇】

Sat, 22 Dec 2018 00:00:00 +0000

关系型数据库本身比较容易成为系统瓶颈，单机存储容量、连接数、处理能力都有限。当单表的数据量达到1000万或100GB以后，由于查询维度较多，即使添加从库、优化索引，做很多操作时性能仍下降严重。

概念

什么是分库分表

顾名思义，分库分表就是按照一定的规则，对原有的数据库和表进行拆分，把原本存储于一个库的数据分块存储到多个库上，把原本存储于一个表的数据分块存储到多个表上。

为什么需要分库分表

随着时间和业务的发展，数据库中的数据量增长是不可控的，库和表中的数据会越来越大，随之带来的是更高的磁盘、IO、系统开销，甚至性能上的瓶颈，而一台服务的资源终究是有限的，因此需要对数据库和表进行拆分，从而更好的提供数据服务。

数据切分

数据库分布式核心内容无非就是数据切分（Sharding），以及切分后对数据的定位、整合。

数据切分就是将数据分散存储到多个数据库中，使得单一数据库中的数据量变小，通过扩充主机的数量缓解单一数据库的性能问题，从而达到提升数据库操作性能的目的。

数据切分根据其切分类型，可以分为两种方式：垂直（纵向）切分和水平（横向）切分

切分方式

垂直切分

简单来说就是竖着切，试想一下，把一个库中很多张表竖着切，这些表就会散开。其实垂直切分就是这个意思，将不同模块的表放到不同的数据库中。

比如支付的放在支付数据库，用户的放在用户数据库，会员的放在会员数据库等等，可以减少耦合性。

常见有垂直分库和垂直分表两种。

垂直分库
- 就是根据业务耦合性，将关联度低的不同表存储在不同的数据库。
- 做法与大系统拆分为多个小系统类似，按业务分类进行独立划分。
- 与"微服务治理"的做法相似，每个微服务使用单独的一个数据库。

垂直分表
- 基于数据库中的"列"进行，某个表字段较多，可以新建一张扩展表，将不经常用或字段长度较大的字段拆分出去到扩展表中。
- 在字段很多的情况下（例如一个大表有100多个字段），通过"大表拆小表"，更便于开发与维护，也能避免跨页问题。
- MySQL底层是通过数据页存储的，一条记录占用空间过大会导致跨页，造成额外的性能开销。
- 另外数据库以行为单位将数据加载到内存中，这样表中字段长度较短且访问频率较高，内存能加载更多的数据，命中率更高，减少了磁盘IO，从而提升了数据库性能。

【优点】

解决业务系统层面的耦合，业务清晰
与微服务的治理类似，也能对不同业务的数据进行分级管理、维护、监控、扩展等
高并发场景下，垂直切分一定程度的提升IO、数据库连接数、单机硬件资源的瓶颈

【缺点】

部分表无法join，只能通过接口聚合方式解决，提升了开发的复杂度
分布式事务处理复杂
依然存在单表数据量过大的问题（需要水平切分）

水平切分

将某张访问非常频繁的表，按照某个特定的规则（通常是某个字段进行hash），然后将数据分散到多个表，甚至是多个数据库中，这样每张表或者每张库都含有一部分数据。

【优点】

不存在单库数据量过大、高并发的性能瓶颈，提升系统稳定性和负载能力
应用端改造较小，不需要拆分业务模块

【缺点】

跨分片的事务一致性难以保证
跨库的join关联查询性能较差
数据多次扩展难度和维护量极大

水平切分后同一张表会出现在多个数据库/表中，每个库/表的内容不同。

数据分片规则

I. 查询切分

首先数据库分片，将sharding key记录在一个单独的库中，你每次要查询数据库的时候，请先到mapping db里面去查一下你应该到那个数据库去拿数据。

这个mapping db是否真的有需要，是否shading key提供一种约定，比如说根据用户id来进行hash进行分散到不同的数据库中。
当然这只是一种分片策略，如果你觉得慢，可以把这个表结构缓存在内存中。这样就很快了

II. 范围切分

按照范围来切分，比如说按照时间范围和ID的范围来进行切分

例如：按日期将不同月甚至是日的数据分散到不同的库中；将userId为1 ~ 9999的记录分到第一个库，10000 ~ 20000的分到第二个库，以此类推。

某种意义上，某些系统中使用的"冷热数据分离"，将一些使用较少的历史数据迁移到其他库中，业务功能上只提供热点数据的查询，也是类似的实践。

【优点】

单表大小可控
天然便于水平扩展，后期如果想对整个分片集群扩容时，只需要添加节点即可，无需对其他分片的数据进行迁移
使用分片字段进行范围查找时，连续分片可快速定位分片进行快速查询，有效避免跨分片查询的问题。

【缺点】

热点数据成为性能瓶颈。
- 连续分片可能存在数据热点，例如按时间字段分片，有些分片存储最近时间段内的数据，可能会被频繁的读写，而有些分片存储的历史数据，则很少被查询

III. Hash切分

一般使用取模运算来进行切分，也就是Mod切分，图中db mod代表db取模，tb mod代表tb取模

比如分库分表的方案是32个数据库实例，通过userId进行取模的话就是，将UserId后面4位模32然后丢到32个数据库中，同时又将UserId后面4位除以32再mod32丢到32张表里面，这样就有1024张表，然后线上部署8个主从实例，每个实例4个数据库。完毕。

【优点】

数据分片相对比较均匀，不容易出现热点和并发访问的瓶颈

【缺点】

后期分片集群扩容时，需要迁移旧的数据（使用一致性hash算法能较好的避免这个问题）
容易面临跨分片查询的复杂问题。
- 如果频繁用到的查询条件中不带sharding key时，将会导致无法定位数据库，从而需要同时向多个库发起查询，再在内存中合并数据，取最小集返回给应用，分库反而成为拖累。

潜在问题

事务问题

当更新内容同时分布在不同库中，不可避免会带来跨库事务问题。

解决事务问题目前有两种可行的方案：

方案一：使用分布式事务

跨分片事务也是分布式事务，没有简单的方案，一般可使用"XA协议"和"两阶段提交"处理。

【优点】

交由数据库管理，简单有效

【缺点】

性能代价高，特别是shard越来越多时

方案二：由应用程序和数据库共同控制

原理：将一个跨多个数据库的分布式事务分拆成多个仅处于单个数据库上面的小事务，并通过应用程序来总控各个小事务。

【优点】

性能上有优势

【缺点】

需要应用程序在事务控制上做灵活设计。
如果使用了spring的事务管理，改动起来会面临一定的困难。

一致性

对于那些性能要求很高，但对一致性要求不高的系统，往往不苛求系统的实时一致性，只要在允许的时间段内达到最终一致性即可，可采用事务补偿的方式。

与事务在执行中发生错误后立即回滚的方式不同，事务补偿是一种事后检查补救的措施。
一些常见的实现方法有：对数据进行对账检查，基于日志进行对比，定期同标准数据来源进行同步等等。事务补偿还要结合业务系统来考虑。

跨节点Join的问题

只要是进行切分，跨节点Join的问题是不可避免的。但是良好的设计和切分却可以减少此类情况的发生。

1）全局表

全局表，也可看做是"数据字典表"，就是系统中所有模块都可能依赖的一些表，为了避免跨库join查询，可以将这类表在每个数据库中都保存一份。

这些数据通常很少会进行修改，所以也不担心一致性的问题。

2）字段冗余

一种典型的反范式设计，利用空间换时间，为了性能而避免join查询。

例如：订单表保存userId时候，也将userName冗余保存一份，这样查询订单详情时就不需要再去查询"买家user表"了。

【缺点】

但这种方法适用场景也有限，比较适用于依赖字段比较少的情况。
而冗余字段的数据一致性也较难保证，就像上面订单表的例子，买家修改了userName后，是否需要在历史订单中同步更新呢？这也要结合实际业务场景进行考虑。

3）数据组装

在系统层面，分两次查询。

第一次查询的结果集中找出关联数据id，
然后根据id发起第二次请求得到关联数据。
最后将获得到的数据进行字段拼装。

4）ER分片

关系型数据库中，如果可以先确定表之间的关联关系，并将那些存在关联关系的表记录存放在同一个分片上，那么就能较好的避免跨分片join问题。

在1:1或1:n的情况下，通常按照主表的ID主键切分。

这样一来，Data Node1上面的order订单表与orderdetail订单详情表，就可以通过orderId进行局部的关联查询了，Data Node2上也一样。

数据迁移，容量规划，扩容等问题

【方案】

利用对2的倍数取余具有向前兼容的特性（如：对4取余得1、对2取余也是1的数）来分配数据。
避免了行级别的数据迁移，但是依然需要进行表级别的迁移，同时对扩容规模和分表数量都有限制。

【缺点】

总的来说，这些方案都不是十分的理想，多多少少都存在一些缺点，这也从一个侧面反映出了Sharding扩容的难度。

主键ID问题

一旦数据库被切分到多个物理结点上，我们将不能再依赖数据库自身的主键生成机制。

一方面，某个分区数据库自生成的ID无法保证在全局上是唯一的；
另一方面，应用程序在插入数据之前需要先获得ID，以便进行SQL路由。

1) UUID

UUID标准形式包含32个16进制数字，分为5段，形式为8-4-4-4-12的36个字符，例如：550e8400-e29b-41d4-a716-446655440000

UUID是主键是最简单的方案，本地生成，性能高，没有网络耗时。

【缺点】

由于UUID非常长，会占用大量的存储空间；
另外，作为主键建立索引和基于索引进行查询时都会存在性能问题;
在InnoDB下，UUID的无序性会引起数据位置频繁变动，导致分页。

2) 结合数据库维护一个Sequence表

此方案的思路也很简单，在数据库中建立一个Sequence表，表的结构类似于：

CREATE TABLE `SEQUENCE` ( 
 `table_name` varchar(18) NOT NULL, 
 `nextid` bigint(20) NOT NULL, 
 PRIMARY KEY (`table_name`) 
) ENGINE=InnoDB

每当需要为某个表的新纪录生成ID时就从Sequence表中取出对应表的nextid，并将nextid的值加1后更新到数据库中以备下次使用。

【缺点】

由于所有插入任何都需要访问该表，该表很容易成为系统性能瓶颈。
同时它也存在单点问题，一旦该表数据库失效，整个应用程序将无法工作。
有人提出使用Master-Slave进行主从同步，但这也只能解决单点问题，并不能解决读写比为1:1的访问压力问题。

3) Snowflake分布式自增ID算法

Twitter的snowflake算法解决了分布式系统生成全局ID的需求，生成64位的Long型数字，组成部分：

第一位未使用
接下来41位是毫秒级时间，41位的长度可以表示69年的时间
5位datacenterId，5位workerId。10位的长度最多支持部署1024个节点
最后12位是毫秒内的计数，12位的计数顺序号支持每个节点每毫秒产生4096个ID序列

【优点】

毫秒数在高位，生成的ID整体上按时间趋势递增；
不依赖第三方系统，稳定性和效率较高，理论上QPS约为409.6w/s（1000*2^12）；
并且整个分布式系统内不会产生ID碰撞；
可根据自身业务灵活分配bit位。

【缺点】

强依赖机器时钟，如果时钟回拨，则可能导致生成ID重复。

跨分片的排序分页

一般来讲，分页时需要按照指定字段进行排序。当排序字段就是分片字段的时候，我们通过分片规则可以比较容易定位到指定的分片，而当排序字段非分片字段的时候，情况就会变得比较复杂了。

为了最终结果的准确性，我们需要在不同的分片节点中将数据进行排序并返回，并将不同分片返回的结果集进行汇总和再次排序，最后再返回给用户。

如果取得页数很大，情况则变得复杂很多，因为各分片节点中的数据可能是随机的，为了排序的准确性，需要将所有节点的前N页数据都排序好做合并，最后再进行整体的排序，这样的操作时很耗费CPU和内存资源的，所以页数越大，系统的性能也会越差。

【方案】

如果是在前台应用提供分页，则限定用户只能看前面n页，这个限制在业务上也是合理的，一般看后面的分页意义不大（如果一定要看，可以要求用户缩小范围重新查询）。
如果是后台批处理任务要求分批获取数据，则可以加大page size，比如每次获取5000条记录，有效减少分页数（当然离线访问一般走备库，避免冲击主库）。
分库设计时，一般还有配套大数据平台汇总所有分库的记录，有些分页查询可以考虑走大数据平台。

原则

能不切分尽量不要切分

并不是所有表都需要进行切分，主要还是看数据的增长速度。

切分后会在某种程度上提升业务的复杂度，数据库除了承载数据的存储和查询外，协助业务更好的实现需求也是其重要工作之一。
不到万不得已不用轻易使用分库分表这个大招，避免"过度设计"和"过早优化"。
分库分表之前，不要为分而分，先尽力去做力所能及的事情，例如：升级硬件、升级网络、读写分离、索引优化等等。
当数据量达到单表的瓶颈时候，再考虑分库分表。

数据量过大，正常运维影响业务访问

1）对数据库备份，如果单表太大，备份时需要大量的磁盘IO和网络IO。

例如1T的数据，网络传输占50MB时候，需要20000秒才能传输完毕，整个过程的风险都是比较高的

2）对一个很大的表进行DDL修改时，MySQL会锁住全表。

这个时间会很长，这段时间业务不能访问此表，影响很大。
如果使用pt-online-schema-change，使用过程中会创建触发器和影子表，也需要很长的时间。
在此操作过程中，都算为风险时间。将数据表拆分，总量减少，有助于降低这个风险。

3）大表会经常访问与更新，就更有可能出现锁等待。

将数据切分，用空间换时间，变相降低访问压力

随着业务发展，需要对某些字段垂直拆分

举个例子，假如项目一开始设计的用户表如下：

id bigint #用户的ID
name varchar #用户的名字
last_login_time datetime #最近登录时间
personal_info text #私人信息
..... #其他信息字段

在项目初始阶段，这种设计是满足简单的业务需求的，也方便快速迭代开发。

而当业务快速发展时，用户量从10w激增到10亿，用户非常的活跃。

每次登录会更新 last_login_name 字段，使得 user 表被不断update，压力很大。
而其他字段：id, name, personal_info 是不变的或很少更新的。
- 此时在业务角度，就要将 last_login_time 拆分出去，新建一个 user_time 表。
- personal_info 属性是更新和查询频率较低的，并且text字段占据了太多的空间，这时候就要对此垂直拆分出 user_ext 表了。

数据量快速增长

随着业务的快速发展，单表中的数据量会持续增长，当性能接近瓶颈时，就需要考虑水平切分，做分库分表了。此时一定要选择合适的切分规则，提前预估好数据容量

分库数量

分库数量首先和单库能处理的记录数有关。

一般来说，Mysql 单库超过5000万条记录，Oracle单库超过1亿条记录，DB压力就很大(当然处理能力和字段数量/访问模式/记录长度有进一步关系)。

在满足上述前提下，如果分库数量少，达不到分散存储和减轻DB性能压力的目的；
如果分库的数量多，好处是每个库记录少，单库访问性能好，但对于跨多个库的访问，应用程序需要访问多个库，如果是并发模式，要消耗宝贵的线程资源；
如果是串行模式，执行时间会急剧增加。

最后分库数量还直接影响硬件的投入，一般每个分库跑在单独物理机上，多一个库意味多一台设备。

所以具体分多少个库，要综合评估，一般初次分库建议分4-8个库。

路由透明

分库从某种意义上来说，意味着DB schema改变了，必然影响应用，但这种改变和业务无关，所以要尽量保证分库对应用代码透明，分库逻辑尽量在数据访问层处理。

当然完全做到这一点很困难，具体哪些应该由DAL负责，哪些由应用负责，这里有一些建议：

对于单库访问，比如查询条件指定用户Id，则该SQL只需访问特定库。
- 此时应该由DAL层自动路由到特定库，当库二次分裂时，也只要修改mod 因子，应用代码不受影响。
对于简单的多库查询，DAL负责汇总各个数据库返回的记录，此时仍对上层应用透明。

安全性和可用性

在业务层面上垂直切分，将不相关的业务的数据库分隔。

因为每个业务的数据量、访问量都不同，不能因为一个业务把数据库搞挂而牵连到其他业务。

利用水平切分，当一个数据库出现问题时，不会影响到100%的用户，每个库只承担业务的一部分数据，这样整体的可用性就能提高。

开源中间件

站在巨人的肩膀上能省力很多，目前分库分表已经有一些较为成熟的开源解决方案：

Docker从零构建php-nginx-alpine镜像

Fri, 09 Nov 2018 00:00:00 +0000

虽然之前用 Docker 环境运行了一些项目，但对于镜像这块还不是很理解，且网上现成的镜像都包含太多用不到的库，所以决定从零开始构建一个自己的镜像。

选择 Alpine Linux 作为基础镜像

# 拉取 Alpine 镜像
docker pull alpine:latest

# 查看镜像
docker images alpine

Alpine Linux 是一个面向安全的轻量级 Linux 发行版，镜像只有 5MB 左右。

运行并进入容器

# 交互式运行
docker run -it alpine /bin/sh

# 或后台运行
docker run -d --name my-alpine alpine:latest
docker exec -it my-alpine /bin/sh

安装 PHP 和 Nginx

# 更新包索引
apk update

# 安装 PHP 和 Nginx
apk add php7 php7-fpm php7-cli nginx

# 如果使用 PHP 8.x
apk add php81 php81-fpm php81-cli nginx

⚠️ 提示：Alpine 3.18+ 使用 php81、php82 等命名

安装 PHP 扩展

# 安装常用扩展
apk add php7-mysqli \
 php7-pdo_mysql \
 php7-mbstring \
 php7-json \
 php7-zlib \
 php7-gd \
 php7-intl \
 php7-session \
 php7-curl \
 php7-posix \
 php7-fileinfo \
 php7-simplexml \
 php7-xml \
 php7-openssl \
 php7-dom \
 php7-phar

# PHP 8.x 扩展
apk add php81-mysqli php81-pdo_mysql php81-mbstring php81-xml php81-curl

目录结构

软件	路径
PHP 配置	`/etc/php7`
Nginx 配置	`/etc/nginx`
网站目录	`/var/www/localhost/htdocs`
日志目录	`/var/log/nginx`

配置 PHP-FPM

修改 www.conf

vi /etc/php7/php-fpm.d/www.conf

[www]
user = nobody
group = nobody
listen = 127.0.0.1:9000

配置 Nginx

nginx.conf

vi /etc/nginx/nginx.conf

worker_processes auto;
error_log /var/log/nginx/error.log warn;
pid /run/nginx.pid;

events {
 worker_connections 1024;
}

http {
 include /etc/nginx/mime.types;
 default_type application/octet-stream;
 
 log_format main '$remote_addr - $remote_user [$time_local] "$request" '
 '$status $body_bytes_sent "$http_referer" '
 '"$http_user_agent" "$http_x_forwarded_for"';
 
 access_log /var/log/nginx/access.log main;
 
 sendfile on;
 keepalive_timeout 65;
 
 include /etc/nginx/conf.d/*.conf;
}

default.conf

vi /etc/nginx/conf.d/default.conf

server {
 listen 80 default_server;
 root /var/www/localhost/htdocs;
 index index.php index.html;
 
 server_name localhost;
 
 location / {
 try_files $uri $uri/ =404;
 }
 
 location ~ \.php$ {
 fastcgi_pass 127.0.0.1:9000;
 fastcgi_index index.php;
 fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
 include fastcgi_params;
 }
 
 location ~ /\.ht {
 deny all;
 }
}

启动服务

# 创建必要的目录
mkdir -p /run/nginx

# 启动 PHP-FPM
/usr/sbin/php-fpm7

# 启动 Nginx
/usr/sbin/nginx

# 测试
curl http://localhost

创建 Dockerfile

基础版本

# Dockerfile
FROM alpine:latest

LABEL maintainer="yisonli <email@example.com>"
LABEL version="1.0"
LABEL description="PHP7 + Nginx on Alpine Linux"

# 安装系统工具
RUN apk add --no-cache \
 openssl \
 curl \
 ca-certificates \
 bash

# 安装 PHP 和扩展
RUN apk add --no-cache \
 php7 \
 php7-fpm \
 php7-mysqli \
 php7-pdo_mysql \
 php7-mbstring \
 php7-json \
 php7-gd \
 php7-curl

# 安装 Nginx
RUN apk add --no-cache nginx

# 配置 PHP-FPM
RUN mkdir -p /run/nginx \
 && chown -R nobody:nobody /var/www/localhost

# 复制配置文件
COPY nginx.conf /etc/nginx/nginx.conf
COPY default.conf /etc/nginx/conf.d/
COPY php.ini /etc/php7/php.ini
COPY php-fpm.conf /etc/php7/php-fpm.conf

# 复制应用代码
COPY ./app /var/www/localhost/htdocs

# 暴露端口
EXPOSE 80 443

# 启动脚本
COPY start.sh /start.sh
RUN chmod +x /start.sh

CMD ["/start.sh"]

启动脚本

#!/bin/sh
# start.sh

# 创建必要目录
mkdir -p /run/nginx /var/log/nginx /var/tmp/php-fpm

# 设置权限
chown -R nobody:nobody /var/www/localhost

# 启动 PHP-FPM
/usr/sbin/php-fpm7 &

# 启动 Nginx
/usr/sbin/nginx -g 'daemon off;'

PHP 配置文件

; php.ini
upload_max_filesize = 50M
post_max_size = 50M
memory_limit = 128M
max_execution_time = 300

docker-compose.yml

version: '3.8'

services:
 web:
 build: .
 ports:
 - "8080:80"
 volumes:
 - ./app:/var/www/localhost/htdocs
 environment:
 - PHP_MEMORY_LIMIT=256M
 restart: unless-stopped

 mysql:
 image: mysql:8.0
 environment:
 MYSQL_ROOT_PASSWORD: secret
 MYSQL_DATABASE: app
 volumes:
 - mysql_data:/var/lib/mysql

volumes:
 mysql_data:

构建并运行

# 构建镜像
docker build -t my-php-app:1.0 .

# 运行容器
docker run -d -p 8080:80 --name my-app my-php-app:1.0

# 使用 docker-compose
docker-compose up -d

# 查看日志
docker logs -f my-app

# 进入容器
docker exec -it my-app /bin/sh

常用 Docker 命令

# 查看运行中的容器
docker ps

# 查看所有容器
docker ps -a

# 删除未运行的容器
docker rm $(docker ps -a -q)

# 提交镜像
docker commit -a "yisonli" -m "my php7-nginx" CONTAINER_ID my-php-app:0.1

# 添加标签
docker tag IMAGE_ID my-repo/my-image:tag

# 推送镜像
docker push my-repo/my-image:tag

共享文件夹

# 挂载本地目录
docker run -v $(pwd)/www:/var/www/localhost/htdocs \
 -p 8080:80 \
 my-php-app:1.0

优化建议

使用多阶段构建减小镜像体积
合并 RUN 指令减少层数
使用 .dockerignore排除不需要的文件
使用国内镜像源加速构建

多阶段构建示例

# 构建阶段
FROM composer:2 as builder
WORKDIR /app
COPY composer.* ./
RUN composer install --no-dev
COPY . .
RUN composer dump-autoload --optimize

# 运行阶段
FROM alpine:latest
COPY --from=builder /app /var/www/localhost/htdocs
# ...

参考链接

PHP7内存管理 - 谁动了我的内存

Mon, 05 Nov 2018 00:00:00 +0000

来源：Laruence

Zend 引擎提供了一种特殊的内存管理器，用于处理请求相关数据。请求相关数据是指只需要服务于单个请求，最迟会在请求结束时释放的数据。

内存管理基础

问题引入

<?php

var_dump(memory_get_usage());
// 输出：int(61800) 初始内存

$a = "laruence";
var_dump(memory_get_usage());
// 输出：int(61864) 字符串占用

unset($a);
var_dump(memory_get_usage());
// 输出：int(61864) 为什么没有释放？

内存管理机制

┌─────────────────────────────────────────────────────────────┐
│ PHP 内存管理机制 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 分配请求数据 │
│ │ │
│ ▼ │
│ ┌─────────┐ │
│ │ Zend MM │ ← 特殊内存管理器 │
│ └────┬────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────┐ │
│ │ 堆（Heap） │ │
│ │ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ │ │
│ │ │chunk│ │chunk│ │chunk│ │chunk│ │ │
│ │ └─────┘ └─────┘ └─────┘ └─────┘ │ │
│ └─────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘

内存分配策略

Zend MM 内存池

<?php

// 预分配内存（减少系统调用）
var_dump(memory_get_usage(true));
// 输出：int(262144) 256KB 预分配

// 查看峰值
var_dump(memory_get_peak_usage());
// 输出：最大内存使用量

// 峰值（真实分配）
var_dump(memory_get_peak_usage(true));

内存分配函数

函数	说明
`emalloc()`	分配请求内存
`efree()`	释放请求内存
`estrdup()`	复制字符串
`ecalloc()`	分配并初始化为零
`erealloc()`	重新分配内存

PHP 7 内存改进

与 PHP 5 的区别

┌─────────────────────────────────────────────────────────────┐
│ PHP 5 vs PHP 7 内存对比 │
├─────────────────────────────────────────────────────────────┤
│ │
│ PHP 5: │
│ ┌────────────────────┐ │
│ │ zval (16 bytes) │ │
│ │ ├─ refcount (4B) │ │
│ │ ├─ is_ref (4B) │ │
│ │ └─ value (8B) │ │
│ └────────────────────┘ │
│ │
│ PHP 7: │
│ ┌────────────────────┐ │
│ │ zval (16/32 bytes) │ │
│ │ ├─ type (1B) │ │
│ │ ├─ flags (1B) │ │
│ │ └─ value/unioned │ │
│ └────────────────────┘ │
│ │
│ 字符串： zend_string (40 bytes) → (x)ptr + len + hash │
│ 对象： zend_object → Object handlers │
│ │
└─────────────────────────────────────────────────────────────┘

优化效果

<?php
// PHP 5 vs PHP 7 性能对比

// 创建 100000 个简单对象
$start = memory_get_usage();

// PHP 5: ~50MB
// PHP 7: ~5MB

for ($i = 0; $i < 100000; $i++) {
 $objects[] = new stdClass();
}

$end = memory_get_usage();
echo "内存增长: " . ($end - $start) . " bytes\n";

引用计数与循环引用

引用计数机制

<?php

// 变量 a 引用计数为 1
$a = "hello";
debug_zval_dump($a);
// 输出：string(5) "hello" refcount(1)

// 变量 b 也引用同一个值，引用计数为 2
$b = $a;
debug_zval_dump($a);
// 输出：string(5) "hello" refcount(2)

// 删除 b，引用计数回到 1
unset($b);
debug_zval_dump($a);
// 输出：string(5) "hello" refcount(1)

循环引用问题

<?php

// PHP 5 中的循环引用
$a = new stdClass();
$b = new stdClass();

$a->b = $b; // a 引用 b
$b->a = $a; // b 引用 a

// 此时：refcount(a) = 2, refcount(b) = 2
// unset(a): refcount(a) = 1, refcount(b) = 2
// 内存泄漏！

// PHP 7 使用标记清除（GC）解决
unset($a);
unset($b);
// GC 周期会清除循环引用

手动垃圾回收

<?php

// 查看待回收数量
gc_enabled(); // 垃圾回收是否启用
gc_collect_cycles(); // 强制回收循环引用

// 记录垃圾回收状态
$start = gc_collect_cycles();
echo "回收前待处理: $start\n";

// 产生循环引用
$a = new stdClass();
$b = new stdClass();
$a->b = $b;
$b->a = $a;

unset($a);
unset($b);

$after = gc_collect_cycles();
echo "回收后待处理: $after\n";

内存泄漏检测

开启内存泄漏检测

# 编译时启用
./configure --enable-debug --with-valgrind

# 运行测试
php -d memory_limit=128M -d zend.enable_gc=1 script.php

Xdebug 内存跟踪

; php.ini
[xdebug]
xdebug.mode=memory

<?php

// 查看函数调用栈
xdebug_debug_zval('a');

// 查看文件调用
xdebug_stop_trace();

优化建议

1. 及时 unset 大变量

<?php

// 不推荐：大数组保留在内存中
$bigArray = loadLargeData(); // 10MB
process($bigArray);
// $bigArray 仍然占用内存

// 推荐：及时释放
$bigArray = loadLargeData();
process($bigArray);
unset($bigArray); // 释放内存

2. 使用引用减少复制

<?php

// 不推荐：复制整个数组
function processArray(array $arr) {
 // 副本，额外内存
}
$data = range(1, 100000);
processArray($data);

// 推荐：引用传递
function processArray(array &$arr) {
 // 同一数组，无复制
}
processArray($data);

3. 生成器处理大数据

<?php

// 不推荐：一次性加载
function getAllUsers() {
 $users = [];
 foreach ($db->query('SELECT * FROM users') as $row) {
 $users[] = $row; // 全部加载到内存
 }
 return $users;
}

// 推荐：生成器
function getUsersGenerator() {
 foreach ($db->query('SELECT * FROM users') as $row) {
 yield $row; // 逐个返回
 }
}

foreach (getUsersGenerator() as $user) {
 process($user);
}

4. 静态变量陷阱

<?php

class HeavyClass {
 private static $cache = [];

 public static function getInstance() {
 if (!isset(self::$cache['instance'])) {
 self::$cache['instance'] = new HeavyClass();
 }
 return self::$cache['instance'];
 }
 
 // 清理静态缓存
 public static function clearCache() {
 self::$cache = [];
 }
}

性能监控

<?php

class MemoryProfiler {
 private static $marks = [];

 public static function mark(string $name) {
 self::$marks[$name] = memory_get_usage(true);
 }

 public static function report(): array {
 $report = [];
 $last = null;
 foreach (self::$marks as $name => $usage) {
 $delta = ($last !== null) ? ($usage - $last) : 0;
 $report[$name] = [
 'memory' => $usage,
 'delta' => $delta,
 ];
 $last = $usage;
 }

 return $report;
 }
}

// 使用示例
MemoryProfiler::mark('bootstrap');
// ... 业务 ...
MemoryProfiler::mark('after_query');
print_r(MemoryProfiler::report());

1024挑战赛题解

Mon, 29 Oct 2018 00:00:00 +0000

离开学校出社会工作已久，甚是怀念大学时代 ACM 的时光，偶遇组织于 10.24 举行编程挑战赛，遂前去试了一下，很幸运地也拿了点小奖，后于此简单分享。

题目描述

某客户来到我司，购买了 N 份保单，每份保单都有一个起始时间和终止时间。为了简化计算，这两个时间使用两个整数来表示，取值范围为 0 到 1,000,000,000。

例如，其中一份保单的起始时间 t=3 且终止时间 t=9，那么这份保单的有效区间则覆盖了 6 个单位时间（包含两端点）。

可是，由于个人原因，该客户想退掉其中 1 份保单，求 剩余保单能覆盖的最大单位时间总量 是多少？

输入输出格式

输入文件 input.txt：

第一行是整数 N（0 < N <= 100,000），表示接下来总共有 N 行
接下来的 N 行，每行表示一份保单的起始以及终止时间（以空格分割）
所有终止时间都是不同的

输出文件 output.txt：

输出一个数，表示退保 1 份保单后仍能得到覆盖的最大单位时间总量

示例

输入文件(input.txt)：
3
6 9
1 5
3 7

输出文件(output.txt)：
7

解释： 三份保单覆盖区间 [1,5]、[3,7]、[6,9]

最大覆盖总量 = (5-1) + (9-6) = 4 + 3 = 7
选择退掉 [3,7]（最短独立区间），剩余覆盖量最大

题目分析

要点	说明
数据规模	最多 10 万个区间
时间范围	0 到 1,000,000,000
核心考察	区间处理、动态规划思想
关键难点	如何找到"最无用"的保单

暴破解法（不可行）

假设分配 10 亿个桶，遍历所有区间… ❌ 数据量太大

正确思路

每个保单是否"有用"，取决于它的独立覆盖区域
只需计算每个保单独立拥有的区域大小
剔除独立区域最小的保单即可

解题思路

┌─────────────────────────────────────────────────────────┐
│ 算法流程 │
├─────────────────────────────────────────────────────────┤
│ │
│ 1. 读取 N 个保单，计算每个保单的区间长度 │
│ │
│ 2. 按起点、终点递增方式进行二级排序 │
│ │
│ 3. 划分不重叠的大区间（多个重叠取最小&最大值） │
│ │
│ 4. 计算每个保单的独立覆盖区域 │
│ │
│ 5. 找到独立区域最小的保单，剔除 │
│ │
│ 6. 累加剩余保单的独立区域 = 答案 │
│ │
└─────────────────────────────────────────────────────────┘

C 语言实现

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_N 100000

// 区间结构体
typedef struct {
 int start;
 int end;
 int length; // 区间长度
 int alone; // 独立区域
} Interval;

// 比较函数：按起点排序
int cmp_start(const void *a, const void *b) {
 Interval *ia = (Interval *)a;
 Interval *ib = (Interval *)b;
 if (ia->start != ib->start) {
 return ia->start - ib->start;
 }
 return ia->end - ib->end;
}

// 读取输入
int read_input(const char *filename, Interval *intervals) {
 FILE *fp = fopen(filename, "r");
 if (!fp) {
 printf("Cannot open file: %s\n", filename);
 return -1;
 }
 
 int n;
 fscanf(fp, "%d", &n);
 
 for (int i = 0; i < n; i++) {
 fscanf(fp, "%d %d", &intervals[i].start, &intervals[i].end);
 intervals[i].length = intervals[i].end - intervals[i].start;
 intervals[i].alone = 0;
 }
 
 fclose(fp);
 return n;
}

// 计算独立区域
void calculate_alone(Interval *intervals, int n) {
 // 遍历所有区间对
 for (int i = 0; i < n; i++) {
 int start = intervals[i].start;
 int end = intervals[i].end;
 int overlap_start = -1;
 int overlap_end = -1;
 
 // 找到所有与当前区间重叠的区间
 for (int j = 0; j < n; j++) {
 if (i == j) continue;
 
 // 检测重叠：当前区间的起点在另一个区间内
 if (intervals[j].start <= start && start < intervals[j].end) {
 if (overlap_start == -1 || intervals[j].start > overlap_start) {
 overlap_start = intervals[j].start;
 }
 }
 
 // 检测重叠：当前区间的终点在另一个区间内
 if (intervals[j].start < end && end <= intervals[j].end) {
 if (overlap_end == -1 || intervals[j].end < overlap_end) {
 overlap_end = intervals[j].end;
 }
 }
 }
 
 // 计算独立区域
 int left_alone = 0;
 int right_alone = 0;
 
 if (overlap_start != -1) {
 left_alone = start - overlap_start;
 } else {
 left_alone = intervals[i].length;
 }
 
 if (overlap_end != -1) {
 right_alone = overlap_end - end;
 } else {
 right_alone = intervals[i].length;
 }
 
 intervals[i].alone = left_alone + right_alone;
 }
}

// 写输出
void write_output(const char *filename, long long result) {
 FILE *fp = fopen(filename, "w");
 if (!fp) {
 printf("Cannot open file: %s\n", filename);
 return;
 }
 
 fprintf(fp, "%lld\n", result);
 fclose(fp);
}

int main() {
 Interval intervals[MAX_N];
 
 // 读取输入
 int n = read_input("input.txt", intervals);
 if (n <= 0) {
 return 1;
 }
 
 // 排序
 qsort(intervals, n, sizeof(Interval), cmp_start);
 
 // 计算每个保单的独立区域
 calculate_alone(intervals, n);
 
 // 找到独立区域最小的
 int min_alone = intervals[0].alone;
 long long total_length = intervals[0].length;
 
 for (int i = 1; i < n; i++) {
 total_length += intervals[i].length;
 if (intervals[i].alone < min_alone) {
 min_alone = intervals[i].alone;
 }
 }
 
 // 结果 = 总长度 - 被剔除区间的独立区域
 long long result = total_length - min_alone;
 
 // 写输出
 write_output("output.txt", result);
 
 printf("Result: %lld\n", result);
 
 return 0;
}

优化版本（单次读入 + 动态内存）

下面的写法与上文算法一致：读入后排序，调用同样的 calculate_alone 逻辑，再把「总区间长度之和 − 最小独立覆盖」写入结果。此处用 malloc/free 取代固定栈上大数组，适合在栈空间受限的环境编译；去掉 C++ 的 new，避免混用两套语言特性。

#include <stdio.h>
#include <stdlib.h>

#define MAX_N 100000

typedef struct {
 int start;
 int end;
 int length;
 int alone;
} Interval;

static int cmp_start(const void *a, const void *b) {
 Interval *ia = (Interval *)a;
 Interval *ib = (Interval *)b;
 return ia->start != ib->start ? ia->start - ib->start : ia->end - ib->end;
}

static void calculate_alone(Interval *intervals, int n) {
 int i, j;
 for (i = 0; i < n; i++) {
 int start = intervals[i].start;
 int end = intervals[i].end;
 int overlap_start = -1;
 int overlap_end = -1;

 for (j = 0; j < n; j++) {
 if (i == j) continue;

 if (intervals[j].start <= start && start < intervals[j].end) {
 if (overlap_start == -1 || intervals[j].start > overlap_start) {
 overlap_start = intervals[j].start;
 }
 }

 if (intervals[j].start < end && end <= intervals[j].end) {
 if (overlap_end == -1 || intervals[j].end < overlap_end) {
 overlap_end = intervals[j].end;
 }
 }
 }

 {
 int left_alone, right_alone;
 if (overlap_start != -1) {
 left_alone = start - overlap_start;
 } else {
 left_alone = intervals[i].length;
 }

 if (overlap_end != -1) {
 right_alone = overlap_end - end;
 } else {
 right_alone = intervals[i].length;
 }

 intervals[i].alone = left_alone + right_alone;
 }
 }
}

int main(void) {
 FILE *fin = fopen("input.txt", "r");
 FILE *fout = fopen("output.txt", "w");
 int n, i;

 if (!fin || !fout) return 1;

 fscanf(fin, "%d", &n);
 if (n <= 0 || n > MAX_N) {
 fclose(fin);
 fclose(fout);
 return 1;
 }

 Interval *intervals = (Interval *)malloc(sizeof(Interval) * (size_t)n);
 if (!intervals) {
 fclose(fin);
 fclose(fout);
 return 1;
 }

 long long total_length = 0;

 for (i = 0; i < n; i++) {
 fscanf(fin, "%d %d", &intervals[i].start, &intervals[i].end);
 intervals[i].length = intervals[i].end - intervals[i].start;
 intervals[i].alone = intervals[i].length;
 total_length += intervals[i].length;
 }
 fclose(fin);

 qsort(intervals, (size_t)n, sizeof(Interval), cmp_start);
 calculate_alone(intervals, n);

 int min_alone = intervals[0].alone;
 for (i = 1; i < n; i++) {
 if (intervals[i].alone < min_alone) {
 min_alone = intervals[i].alone;
 }
 }

 {
 long long result = total_length - min_alone;
 fprintf(fout, "%lld\n", result);
 printf("Result: %lld\n", result);
 }

 fclose(fout);
 free(intervals);
 return 0;
}

说明：比赛场景下也可继续尝试「扫描线 / 线段树」等更精细的区间结构以降低常数；本文侧重与前一版一致的思路对照。

PHP的OpenSSL加密扩展使用小结

Wed, 25 Jul 2018 00:00:00 +0000

互联网的发展史上，安全性一直是开发者们相当重视的主题。为了实现数据传输安全，我们需要保证：数据来源（防伪造）、数据完整性（防篡改）、数据私密性（防窃听）。

加密基础

加密算法分类

┌─────────────────────────────────────────────────────────────┐
│ 加密算法分类 │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────┐ ┌─────────────────┐ │
│ │ 对称加密 │ │ 非对称加密 │ │
│ ├─────────────────┤ ├─────────────────┤ │
│ │ • DES │ │ • RSA │ │
│ │ • AES │ │ • DSA │ │
│ │ • 3DES │ │ • ECC │ │
│ │ • Blowfish │ │ • DH │ │
│ └─────────────────┘ └─────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────┐ │
│ │ 数字签名 │ │
│ ├─────────────────────────────────────────────────┤ │
│ │ • MD5 (已不安全) • SHA-1 (已不安全) │ │
│ │ • SHA-256 • SHA-512 • HMAC │ │
│ └─────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘

对称加密

特点：

加密和解密使用同一密钥
速度快，适合大量数据
加密前后文件大小变化不大
密钥管理是难题

常见算法：DES、AES、3DES、Blowfish

非对称加密

特点：

使用公钥和私钥一对密钥
公钥加密，私钥解密（或反之）
计算量大，速度慢
适合密钥交换和数字签名

常见算法：RSA、DSA、ECC

数字签名

特点：

无论原始数据多大，输出长度固定
输入相同，输出相同
微小改变导致输出巨大变化
不可逆，无法从哈希值恢复原始数据

常见算法：MD5、SHA-1、SHA-256、HMAC

PHP OpenSSL 扩展

安装检查

<?php
// 检查 OpenSSL 扩展是否启用
if (extension_loaded('openssl')) {
 echo "OpenSSL 已启用";
 
 // 查看支持的加密算法
 print_r(openssl_get_cipher_methods());
 print_r(openssl_get_md_methods());
} else {
 echo "OpenSSL 未启用";
}

对称加密

AES 加密

<?php

/**
 * AES-256-CBC 加密
 * 
 * @param string $data 待加密数据
 * @param string $key 密钥（32字节）
 * @param string $iv 初始化向量（16字节）
 * @return string 加密后的数据（base64编码）
 */
function aes_encrypt(string $data, string $key, string $iv = ''): string
{
 // 密钥必须是 32 字节（AES-256）
 $key = hash('sha256', $key, true);
 
 // IV 必须是 16 字节（AES 块大小）
 if (strlen($iv) !== 16) {
 $iv = openssl_random_pseudo_bytes(16);
 }
 
 $encrypted = openssl_encrypt(
 $data,
 'AES-256-CBC',
 $key,
 OPENSSL_RAW_DATA, // 返回原始数据
 $iv
 );
 
 // 返回 IV + 密文（便于解密）
 return base64_encode($iv . $encrypted);
}

/**
 * AES-256-CBC 解密
 * 
 * @param string $encrypted 加密数据（base64编码）
 * @param string $key 密钥
 * @return string 解密后的数据
 */
function aes_decrypt(string $encrypted, string $key): string
{
 $key = hash('sha256', $key, true);
 $data = base64_decode($encrypted);
 
 // 提取 IV（前 16 字节）
 $iv = substr($data, 0, 16);
 $ciphertext = substr($data, 16);
 
 return openssl_decrypt(
 $ciphertext,
 'AES-256-CBC',
 $key,
 OPENSSL_RAW_DATA,
 $iv
 );
}

// 使用示例
$key = 'your-secret-key-here';
$data = 'Hello, World! 你好世界！';

$encrypted = aes_encrypt($data, $key);
echo "加密后: " . $encrypted . "\n";

$decrypted = aes_decrypt($encrypted, $key);
echo "解密后: " . $decrypted . "\n";

其他对称加密算法

<?php

$key = hash('sha256', 'password', true);

// AES-128-CBC（密钥 16 字节）
$encrypted = openssl_encrypt($data, 'AES-128-CBC', $key, OPENSSL_RAW_DATA, $iv);

// AES-128-ECB（无需 IV，但不安全）
$encrypted = openssl_encrypt($data, 'AES-128-ECB', $key);

// DES（不安全，不推荐）
$encrypted = openssl_encrypt($data, 'DES-ECB', $key);

非对称加密

生成 RSA 密钥对

<?php

/**
 * 生成 RSA 密钥对
 * 
 * @param int $bits 密钥位数（推荐 2048 或 4096）
 * @return array ['private_key' => string, 'public_key' => string]
 */
function generate_rsa_keypair(int $bits = 2048): array
{
 $config = [
 'private_key_bits' => $bits,
 'private_key_type' => OPENSSL_KEYTYPE_RSA,
 ];
 
 // 生成密钥对
 $keyPair = openssl_pkey_new($config);
 
 // 导出私钥
 openssl_pkey_export($keyPair, $privateKey);
 
 // 导出公钥
 $publicKeyDetails = openssl_pkey_get_details($keyPair);
 $publicKey = $publicKeyDetails['key'];
 
 return [
 'private_key' => $privateKey,
 'public_key' => $publicKey,
 ];
}

// 生成密钥对
$keyPair = generate_rsa_keypair(2048);

echo "私钥:\n" . $keyPair['private_key'] . "\n\n";
echo "公钥:\n" . $keyPair['public_key'] . "\n";

// 保存到文件
file_put_contents('private.key', $keyPair['private_key']);
file_put_contents('public.key', $keyPair['public_key']);

// 设置权限（Linux）
chmod('private.key', 0600);

RSA 加密解密

<?php

/**
 * RSA 加密（使用公钥）
 * 
 * @param string $data 待加密数据
 * @param string $publicKey 公钥
 * @return string 加密后的数据（base64编码）
 */
function rsa_encrypt(string $data, string $publicKey): string
{
 $publicKey = openssl_pkey_get_public($publicKey);
 
 openssl_public_encrypt($data, $encrypted, $publicKey);
 
 return base64_encode($encrypted);
}

/**
 * RSA 解密（使用私钥）
 * 
 * @param string $encrypted 加密数据（base64编码）
 * @param string $privateKey 私钥
 * @return string 解密后的数据
 */
function rsa_decrypt(string $encrypted, string $privateKey): string
{
 $privateKey = openssl_pkey_get_private($privateKey);
 
 $data = base64_decode($encrypted);
 openssl_private_decrypt($data, $decrypted, $privateKey);
 
 return $decrypted;
}

// 使用示例
$keyPair = generate_rsa_keypair();

$data = 'Hello, RSA!';

$encrypted = rsa_encrypt($data, $keyPair['public_key']);
echo "加密后: " . $encrypted . "\n";

$decrypted = rsa_decrypt($encrypted, $keyPair['private_key']);
echo "解密后: " . $decrypted . "\n";

⚠️ 限制：RSA 加密的数据长度有限制（密钥位数 / 8 - 11 字节）

分块加密大文件

<?php

/**
 * RSA 分块加密（用于大数据）
 * 
 * @param string $data 待加密数据
 * @param string $publicKey 公钥
 * @return string 加密后的数据（base64编码）
 */
function rsa_encrypt_large(string $data, string $publicKey): string
{
 $res = openssl_pkey_get_public($publicKey);
 if ($res === false) {
 throw new InvalidArgumentException('Invalid public key');
 }
 $details = openssl_pkey_get_details($res);
 $maxChunk = (int) ($details['bits'] / 8) - 11; // PKCS#1 填充占用 11 字节
 if ($maxChunk <= 0) {
 throw new RuntimeException('Key size too small');
 }

 $cipherRaw = '';
 $len = strlen($data);
 for ($i = 0; $i < $len; $i += $maxChunk) {
 $chunk = substr($data, $i, $maxChunk);
 $out = '';
 if (!openssl_public_encrypt($chunk, $out, $res, OPENSSL_PKCS1_PADDING)) {
 throw new RuntimeException('openssl_public_encrypt failed');
 }
 $cipherRaw .= $out;
 }
 return base64_encode($cipherRaw);
}

/**
 * RSA 分块解密
 *
 * @param string $encrypted 公钥加密且经 base64 编码的密文
 * @param string $privateKey 私钥
 * @return string 原文
 */
function rsa_decrypt_large(string $encrypted, string $privateKey): string
{
 $res = openssl_pkey_get_private($privateKey);
 if ($res === false) {
 throw new InvalidArgumentException('Invalid private key');
 }
 $details = openssl_pkey_get_details($res);
 $block = (int) ($details['bits'] / 8);
 $raw = base64_decode($encrypted, true);
 if ($raw === false) {
 throw new InvalidArgumentException('Invalid base64 cipher');
 }

 $plain = '';
 $len = strlen($raw);
 for ($i = 0; $i < $len; $i += $block) {
 $chunk = substr($raw, $i, $block);
 $out = '';
 if (!openssl_private_decrypt($chunk, $out, $res, OPENSSL_PKCS1_PADDING)) {
 throw new RuntimeException('openssl_private_decrypt failed');
 }
 $plain .= $out;
 }
 return $plain;
}

/*
 * 小结：超长明文请优先使用「RSA 协商对称密钥 + AES」的混合加密；本节分块 RSA 适用于必须纯 RSA 的场景，
 * 实现时注意密钥位数与性能开销。
 */

在Yii2框架上使用PHPUnit做单元测试与代码覆盖率

Fri, 11 May 2018 00:00:00 +0000

PHPUnit 是一个很不错的测试框架，既能做自动化单元测试，也能同时检测代码覆盖率。自己在 Yii 框架上经过一番尝试，总结了这篇配置指南。

目录结构约定

在 Yii2 项目下，需要创建 phpunit 目录：

yii2-project/
├── phpunit/
│ ├── README.md # 说明文档
│ ├── _bootstrap.php # 框架初始化文件
│ ├── phpunit.xml # 配置文件
│ └── tests/
│ ├── UserAuthTest.php
│ └── ...
├── frontend/
├── backend/
└── common/

_bootstrap.php 引导文件

参考 frontend/web/index.php，创建引导文件：

<?php
// phpunit/_bootstrap.php

// 定义测试环境常量
defined('YII_DEBUG') or define('YII_DEBUG', true);
defined('YII_ENV') or define('YII_ENV', 'test');

// 引入 Composer 自动加载
require_once dirname(__DIR__) . '/vendor/autoload.php';

// 引入 Yii 入口文件
require_once dirname(__DIR__) . '/frontend/web/index.php';

// 返回应用实例（而不是运行）
return Yii::$app;

phpunit.xml 配置

<?xml version="1.0" encoding="UTF-8"?>
<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:noNamespaceSchemaLocation="vendor/phpunit/phpunit/phpunit.xsd"
 bootstrap="_bootstrap.php"
 backupGlobals="false"
 backupStaticAttributes="false"
 beStrictAboutCoversAnnotation="true"
 beStrictAboutOutputDuringTests="true"
 beStrictAboutTestsThatDoNotTestAnything="true"
 beStrictAboutTodoAnnotatedTests="true"
 forceCoversAnnotation="true"
 verbose="true"
 colors="true">
 
 <!-- 测试套件配置 -->
 <testsuites>
 <testsuite name="Application Test Suite">
 <directory suffix="Test.php">./tests</directory>
 </testsuite>
 </testsuites>

 <!-- 代码覆盖率配置 -->
 <coverage>
 <include>
 <directory suffix=".php">../frontend/controllers</directory>
 <directory suffix=".php">../backend/controllers</directory>
 <directory suffix=".php">../common</directory>
 <directory suffix=".php">../console</directory>
 </include>
 <exclude>
 <directory suffix=".php">../common/mail</directory>
 <directory suffix=".php">../common/config</directory>
 </exclude>
 </coverage>

 <!-- 日志配置 -->
 <logging>
 <log type="coverage-html" target="coverage"/>
 <log type="coverage-clover" target="logs/clover.xml"/>
 <log type="coverage-crap4j" target="logs/crap4j.xml"/>
 <log type="junit" target="logs/junit.xml"/>
 <log type="testdox-html" target="testdox/index.html"/>
 </logging>
</phpunit>

安装 PHPUnit

使用 Composer 安装

# 进入项目目录
cd your-yii2-project

# 安装 PHPUnit（建议作为开发依赖）
composer require --dev phpunit/phpunit:^9.0

# 或者安装带 PHP 版本支持的版本
composer require --dev phpunit/phpunit:"^9.0" --ignore-platform-reqs

# 安装代码覆盖率扩展
composer require --dev phpunit/php-code-coverage

验证安装

# 检查 PHPUnit 版本
./vendor/bin/phpunit --version

# PHPUnit 9.x 输出
# PHPUnit 9.6.x by Sebastian Bergmann and contributors.

测试命令

运行测试

# 进入测试目录
cd phpunit/

# 运行所有测试
../vendor/bin/phpunit --configuration phpunit.xml

# 指定测试文件
../vendor/bin/phpunit --configuration phpunit.xml tests/UserAuthTest.php

# 运行测试套件
../vendor/bin/phpunit --configuration phpunit.xml --testsuite "Application Test Suite"

生成覆盖率报告

# 生成 HTML 覆盖率报告
../vendor/bin/phpunit --configuration phpunit.xml --coverage-html coverage

# 生成 Clover XML 格式报告（可导入 CI 系统）
../vendor/bin/phpunit --configuration phpunit.xml --coverage-clover logs/clover.xml

编写单元测试

基本测试示例

<?php
// tests/UserAuthTest.php

namespace tests;

use PHPUnit\Framework\TestCase;
use common\models\User;

class UserAuthTest extends TestCase
{
 /**
 * @covers \common\models\User
 */
 public function testUserCanBeCreated()
 {
 $user = new User();
 $user->username = 'testuser';
 $user->email = 'test@example.com';
 
 $this->assertInstanceOf(User::class, $user);
 $this->assertEquals('testuser', $user->username);
 }

 /**
 * @covers \common\models\User::validatePassword()
 */
 public function testPasswordValidation()
 {
 $user = new User();
 $user->password_hash = password_hash('secret', PASSWORD_DEFAULT);
 
 $this->assertTrue($user->validatePassword('secret'));
 $this->assertFalse($user->validatePassword('wrong'));
 }

 /**
 * @covers \common\models\User::getId()
 */
 public function testUserIdReturnsInteger()
 {
 $user = new User();
 $user->id = 123;
 
 $this->assertIsInt($user->getId());
 $this->assertEquals(123, $user->getId());
 }
}

Yii2 ActiveRecord 测试

<?php
// tests/UserModelTest.php

namespace tests;

use Yii;
use Codeception\Specify;
use common\fixtures\UserFixture;
use common\models\User;

class UserModelTest extends \yii\codeception\TestCase
{
 // 加载测试数据
 public $fixtures = [
 'user' => [
 'class' => UserFixture::class,
 'dataFile' => '@tests/fixtures/data/user.php',
 ],
 ];

 public function testUserLogin()
 {
 $user = User::findByUsername('erau');
 
 $this->assertNotNull($user);
 $this->assertTrue($user->validatePassword('password_0'));
 }

 public function testUserNotFound()
 {
 $user = User::findByUsername('nonexistent');
 
 $this->assertNull($user);
 }
}

Fixture 数据文件

<?php
// tests/fixtures/data/user.php

return [
 'user1' => [
 'id' => 1,
 'username' => 'erau',
 'auth_key' => 'testAuthKey_0',
 'password_hash' => '$2y$13$qFS7HXXkJb9V5KjZ8xX7EOYKvW7YQZ1xX7EOYKvW7YQZ1xX7EO',
 'email' => 'erau@example.com',
 'status' => 10,
 'created_at' => 1500000000,
 'updated_at' => 1500000000,
 ],
];

常用注解

注解	说明
`@covers ClassName`	指定测试覆盖的类
`@covers ClassName::method`	指定测试覆盖的方法
`@coversNothing`	该测试不计入覆盖率
`@depends`	依赖另一个测试
`@dataProvider`	数据供给器

/**
 * @covers \common\models\User::findByUsername()
 * @covers \common\models\User::validatePassword()
 */
public function testLoginWithValidCredentials()
{
 // ...
}

CI 集成

GitHub Actions

# .github/workflows/phpunit.yml
name: PHPUnit Tests

on: [push, pull_request]

jobs:
 test:
 runs-on: ubuntu-latest
 
 steps:
 - uses: actions/checkout@v3
 
 - name: Setup PHP
 uses: shivammathur/setup-php@v2
 with:
 php-version: '8.1'
 extensions: pdo_mysql, intl
 coverage: xdebug
 
 - name: Install Dependencies
 run: composer install --prefer-dist
 
 - name: Run PHPUnit
 run: ./vendor/bin/phpunit --configuration phpunit.xml --colors=never

最佳实践

遵循 AAA 模式（Arrange-Act-Assert）
测试单一职责 - 每个测试只验证一个行为

PHP代码覆盖率入门指南

Fri, 04 May 2018 00:00:00 +0000

最近在玩 PHP 的单元测试，以及代码覆盖率这块，遇到一些问题，记录下来作为简单入门参考。

安装 PHPUnit

Composer 安装（推荐）

# 进入项目目录
cd your-project

# 安装 PHPUnit
composer require --dev phpunit/phpunit:^10.0

# 安装代码覆盖率扩展
composer require --dev phpunit/php-code-coverage

PHP Archive (PHAR)

# 下载 PHPUnit
wget https://phar.phpunit.de/phpunit-10.phar

# 添加执行权限
chmod +x phpunit-10.phar

# 全局安装
sudo mv phpunit-10.phar /usr/local/bin/phpunit

# 验证
phpunit --version

基础单元测试示例

编写测试

<?php
// tests/StackTest.php

namespace tests;

use PHPUnit\Framework\TestCase;

class StackTest extends TestCase
{
 /**
 * 测试空栈
 */
 public function testEmpty(): void
 {
 $stack = [];
 $this->assertEmpty($stack);

 return $stack;
 }

 /**
 * 测试压栈
 * @depends testEmpty
 */
 public function testPush(array $stack): array
 {
 array_push($stack, 'foo');
 $this->assertEquals('foo', $stack[count($stack) - 1]);
 $this->assertNotEmpty($stack);

 return $stack;
 }

 /**
 * 测试弹栈
 * @depends testPush
 */
 public function testPop(array $stack): void
 {
 $this->assertEquals('foo', array_pop($stack));
 $this->assertEmpty($stack);
 }
}

运行测试

# 运行所有测试
phpunit --verbose tests/

# 运行指定测试文件
phpunit --verbose tests/StackTest.php

# 运行指定测试方法
phpunit --verbose tests/StackTest.php --filter testPush

输出示例

PHPUnit 10.0 by Sebastian Bergmann and contributors.

Runtime: PHP 8.2.0 with Xdebug 3.2.0

... 3 / 3 (100%)

Time: 149 ms, Memory: 10.00MB

OK (3 tests, 5 assertions)

代码覆盖率配置

phpunit.xml 配置

<?xml version="1.0" encoding="UTF-8"?>
<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:noNamespaceSchemaLocation="vendor/phpunit/phpunit/phpunit.xsd"
 bootstrap="vendor/autoload.php"
 colors="true"
 executionOrder="depends,defects"
 beStrictAboutOutputDuringTests="true"
 cacheResultFile=".phpunit.cache/test-results">
 
 <testsuites>
 <testsuite name="Unit Tests">
 <directory suffix="Test.php">./tests</directory>
 </testsuite>
 </testsuites>

 <coverage>
 <include>
 <directory suffix=".php">./src</directory>
 </include>
 <exclude>
 <directory suffix=".php">./src/Exceptions</directory>
 <file>./src/bootstrap.php</file>
 </exclude>
 
 <!-- HTML 报告 -->
 <report>
 <html outputDirectory="coverage"/>
 </report>
 
 <!-- Clover XML 报告（CI 集成） -->
 <report>
 <clover outputFile="coverage/clover.xml"/>
 </report>
 </coverage>
</phpunit>

运行覆盖率测试

# 生成覆盖率报告
phpunit --coverage-html coverage/

# 指定覆盖率输出目录
phpunit --coverage-html ./report/coverage/

# 生成 Clover XML 格式
phpunit --coverage-clover coverage/clover.xml

常用断言方法

断言	说明
`assertEquals($expected, $actual)`	值相等
`assertSame($expected, $actual)`	同一对象/值
`assertTrue($condition)`	条件为真
`assertFalse($condition)`	条件为假
`assertNull($value)`	值为空
`assertContains($needle, $haystack)`	数组/字符串包含
`assertCount($expected, $actual)`	元素数量
`assertEmpty($actual)`	值为空
`assertThrows($exception, $callable)`	抛出异常
`assertMatchesRegularExpression($pattern, $string)`	正则匹配

测试依赖

@depends 依赖

public function testCreate(): array
{
 $entity = new Entity();
 $entity->create(['name' => 'test']);
 $this->assertNotNull($entity->getId());
 
 return ['id' => $entity->getId()];
}

/**
 * @depends testCreate
 */
public function testFind(array $data): void
{
 $entity = new Entity();
 $found = $entity->find($data['id']);
 
 $this->assertNotNull($found);
 $this->assertEquals('test', $found->name);
}

数据供给器

@dataProvider

/**
 * @dataProvider additionProvider
 */
public function testAddition(int $a, int $b, int $expected): void
{
 $this->assertEquals($expected, $a + $b);
}

public function additionProvider(): array
{
 return [
 'zero plus zero' => [0, 0, 0],
 'positive numbers' => [1, 2, 3],
 'negative numbers' => [-1, -1, -2],
 ];
}

Mock 对象

创建 Mock

use PHPUnit\Framework\TestCase;
use App\Services\UserService;
use App\Repositories\UserRepository;

class UserServiceTest extends TestCase
{
 public function testGetUserName(): void
 {
 // 创建 Mock 对象
 $repository = $this->createMock(UserRepository::class);
 
 // 配置 Mock 行为
 $repository->method('find')
 ->with(1)
 ->willReturn(['id' => 1, 'name' => 'John']);
 
 // 使用 Mock
 $service = new UserService($repository);
 $name = $service->getUserName(1);
 
 $this->assertEquals('John', $name);
 }
}

Mock 方法链

$mock = $this->getMockBuilder(stdClass::class)
 ->addMethods(['getName', 'setName'])
 ->getMock();

$mock->method('getName')->willReturn('Test');

数据集测试

use PHPUnit\Framework\TestCase;

class DataProviderTest extends TestCase
{
 /**
 * @dataProvider additionProvider
 */
 public function testAdditions(int $a, int $b, int $expected): void
 {
 $this->assertEquals($expected, $a + $b);
 }

 public static function additionProvider(): array
 {
 return [
 'integers' => [1, 2, 3],
 'floats' => [0.1, 0.2, 0.3],
 ];
 }
}

CI 集成

GitHub Actions

# .github/workflows/phpunit.yml
name: PHPUnit Tests

on: [push, pull_request]

jobs:
 test:
 runs-on: ubuntu-latest
 
 steps:
 - uses: actions/checkout@v3
 
 - name: Setup PHP
 uses: shivammathur/setup-php@v2
 with:
 php-version: '8.2'
 extensions: xdebug
 coverage: xdebug
 
 - name: Install Dependencies
 run: composer install --prefer-dist
 
 - name: Run Tests with Coverage
 run: |
 ./vendor/bin/phpunit \n --coverage-text \n --coverage-clover coverage/clover.xml
 env:
 XDEBUG_MODE: coverage

常见问题

Q: Xdebug 版本不兼容

# PHPUnit 10 需要 Xdebug 3.x
composer require --dev phpunit/phpunit:^10.0
pecl install xdebug

# Xdebug 2.x 适配 PHPUnit 9
composer require --dev phpunit/phpunit:^9.0
pecl install xdebug-2.9.8

Q: 覆盖率不准确

检查 phpunit.xml 中的 include/exclude 配置是否正确：

<coverage>
 <include>
 <directory suffix=".php">./src</directory>
 </include>
</coverage>

最佳实践

每个发布单元（类/模块）至少覆盖一条主路径与一条异常路径，优先保证核心业务与错误分支可被测试执行到。
单元测试避免直连真实数据库、MQ、第三方 HTTP，可用接口抽象 + 内存实现或 Mock，使覆盖率反映的是「你的代码」而非外部环境。
在 CI 中固定 PHPUnit、Xdebug 主版本，并通过环境变量注入 XDEBUG_MODE=coverage，避免本地与流水线结果不一致。
覆盖率是手段不是目的：不必盲目追求 100%；对复杂条件分支优先补测试用例或重构降低圈复杂度。
结合静态分析与 CR：将 Clover/XML 输出接入 SonarQube、Codecov 等工具，对新增未覆盖代码做团队约定（例如 Diff Coverage 阈值）。

Xdebug源码安装指南

Fri, 04 May 2018 00:00:00 +0000

PHP 在 Linux/macOS 上安装 Xdebug 的方法

方法一：PECL 安装（推荐）

# 安装 Xdebug（会自动编译）
pecl install xdebug

# 或者指定版本
pecl install xdebug-3.2.2

安装后会在输出中显示需要添加到 php.ini 的配置。

方法二：源码编译安装

1. 下载源码

到 Xdebug 官网下载源码：

# 下载稳定版本（推荐）
wget https://xdebug.org/files/xdebug-3.2.2.tgz

# 或者下载最新版本
wget https://xdebug.org/files/xdebug-3.3.1.tgz

2. 解压并编译

# 解压
tar -xvf xdebug-3.3.1.tgz
cd xdebug-3.3.1

# 生成编译配置
phpize

# 编译
./configure --enable-xdebug
make

3. 安装

# 查看编译产物
ls modules/
# 输出：xdebug.so

# 拷贝到 PHP 扩展目录
cp modules/xdebug.so /usr/lib/php/extensions/xdebug.so

💡 使用 php -i | grep extension_dir 查看扩展目录路径

4. 配置 php.ini

在 php.ini 中添加：

[xdebug]
; Xdebug 3.x 配置
zend_extension=xdebug.so

; 开启性能分析
xdebug.mode=profile

; 开启调试模式
; xdebug.mode=debug

; IDE IP 地址
xdebug.client_host=127.0.0.1

; IDE 端口
xdebug.client_port=9003

; 启动调试的方式
; xdebug.start_with_request=yes

5. 重启服务

# Nginx + PHP-FPM
sudo service php-fpm restart
# 或
sudo systemctl restart php-fpm

# Apache
sudo service apache2 restart

Xdebug 3.x 配置详解

⚠️ 重要：Xdebug 3.x 相比 2.x 有重大变化！

配置项对照表

Xdebug 2.x	Xdebug 3.x	说明
`xdebug.remote_enable`	`xdebug.mode`	调试模式开关
`xdebug.remote_host`	`xdebug.client_host`	IDE 主机地址
`xdebug.remote_port`	`xdebug.client_port`	IDE 端口
`xdebug.remote_autostart`	`xdebug.start_with_request`	自动启动调试
`xdebug.remote_handler`	-	已移除
`xdebug.idekey`	`xdebug.idekey`	IDE Key

常用配置示例

[xdebug]
; 加载扩展
zend_extension=xdebug.so

; 调试模式：debug/profile/coverage/off
xdebug.mode=debug

; IDE 主机地址（IDE 所在机器的 IP）
xdebug.client_host=127.0.0.1

; IDE 端口
xdebug.client_port=9003

; 自动启动调试
xdebug.start_with_request=trigger

; 记录调试日志
xdebug.log=/var/log/xdebug.log
xdebug.log_level=3

不同模式说明

# 关闭所有功能
xdebug.mode=off

# 调试模式（断点调试）
xdebug.mode=debug

# 性能分析（生成 cachegrind 文件）
xdebug.mode=profile

# 代码覆盖率分析
xdebug.mode=coverage

# 触发调试（浏览器安装 Xdebug Helper 插件）
xdebug.mode=debug
xdebug.start_with_request=trigger

验证安装

# 检查 Xdebug 是否加载
php -m | grep xdebug

# 查看详细配置
php -i | grep xdebug

输出示例：

xdebug
xdebug Support => enabled
Version => 3.3.1
IDE Key => yison

IDE 配置

VS Code

安装 PHP Debug 扩展，配置 launch.json：

{
 "version": "0.2.0",
 "configurations": [
 {
 "name": "Listen for Xdebug",
 "type": "php",
 "request": "launch",
 "port": 9003,
 "pathMappings": {
 "/var/www/html": "${workspaceFolder}"
 }
 }
 ]
}

PhpStorm

Settings → PHP → Debug
确认 Xdebug 端口为 9003
点击电话图标开始监听

常见问题

Q: phpize 报错：autoconf not found

# Ubuntu/Debian
sudo apt-get install autoconf

# CentOS/RHEL
sudo yum install autoconf

# macOS
brew install autoconf

Q: Xdebug 无法连接

检查防火墙
```
sudo firewall-cmd --add-port=9003/tcp
```

检查 SELinux

sudo setsebool -P httpd_can_network_connect 1

Q: Xdebug 3.x 配置不生效

检查 PHP 版本和 Xdebug 版本兼容性：

php -v
php -m | grep xdebug

Docker 中使用 Xdebug

# Dockerfile
RUN pecl install xdebug \
 && docker-php-ext-enable xdebug

# php.ini 追加配置
RUN echo "xdebug.mode=debug" >> /usr/local/etc/php/conf.d/xdebug.ini \
 && echo "xdebug.client_host=host.docker.internal" >> /usr/local/etc/php/conf.d/xdebug.ini

macOS 特殊路径

类型	路径
Apache 配置	`/etc/apache2/httpd.conf`
Apache 根目录	`/Library/WebServer/Documents`
Hosts 文件	`/etc/hosts`
PHP 配置	`/etc/php.ini`
PHP 扩展目录	`/usr/lib/php/extensions/`

参考链接

《PHP7内核剖析》之PHP基础架构

Fri, 27 Apr 2018 00:00:00 +0000

有幸在读秦朋的《PHP 内核剖析》一书，收获良多。为了加深理解，依照书中内容整理了 PHP 的基本架构和生命周期。

PHP 的构成

PHP 的源代码主要由以下几个核心模块组成：

┌─────────────────────────────────────────────────────┐
│ PHP 架构图 │
├─────────────────────────────────────────────────────┤
│ ┌─────────┐ │
│ │ SAPI │ ← 应用接口层（Apache2Handler/FastCGI）│
│ └────┬────┘ │
│ ┌────▼────┐ │
│ │ main │ ← 输入/输出、Web通信、框架初始化 │
│ └────┬────┘ │
│ ┌────▼────┐ │
│ │ Zend │ ← PHP 解析器核心（Zend Engine） │
│ └────┬────┘ │
│ ┌────▼────┐ │
│ │ ext │ ← PHP 扩展目录 │
│ └─────────┘ │
│ ┌─────────┐ │
│ │ TSRM │ ← 线程安全资源管理 │
│ └─────────┘ │
└─────────────────────────────────────────────────────┘

核心模块说明

模块	说明
SAPI	Server Application Programming Interface，PHP 的应用接口层，负责与 Web 服务器交互
main	PHP 的核心代码，处理输入/输出、Web 通信、扩展加载、配置解析等工作
Zend	PHP 解析器的主要实现，即 Zend Engine，是 PHP 语言的核心
ext	PHP 的扩展目录，提供了各种功能的扩展（GD、MySQL、JSON 等）
TSRM	Thread Safe Resource Manager，线程安全相关的实现

各模块协作关系

Web Server (Apache/Nginx)
 │
 ▼
 SAPI Layer
 │
 ▼
 main (请求初始化、配置解析)
 │
 ▼
 Zend Engine (词法分析 → 语法分析 → 编译 → 执行)
 │
 ▼
 PHP Extensions (提供各种内置函数)

PHP 的生命周期

┌─────────────────────────────────────────────────────────────┐
│ PHP 生命周期 │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌───────────────────┐ │
│ │ 模块初始化阶段 │ MINIT (Module Initialization) │
│ │ (PHP-FPM 启动时) │ - 加载扩展 │
│ └─────────┬─────────┘ - 初始化扩展 │
│ │ - 注册常量/函数 │
│ ▼ │
│ ┌───────────────────┐ │
│ │ 请求初始化阶段 │ RINIT (Request Initialization) │
│ │ (每个请求开始时) │ - 重置全局变量 │
│ └─────────┬─────────┘ - 初始化静态变量 │
│ │ - 启动 session │
│ ▼ │
│ ┌───────────────────┐ │
│ │ 执行脚本阶段 │ Execute Script │
│ │ (核心执行期) │ - 编译 PHP 代码为 OpCodes │
│ └─────────┬─────────┘ - 执行 OpCodes │
│ │ - 输出响应 │
│ ▼ │
│ ┌───────────────────┐ │
│ │ 请求关闭阶段 │ RSHUTDOWN (Request Shutdown) │
│ │ (每个请求结束时) │ - 刷新输出缓冲区 │
│ └─────────┬─────────┘ - 发送 HTTP 响应 │
│ │ - 清理全局变量 │
│ ▼ │
│ ┌───────────────────┐ │
│ │ 模块关闭阶段 │ MSHUTDOWN (Module Shutdown) │
│ │ (PHP-FPM 关闭时) │ - 关闭扩展 │
│ └───────────────────┘ - 释放资源 │
│ │
└─────────────────────────────────────────────────────────────┘

1. 模块初始化阶段 (MINIT)

// PHP 扩展中的模块初始化函数
PHP_MINIT_FUNCTION(my_extension)
{
 // 注册常量
 REGISTER_STRING_CONSTANT("MY_EXT_VERSION", "1.0.0", CONST_PERSISTENT);
 
 // 注册函数
 REGISTER_FUNCTION(MyNamespace, my_function);
 
 // 初始化类
 zend_class_entry ce;
 INIT_CLASS_ENTRY(ce, "MyClass", my_class_methods);
 // ...
 
 return SUCCESS;
}

主要任务：

加载并初始化 PHP 扩展
注册常量和函数
注册类接口
初始化线程安全

2. 请求初始化阶段 (RINIT)

// 请求开始时调用
PHP_RINIT_FUNCTION(my_extension)
{
 // 重置全局变量
 MyG(enabled) = 0;
 
 // 启动 session（如果配置了 auto_start）
 php_session_start();
 
 return SUCCESS;
}

主要任务：

重置全局变量
初始化静态变量
启动 session
初始化用户级别的计数器

3. 执行脚本阶段

PHP 代码
 │
 ▼
┌─────────────────┐
│ Lexer (词法) │ 将代码转换为 Token
└────────┬────────┘
 │
 ▼
┌─────────────────┐
│ Parser (语法) │ 将 Token 转换为 AST
└────────┬────────┘
 │
 ▼
┌─────────────────┐
│ Compiler (编译) │ 将 AST 转换为 OpArray
└────────┬────────┘
 │
 ▼
┌─────────────────┐
│ Executor (执行) │ 逐条执行 OpCode
└─────────────────┘

主要任务：

词法分析 → 语法分析 → 编译
生成 OpCode（操作码）
执行 OpCode
输出响应内容

4. 请求关闭阶段 (RSHUTDOWN)

// 请求结束时调用
PHP_RSHUTDOWN_FUNCTION(my_extension)
{
 // 刷新输出
 while (OG(ob_nesting_level) > 0) {
 og_level--;
 }
 
 // 清理用户空间对象
 // ...
 
 return SUCCESS;
}

主要任务：

刷新输出缓冲区
发送 HTTP 响应
清理全局变量
关闭 session

5. 模块关闭阶段 (MSHUTDOWN)

// PHP-FPM 关闭时调用
PHP_MSHUTDOWN_FUNCTION(my_extension)
{
 // 注销常量和类
 // 释放持久化资源
 
 return SUCCESS;
}

主要任务：

关闭所有扩展
释放持久化资源
清理线程安全数据

不同的 SAPI 模式

PHP 在不同运行环境下，工作模式有所差异：

SAPI	启动次数	生命周期
CLI/CGI	每次请求	完整生命周期
PHP-FPM	一次启动	MINIT 一次，请求周期重复
mod_php (Apache)	一次启动	MINIT 一次，请求周期重复

PHP-FPM 生命周期

┌─────────────────────────────────────────────────────┐
│ PHP-FPM Master Process │
│ - 监听端口 │
│ - 管理 Worker 进程 │
│ - MINIT 只执行一次 │
└───────────────────────┬─────────────────────────────┘
 │ fork
 ▼
┌─────────────────────────────────────────────────────┐
│ PHP-FPM Worker Process │
│ - 处理请求 │
│ - 重复执行 RINIT → 执行 → RSHUTDOWN │
└─────────────────────────────────────────────────────┘

总结

PHP 架构由 SAPI、main、Zend、ext、TSRM 五大模块组成
PHP 生命周期分为 5 个阶段：模块初始化、请求初始化、脚本执行、请求关闭、模块关闭
不同 SAPI 模式下，生命周期有所差异（CLI 每次都完整执行，PHP-FPM 只在启动时执行 MINIT）
理解 PHP 生命周期对于编写高效扩展和排查问题非常重要

参考资料

《PHP 内核剖析》- 秦朋
PHP 官方文档

指尖之上 - 移动端H5开发资源汇总

Fri, 02 Feb 2018 00:00:00 +0000

移动端 H5 开发过程中收藏的优质资源链接，涵盖布局、动画、设备 API 等各个方面。

布局相关

示例	说明
滑屏页面布局	移动端常见滑屏布局实现
水平垂直居中	CSS 居中方案汇总
布局形式	常见布局形式示例
图片列表	图片列表布局
屏幕适应	多分辨率适配方案
Rem 自适应	Rem 布局详解
视频自适应	响应式视频方案

CSS3 动画

示例	说明
Transform 变形	CSS3 Transform 详解
Transition 转换	CSS3 Transition 详解
Animation 动画	CSS3 Animation 详解
简单 CSS3 动画	入门动画示例
带点击交互的动画	交互动画示例

设备 API

媒体相关

示例	说明
Audio 事件支持检测	Audio API 兼容性检测
摄像头捕捉	getUserMedia 摄像头调用
用户声音录制	麦克风录音功能
Web Speech	语音识别 API
Web Audio API	Web Audio 音频处理

传感器相关

示例	说明
地理定位	Geolocation API 使用
陀螺仪	DeviceOrientation 事件
运动传感器	DeviceMotion 事件
设备震动	Vibration API
电池状态	Battery API
环境光	Ambient Light API
网络信息	Network Information API

精品案例

示例	说明
驯龙公主	3D 交互案例
跑就有型	跑步主题互动
帧动画-互娱周末	帧动画应用
Three.js 完整实例	3D 场景示例
CreateJS 动画	Canvas 动画方案

工具与框架

常用框架

// Zepto - 轻量级 jQuery 替代品
// <script src="zepto.min.js"></script>

// Hammer.js - 手势库
// <script src="hammer.min.js"></script>

// Swiper - 轮播滑动组件
// <script src="swiper.min.js"></script>

// Animate.css - 动画库
// <link href="animate.min.css">

// Three.js - 3D 渲染
// <script src="three.min.js"></script>

移动端调试

// VConsole - 移动端调试面板
// <script src="vconsole.min.js"></script>
new VConsole();

// Eruda - 另一个移动端调试工具
// <script src="eruda.min.js"></script>
eruda.init();

移动端适配方案

1. viewport 视口设置

<meta name="viewport" 
 content="width=device-width, initial-scale=1.0, 
 maximum-scale=1.0, user-scalable=no">

2. Rem 适配方案

// 根据 dpr 和屏幕宽度动态设置 font-size
function setRem() {
 const dpr = window.devicePixelRatio || 1;
 const width = document.documentElement.clientWidth;
 const fontSize = width / 10; // 设计稿 750px 时，1rem = 75px
 document.documentElement.style.fontSize = fontSize + 'px';
}
setRem();
window.addEventListener('resize', setRem);

3. 一像素边框

/* 使用 transform 实现物理像素边框 */
.border-1px {
 position: relative;
}
.border-1px::after {
 content: '';
 position: absolute;
 bottom: 0;
 left: 0;
 right: 0;
 height: 1px;
 background: #ddd;
 transform: scaleY(0.5);
}

性能优化建议

减少重排重绘

/* 避免 */
element.style.width = '100px';
element.style.height = '100px';

/* 使用 transform */
element.style.transform = 'translate(100px, 100px)';

使用 CSS 动画

/* 开启 GPU 加速 */
.animate {
 transform: translateZ(0);
 will-change: transform;
}

图片优化
- 使用 WebP 格式
- 根据 dpr 提供 @2x @3x 图片
- 使用懒加载

参考资源

Can I Use - 特性兼容性查询
MDN Web Docs - Web API 文档
腾讯 TGideas - 移动端开发规范

这些资源帮助我更好地理解了移动端 H5 开发的各个方面，希望对您也有帮助。

使用Composer安装Laravel/Lumen

Fri, 08 Dec 2017 00:00:00 +0000

本文介绍如何搭建 PHP 的 Laravel 和 Lumen 环境

安装 Composer

方法一：官方安装脚本

php -r "copy('https://install.phpcomposer.com/installer', 'composer-setup.php');"
php composer-setup.php
php -r "unlink('composer-setup.php');"

# 移动到系统 PATH
sudo mv composer.phar /usr/local/bin/composer

方法二：直接下载（推荐）

# Linux/macOS
curl -sS https://getcomposer.org/installer | php
sudo mv composer.phar /usr/local/bin/composer

# Windows
# 下载 https://getcomposer.org/Composer-Setup.exe

设置权限

# 添加执行权限
sudo chmod +x /usr/local/bin/composer

修改 Composer 镜像

由于国内网络原因，建议使用国内镜像加速：

# 阿里云镜像（推荐）
composer config -g repo.packagist composer https://mirrors.aliyun.com/composer/

# Laravel China 镜像
composer config -g repo.packagist composer https://packagist.laravel-china.org

# 恢复官方源
composer config -g --unset repos.packagist

安装 Laravel/Lumen

全局安装 Laravel

composer global require "laravel/installer"

全局安装 Lumen

composer global require "laravel/lumen-installer"

添加到系统 PATH

# 编辑 ~/.bashrc 或 ~/.zshrc
echo 'export PATH="$PATH:$HOME/.composer/vendor/bin"' >> ~/.bashrc
source ~/.bashrc

# 确认目录（可能因 Composer 版本而异）
echo 'export PATH="$PATH:/home/yison/.config/composer/vendor/bin"' >> ~/.bashrc
source ~/.bashrc

验证安装：

composer --version
laravel --version
lumen --version

创建项目

使用 Laravel 创建项目

# 方式一：使用 laravel 命令
laravel new blog

# 方式二：使用 Composer
composer create-project --prefer-dist laravel/laravel blog

# 指定版本
composer create-project --prefer-dist laravel/laravel blog "10.*"

使用 Lumen 创建项目

# 方式一：使用 lumen 命令
lumen new lumen

# 方式二：使用 Composer（推荐）
composer create-project --prefer-dist laravel/lumen lumen

# 指定版本
composer create-project --prefer-dist laravel/lumen lumen "10.*"

启动 Laravel 项目

cd blog

# 安装依赖
composer install

# 复制环境配置
cp .env.example .env

# 生成应用密钥
php artisan key:generate

# 启动开发服务器
php artisan serve
# 访问 http://localhost:8000

启动 Lumen 项目

cd lumen

# 安装依赖
composer install

# 复制环境配置
cp .env.example .env

# 生成应用密钥
php artisan key:generate

# 启动开发服务器
php -S localhost:8000 -t public
# 访问 http://localhost:8000

Laravel/Lumen 常用命令

Artisan 命令

# 查看所有命令
php artisan list

# 创建控制器
php artisan make:controller UserController

# 创建模型
php artisan make:model User

# 创建中间件
php artisan make:middleware AuthMiddleware

# 创建数据库迁移
php artisan make:migration create_users_table

# 执行数据库迁移
php artisan migrate

# 路由列表
php artisan route:list

# 清除缓存
php artisan config:clear
php artisan cache:clear
php artisan view:clear

Composer 常用命令

# 更新依赖
composer update

# 添加依赖
composer require package/name

# 添加开发依赖
composer require --dev phpunit/phpunit

# 移除依赖
composer remove package/name

# 优化自动加载
composer dump-autoload -o

# 查看可用更新
composer outdated

Lumen vs Laravel

特性	Lumen	Laravel
定位	微服务/API	全栈应用
体积	~1MB	~10MB
视图	❌ 不支持	✅ 支持
Session	❌	✅
路由	FastRoute	Symfony Router
开箱即用	较少	丰富
性能	更快	较慢

Docker 部署 Laravel

# 使用 Laravel Sail 快速搭建开发环境
composer require laravel/sail --dev
php artisan sail:install
php artisan db:seed
docker-compose up -d

常见问题

Q: composer 命令找不到

A: 确保 Composer 在 PATH 中：

export PATH="$PATH:$HOME/.composer/vendor/bin"
source ~/.bashrc

Q: 依赖安装失败

A: 尝试清除缓存或更换镜像：

composer clear-cache
composer config -g repo.packagist composer https://mirrors.aliyun.com/composer/
composer install

Q: 权限不足

A: Linux 系统设置目录权限：

sudo chown -R $USER:$USER /path/to/project
chmod -R 755 /path/to/project
chmod -R 775 /path/to/project/storage

参考链接

使用GD库给图片铺满水印

Fri, 08 Dec 2017 00:00:00 +0000

PHP 使用 GD 库生成平铺水印的方法，可以将水印图片铺满整个图片。

原理说明

平铺水印的核心思想是：

读取原图和水印图片
循环遍历原图的每一个区域
将水印图片复制到每个区域
处理边界情况（水印超出原图边界）

完整代码实现

<?php

/**
 * 图片平铺水印
 * 
 * @param string $dst_file 处理完成后保存的文件路径
 * @param string $src_file 待处理的图片文件路径
 * @param string $logo_file 水印图片文件路径
 * @param int $top 上间距（水印之间的垂直间距）
 * @param int $left 左间距（水印之间的水平间距）
 * @param int|false $alpha 透明度 0-100，false 表示不透明
 * @return bool
 */
function fullFillLogos($dst_file, $src_file, $logo_file, $top = 0, $left = 0, $alpha = false) {
 try {
 // 检查文件是否存在
 if (!file_exists($src_file)) {
 throw new Exception("源图片不存在: $src_file");
 }
 if (!file_exists($logo_file)) {
 throw new Exception("水印图片不存在: $logo_file");
 }
 
 // 检查 GD 库是否支持
 if (!extension_loaded('gd')) {
 throw new Exception("GD 库未安装");
 }
 
 // 创建图片资源
 $dst = imagecreatefromstring(file_get_contents($src_file));
 $logo = imagecreatefrompng($logo_file); // PNG 保留透明度
 
 if (!$dst || !$logo) {
 throw new Exception("图片创建失败");
 }
 
 // 获取尺寸
 $logo_w = imagesx($logo);
 $logo_h = imagesy($logo);
 $dst_w = imagesx($dst);
 $dst_h = imagesy($dst);
 
 // 循环铺上水印
 for ($off_y = $top; $off_y < $dst_h; $off_y += $logo_h + $top) {
 for ($off_x = $left; $off_x < $dst_w; $off_x += $logo_w + $left) {
 // 计算边界：如果水印超出原图边界，需要裁剪
 $width = ($off_x + $logo_w > $dst_w) ? ($dst_w - $off_x) : $logo_w;
 $height = ($off_y + $logo_h > $dst_h) ? ($dst_h - $off_y) : $logo_h;
 
 // 如果超出边界，从水印图片的 (0,0) 开始裁剪
 $src_x = 0;
 $src_y = 0;
 if ($off_x + $logo_w > $dst_w) {
 $src_x = $logo_w - $width;
 }
 if ($off_y + $logo_h > $dst_h) {
 $src_y = $logo_h - $height;
 }
 
 // 根据透明度选择复制方式
 if ($alpha === false) {
 // 不透明复制（忽略 PNG 原有透明度）
 imagecopy($dst, $logo, $off_x, $off_y, $src_x, $src_y, $width, $height);
 } else {
 // 带透明度复制（PNG 透明度会被忽略）
 imagecopymerge($dst, $logo, $off_x, $off_y, $src_x, $src_y, $width, $height, $alpha);
 }
 }
 }
 
 // 获取原图格式
 $mime = mime_content_type($src_file);
 $ext = strtolower(pathinfo($src_file, PATHINFO_EXTENSION));
 
 // 保存图片
 switch ($ext) {
 case 'jpg':
 case 'jpeg':
 imagejpeg($dst, $dst_file, 90);
 break;
 case 'png':
 imagepng($dst, $dst_file, 9);
 break;
 case 'gif':
 imagegif($dst, $dst_file);
 break;
 default:
 imagejpeg($dst, $dst_file, 90);
 }
 
 // 释放内存
 imagedestroy($dst);
 imagedestroy($logo);
 
 return true;
 } catch (Exception $e) {
 error_log($e->getMessage());
 return false;
 }
}

使用示例

<?php

// 示例1：最基本的用法
$result = fullFillLogos(
 '/path/to/output.jpg', // 输出文件
 '/path/to/source.jpg', // 源图片
 '/path/to/watermark.png', // 水印图片
 10, // 垂直间距
 10, // 水平间距
 50 // 50% 透明度
);

// 示例2：不透明水印
$result = fullFillLogos(
 '/path/to/output.jpg',
 '/path/to/source.jpg',
 '/path/to/logo.png',
 20, // 更大的间距
 20,
 false // 不透明
);

// 示例3：API 形式调用
if (fullFillLogos($dst, $src, $logo, 0, 0, 30)) {
 echo "水印添加成功";
} else {
 echo "水印添加失败";
}

进阶版本：支持水印位置

/**
 * 带位置参数的水印函数
 * 
 * @param string $dst_file 输出文件
 * @param string $src_file 源文件
 * @param string $logo_file 水印文件
 * @param string $position 水印位置：center/tiled/single
 * @param int $margin 边距（single 模式下有效）
 * @param int|false $alpha 透明度
 */
function watermark($dst_file, $src_file, $logo_file, $position = 'tiled', $margin = 10, $alpha = false) {
 $dst = imagecreatefromstring(file_get_contents($src_file));
 $logo = imagecreatefrompng($logo_file);
 
 $logo_w = imagesx($logo);
 $logo_h = imagesy($logo);
 $dst_w = imagesx($dst);
 $dst_h = imagesy($dst);
 
 if ($position === 'tiled') {
 // 平铺模式
 for ($off_y = 0; $off_y < $dst_h; $off_y += $logo_h) {
 for ($off_x = 0; $off_x < $dst_w; $off_x += $logo_w) {
 imagecopy($dst, $logo, $off_x, $off_y, 0, 0, $logo_w, $logo_h);
 }
 }
 } elseif ($position === 'center') {
 // 居中模式
 $x = ($dst_w - $logo_w) / 2;
 $y = ($dst_h - $logo_h) / 2;
 imagecopy($dst, $logo, $x, $y, 0, 0, $logo_w, $logo_h);
 } elseif ($position === 'bottom-right') {
 // 右下角
 $x = $dst_w - $logo_w - $margin;
 $y = $dst_h - $logo_h - $margin;
 imagecopy($dst, $logo, $x, $y, 0, 0, $logo_w, $logo_h);
 }
 
 imagepng($dst, $dst_file);
 imagedestroy($dst);
 imagedestroy($logo);
}

水印图片制作建议

1. 使用 PNG 格式

PNG 格式支持透明背景，适合做水印：

# 使用 ImageMagick 创建水印图片
convert -size 100x50 xc:none -fill black \n -pointsize 20 -gravity center \n -annotate +0+0 "© YISON" logo.png

2. 保持水印图片尺寸适中

水印太小：看不清
水印太大：影响原图观赏

建议水印尺寸为原图的 5%-15%

3. 半透明效果

使用 PNG-24 格式并设置透明度：

// 使用 imagecopymerge 可以保留 PNG 的透明通道
imagecopymerge($dst, $logo, $x, $y, 0, 0, $logo_w, $logo_h, 50);

注意事项

内存消耗：处理大图片时注意 PHP 内存限制

ini_set('memory_limit', '256M'); // 根据需要调整

GD 库与格式：确认 PHP 已启用 GD（php -m | grep -i gd）。JPEG、PNG、GIF、WebP 需分别使用 imagecreatefromjpeg / imagecreatefrompng / imagecreatefromgif / imagecreatefromwebp 创建画布；保存时对应使用 imagejpeg、imagepng 等，并对透明 PNG 选用 imagesavealpha($im, true)，避免透明通道丢失。
压缩与画质：对大图先做适当缩放再叠水印以节省内存。JPEG 保存时可指定质量参数，例如 imagejpeg($dst, $path, 90);，在体积与观感之间折中；尽量避免对同一文件反复解码—编码多次，以免画质明显下降。

小结

铺满水印本质是「遍历网格 + imagecopy/imagecopymerge」。实现时注意内存、格式与透明度处理，并在批量任务里做好异常与日志，便于线上排查。

WordPress如何使用腾讯云COS

Wed, 03 May 2017 00:00:00 +0000

COS 是腾讯云的对象存储服务，免费 50G 存储空间，按外网流量收费，内网调用免流量。本文介绍如何让 WordPress 使用 COS 存储图片并享受内网流量。

一、COS 开通与配置

1. 开通对象存储服务

登录腾讯云控制台，按照提示开通 COS 服务。

2. 创建 Bucket

⚠️ 重要：Bucket 所属地域必须与 ECS 服务器一致，否则无法享受内网流量！

在 COS 控制台创建存储桶：

选择与 ECS 相同地域（如广州、上海等）
设置访问权限（建议私有读写）
记录 Bucket 名称和地域

3. 获取密钥

在访问密钥管理页面获取：

SecretId
SecretKey

二、安装 COS 插件

本文采用 cos-sync 插件，上传图片时自动同步到 COS。

安装步骤

下载插件并解压
上传到 WordPress 插件目录
在 WordPress 后台启用插件
配置插件参数（SecretId、SecretKey、Bucket、地域等）

插件配置

// 插件配置参数示例
cos_options = [
 'secretId' => '你的SecretId',
 'secretKey' => '你的SecretKey',
 'bucket' => 'your-bucket-1250000000',
 'regional' => 'ap-guangzhou', // 地域代码
 'domain' => 'https://your-bucket.cos.ap-guangzhou.myqcloud.com'
];

三、享受 COS 内网流量

方法 A：自建代理服务

在服务器上实现一个读取 COS 图片的服务：

<?php
// proxy.php - COS 代理服务
if (empty($_GET["file"])) {
 die('no access');
}

require_once __DIR__ . '/../../../wp-blog-header.php';
require_once 'vendor/autoload.php';

use Qcloud\Cos\Client;
use Qcloud\Cos\Exception\ServiceResponseException;

$cos_options = get_option('cos_options', true);
$secretId = $cos_options['secretId'];
$secretKey = $cos_options['secretKey'];
$bucket = $cos_options['bucket'];
$region = $cos_options['regional'];

$client = new Client([
 'region' => $region,
 'credentials' => [
 'secretId' => $secretId,
 'secretKey' => $secretKey,
 ],
]);

$file = $_GET["file"];

try {
 $result = $client->getObject([
 'Bucket' => $bucket,
 'Key' => ltrim($file, '/'),
 ]);
 
 // 设置 Content-Type
 $contentType = $result['ContentType'] ?? 'application/octet-stream';
 header('Content-Type: ' . $contentType);
 echo $result['Body'];
} catch (ServiceResponseException $e) {
 http_response_code(404);
 die('File not found');
}

评价：

✅ 实现灵活，可自定义缓存、压缩等
❌ 需要处理 COS 的 keep-alive 问题
❌ 需要设置合理的超时时间

方法 B：Nginx 反向代理（推荐）

使用 Nginx 代理 COS 请求，实现内网访问：

server {
 listen 80;
 server_name your-blog.com;
 
 # WordPress 其他请求
 location / {
 try_files $uri $uri/ /index.php?$query_string;
 }
 
 # COS 图片代理
 location ^~ /cos/ {
 # 去掉 /cos/ 前缀，重写为实际 COS 路径
 rewrite ^/cos/(.*) /$1 break;
 
 # 代理到 COS
 proxy_pass https://your-bucket.cos.ap-guangzhou.myqcloud.com/;
 
 # 代理配置
 proxy_set_header Host $host;
 proxy_set_header X-Real-IP $remote_addr;
 proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
 
 # 超时设置
 proxy_connect_timeout 60s;
 proxy_read_timeout 60s;
 proxy_send_timeout 60s;
 
 # 缓存设置
 proxy_cache cache;
 proxy_cache_valid 200 7d;
 add_header X-Cache-Status $upstream_cache_status;
 }
 
 location ~ \.php$ {
 fastcgi_pass unix:/run/php/php-fpm.sock;
 fastcgi_index index.php;
 include fastcgi_params;
 fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
 }
}

访问方式：http://your-blog.com/cos/uploads/2023/01/image.jpg

评价：

✅ 实现简单，配置灵活
✅ 响应及时，支持缓存
✅ 可复用 Nginx 的各种优化

四、插件优化配置

问题 A：媒体库缩略图显示异常

现象：不勾选"本地保存"后，媒体库缩略图显示不正确

原因：服务器不存储图片，无法获取尺寸，默认宽高为 1px

解决：修改 WordPress 核心文件最小尺寸

// wp-includes/media.php，约 444 行
// 将 $w 和 $h 的最小值改为 150
$w = max(150, (int) round($current_width * $ratio));
$h = max(150, (int) round($current_height * $ratio));

// wp-admin/includes/image-edit.php，约 606 行
$w2 = max(150, $w * $ratio);
$h2 = max(150, $h * $ratio);

问题 B：预览看不到图片

解决：修改媒体模板文件

// wp-includes/media-template.php，约 680 行和 931 行
// 在 else 分支中设置 size 为 full
<# } else { #>
 <label class="setting">
 <input type="hidden" name="size" value="full" />
 </label>
<# } #>

五、完整配置示例

docker-compose.yml

version: '3.8'

services:
 wordpress:
 image: wordpress:latest
 ports:
 - "8080:80"
 volumes:
 - ./wp-content:/var/www/html/wp-content
 environment:
 - WORDPRESS_DB_HOST=db
 - WORDPRESS_DB_NAME=wordpress
 - WORDPRESS_DB_USER=wp_user
 - WORDPRESS_DB_PASSWORD=wp_password

 db:
 image: mysql:8.0
 environment:
 - MYSQL_ROOT_PASSWORD=root_password
 - MYSQL_DATABASE=wordpress
 - MYSQL_USER=wp_user
 - MYSQL_PASSWORD=wp_password
 volumes:
 - db_data:/var/lib/mysql

volumes:
 db_data:

Nginx 配置（生产环境）

upstream wordpress {
 server 127.0.0.1:8080;
}

server {
 listen 443 ssl http2;
 server_name your-blog.com;
 
 ssl_certificate /etc/ssl/certs/your-blog.crt;
 ssl_certificate_key /etc/ssl/private/your-blog.key;
 
 root /var/www/html;
 index index.php index.html;
 
 # COS 代理
 location ^~ /cos/ {
 rewrite ^/cos/(.*) /$1 break;
 proxy_pass https://your-bucket.cos.ap-guangzhou.myqcloud.com/;
 proxy_cache_valid 200 30d;
 expires 30d;
 }
 
 # WordPress
 location / {
 proxy_pass http://wordpress;
 proxy_set_header Host $host;
 proxy_set_header X-Real-IP $remote_addr;
 }
 
 location ~ \.php$ {
 proxy_pass http://wordpress;
 fastcgi_pass unix:/run/php/php-fpm.sock;
 include fastcgi_params;
 }
}

六、常见问题

Q: Bucket 地域选错了怎么办？

A: 可以删除重建，或在插件中手动指定地域参数。

Q: 内网流量仍然收费？

A: 检查 ECS 和 COS 是否同地域，确保使用内网域名访问。

Q: 图片加载很慢？

A: 建议开启 CDN 加速，配合 Nginx 缓存优化。

七、费用说明

项目	说明
存储空间	免费 50GB
内网流量	免费
外网下行流量	按量计费
请求次数	按量计费

💡 建议：将 ECS 和 COS 放在同一地域，使用 内网 Endpoint（内网域名） 访问存储与回源，可省去外网下行流量费用并降低访问延迟。若站点必须对公网用户分发图片，可在 COS 或 CDN 侧单独配置外网访问与缓存策略，按业务场景权衡成本与性能。

八、小结

按本文完成 COS 对接与域名配置后，媒体资源可走对象存储承载流量，ECS 专注计算；后续若有访问热点，再结合 CDN 与缓存策略进一步优化即可。

PHP7和Nginx安装记录

Thu, 02 Jun 2016 00:00:00 +0000

本文主要记录 PHP7 + Nginx 的编译安装以及环境搭建的操作步骤

1. 获取 PHP 源码

# 下载 PHP 7.0.7（注意：PHP 7.0 已停止维护，建议使用更高版本）
sudo wget http://cn2.php.net/distributions/php-7.0.7.tar.xz

# 解压
tar -xvf php-7.0.7.tar.xz
cd php-7.0.7

⚠️ 提示：PHP 7.0 已停止维护，建议使用 PHP 7.4 或 PHP 8.x

2. 安装依赖

sudo apt-get update

sudo apt-get install -y \
 nginx \
 mysql-client \
 git \
 build-essential \
 libxml2-dev \
 libssl-dev \
 libcurl4-openssl-dev \
 libjpeg-dev \
 libpng-dev \
 libmcrypt-dev \
 libreadline-dev \
 libgmp-dev \
 libzip-dev \
 libonig-dev \
 libicu-dev

现代推荐：如果安装 PHP 8.x，mcrypt 已被移除，gd 扩展改为 libgd-dev

3. 编译 PHP

cd php-7.0.7

sudo ./configure \
 --prefix=/usr/local/php7 \
 --enable-fpm \
 --enable-inline-optimization \
 --disable-debug \
 --disable-rpath \
 --enable-shared \
 --enable-opcache \
 --with-mysqli \
 --with-mysql-sock \
 --enable-pdo \
 --with-pdo-mysql \
 --with-gettext \
 --enable-mbstring \
 --with-iconv \
 --enable-bcmath \
 --enable-soap \
 --with-libxml-dir \
 --enable-pcntl \
 --enable-shmop \
 --enable-sysvmsg \
 --enable-sysvsem \
 --enable-sysvshm \
 --enable-sockets \
 --with-curl \
 --with-zlib \
 --enable-zip \
 --with-readline \
 --with-pear \
 --with-gd \
 --with-jpeg-dir=/usr/lib \
 --enable-gd-native-ttf \
 --enable-xml

# 编译安装
sudo make -j$(nproc)
sudo make install

# 创建软链接
sudo ln -s /usr/local/php7 /usr/local/php

# 复制配置文件
sudo cp php.ini-production /usr/local/php/lib/php.ini

⚠️ 警告：--with-mysql 在 PHP 7.0 中已被移除，请使用 --with-mysqli

4. 配置 PHP-FPM

cd /usr/local/php/etc

# 复制默认配置
sudo cp php-fpm.conf.default php-fpm.conf
cd /usr/local/php/etc/php-fpm.d
sudo cp www.conf.default www.conf

# 编辑 www.conf
sudo vim www.conf

修改用户和组：

[www]
user = www-data
group = www-data

; 如果使用 socket 连接
listen = /run/php/php-fpm.sock
listen.owner = www-data
listen.group = www-data
listen.mode = 0660

如果 www-data 用户不存在，需要先创建：

sudo groupadd -g 33 www-data
sudo useradd -g www-data -u 33 -s /usr/sbin/nologin www-data

5. 启动 PHP-FPM

# 启动 php-fpm
sudo /usr/local/php/sbin/php-fpm

# 添加到系统 PATH
sudo tee -a /etc/profile << 'EOF'
export PATH=$PATH:/usr/local/php/bin:/usr/local/php/sbin
EOF
source /etc/profile

# 验证安装
php -v
php-fpm -v

6. Nginx 配置

cd /etc/nginx/sites-enabled
sudo vim default

修改 PHP 配置文件块：

server {
 listen 80 default_server;
 root /var/www/html;
 
 index index.php index.html index.htm;

 server_name _;

 location / {
 try_files $uri $uri/ =404;
 }

 # PHP 配置
 location ~ \.php$ {
 fastcgi_split_path_info ^(.+\.php)(/.+)$;
 fastcgi_pass unix:/run/php/php-fpm.sock;
 # 或者使用 IP:9000
 # fastcgi_pass 127.0.0.1:9000;
 fastcgi_index index.php;
 include fastcgi_params;
 fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
 }

 # 禁止访问隐藏文件
 location ~ /\. {
 deny all;
 }
}

# 重载 Nginx 配置
sudo nginx -t
sudo service nginx reload

7. 测试

创建测试文件：

<?php
// /var/www/html/info.php
phpinfo();

访问 http://your_server_ip/info.php

⚠️ 安全提醒：测试完成后记得删除 info.php

8. 腾讯云/阿里云安全组

重要：记得在云控制台开放 80 端口的安全组规则！

现代安装方式推荐

使用 Ondrej PPA（Ubuntu/Debian）

sudo apt install software-properties-common
sudo add-apt-repository ppa:ondrej/php
sudo apt update
sudo apt install php8.1-fpm php8.1-mysql php8.1-curl php8.1-gd php8.1-mbstring php8.1-xml php8.1-zip

使用 Remi（CentOS/RHEL）

sudo dnf install epel-release
sudo dnf install dnf-utils
sudo dnf module reset php
sudo dnf module enable php:8.1
sudo dnf install php php-fpm php-mysqlnd

常见问题

问题	解决方案
make 报错	检查依赖是否安装完整
php-fpm 无法启动	检查用户权限和 socket 路径
502 Bad Gateway	检查 php-fpm 是否运行，socket 权限
访问不到 PHP	检查 Nginx fastcgi_pass 配置