为什么要构建自己的 PHP 框架？

现在的 PHP 框架很多，当然不止 PHP ，即使是其他编程语言也有很多框架，这篇文章讲 PHP 框架构建是因为我对 PHP 的生态最为熟悉，但这个方法同样也适用于其他编程语言框架的构建。

框架是为了提升我们的应用开发效率，市面上有很多开源免费的框架给我们使用，我们尽可以拿来用，为什么还要自己构建一个自己的框架呢？原因就在于市面上的开源框架，是给大部分人用的，给通用项目用的，作为框架的开发者是不知道自己的框架使用者的具体业务的，所以开源框架一定是满足大部分人的需求，而且力求能够为开发者提供所有可能用到的功能。

但是对于一个商业项目或者是一个你自己要做的项目也许只能用到框架的很少一部分功能，或者是框架给你提供的东西并不是最符合你自己的需求的，你使用了框架的一部分功能，另一部分根本没用，这样使用框架首先是性能上的损失，一些你根本用不到的功能却要降低你应用的性能显然不合适的。再就是也许框架提供的功能不是你想要的，或者这个功能这个框架提供的并不是符合你需求的，又或者要使用这部分功能必须按照框架开发者制定的规范来使用，这个规范并符合你的开发哲学。

从哪开始？

各种现代编程语言都有自己的包管理工具，PHP 就是 composer ，利用它我们就可以构建属于自己的框架了，并能很好的组织我们的框架。

怎么开始？

我们该怎么开始构建我们自己的框架呢？从零开始吗？这个问题没有标准答案，如果你要做的项目要求很严格，从底层开始就要保证项目架构的最稳定可控，那么建议你从零开始。如果要求不是非常严格那么我们就从那些开发一个应用最基本需要的功能开始，这样的功能谁提供呢？PHP 有很多微框架，这些框架提供开发一个应用最基础的功能，我们可以从这里开始。

首先我们通过 composer init 初始化一个项目：

1. { 
2.  
3.     "name": "dongm2ez/m2ez-framework", 
4.  
5.     "description": "a dongm2ez's framework", 
6.  
7.     "keywords": ["framework", "m2ez-framework"], 
8.  
9.     "license": "MIT", 
10.  
11.     "authors": [ 
12.  
13.         { 
14.  
15.             "name": "dongm2ez", 
16.  
17.             "email": "dongm2ez@163.com" 
18.  
19.         } 
20.  
21.     ], 
22.  
23.     "require": {} 
24.  
25. } 

这就是我得到的一个 composer.json 的描述文件，现在我们就从这里开始。我的目标是构建一个最符合我开发习惯的框架，让我的开发效率最高。

我选择 Slim 框架作为我的框架基础框架，这是一个微框架，我喜欢它，它足够简单，提供了 web 开发 和 API 开发最基础的功能，而且还有一个原因开发这个框架的作者写了一本名为《Modern PHP》的书，这本书颠覆了我对 PHP 这个语言的认知，开始喜欢并乐于使用它。

在引入这个框架之前我还要对 PHP 版本做个限制，从我使用 PHP 从 5.2 开始到现在，PHP 已经发展到 PHP 7.2 了，但是我不想再去使用低版本的 PHP，一个是 PHP 低版本马上将失去官方的支付，另一个是一些 PHP 的新特性我不能使用，而且低版本的性能也是不好的。所以我要将我的框架限制在 PHP 7.0 以上，同时我希望我的框架对中文有更好的支持。

那么我将更新我的框架 composer.json 文件:

1. { 
2.  
3.     "name": "dongm2ez/m2ez-framework", 
4.  
5.     "description": "a dongm2ez's framework", 
6.  
7.     "keywords": ["framework", "m2ez-framework"], 
8.  
9.     "license": "MIT", 
10.  
11.     "authors": [ 
12.  
13.         { 
14.  
15.             "name": "dongm2ez", 
16.  
17.             "email": "dongm2ez@163.com" 
18.  
19.         } 
20.  
21.     ], 
22.  
23.     "require": { 
24.  
25.         "php": ">=7.0.0", 
26.  
27.         "ext-mbstring": "*", 
28.  
29.         "slim/slim": "^3.0" 
30.  
31.     } 
32.  
33. } 

这样我就获得了一个最基础的我的框架版本，但是我还没完成，因为我们没有定义我的框架目录结构。我觉得 laravel 框架的目录划分是挺让我喜欢的，但我又不完全喜欢 laravel 的目录结构，我需要对它进行改造。

