生产环境与性能
框架在运行时的开销,以及如何构建、调优并发布缓存,让生产环境只为带有 behavior 的调用付出开销。
本页译自英文,以英文页面为准。 阅读原文
框架会把你的类连同它们的 behavior(行为)编译一次,并把结果存成普通的 PHP 文件。此后这些文件和其他代码一样被加载:OPcache 缓存它们,Composer 加载它们,请求期间不会运行任何解析器、反射或 eval()。缓存就绪时,一个生产请求只读取一个元数据文件,把生成的类交给 Composer,并且只为真正被拦截的调用付出开销。没有 behavior 的方法和属性没有任何开销。
本页给出实测数据,解释开销从何而来,并说明如何发布缓存:部署时预热、OPcache、Composer、Docker 和 Kubernetes。内核选项见 配置与命令行。直观的总结见 Performance 特性页面。
本页所有数据都来自 goaop/framework 上游的 docs/performance.md。它们是在同一台机器上测得的,所以请把它们看作不同模式之间的比例。能推广到其他机器上的,正是这些比例。
基准测试环境
Section titled “基准测试环境”- 一个小型商店应用:包含路径(include paths)下约 250 个文件(其中 94 个类被编译),包含路径之外的 120 个库类,以及 6 个 behavior class(行为类),用到了
#[Before]、#[Around]、#[AfterThrowing]和属性上的 behavior。 - 一个请求下 50 个订单。这会产生约 2,600 次被拦截的方法调用和约 950 次被拦截的属性访问。
- PHP 8.5.12 NTS,4 个 CPU,OPcache 使用共享内存,
opcache.jit=disable,opcache.file_update_protection=0。
完整的测量方法见下文 复现基准测试。
各模式下的请求耗时
Section titled “各模式下的请求耗时”三种缓存状态:
- hot:编译缓存已存在,OPcache 已填充。这是生产 worker 的稳定状态。
- warm:编译缓存已存在,OPcache 为空。对应刚启动的 PHP-FPM 或新的 pod。
- cold:还没有任何缓存。第一个请求会编译它加载的每一个类。
| 模式 | hot | warm | 峰值内存(hot) |
|---|---|---|---|
debug => false + PREBUILT_CACHE |
5.4 ms | 59 ms | 1.3 MB |
debug => false |
5.5 ms | 62 ms | 1.3 MB |
debug => true |
13.0 ms | 63 ms | 2.2 MB |
| 不使用框架的同一个应用(behavior 不运行) | 2.1 ms | 36 ms | 0.7 MB |
- 约 3,500 次带有真实 behavior 逻辑(日志、缓存查找、计时器)的拦截,让请求增加约 3.3 ms,其中内核启动约占 0.15 ms。
- 一次被拦截的调用大约耗时三分之一微秒,每多叠加一个 behavior 约增加 70 ns。
- 用
cache:warmup:aop构建整个缓存不到半秒。一个 2,000 个文件的应用用 4 个 worker 需要 1.1 s。 - 容器一启动就是 hot 状态。有了预先填充的 OPcache 文件缓存,新 PHP-FPM 的第一个请求耗时 19 ms,而不是 71 ms;再加上预加载则为 10 ms,与不使用框架的普通应用(9 ms)持平。
单次调用开销
Section titled “单次调用开销”这些数据使用的是空 behavior,因此只衡量框架自身的工作:call context(调用上下文)、拦截器链,以及对原始方法的调用。
| 调用 | 单次调用开销 |
|---|---|
| 已编译类中没有 behavior 的方法或属性 | 0 |
带一个 #[Before] 或 #[Around] 的方法 |
~0.33 µs |
带三个 #[Around] 的方法 |
~0.48 µs |
带一个 #[Around] 的静态方法 |
~0.34 µs |
带一个 #[Around] 的属性读取 |
~0.22 µs |
带一个 #[Around] 的属性写入 |
~0.26 µs |
一百万次被拦截的调用大约耗时三分之一秒。一个有几百次拦截的典型请求,开销只有零点几毫秒。
CLI 进程
Section titled “CLI 进程”每个 CLI 进程启动时 OPcache 都是空的。预先填充的 opcache.file_cache 能让短时运行的命令启动得几乎和 hot 状态的 Web 请求一样快。
| 每个进程的脚本耗时 | 关闭 OPcache | 开启 OPcache(仅内存) | opcache.file_cache,已预填充 |
|---|---|---|---|
PREBUILT_CACHE |
33 ms | 69 ms | 21 ms |
debug => false |
30 ms | 69 ms | 22 ms |
| 不使用框架 | 19 ms | 34 ms | 10 ms |
开销从何而来
Section titled “开销从何而来”没有 behavior 的成员
Section titled “没有 behavior 的成员”代理只覆盖带有 behavior 的成员。其他所有方法和属性都是你的原始代码,全速运行:开销为 0。没有被任何 matching rule(匹配规则)选中的类根本不会被编译。
被拦截的调用与叠加的 behavior
Section titled “被拦截的调用与叠加的 behavior”每个被拦截的方法都声明一个静态 call context:
static $__joinPoint = InterceptorInjector::forMethod(...)Call context 及其拦截器列表在第一次调用时构建。之后的每次调用都只是一次 $__joinPoint->__invoke($this, [$args])。这个列表保存的是一等可调用对象(first-class callable),直接指向你的 behavior class 中的方法,因此既不需要查找 behavior,也没有反射和 __call()。
方法上的第一个 behavior 约耗时 0.33 µs。每多一个 behavior 增加约 70 ns,因此三个 #[Around] behavior 约耗时 0.48 µs。带一个 #[Around] 的静态方法约耗时 0.34 µs。
Behavior 所用的反射(getMethod()、getField())只在 behavior 请求时才会创建。
属性拦截会被编译为代理上原生的 PHP 8.4 get 和 set 钩子。没有 __get() 或 __set() 魔术方法,每次访问也不做反射。带一个 #[Around] 的属性读取约耗时 0.22 µs,写入约 0.26 µs。
在基准测试中,内核启动约耗时 0.15 ms。框架的服务、转换器(transformer)和你的 behavior class 都注册为工厂,每个只是一次数组写入。启动时不会自动加载、反射或创建任何东西,因此 warm 请求从不加载解析器、matching rule 语法、behavior 匹配器或转换器。
- 缓存索引(
CachePathManager)是唯一在init()中构建的服务,因为自动加载器会立即读取类映射(class map)。 - Behavior class 在它的某个 behavior 第一次被调用时才创建,形式是 PHP 8.4 的原生惰性对象。Compile step(编译步骤)和缓存预热从不创建 behavior class,只读取它。
- 生产环境不挂接任何注册监听器。调试模式通过一个监听器跟踪 behavior class 文件的变化,这个监听器借助 Composer 解析文件位置,而不加载这些类。
- Matching rule 语法的解析表是生成好的 PHP 代码,规则只在首次使用时才解析。
冷启动与温启动
Section titled “冷启动与温启动”warm 请求(编译缓存已存在,OPcache 为空)在使用 PREBUILT_CACHE 时耗时 59 ms,普通应用为 36 ms。可以用预先填充的 opcache.file_cache 和预加载来缩短它,见 Docker 与 Kubernetes。
cold 请求会编译它加载的每一个类。在部署时构建缓存并启用 PREBUILT_CACHE 后,生产请求永远不会触发编译。
编译只在部署时进行一次。
- 基准测试应用的缓存不到半秒即可构建完成。
- 一个 2,047 个文件的应用在 4 个 CPU 上,用一个 worker 耗时 2.2 s,用 4 个 worker 耗时 1.1 s。
- 编译期间,每个保留在内存中的已解析文件约占 0.2 MB。内核选项
parsedFilesLimit(默认100)限制最多保留多少个。
让编译保持快速的原因:
- 缓存命中的路径不做任何解析。新鲜的记录在任何转换器出现之前就作为缓存内容返回。流过滤器(stream filter)和转换器链只在第一次未命中时才构建。
- 所有改写规则共用一次语法树遍历。如果某条规则的源码标记没有出现在文件中,这条规则就会被跳过;没有任何适用规则的文件根本不会被遍历。大多数文件都属于这种情况。
- 这些机制由你的 behavior class 来开启。只有在注册了
initialization(...)规则时,new表达式才会被改写。函数代理只在有函数规则时才存在。 - Behavior class 检查需要反射每一个祖先类,它只对带有 behavior 的类运行。
- Behavior class 中的 behavior 被缓存为一个由静态构造表达式组成的普通 PHP 文件,加载速度大约是
unserialize()的两倍。 - 代理以语法树的形式构建,只打印一次(编译时间 −43 %)。生成的 trait 通过 token 级编辑产生,保留你的行号,供 Xdebug 使用。
生产请求做了什么
Section titled “生产请求做了什么”| 步骤 | debug => false(+ PREBUILT_CACHE) |
debug => true |
|---|---|---|
内核 init() |
选项、容器、服务工厂(不创建任何对象) | 同左,另外跟踪内核文件和 behavior class 文件的变化 |
_include.cache(类映射、跳过集合) |
一次 include,由 OPcache 提供,不对缓存目录做 stat() |
同左 |
| 已编译的类 | Composer 类映射 → 缓存文件,来自 OPcache | 新鲜度检查,然后经过流过滤器,让 Xdebug 断点和魔术常量指向你的原始文件 |
| 包含路径下未转换的类 | 跳过集合 → 原始文件,来自 OPcache | 新鲜度检查 → 原始文件,来自 OPcache |
| 解析器、转换器、流过滤器 | 从不加载 | 注册流过滤器,不构建转换器 |
| 修改过的源文件 | 按原样提供部署时构建的缓存 | 在下一个请求中重新编译 |
性能分析器统计的单个 hot 请求的文件系统调用:
| 调用 | PREBUILT_CACHE |
debug => false |
debug => true |
不使用框架 |
|---|---|---|---|---|
filemtime / filesize |
0 | 0 | 323 / 239 | 0 |
file_get_contents |
0 | 0 | 94 | 0 |
file_exists(Composer PSR-4) |
307 | 307 | 412 | 357 |
生产请求不检查任何源文件。它需要的 Composer 查找甚至比普通应用还少,因为生成的类直接来自类映射。优化过的 Composer 类映射会消除剩下的查找,见 Composer 自动加载器。
运行时索引还有两个细节:
_include.cache只保存请求所需的内容:类映射、跳过集合和包含映射(include map)。完整的构建记录放在_transformation.cache中,生产环境从不读取它。- 两个元数据文件都是用
var_export()导出的数组,路径相对于__DIR__。OPcache 把它们作为不可变数据保存在共享内存中,所以 include 它们不会复制任何内容,应用目录移动后缓存也依然有效。
调试模式是为开发准备的。在基准测试中,它的 hot 请求耗时约 13 ms,生产模式约 5.5 ms。调试模式仍然按原始路径 include 新鲜的未转换文件,因此 OPcache 会缓存它们(每个文件约 38 µs → 约 10 µs,调试请求快 27–40 %)。
生产环境检查清单
Section titled “生产环境检查清单”-
设置
'debug' => false和'features' => Features::PREBUILT_CACHE。 -
在部署或构建镜像时用
cache:warmup:aop构建缓存。 -
让
includePaths保持精简:只放你的src/,不放vendor/。 -
用
addLazyService()注册 behavior class。 -
用
composer install --no-dev --classmap-authoritative安装依赖。 -
运行 OPcache 时设置
opcache.validate_timestamps=0,并为生成的文件留出足够的内存和文件槽位。 -
在容器中,把缓存构建进镜像,并加上预先填充的
opcache.file_cache或预加载。
生产环境的内核:
use Go\Aop\Features;
ApplicationAspectKernel::getInstance()->init([ 'debug' => false, 'appDir' => __DIR__ . '/..', 'cacheDir' => __DIR__ . '/../var/cache/aop', 'includePaths' => [__DIR__ . '/../src'], 'features' => Features::PREBUILT_CACHE,]);在部署时构建缓存
Section titled “在部署时构建缓存”rm -rf var/cache/aopvendor/bin/aspect cache:warmup:aop public/index.php --workers=$(nproc)从空目录开始,让缓存恰好只包含当前发布的版本。参数是初始化内核的文件:前端控制器或引导文件。命令会执行这个文件,因此内核以与生产环境相同的选项启动。
该命令:
- 编译
includePaths下(去掉excludePaths)的每个文件,写出生成的文件、代理、behavior class 缓存和两个元数据文件; - 把每个无法编译的文件报告到 stderr,并以非零退出码退出,这样部署脚本或
docker build会就此停下,而不会发布一个不完整的缓存。
只要代码、behavior class、内核选项或 composer.lock 发生变化,就要重建缓存。实际上,这意味着每次部署都要重建。调试模式不需要重建:它会自行重新编译修改过的类、behavior class 和内核文件。
完整的命令签名:
cache:warmup:aop [<loader>] [--fail-fast] [--workers=N] [--cached-files=N] [--cache-dir=DIR] [--preload[=FILE]]在已经初始化了内核的应用中(比如框架集成提供的控制台),省略 loader 参数,命令会使用当前进程的内核。见 集成。
Worker 进程
Section titled “Worker 进程”--workers=N 在 N 个 worker 进程中编译,最大的文件优先。默认值为 1,即在命令进程本身中编译。设为 CPU 的数量即可。协调进程只写一次元数据,每个进程在内存中保留的语法树数量都有上限。
--cached-files=N 设置每个进程的这个上限,默认取内核选项 parsedFilesLimit 的值(100)。缓存的文件越多,重新解析就越少;越少则内存占用越低。加上 -v 会逐个列出文件,而不显示进度条。
在运行中的版本旁边构建
Section titled “在运行中的版本旁边构建”--cache-dir=DIR 在另一个目录中从头构建缓存,内核则继续从它自己的目录提供服务。用它可以在运行中的版本旁边准备好下一个版本的缓存,再以原子方式切换过去,例如替换符号链接。
用这种方式构建的缓存是完整的,并且与位置无关,即使构建它的是一个自身缓存已经预热的生产内核。编译器总是读取它所反射的类的原始源码,从不读取生产环境中由 Composer 提供的生成文件。
在已有的目录上运行时,命令会重新编译源码有变化(大小或修改时间)的每个文件,其余文件保持不变。启用 PREBUILT_CACHE 时同样如此:只有请求会原样信任缓存,预热命令不会。
PREBUILT_CACHE 与只读文件系统
Section titled “PREBUILT_CACHE 与只读文件系统”Features::PREBUILT_CACHE 让请求完全信任部署时构建的缓存。它会跳过:
- 缓存目录及其可写性探测;
- 源文件的
filemtime比较; - 被跟踪资源的检查;
- Behavior class 缓存的新鲜度检查。
请求永远不会编译,也永远不会写入缓存目录,因此可以在只读文件系统上运行。也正因为如此,缓存必须是完整的。如果包含路径下的某个类或被 include 的文件在缓存中没有记录,或者某条记录对应的缓存文件已经不存在,请求会在编译任何东西之前以 WeavingException 失败。构建之后新增的文件也算在内,哪怕它根本不需要编译。
编译器从不处理的文件按原样加载:包含路径之外的文件、被排除的文件,以及非 .php 文件,例如被 include 的模板。
每个缓存文件都先写入一个唯一的临时文件,再重命名到目标位置,然后在 OPcache 中失效。并发请求永远不会看到写了一半的文件,不需要锁,并发写入元数据的进程会合并各自的记录。
Composer 自动加载器
Section titled “Composer 自动加载器”没有被编译的类照常由 Composer 查找。使用优化过的类映射时,每次查找都是一次数组访问,而不是一次 file_exists(),生成类的类映射则通过 addClassMap() 合并进去。这样,生成的类和未转换的类就以同样的方式提供。
基准测试中的 hot 请求:
| 自动加载器 | PREBUILT_CACHE |
debug => false |
不使用框架 |
|---|---|---|---|
PSR-4(composer install) |
5.5 ms | 6.7 ms | 2.3 ms |
--optimize-autoloader(-o) |
5.2 ms | 5.0 ms | 1.6 ms |
--classmap-authoritative(-a) |
4.8 ms | 4.6 ms | 1.9 ms |
使用 --classmap-authoritative 时,Composer 从不在类映射之外查找类。在任何代码生成之后、预热之前,运行 dump-autoload。
OPcache 调优
Section titled “OPcache 调优”每个被编译的类都会变成两个缓存文件:作为 trait 的原始类体,以及代理。每个 behavior class 还有一个自己的缓存文件。给 OPcache 留出容纳它们的空间。
| 设置 | 生产环境取值 | 原因 |
|---|---|---|
opcache.enable |
1 |
生成的代码是普通的 PHP,和应用的其余部分一样被缓存。 |
opcache.memory_consumption |
128–256(MB) |
在负载下检查 opcache_get_status()['memory_usage']。 |
opcache.interned_strings_buffer |
16–32(MB) |
代理和生成的 trait 共用类名和方法名。 |
opcache.max_accelerated_files |
≥ 应用与 vendor/ 中 PHP 文件数的 2 倍 |
每个被编译的类都会增加一个文件。 |
opcache.validate_timestamps |
0 |
发布版本和容器都是不可变的:每次 include 无需 stat。部署后重新加载 PHP-FPM。 |
opcache.file_update_protection |
0 |
框架以原子方式写入每个缓存文件,因此 OPcache 可以立即缓存新生成的文件,而不必等待 2 秒(默认值)。 |
opcache.file_cache |
一个目录 | 磁盘上的二级缓存:新的 PHP-FPM 主进程或 CLI 进程直接加载已编译的脚本,不必重新编译。在构建时预先填充它。 |
opcache.preload |
可选 | 在服务器启动时一次性链接生成的类,见 预加载。 |
realpath_cache_size / realpath_cache_ttl |
4096K / 600 |
在 validate_timestamps=1 时:每次 include 的路径查找更少。 |
生成的代码是普通的 PHP,和应用的其余部分一样由 JIT 编译。典型的 Web 请求把时间花在大量短调用上,JIT 在这种场景下收益不大,所以启用之前先测量。
生成的文件都是普通的类声明,因此预构建的缓存可以被预加载。--preload 会为它所构建的缓存写出 opcache.preload 脚本:缓存目录中的 _preload.php,或者由 --preload=FILE 指定的文件。
vendor/bin/aspect cache:warmup:aop public/index.php --workers=$(nproc) --preloadopcache.preload=/app/var/cache/aop/_preload.phpopcache.preload_user=www-data不带值的 --preload 必须放在 loader 参数之后,否则它会把 loader 当作自己的值。
PHP-FPM 启动时,这个脚本会 require Composer 的自动加载器,把生成类的类映射交给它,然后把每个已编译的类、它的代理,以及缓存已知的每个未转换类链接进 OPcache。
- Composer 的
files自动加载项(辅助函数、polyfill 引导文件)不会被预加载。请求照常 include 它们。 - 脚本中没有任何绝对路径。和元数据文件一样,一切都通过
__DIR__定位,所以随应用一起移动的缓存依然有效。 - 它列出的恰好是构建时所用缓存中的类。随缓存一起重建它。
- 预加载时无法链接的类(缺少某个可选依赖)会写入错误日志,交给请求的自动加载器处理。
- 在静态初始化上带有 behavior 的类同样交给自动加载器:这个 behavior 需要内核,所以由请求来加载它。
每个请求仍然会初始化内核;只是自动加载器再也不必加载那些已经预加载的类。在基准测试中,预加载把每个请求 include 的文件从 517 个减少到 174 个,hot 请求从 5.2 ms 降到 4.9 ms,服务器启动后的第一个请求从 71 ms 降到 24 ms(配合预先填充的文件缓存为 10 ms)。
预加载的类只有在 PHP-FPM 重启后才会改变,而容器本来就是这样部署的。除非设置了 opcache.enable_cli=1,CLI 中不会预加载任何内容。
Docker 与 Kubernetes
Section titled “Docker 与 Kubernetes”把框架的缓存构建进镜像。这样每个容器启动时都带着完整的只读缓存,每个副本提供完全相同的生成代码,任何 pod 都不会触发编译。shop demo 以可运行镜像的形式提供了这套配置。
Dockerfile
Section titled “Dockerfile”FROM php:8.5-fpm
# OPcache is part of PHP 8.5, no docker-php-ext-install neededCOPY docker/opcache.ini /usr/local/etc/php/conf.d/opcache.iniCOPY --from=composer:2 /usr/bin/composer /usr/bin/composer
WORKDIR /appCOPY composer.json composer.lock ./RUN composer install --no-dev --no-scripts --no-autoloader --prefer-distCOPY . .RUN composer dump-autoload --no-dev --classmap-authoritative
# 1. The framework's cache: generated classes, proxies, behavior caches, metadata, owned by the user that serves it# (cache files get the `cacheFileMode` kernel option, by default 0770 minus the umask)RUN rm -rf var/cache/aop \ && php vendor/bin/aspect cache:warmup:aop public/index.php --workers="$(nproc)" --preload \ && chown -R www-data:www-data var/cache/aop \ && chmod -R a-w var/cache/aop
# 2. The OPcache file cache: a new PHP-FPM master loads compiled scripts instead of compiling them.# Built in the final image, as the file cache belongs to this PHP build and these paths.RUN mkdir -p /var/cache/opcache \ && php -d opcache.enable_cli=1 -d opcache.file_cache_only=1 -d opcache.file_cache=/var/cache/opcache \ vendor/bin/aspect cache:warmup:opcache public/index.php --file-cache=/var/cache/opcache --entry=public/index.php \ && chown -R www-data /var/cache/opcache
USER www-datacache:warmup:opcache 会编译应用加载的所有内容:框架的缓存(生成的文件、代理、behavior class 缓存和元数据)、Composer 的类映射和自动加载的文件、包含路径下未被编译的源码、loader 文件,以及用 --entry 指定的入口文件。
- 只有以
opcache.enable_cli=1、opcache.file_cache_only=1和opcache.file_cache=DIR启动的进程,才会把编译后的脚本写到磁盘。这些设置无法在运行时修改。命令会检查它们,并检查--file-cache=DIR是否就是配置的目录;否则会打印出需要运行的确切命令。 - 框架的缓存、loader 和入口文件必须能够编译,否则命令失败。Composer 类映射中无法编译的文件(例如为更新版本的 PHP 编写的 vendor 测试桩)会被列出并跳过;PHP 会记录编译错误。
- 在
cache:warmup:aop之后、在最终镜像中、用处理请求的那个 PHP 二进制文件运行它。文件缓存以 PHP 构建和文件的绝对路径为键。
opcache.ini
Section titled “opcache.ini”opcache.enable=1opcache.memory_consumption=192opcache.interned_strings_buffer=32opcache.max_accelerated_files=50000opcache.validate_timestamps=0opcache.file_cache=/var/cache/opcacheopcache.file_cache_consistency_checks=0; PHP 8.5: the primed file cache is only read at runtime, also on a read-only root file systemopcache.file_cache_read_only=1; required on PHP 8.5.11 / 8.5.12, see "JIT"opcache.jit=disable; optional, see "Preloading" (written by cache:warmup:aop --preload); opcache.preload=/app/var/cache/aop/_preload.php; opcache.preload_user=www-data镜像中的内核就是 检查清单 里的生产内核:debug => false,includePaths 只限于 src/,外加 Features::PREBUILT_CACHE。
在基准测试中,这套配置让刚启动的服务器在使用文件缓存时 19 ms 处理完第一个请求,在文件缓存加预加载时只需 10 ms,而两者都不用时为 71 ms。pod 从第一个请求起就很快。
Kubernetes
Section titled “Kubernetes”- 只读根文件系统(
readOnlyRootFilesystem: true)。PREBUILT_CACHE读取构建进镜像的缓存,运行时不写入任何内容。 - 一个镜像,一份缓存。 把缓存放在镜像里,而不是共享卷上,这样每个版本提供的正是它构建时的代码。
- 滚动更新不需要任何特殊处理。新 pod 带来自己的缓存,旧 pod 保留它们的缓存。
- 当镜像无法包含缓存时,在 init 容器中运行
cache:warmup:aop,写入一个emptyDir卷,并把这个卷挂载到应用容器的缓存路径上。这样仍然可以使用PREBUILT_CACHE,pod 就绪时缓存已经完整。 - CLI 容器(队列消费者、cron 任务)使用同一个镜像和缓存。将
opcache.enable_cli=1与预先填充的opcache.file_cache一起启用,见 CLI 进程。
常驻 worker
Section titled “常驻 worker”常驻 worker(RoadRunner、FrankenPHP worker 模式、Swoole、ReactPHP)每个 worker 只启动一次内核。Call context 在请求之间一直保持已初始化的状态。
编写高效的 behavior
Section titled “编写高效的 behavior”- 精确定位。 只有匹配的成员会被拦截,只有匹配的类会被编译,所以精确的规则就是快的规则。
execution(public App\Service\*->*(*))也会匹配构造函数。不需要它们时,加上&& !execution(**->__construct(*))。 - 优先使用方法规则,而不是
initialization(...)。 只要注册了initialization规则,生成文件中的每个new都会经过转换器。没有初始化 behavior(且构造函数为 public)的类仍然通过原生new创建,比普通的new大约多花 130 ns。带有初始化 behavior 的类则会走完整的 call context。 - 惰性注册 behavior class,使用
addLazyService()。Behavior class 及其依赖在第一次 behavior 调用时才创建,而不是每个请求都创建。 - 让 behavior 保持轻量。
getMethod()和getField()在每个 call context 首次使用时创建一个反射对象。从中一次性取出注解或名称,以class::method为键保存在 behavior class 中。 - 惰性格式化 call context。
(string) $invocation每次调用都会构建一个字符串。只在真正要写出的消息中使用它。 - 原生 include。
Features::INTERCEPT_INCLUDES让生成文件中的include/require经过编译器,用于不由 Composer 加载的遗留代码。启用它之后,在生产环境中 include 一个缓存已知的文件时,会直接通过其原始路径或缓存路径提供,不经过流过滤器(每次 include 约 250 µs → 约 11 µs)。
一个惰性注册的 behavior class:
use Go\Core\AspectContainer;use Go\Core\AspectKernel;use Psr\Log\LoggerInterface;
class ApplicationAspectKernel extends AspectKernel{ protected function configureAop(AspectContainer $container): void { // Runs when one of its behaviors first runs, after the application container is attached $container->addLazyService( MonitorAspect::class, static fn(AspectContainer $container) => new MonitorAspect($container->getService(LoggerInterface::class)), ); }}如何编写 behavior 和 matching rule,见 行为与匹配规则。
预热与预构建缓存
Section titled “预热与预构建缓存”| 消息或现象 | 含义与处理方法 |
|---|---|
cache:warmup:aop 向 stderr 写出错误,并以非零退出码退出 |
有文件无法编译。部署或 docker build 会停下,这样就永远不会发布不完整的缓存。修复该文件后重新运行预热。 |
WeavingException:... is missing from the prebuilt AOP cache in ... |
启用 PREBUILT_CACHE 时,包含路径下的某个类或被 include 的文件在缓存中没有记录,或者它的缓存文件已经不存在。用 cache:warmup:aop 重建缓存。 |
cache:warmup:opcache 打印出一条命令,而没有预填充缓存 |
进程不是以 -d opcache.enable_cli=1 -d opcache.file_cache_only=1 -d opcache.file_cache=DIR 启动的,或者 --file-cache 指定的是另一个目录。运行打印出的命令。 |
PHP 只在 PHP-FPM 主进程(或 php -S)启动时报告一次预加载问题,写在它的错误日志中。
| 消息 | 含义与处理方法 |
|---|---|
Fatal Error "opcache.preload" requires "opcache.preload_user" when running under uid 0 |
主进程以 root 身份运行。把 opcache.preload_user 设为运行 worker 的用户(www-data)。 |
Failed opening required '.../_preload.php' |
脚本不存在:构建缓存时没有加 --preload,或者 opcache.preload 指向了另一个缓存目录。用 cache:warmup:aop --preload 重新构建。 |
Go! AOP preload: <class> is left to the autoloader: ... |
脚本无法加载缓存中的某个类,多半是因为没有安装某个可选依赖(--no-dev 镜像)。无害:这个类不会被预加载,需要它的请求照常自动加载。 |
Can't preload unlinked class <class>: Unknown parent/trait/interface <name> in <file> |
OPcache 无法链接预加载所 include 的某个文件中的类,原因同上。对于缓存中的类,它会和上一行一起出现。无害:这个类只是没有被预加载。 |
vendor 辅助文件中的 Can't preload unlinked class class@anonymous: Unknown trait ... |
来自 Composer files 自动加载文件的匿名类,例如 Laravel 的 Illuminate/Reflection/helpers.php。缓存的脚本不包含这些文件;这个警告来自另一个在它之前 require 了 vendor/autoload.php 的脚本。先 require 缓存的脚本:这样 Composer 会直接返回它的加载器,不会再次 include 这些文件。 |
复现基准测试
Section titled “复现基准测试”应用、基准测试脚本和 Docker 镜像都在 goaop/shop-demo 中。一个脚本即可复现本页的所有表格:
bash bench/run-all.sh数据是如何测得的
Section titled “数据是如何测得的”- 应用: 约 45 个手写的类(领域、仓储、服务、控制器、内存中的基础设施)、40 个生成的模块(服务和仓储被编译;DTO、验证器和事件不被编译),以及包含路径之外的 120 个库类。
- Behavior class: 日志(注解上的
#[Before])、缓存和事务(注解上的#[Around])、监控(仓储上的#[Around],服务上的#[AfterThrowing])、库存审计(属性上的#[Around])、安全(模块服务上的#[Before])。 - 基线: 不带内核的同一份代码。其中的 behavior 不会运行。
- 运行时: PHP 8.5.12 NTS,4 个 CPU,OPcache 设置
opcache.jit=disable和opcache.file_update_protection=0。 - Web 请求: 内置 Web 服务器(
php -S,一个 worker,OPcache 共享内存在请求之间保留)。warm 指新启动服务器的第一个请求(7 个样本);hot 指 350 个请求的中位数。时间在脚本内部用hrtime()测量。 - 性能分析: 用 Xdebug 3.5 的
xdebug.mode=profile对每种模式和状态各运行一次,用于统计调用次数和时间分布。耗时数据来自不带 Xdebug 的运行。
能推广到其他机器上的,是各模式之间的比例。
© 2026 Alexander Lisachenko
