PHP on Yison's Blog

微信消息编辑器 - 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 等）
美化操作界面
提供实时效果预览
支持消息模板

参考链接

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 脚本重复编译，再配合数据缓存，通常能在成本可控的前提下显著提升站点响应速度。

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());

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 官方文档

使用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」。实现时注意内存、格式与透明度处理，并在批量任务里做好异常与日志，便于线上排查。

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 配置