1. ├── app 
2.  
3. │   ├── Helpers.php 
4.  
5. │   ├── Http 
6.  
7. │   │   └── Controllers 
8.  
9. │   └── Models 
10.  
11. ├── composer.json 
12.  
13. └── tests 

我这样设置我的目录结构，并更新我的 composer.json:

1. { 
2.  
3.     "name": "dongm2ez/m2ez-framework", 
4.  
5.     "description": "a dongm2ez's framework", 
6.  
7.     "keywords": ["framework", "m2ez-framework"], 
8.  
9.     "license": "MIT", 
10.  
11.     "type": "project", 
12.  
13.     "authors": [ 
14.  
15.         { 
16.  
17.             "name": "dongm2ez", 
18.  
19.             "email": "dongm2ez@163.com" 
20.  
21.         } 
22.  
23.     ], 
24.  
25.     "require": { 
26.  
27.         "php": ">=7.0.0", 
28.  
29.         "slim/slim": "^3.0" 
30.  
31.     }, 
32.  
33.     "require-dev": { 
34.  
35.         "phpunit/phpunit": "~6.0" 
36.  
37.     }, 
38.  
39.     "autoload": { 
40.  
41.         "classmap": [ 
42.  
43.             "app/Models" 
44.  
45.         ], 
46.  
47.         "psr-4": { 
48.  
49.             "App\\": "app/" 
50.  
51.         }, 
52.  
53.         "files": [ 
54.  
55.             "app/Helpers.php" 
56.  
57.         ] 
58.  
59.     }, 
60.  
61.     "autoload-dev": { 
62.  
63.         "psr-4": { 
64.  
65.             "Tests\\": "tests/" 
66.  
67.         } 
68.  
69.     } 
70.  
71. } 

这样的框架可以访问吗，显然是不行的，我们还要加一些东西让我们的框架真正可以跑起来，然后在来迭代它。

1. ├── app 
2.  
3. │   ├── Helpers.php 
4.  
5. │   ├── Http 
6.  
7. │   │   └── Controllers 
8.  
9. │   └── Models 
10.  
11. ├── bootstrap 
12.  
13. │   ├── app.php 
14.  
15. │   └── autoload.php 
16.  
17. ├── composer.json 
18.  
19. ├── config 
20.  
21. ├── public 
22.  
23. │   └── index.php 
24.  
25. ├── routers 
26.  
27. └── tests 

我们将目录结构改造成这样，并编写一些启动框架的代码到相应的文件

1. // public/index.php 
2.  
3. <?php 
4.  
5.  
6.  
7. require __DIR__.'/../bootstrap/autoload.php'; 
8.  
9.  
10.  
11. $app = require_once __DIR__.'/../bootstrap/app.php'; 
12.  
13.  
14.  
15. $app->run(); 
16.  
17.  
18.  
19. // bootstrap/app.php 
20.  
21.  
22.  
23. <?php 
24.  
25.  
26.  
27. $app = new \Slim\App; 
28.  
29.  
30.  
31. return $app; 
32.  
33.  
34.  
35. // bootstrap/autoload.php 
36.  
37.  
38.  
39. <?php 
40.  
41.  
42.  
43. define('M2EZ_START', microtime(true)); 
44.  
45.  
46.  
47. require __DIR__.'/../vendor/autoload.php'; 

然后运行 composer install 安装框架的依赖包，安装完成后我们的目录中就会多出一个 vendor 的目录和 composer.lock 的文件，此时运行 php -S 0.0.0.0:8080 -t public public/index.php 利用 PHP 自带的 web 服务器进行测试，为了这个命令更简单使用，我们可以将这个命令加到 composer.json 的 script 中。

此时访问 127.0.0.1:8080 或 localhost:8080 就可以看到如下的页面：

这说明框架正确启动了，那么我们怎么确定框架工作正常呢，这里有个简单方法：

1. <?php 
2.  
3.  
4.  
5. use Slim\Http\Request; 
6.  
7. use Slim\Http\Response; 
8.  
9.  
10.  
11. require __DIR__.'/../bootstrap/autoload.php'; 
12.  
13.  
14.  
15. $app = require_once __DIR__.'/../bootstrap/app.php'; 
16.  
17.  
18.  
19. $app->get('/hello/{name}', function (Request $request, Response $response) { 
20.  
21.     $name = $request->getAttribute('name'); 
22.  
23.     $response->getBody()->write("Hello, $name"); 
24.  
25.  
26.  
27.     return $response; 
28.  
29. }); 
30.  
31.  
32.  
33. $app->run(); 

