真實(shí)世界中當(dāng)我們了解了一件工具的運(yùn)行原理后，我們將能夠更好的使用它涡上，程序也是一樣≈憾希現(xiàn)在框架大多是基于 MVC 的架構(gòu)，Phalcon 也不例外吩愧。下面來(lái)看下 Phalcon 是如何來(lái)處理一個(gè)請(qǐng)求的芋酌。
首先看下 Phalcon 的入口程序 index.php，一個(gè)最基礎(chǔ)的入口文件雁佳，主要做了哪些事情脐帝。
<?php
use Phalcon\Loader;
use Phalcon\Mvc\View;
use Phalcon\Mvc\Application;
use Phalcon\Di\FactoryDefault;
use Phalcon\Mvc\Url as UrlProvider;
use Phalcon\Db\Adapter\Pdo\Mysql as DbAdapter;
// Register an autoloader
$loader = new Loader();
$loader->registerDirs( [
"../app/controllers/",
"../app/models/",
]);
$loader->register();
// Create a DI
$di = new FactoryDefault();
// Setup the view component
$di->set( "view", function () {
$view = new View();
$view->setViewsDir("../app/views/");
return $view;
});
// Setup a base URI so that all generated URIs include the "tutorial" folder
$di->set( "url", function () {
$url = new UrlProvider();
$url->setBaseUri("/tutorial/");
return $url;
});
$application = new Application($di);
try {
// Handle the request
$response = $application->handle();
$response->send();
} catch (\Exception $e) {
echo "Exception: ", $e->getMessage();
}
程序中可以看到同云，入口文件主要干了以下事情：
1.創(chuàng)建自動(dòng)加載器 $loader，注冊(cè)自動(dòng)加載目錄堵腹；
2.創(chuàng)建服務(wù)容器 $di炸站， 注冊(cè)服務(wù)（其他一些服務(wù)使用默認(rèn)的，如：路由 Router 服務(wù)疚顷『狄祝可以打印 $di查看已注冊(cè)的服務(wù)）；
3.創(chuàng)建程序?qū)ο?$application荡含，運(yùn)行程序 $application->handle()咒唆；
4.發(fā)送響應(yīng)的內(nèi)容。
從以上幾點(diǎn)可以看出释液，程序的主要處理邏輯還是在 Application 的 handle() 函數(shù)中全释，在到 handle() 函數(shù)中看下它做了什么事。
// ################################################
// 源碼文件 cphalcon/phalcon/mvc/application.zep
// 這里截取 handle() 函數(shù)出來(lái)看下误债，
// ################################################
/**
* Handles a MVC request
*/
public function handle(string uri = null) -> <ResponseInterface> | boolean
{
var dependencyInjector, eventsManager, router, dispatcher, response, view,
module, moduleObject, moduleName, className, path,
implicitView, returnedResponse, controller, possibleResponse,
renderStatus, matchedRoute, match;
let dependencyInjector = this->_dependencyInjector;
if typeof dependencyInjector != "object" {
throw new Exception("A dependency injection object is required to access internal services");
}
let eventsManager = <ManagerInterface> this->_eventsManager;
/**
* Call boot event, this allow the developer to perform initialization actions
*/
if typeof eventsManager == "object" {
if eventsManager->fire("application:boot", this) === false {
return false;
}
}
let router = <RouterInterface> dependencyInjector->getShared("router");
/**
* Handle the URI pattern (if any)
*/
router->handle(uri);
/**
* If a 'match' callback was defined in the matched route
* The whole dispatcher+view behavior can be overriden by the developer
*/
let matchedRoute = router->getMatchedRoute();
if typeof matchedRoute == "object" {
let match = matchedRoute->getMatch();
if match !== null {
if match instanceof \Closure {
let match = \Closure::bind(match, dependencyInjector);
}
/**
* Directly call the match callback
*/
let possibleResponse = call_user_func_array(match, router->getParams());
/**
* If the returned value is a string return it as body
*/
if typeof possibleResponse == "string" {
let response = <ResponseInterface> dependencyInjector->getShared("response");
response->setContent(possibleResponse);
return response;
}
/**
* If the returned string is a ResponseInterface use it as response
*/
if typeof possibleResponse == "object" {
if possibleResponse instanceof ResponseInterface {
possibleResponse->sendHeaders();
possibleResponse->sendCookies();
return possibleResponse;
}
}
}
}
/**
* If the router doesn't return a valid module we use the default module
*/
let moduleName = router->getModuleName();
if !moduleName {
let moduleName = this->_defaultModule;
}
let moduleObject = null;
/**
* Process the module definition
*/
if moduleName {
if typeof eventsManager == "object" {
if eventsManager->fire("application:beforeStartModule", this, moduleName) === false {
return false;
}
}
/**
* Gets the module definition
*/
let module = this->getModule(moduleName);
/**
* A module definition must ne an array or an object
*/
if typeof module != "array" && typeof module != "object" {
throw new Exception("Invalid module definition");
}
/**
* An array module definition contains a path to a module definition class
*/
if typeof module == "array" {
/**
* Class name used to load the module definition
*/
if !fetch className, module["className"] {
let className = "Module";
}
/**
* If developer specify a path try to include the file
*/
if fetch path, module["path"] {
if !class_exists(className, false) {
if !file_exists(path) {
throw new Exception("Module definition path '" . path . "' doesn't exist");
}
require path;
}
}
let moduleObject = <ModuleDefinitionInterface> dependencyInjector->get(className);
/**
* 'registerAutoloaders' and 'registerServices' are automatically called
*/
moduleObject->registerAutoloaders(dependencyInjector);
moduleObject->registerServices(dependencyInjector);
} else {
/**
* A module definition object, can be a Closure instance
*/
if !(module instanceof \Closure) {
throw new Exception("Invalid module definition");
}
let moduleObject = call_user_func_array(module, [dependencyInjector]);
}
/**
* Calling afterStartModule event
*/
if typeof eventsManager == "object" {
eventsManager->fire("application:afterStartModule", this, moduleObject);
}
}
/**
* Check whether use implicit views or not
*/
let implicitView = this->_implicitView;
if implicitView === true {
let view = <ViewInterface> dependencyInjector->getShared("view");
}
/**
* We get the parameters from the router and assign them to the dispatcher
* Assign the values passed from the router
*/
let dispatcher = <DispatcherInterface> dependencyInjector->getShared("dispatcher");
dispatcher->setModuleName(router->getModuleName());
dispatcher->setNamespaceName(router->getNamespaceName());
dispatcher->setControllerName(router->getControllerName());
dispatcher->setActionName(router->getActionName());
dispatcher->setParams(router->getParams());
/**
* Start the view component (start output buffering)
*/
if implicitView === true {
view->start();
}
/**
* Calling beforeHandleRequest
*/
if typeof eventsManager == "object" {
if eventsManager->fire("application:beforeHandleRequest", this, dispatcher) === false {
return false;
}
}
/**
* The dispatcher must return an object
*/
let controller = dispatcher->dispatch();
/**
* Get the latest value returned by an action
*/
let possibleResponse = dispatcher->getReturnedValue();
/**
* Returning false from an action cancels the view
*/
if typeof possibleResponse == "boolean" && possibleResponse === false {
let response = <ResponseInterface> dependencyInjector->getShared("response");
} else {
/**
* Returning a string makes use it as the body of the response
*/
if typeof possibleResponse == "string" {
let response = <ResponseInterface> dependencyInjector->getShared("response");
response->setContent(possibleResponse);
} else {
/**
* Check if the returned object is already a response
*/
let returnedResponse = ((typeof possibleResponse == "object") && (possibleResponse instanceof ResponseInterface));
/**
* Calling afterHandleRequest
*/
if typeof eventsManager == "object" {
eventsManager->fire("application:afterHandleRequest", this, controller);
}
/**
* If the dispatcher returns an object we try to render the view in auto-rendering mode
*/
if returnedResponse === false && implicitView === true {
if typeof controller == "object" {
let renderStatus = true;
/**
* This allows to make a custom view render
*/
if typeof eventsManager == "object" {
let renderStatus = eventsManager->fire("application:viewRender", this, view);
}
/**
* Check if the view process has been treated by the developer
*/
if renderStatus !== false {
/**
* Automatic render based on the latest controller executed
*/
view->render(
dispatcher->getControllerName(),
dispatcher->getActionName(),
dispatcher->getParams()
);
}
}
}
/**
* Finish the view component (stop output buffering)
*/
if implicitView === true {
view->finish();
}
if returnedResponse === true {
/**
* We don't need to create a response because there is one already created
*/
let response = possibleResponse;
} else {
let response = <ResponseInterface> dependencyInjector->getShared("response");
if implicitView === true {
/**
* The content returned by the view is passed to the response service
*/
response->setContent(view->getContent());
}
}
}
}
/**
* Calling beforeSendResponse
*/
if typeof eventsManager == "object" {
eventsManager->fire("application:beforeSendResponse", this, response);
}
/**
* Headers and Cookies are automatically sent
*/
response->sendHeaders();
response->sendCookies();
/**
* Return the response
*/
return response;
}
函數(shù)handle()里主要干了這些事：
1.匹配路由浸船；
2.調(diào)用派遣器，分發(fā)匹配的路由寝蹈；
3.渲染視圖李命；
4.返回響應(yīng)對(duì)象 response。
還有一些事件處理箫老，具體查看源碼了解封字。所以可以看出 Phalcon 請(qǐng)求的生命周期大致如下圖所示：
Phalcon 請(qǐng)求的生命周期
