理解Flight框架核心
冯驰
Flight框架（官网）是一个微型的PHP框架，它简单，快速，可扩展。借助Flight可以快捷而轻松的创建你的RESTFul web应用。
虽然是一个微型的框架，而且代码量确实也较少，但我在阅读Flight代码的过程中，感到了它设计和构思独特而精妙的地方，觉得有学习的价值，便决定做一下整理分享出来。
如果你对框架还不熟悉，可以先去官网看下文档，如果需要中文文档的话可以可以点这里。
如果你已经对Flight有一定了解了，接下来就来看看Flight是怎么工作的吧。
<?php
class Flight {
/**
* Framework engine.
* @var object
*/
private static $engine;
// Don't allow object instantiation
private function __construct() {}
private function __destruct() {}
private function __clone() {}
/**
* 之前已经看到了，框架内所有函数都是以Flight类的静态函数形式调用的
* __callStatic()这个魔术方法能处理所有的静态函数
* @param string $name Method name
* @param array $params Method parameters
* @return mixed Callback results
*/
public static function __callStatic($name, $params) {
static $initialized = false;
if (!$initialized) {
//这里定义框架的自动加载机制，实际上是依据PSR-0标准来做的
require_once __DIR__.'/autoload.php';
//Engine类是框架的引擎所在
self::$engine = new \flight\Engine();
$initialized = true;
}
//在这里，Flight对Engine包装了一层而已。对Flight类静态函数的调用，实质上是对Engine类的相应函数的调用
return \flight\core\Dispatcher::invokeMethod(array(self::$engine, $name), $params);
}
}
//那么就直接就来看看Dispatcher::invokeMethod函数吧
namespace flight\core;
class Dispatcher {
/**
* 调用一个方法
* @param mixed $func Class method
* @param array $params Class method parameters
* @return mixed Function results
*/
public static function invokeMethod($func, array &$params = array()) {
list($class, $method) = $func;
$instance = is_object($class);
switch (count($params)) {
case 0:
return ($instance) ?
$class->$method() :
$class::$method();
case 1:
return ($instance) ?
$class->$method($params[0]) :
$class::$method($params[0]);
case 2:
return ($instance) ?
$class->$method($params[0], $params[1]) :
$class::$method($params[0], $params[1]);
case 3:
return ($instance) ?
$class->$method($params[0], $params[1], $params[2]) :
$class::$method($params[0], $params[1], $params[2]);
case 4:
return ($instance) ?
$class->$method($params[0], $params[1], $params[2], $params[3]) :
$class::$method($params[0], $params[1], $params[2], $params[3]);
case 5:
return ($instance) ?
$class->$method($params[0], $params[1], $params[2], $params[3], $params[4]) :
$class::$method($params[0], $params[1], $params[2], $params[3], $params[4]);
default:
return call_user_func_array($func, $params);
}
}
}上面注释里提到了，自动加载和PSR-0，我之前写过一篇关于这部分内容的文章。Flight框架的自动加载就是基于namespace和psr-0标准的：
//只列出有关自动加载部分的主要代码
namespace flight\core;
class Loader {
/**
* Starts/stops autoloader.
*
* @param bool $enabled Enable/disable autoloading
* @param mixed $dirs Autoload directories
*/
public static function autoload($enabled = true, $dirs = array()) {
if ($enabled) {
spl_autoload_register(array(__CLASS__, 'loadClass'));
}
else {
spl_autoload_unregister(array(__CLASS__, 'loadClass'));
}
if (!empty($dirs)) {
self::addDirectory($dirs);
}
}
/**
* Autoloads classes.
*
* @param string $class Class name
*/
public static function loadClass($class) {
$class_file = str_replace(array('\\', '_'), '/', $class).'.php';
foreach (self::$dirs as $dir) {
$file = $dir.'/'.$class_file;
if (file_exists($file)) {
require $file;
return;
}
}
}
}再继续往下看之前，我们不妨先对Flight内主要的类和函数进行一下梳理，以下是Flight框架的内置类：
- Engine类：包含了这个框架的核心功能。它的责任是加载HTTP请求，运行已注册的服务，并生成最后的HTTP响应。
- Loader类：它负责框架内对象的加载。用自定义的初始化参数来生成新的类实例，并且维护可复用的类实例的列表。它还处理刚才提到过的类的自动加载。
- Dispatcher类：它负责框架内事件的分发处理。事件即是对类方法或函数的简单的称呼（别名）。它还允许你在事件上的挂钩点挂载别的函数，能够改变函数的输入或者输出。
- Router类：它负责将一个HTTP讲求发送到指定的函数进行处理。它视图将请求的URL和一系列用户定义的URL范式进行匹配。
- Route类：它负责路由的具体实现。Router相当于对Route的包装。
- Request类：它代表了一个HTTP请求。所有来自$_GET,$_POST,$_COOKIE,$_FILES中的数据都要通过Request类获取和访问。默认的Request属性就包括url,base,method,user_agent等。
- Response类：对应于Request，它代表了一个HTTP响应。这个对象包括了返回头，HTTP状态码和返回体。
- View类：视图类负责将输出展示。它提供了在渲染时管理视图数据和将数据插入视图模板的函数。
- Collection类：它允许你既可以以使用数组的方式，也能以使用对象的方式来访问数据。
Flight框架的函数分两部分，一部分是核心函数：
Flight::map($name, $callback) // Creates a custom framework method.
Flight::register($name, $class, [$params], [$callback]) // Registers a class to a framework method.
Flight::before($name, $callback) // Adds a filter before a framework method.
Flight::after($name, $callback) // Adds a filter after a framework method.
Flight::path($path) // Adds a path for autoloading classes.
Flight::get($key) // Gets a variable.
Flight::set($key, $value) // Sets a variable.
Flight::has($key) // Checks if a variable is set.
Flight::clear([$key]) // Clears a variable.Flight::start() // Starts the framework.
Flight::stop() // Stops the framework and sends a response.
Flight::halt([$code], [$message]) // Stop the framework with an optional status code and message.
Flight::route($pattern, $callback) // Maps a URL pattern to a callback.
Flight::redirect($url, [$code]) // Redirects to another URL.
Flight::render($file, [$data], [$key]) // Renders a template file.
Flight::error($exception) // Sends an HTTP 500 response.
Flight::notFound() // Sends an HTTP 404 response.
Flight::etag($id, [$type]) // Performs ETag HTTP caching.
Flight::lastModified($time) // Performs last modified HTTP caching.
Flight::json($data, [$code], [$encode]) // Sends a JSON response.
Flight::jsonp($data, [$param], [$code], [$encode]) // Sends a JSONP response.Flight框架的使用方式就是对Flight类静态函数调用(Flight::func())，我们在上面提到过，其实质是对Engine对象中函数的调用($engineObj->func())。
而Engine类的函数有两类，一类是核心函数，是直接进行调用(相对于动态调用)的，另外的扩展函数，则是进行动态调用的。
此外，在Flight中加载类和资源，获得某个类的实例，直接调用Flight::className()即可，等同于$engineObj->className()。这个也是采用动态调用的形式。也就是说，除了Engine类的核心函数，其他函数（类）都是动态调用的。这样，框架就可以为此提供一个统一的入口了。
namespace flight;
class Engine {
//....
public function __construct() {
$this->vars = array();
//上面提到过，Flight中,Dispatcher负责处理函数，Loader负责对象的加载
$this->loader = new Loader();
$this->dispatcher = new Dispatcher();
$this->init();
}
/**
* __call是一个魔术方法，当调用一个不存在的函数时，会调用到该函数
* 刚才讲的动态调用就是通过这个函数进行的
* @param string $name Method name
* @param array $params Method parameters
* @return mixed Callback results
*/
public function __call($name, $params) {
//先判断是类还是可直接调用的函数
$callback = $this->dispatcher->get($name);
//如果是函数，通过dispatcher处理
if (is_callable($callback)) {
return $this->dispatcher->run($name, $params);
}
//是否是共享实例
$shared = (!empty($params)) ? (bool)$params[0] : true;
//通过loader加载该类的对象
return $this->loader->load($name, $shared);
}
/**
* 框架初始化
*/
public function init() {
static $initialized = false;
$self = $this;
if ($initialized) {
$this->vars = array();
$this->loader->reset();
$this->dispatcher->reset();
}
// Flight中，类会通过loader的register函数进行注册
// 注册默认组件
$this->loader->register('request', '\flight\net\Request');
$this->loader->register('response', '\flight\net\Response');
$this->loader->register('router', '\flight\net\Router');
$this->loader->register('view', '\flight\template\View', array(), function($view) use ($self) {
$view->path = $self->get('flight.views.path');
});
// 注册框架方法
$methods = array(
'start','stop','route','halt','error','notFound',
'render','redirect','etag','lastModified','json','jsonp'
);
// Flight中，method会通过dispatcher的set函数将对应的回调函数绑定到一个事件中
// 为了可以进行动态调用，Enginge的扩展函数全部是通过 _method 的名字定义的
foreach ($methods as $name) {
$this->dispatcher->set($name, array($this, '_'.$name));
}
// 默认的配置
$this->set('flight.base_url', null);
$this->set('flight.handle_errors', true);
$this->set('flight.log_errors', false);
$this->set('flight.views.path', './views');
$initialized = true;
}
/**
* 将一个类注册到框架方法中，我们就是通过这个函数注册我们自定义的类的
*
* @param string $name Method name
* @param string $class Class name
* @param array $params Class initialization parameters
* @param callback $callback Function to call after object instantiation
* @throws \Exception If trying to map over a framework method
*/
public function register($name, $class, array $params = array(), $callback = null) {
if (method_exists($this, $name)) {
throw new \Exception('Cannot override an existing framework method.');
}
//通过loader的register函数进行注册
$this->loader->register($name, $class, $params, $callback);
}
/**
* 将一个回调函数映射到框架方式中，我们就是通过这个函数映射我们自定义函数的
*
* @param string $name Method name
* @param callback $callback Callback function
* @throws \Exception If trying to map over a framework method
*/
public function map($name, $callback) {
if (method_exists($this, $name)) {
throw new \Exception('Cannot override an existing framework method.');
}
//会通过dispatcher的set函数将对应的回调函数绑定到一个事件中
$this->dispatcher->set($name, $callback);
}
//...
}Flight中的两个核心函数，map是映射自定义的函数，最后是通过dispathcer的set函数实现的，register是注册自定义的类，最后是通过loader的register函数实现的。而框架自己的核心组件和扩展函数，Engine在初始化过程帮我们完成了这两个过程。接着Flight提供了一个统一的入口，可以动态调用所有非核心的函数，类。这就是Flight的核心加载机制了。
可能你还有疑问，为什么Flight要使用动态调用的形式去访问这些函数或对象？尤其是对于Engine的扩展函数，为什么不直接进行调用呢？因为Flight可以对它们进行过滤或重写。过滤和重写是Flight框架进行扩展的重要功能。框架实现了统一的资源操作方式后，就可以方便的进行重写或者过滤的处理了。需要注意的是，核心函数诸如map和register是不能够进行过滤或重写的，相信你已经清楚为什么了。
框架的重写功能还是使用的map和register这两个函数。这个功能因为框架的设计方式，很轻易的完成了。在Dispatcher和Loader中都动态维护了一个映射表，Dispatcher里是回调到事件的映射，Loader中是class到实例和构造函数等的映射。这样，注册自定义函数或类时，遇到一样名字就会覆盖掉之前的，而使用时只返回最新的。下面是Loader类的部分代码：
namespace flight\core;
class Loader {
//....
/**
* 注册一个类
*
* @param string $name Registry name
* @param string|callable $class Class name or function to instantiate class
* @param array $params Class initialization parameters
* @param callback $callback Function to call after object instantiation
*/
public function register($name, $class, array $params = array(), $callback = null) {
unset($this->instances[$name]);
$this->classes[$name] = array($class, $params, $callback);
}
/**
* 加载一个已注册的类
*
* @param string $name Method name
* @param bool $shared Shared instance
* @return object Class instance
*/
public function load($name, $shared = true) {
$obj = null;
//$this->classes是注册过的类
//$this->instances是加载过的实例
if (isset($this->classes[$name])) {
list($class, $params, $callback) = $this->classes[$name];
$exists = isset($this->instances[$name]);
//是不是共享实例
if ($shared) {
$obj = ($exists) ?
$this->getInstance($name) :
$this->newInstance($class, $params);
if (!$exists) {
$this->instances[$name] = $obj;
}
}
else {
$obj = $this->newInstance($class, $params);
}
if ($callback && (!$shared || !$exists)) {
$ref = array(&$obj);
call_user_func_array($callback, $ref);
}
}
return $obj;
}
/**
* 得到一个类的单一实例
*
* @param string $name Instance name
* @return object Class instance
*/
public function getInstance($name) {
return isset($this->instances[$name]) ? $this->instances[$name] : null;
}
/**
* 得到一个类的新的实例
*
* @param string|callable $class Class name or callback function to instantiate class
* @param array $params Class initialization parameters
* @return object Class instance
*/
public function newInstance($class, array $params = array()) {
if (is_callable($class)) {
return call_user_func_array($class, $params);
}
switch (count($params)) {
case 0:
return new $class();
case 1:
return new $class($params[0]);
case 2:
return new $class($params[0], $params[1]);
case 3:
return new $class($params[0], $params[1], $params[2]);
case 4:
return new $class($params[0], $params[1], $params[2], $params[3]);
case 5:
return new $class($params[0], $params[1], $params[2], $params[3], $params[4]);
default:
$refClass = new \ReflectionClass($class);
return $refClass->newInstanceArgs($params);
}
}
//....
}namespace flight;
class Engine {
/**
* Adds a pre-filter to a method.
*
* @param string $name Method name
* @param callback $callback Callback function
*/
public function before($name, $callback) {
$this->dispatcher->hook($name, 'before', $callback);
}
/**
* Adds a post-filter to a method.
*
* @param string $name Method name
* @param callback $callback Callback function
*/
public function after($name, $callback) {
$this->dispatcher->hook($name, 'after', $callback);
}
}
namespace flight\core;
class Dispatcher {
/**
* 将回调注册到一个事件之中
*
* @param string $name Event name
* @param callback $callback Callback function
*/
public function set($name, $callback) {
$this->events[$name] = $callback;
}
/**
* 得到事件关联的回调
*
* @param string $name Event name
* @return callback $callback Callback function
*/
public function get($name) {
return isset($this->events[$name]) ? $this->events[$name] : null;
}
/**
* 在事件上挂一个回调函数
*
* @param string $name Event name
* @param string $type Filter type
* @param callback $callback Callback function
*/
public function hook($name, $type, $callback) {
$this->filters[$name][$type][] = $callback;
}
/**
* 对事件进行分发处理
*
* @param string $name Event name
* @param array $params Callback parameters
* @return string Output of callback
*/
public function run($name, array $params = array()) {
$output = '';
// 运行前置过滤器
if (!empty($this->filters[$name]['before'])) {
$this->filter($this->filters[$name]['before'], $params, $output);
}
// 运行所请求的方法
$output = $this->execute($this->get($name), $params);
// 运行后置过滤器
if (!empty($this->filters[$name]['after'])) {
$this->filter($this->filters[$name]['after'], $params, $output);
}
return $output;
}
}下面，还差最后一步，运行这个框架时处理流程是怎样的呢？
namespace flight;
class Engine {
/**
* 启动这个框架
*/
public function _start() {
$dispatched = false;
$self = $this;
$request = $this->request();
$response = $this->response();
$router = $this->router();
// 冲刷掉已经存在的输出
if (ob_get_length() > 0) {
$response->write(ob_get_clean());
}
// 启动输出缓冲
ob_start();
// 开启错误处理
$this->handleErrors($this->get('flight.handle_errors'));
// 对AJAX请求关闭缓存
if ($request->ajax) {
$response->cache(false);
}
// 允许后置过滤器的运行
$this->after('start', function() use ($self) {
//start完成之后会调用stop()函数
$self->stop();
});
// 对该请求进行路由
while ($route = $router->route($request)) {
$params = array_values($route->params);
//是否让路由链继续下去
$continue = $this->dispatcher->execute(
$route->callback,
$params
);
$dispatched = true;
if (!$continue) break;
$router->next();
}
//路由没找匹配到
if (!$dispatched) {
$this->notFound();
}
}
/**
* 停止这个框架并且输出当前的响应内容
*
* @param int $code HTTP status code
*/
public function _stop($code = 200) {
$this->response()
->status($code)
->write(ob_get_clean())
->send();
}
}至此，应该对Flight核心的设计，功能以及处理流程有所认识了吧。至于其他的路由，请求已经响应等内容，就留给读者自行学习吧。
–EOF–
类似资料：