对 public/index.php 的代码进行修改，此时访问 http://localhost:8080/hello/dongm2ez，那么我们就会看到：

测试是成功了，但是我们不能把路由和逻辑都写到 index.php 文件里，因此我们需要代码更好的组织。要让我们的目录规划发挥正在的作用。

为了单独管理路由，我将路由单独写在 routers 文件夹中，在文件夹中我们新建两个 PHP 脚本文件，然后在 public/index.php 中加入两行代码：

1. <?php 
2.  
3. require __DIR__ . '/../bootstrap/autoload.php'; 
4.  
5.  
6.  
7. $app = require_once __DIR__ . '/../bootstrap/app.php'; 
8.  
9.  
10.  
11. require __DIR__ . '/../routers/web.php'; 
12.  
13. require __DIR__ . '/../routers/api.php'; 
14.  
15.  
16.  
17. $app->run(); 

变成这样，这样我就可以单独管理 API 和 WEB 项目的路由了，如果有其他路由就也可以 require 更多路由。

1. <?php 
2.  
3. $app->get('/', '\App\Http\Controllers\WelcomeController:index'); 

而我们的控制器长什么样呢，是这个样子的：

1. <?php 
2.  
3.  
4.  
5. namespace App\Http\Controllers; 
6.  
7.  
8.  
9. use Slim\Http\Request; 
10.  
11. use Slim\Http\Response; 
12.  
13.  
14.  
15. class WelcomeController extends Controller 
16.  
17. { 
18.  
19.  
20.  
21.     public function index(Request $request, Response $response) 
22.  
23.     { 
24.  
25.         $response->getBody()->write("Hello, world"); 
26.  
27.  
28.  
29.         return $response; 
30.  
31.  
32.  
33.     } 
34.  
35.  
36.  
37. } 

我们知道在现代化的框架中，容器会让我们很方便，我们的基础框架 Slim 提供一个容器的实现，当然你也可以使用其他的第三方的，那么这显然是我们想要的结果，不是只能使用框架提供的，我们可以随时换掉框架的功能，换成我们想要的同样功能组件。

使用也很简单，在 app.php 文件中初始化 Slim 框架时将容器实例传递给它就可以了。

1. <?php 
2.  
3.  
4.  
5. $container = new \Slim\Container; 
6.  
7. $app = new \Slim\App($container); 
8.  
9.  
10.  
11. return $app; 

还记得上面那个控制器继承的基类控制器吗，那也是我自己写的，里面可以做一些所有控制器都有可能用的的操作封装。比如我为了更方便的使用容器，我在基类里初始化了一个容器实例。

1. <?php 
2.  
3.  
4.  
5. namespace App\Http\Controllers; 
6.  
7.  
8.  
9. use Interop\Container\ContainerInterface; 
10.  
11.  
12.  
13. abstract class Controller 
14.  
15. { 
16.  
17.     protected $ci; 
18.  
19.  
20.  
21.     public function __construct(ContainerInterface $ci) 
22.  
23.     { 
24.  
25.         $this->ci = $ci; 
26.  
27.     } 
28.  
29.  
30.  
31. } 

现在我已经有了 路由功能，有了控制器功能，还有请求响应的操作，那么作为一个完整的框架那么必须有访问数据库的方法。

我很喜欢 Laravel 提供的数据库 ORM 组件，那么我就决定使用它了，执行 composer require illuminate/database "~5.5"，我选择了最新的 Laravel 长期支持版 ORM 。

我们需要此时在 config 文件夹中新添加一个文件 databases.php 文件：

1. <?php 
2.  
3. return [ 
4.  
5.     'settings' => [ 
6.  
7.         'db' => [ 
8.  
9.             'driver' => 'mysql', 
10.  
11.             'host' => 'localhost', 
12.  
13.             'database' => 'database', 
14.  
15.             'username' => 'user', 
16.  
17.             'password' => 'password', 
18.  
19.             'charset'   => 'utf8', 
20.  
21.             'collation' => 'utf8_unicode_ci', 
22.  
23.             'prefix'    => '', 
24.  
25.         ] 
26.  
27.     ], 
28.  
29. ]; 

然后修改 public/index.php：

