原生 PHP 工程化 是将 PHP 从“脚本语言”提升为可维护、可测试、可扩展、可部署的工程体系的系统性实践。它不是“写框架”，而是通过 规范、工具、架构、流程 的整合，让原生 PHP 项目具备企业级系统的质量。

---

一、知识体系总览

模块	核心内容
1. 工程化定义	从脚本到工程的转变
2. 项目结构规范	PSR-4、分层架构、目录组织
3. 底层原理：自动加载、命名空间、依赖管理
4. 依赖管理	Composer、包管理、版本控制
5. 代码规范	PSR-1/2/12、PHPStan、PHP-CS-Fixer
6. 测试体系	PHPUnit、Mockery、测试覆盖率
7. 构建与部署	CI/CD、Docker、Phar 打包
8. 故障排查	静态分析、日志、监控
9. 最佳实践	面向接口编程、依赖注入
10. 源码级解析	Composer 自动加载实现
11. 与框架的关系	Laravel/Symfony 的工程化启示
12. 安全机制	输入验证、XSS/CSRF 防护
13. 性能优化	OPcache、JIT、连接池
14. 未来趋势	DDD、Serverless、AI 辅助

---

二、核心定义：什么是原生 PHP 工程化？

原生 PHP 工程化 = 无框架的 PHP 项目 + 工程化实践
它不是“不用 Composer”，而是不依赖 Laravel/Symfony 等全栈框架，但使用其工程化思想。

✅ 工程化 vs 脚本化

对比项	脚本化	工程化
项目结构	杂乱（index.php + 函数）	规范（src/, tests/, config/）
依赖管理	手动复制文件	Composer
代码规范	无	PSR-12、PHPStan
测试	无或手动测试	PHPUnit 自动化
部署	手动上传	CI/CD + Docker
可维护性	低	高

✅ 工程化是“系统性质量保障”

---

三、底层原理

✅ 1. 自动加载（Autoloading）

• PSR-4：命名空间到目录的映射
• Composer 实现：生成 vendor/autoload.php

// composer.json
{
    "autoload": {
        "psr-4": {
            "App\\": "src/"
        }
    }
}

// 自动加载机制
require_once __DIR__ . '/vendor/autoload.php';

// 使用：App\User 自动加载 src/User.php
$user = new App\User();

✅ 命名空间 + 目录结构 = 自动加载

---

✅ 2. 依赖管理（Composer）

• composer.json：定义依赖
• composer.lock：锁定版本
• vendor/：依赖包存储

{
    "require": {
        "monolog/monolog": "^2.0",
        "guzzlehttp/guzzle": "^7.0"
    },
    "require-dev": {
        "phpunit/phpunit": "^9.0"
    }
}

✅ 依赖声明 → 自动下载 → 自动加载

---

✅ 3. 命名空间（Namespace）

• 解决类名冲突
• 支持 PSR-4 自动加载

// src/Service/UserService.php
namespace App\Service;

class UserService { ... }

// src/Controller/UserController.php
namespace App\Controller;

use App\Service\UserService;

class UserController
{
    private $service;

    public function __construct()
    {
        $this->service = new UserService(); // 自动加载
    }
}

---

四、核心工程化实践

✅ 1. 项目结构规范

project-root/
├── src/                # 源码
│   ├── Service/
│   ├── Controller/
│   ├── Model/
│   └── Infrastructure/
├── tests/              # 测试
│   ├── Unit/
│   └── Integration/
├── config/             # 配置
│   └── app.php
├── public/             # Web 入口
│   └── index.php
├── vendor/             # Composer 依赖
├── composer.json
├── phpunit.xml         # 测试配置
└── .php-cs-fixer.dist.php # 代码格式化

✅ 清晰分层，易于维护

---

✅ 2. 代码规范与静态分析

(1) PSR-12 代码风格

# 安装
composer require --dev friendsofphp/php-cs-fixer

# 修复
php-cs-fixer fix src/

(2) 静态分析

# 安装
composer require --dev phpstan/phpstan

# 分析
vendor/bin/phpstan analyse src/

---

✅ 3. 测试体系

(1) PHPUnit 单元测试