1. <?php 
2.  
3. require __DIR__ . '/../bootstrap/autoload.php'; 
4.  
5.  
6.  
7. $config = require __DIR__ . '/../config/databases.php'; 
8.  
9.  
10.  
11. $app = require_once __DIR__ . '/../bootstrap/app.php'; 
12.  
13.  
14.  
15. require __DIR__ . '/../routers/web.php'; 
16.  
17. require __DIR__ . '/../routers/api.php'; 
18.  
19.  
20.  
21. $app->run(); 

修改 bootstrap/app.php：

1. <?php 
2.  
3.  
4.  
5. $container = new \Slim\Container($config); 
6.  
7. $app = new \Slim\App($container); 
8.  
9.  
10.  
11. // Service factory for the ORM 
12.  
13. $container['db'] = function ($container) { 
14.  
15.     $capsule = new \Illuminate\Database\Capsule\Manager; 
16.  
17.     $capsule->addConnection($container['settings']['db']); 
18.  
19.  
20.  
21.     $capsule->setAsGlobal(); 
22.  
23.     $capsule->bootEloquent(); 
24.  
25.  
26.  
27.     return $capsule; 
28.  
29. }; 
30.  
31.  
32.  
33. return $app; 

然后我们就可以在控制器中使用 ORM 功能了。

1. <?php 
2.  
3.  
4.  
5. namespace App\Http\Controllers; 
6.  
7.  
8.  
9. use App\Models\User; 
10.  
11. use Illuminate\Database\DatabaseManager; 
12.  
13. use Illuminate\Support\Facades\DB; 
14.  
15. use Interop\Container\ContainerInterface; 
16.  
17. use Slim\Http\Request; 
18.  
19. use Slim\Http\Response; 
20.  
21.  
22.  
23. class WelcomeController extends Controller 
24.  
25. { 
26.  
27.  
28.  
29.     public function index(Request $request, Response $response) 
30.  
31.     { 
32.  
33.         /** @var DatabaseManager $db */ 
34.  
35.         $db = $this->ci->get('db'); 
36.  
37.         $user = $db->table("user")->first(); 
38.  
39.         var_dump($user); 
40.  
41.         $response->getBody()->write("Hello, world"); 
42.  
43.  
44.  
45.         return $response; 
46.  
47.  
48.  
49.     } 
50.  
51.  
52.  
53. } 

那么此时这个框架已经是一个可以开发 API 功能的框架了，如果要开发 Web 站我可能还需要加入渲染模板组件，无论是 twig、Smarty、Haml 还是 Blade，全都看你的喜好了。当然我觉得我做到这里就可以了，够我用了，因为对于前端我更喜欢用 React 或者是 Vue 去实现它。

需要更简便的操作 session、cookie 那么我们也可以添加相应的组件，各种已经有的框架了都提供这样的组件，看看你更喜欢哪一个了，现在你的框架你做主，你想添加什么就可以添加什么组件，经过这样的定制的框架一定是最符合你开发需求的。

我这里只是对已有的组件进行了配置组装，一旦哪天你发现所有的开源组件都满足不了你的需求的时候，因为你对你的框架了解，你可以自己造个轮子给自己的框架用，如果你写的好那么你也会创造出一个极好用的框架，现在最流行的 PHP 框架，你可以看看它的 composer.json 文件，它就是在前人的基础上进行开发维护的，已经有的功能他拿来直接用，觉得别人做的不完善的地方自己造一个轮子给大家用。

而且我这里也没有用到太多的设计模式，你还可以改造你的框架，利用PHP的魔术方法，反射，SPL 等等让你的框架更好，更容易扩展，更容易配置。

总结:

框架很神秘吗？看过这篇文章我相信你不会这样觉得了。

造一个框架很难吗，是的很难，因为从 0 到 1 任何事都难，但是我们现在还需要从 0 到 1 吗，基本不需要了！站在巨人身上做事更容易，而且要记住，任何事只有行动起来你就会发现尝试比踌躇不前更好，从小处开始，做小事，有一天这个小事就变成了大事。不积跬步无以至千里。

Laravel 为什么流行，因为作者本是一名 .net 开发者，在使用 CI 框架时萌生了想法要做一个更简洁、灵活的框架，他的思想真的很先进吗，不一定的，其他开发语言早就有了 Laravel 中的功能，它只是在 PHP 中实现了它们。

以上例子其实告诉我们，不要给自己贴标签，人生不设限，你不是 PHP 程序员，你就是开发者，任何开发相关的东西我们都该去了解和掌握，标签只能别人给你贴，不要自己给自己贴。

Tags: Composer PHP框架

分享到：