// tests/Unit/UserServiceTest.php
class UserServiceTest extends TestCase
{
    public function testCreateUser()
    {
        $service = new UserService();
        $user = $service->create('john@example.com');
        $this->assertInstanceOf(User::class, $user);
    }
}

./vendor/bin/phpunit

(2) 测试覆盖率

<!-- phpunit.xml -->
<coverage processUncoveredFiles="true">
    <include>
        <directory>src/</directory>
    </include>
</coverage>

---

✅ 4. 构建与部署

(1) CI/CD（GitHub Actions）

# .github/workflows/ci.yml
name: CI
on: [push]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Setup PHP
        uses: shivammathur/setup-php@v2
        with:
          php-version: '8.1'
      - name: Install dependencies
        run: composer install
      - name: Run tests
        run: vendor/bin/phpunit

(2) Docker 部署

FROM php:8.1-fpm
COPY . /var/www/html
RUN composer install
CMD ["php", "server.php"]

(3) Phar 打包（可执行）

composer require --dev humbug/box
vendor/bin/box compile

✅ 生成 app.phar，可 php app.phar 运行

---

✅ 5. 依赖注入（DI）与解耦

// 手动实现轻量级 DI
class Container
{
    private $bindings = [];

    public function bind($abstract, $concrete)
    {
        $this->bindings[$abstract] = $concrete;
    }

    public function make($abstract)
    {
        $concrete = $this->bindings[$abstract];
        $reflector = new ReflectionClass($concrete);
        $constructor = $reflector->getConstructor();
        $dependencies = $constructor?->getParameters() ?? [];
        $instances = array_map(fn($dep) => $this->make($dep->getType()->getName()), $dependencies);
        return $reflector->newInstanceArgs($instances);
    }
}

// 使用
$container->bind(UserService::class, UserService::class);
$container->bind(Database::class, MySQLDatabase::class);
$service = $container->make(UserService::class);

✅ 无框架也能实现 DI

---

五、最佳实践

✅ 推荐做法

1. 使用 Composer 管理依赖
2. 遵循 PSR-4 目录结构
3. 启用 OPcache 和 JIT
4. 编写单元测试，覆盖率 > 80%
5. 使用 CI/CD 自动化测试与部署
6. 日志记录关键操作
7. 生产环境关闭 display_errors

❌ 避免

• 全局函数、全局变量
• 不规范的目录结构
• 忽略错误处理
• 无测试

---

六、源码级解析

✅ Composer 自动加载实现

// vendor/composer/autoload_psr4.php
return array(
    'App\\' => array($baseDir . '/src'),
);

// vendor/composer/ClassLoader.php
public function loadClass($class)
{
    $prefix = $class;
    while (false !== $pos = strrpos($prefix, '\\')) {
        $prefix = substr($class, 0, $pos + 1);
        $relative_class = substr($class, $pos + 1);
        $mapped_file = $this->findFile($prefix, $relative_class);
        if ($mapped_file) {
            require $mapped_file;
            return;
        }
        $prefix = rtrim($prefix, '\\');
    }
}

✅ 命名空间 → 目录 → 文件 → require

---

七、总结

原生 PHP 工程化的本质

一个“无框架但有体系”的高质量 PHP 项目——你用 Composer 管理依赖，用 PSR-4 组织代码，用 PHPUnit 测试，用 CI/CD 部署，让原生 PHP 具备企业级工程能力

核心原理

• 自动加载：PSR-4 + Composer
• 依赖管理：composer.json + vendor/
• 代码规范：PSR-12 + PHPStan
• 测试：PHPUnit + 覆盖率
• 部署：CI/CD + Docker
• 解耦：DI + 接口编程
• 安全：输入验证、日志

成功关键

✅ 使用 Composer
✅ 规范目录结构
✅ 编写自动化测试
✅ CI/CD 部署
✅ 启用 OPcache/JIT

---

一句话总结：

原生 PHP 工程化不是“不用框架”，而是“用工具链构建体系”——你用 Composer 装轮子，用 PHPUnit 写保险，用 CI/CD 开车，让 PHP 项目真正“工业化生产”。

掌握它，你就能构建真正高质量的原生 PHP 系统。