介绍
Yaf框架是一个c语言编写的PHP框架，是一个以PHP扩展形式提供的PHP开发框架，相比于一般的PHP框架， 它更快，更轻便，内存占用率更低，就是本着对性能的追求，Yaf把框架中不易变的部分抽象出来，类如路由、自动加载、bootstrap、分发等，采用PHP扩展去实现，以此来保证性能。
Yaf优点
- 用c语言开发的PHP框架，相比原生的PHP，几乎不会带来额外的性能开销
- 所有的框架类，不需要编译，在PHP启动的时候加载，并常驻内存.
- 更快的执行速度，更少的内存占用.
- 灵巧的自动加载. 支持全局和局部两种加载规则, 方便类库共享.
yaf缺点
- 维护成本高，要维护PHP扩展，需要熟练C开发和Zend Api.
- 目标用户群小，现在国内很多中小型站都是使用虚拟主机，并不能随意的给PHP添加扩展.
- 不像其他框架一样提供各种丰富功能的类库和各种优雅的写法，它只提供一个MVC的基本骨架.
Yaf框架执行流程图
引用官方流程图
流程图说明
在application目录下有个Bootstrap.php文件，这个就是图中的第一个环节，如果存在Bootstrap()就会先执行该文件，该文件包含了一系列的初始化环节，并返回一个Yaf_Application对象，紧接着调用了它的run方法，run里面包含了图中所有环节，run首先是调用路由，路由的主要目的其实就是找到controllers文件，然后执行里面的init和action方法，或者找到所有actions的地址然后加载，在去执行对应的execute方法，如果设置了autoRender在返回的时候会执行render方法，就是view自动渲染，图中有六个双横线标出的环节，就是六个插件方法，用户可以自定义实现这几个方法，然后Yaf框架会在图中相应的步骤处调用对应的HOOK方法。
Yaf框架目录结构
+ public
|- index.php //入口文件
|- .htaccess //重写规则
|+ css
|+ img
|+ js
+ conf
|- application.ini //配置文件
+ application
|+ actions //可将controller里面的方法单独抽出来做为一个类实现
|+ index
|- Main.php
|+ controllers
|- Index.php //默认控制器
|+ views
|+ index //控制器
|- index.phtml //默认视图
|+ modules //可以按模块来区分不同业务下的控制器层
|+ admin
|+ controllers
|- Index.php
|+ library //本地类库
|+ models //model目录
|- baseModel.php
|+ plugins //插件目录
|- testPlugin.php
Bootstrap.php 引导文件
Yaf配置项说明
- php.ini 配置项
| 选项名称 | 默认值 | 说明 |
|---|---|---|
| yaf.environ | product | 环境名称, 当用INI作为Yaf的配置文件时, 这个指明了Yaf将要在INI配置中读取的节的名字 |
| yaf.library | NULL | 全局类库的目录路径 |
| yaf.cache_config | 0 | 是否缓存配置文件(只针对INI配置文件生效), 打开此选项可在复杂配置的情况下提高性能 |
| yaf.name_suffix | 1 | 在处理Controller, Action, Plugin, Model的时候, 类名中关键信息是否是后缀式, 比如UserModel, 而在前缀模式下则是ModelUser |
| yaf.name_separator | "" | 在处理Controller, Action, Plugin, Model的时候, 前缀和名字之间的分隔符, 默认为空, 也就是UserPlugin, 加入设置为"_", 则判断的依据就会变成:"User_Plugin", 这个主要是为了兼容ST已有的命名规范 |
| yaf.forward_limit | 5 | forward最大嵌套深度 |
| yaf.use_namespace | 0 | 开启的情况下, Yaf将会使用命名空间方式注册自己的类, 比如Yaf_Application将会变成Yaf\Application |
| yaf.use_spl_autoload | 0 | 开启的情况下, Yaf在加载不成功的情况下, 会继续让PHP的自动加载函数加载, 从性能考虑, 除非特殊情况, 否则保持这个选项关闭 |
//php.ini
[Yaf]
yaf.library = "c:/huan"
yaf.name_suffix = 0
yaf.name_separator = "_"
yaf.environ = "product"
- application.ini 配置项
| 选项名称 | 默认值 | 说明 |
|---|---|---|
| application.ext | php | PHP脚本的扩展名 |
| application.bootstrap | Bootstrapplication.php | Bootstrap路径(绝对路径) |
| application.library | application.directory + "/library" | 本地(自身)类库的绝对目录地址 |
| application.baseUri | NULL | 在路由中, 需要忽略的路径前缀, 一般不需要设置, Yaf会自动判断. |
| application.dispatcher.defaultModule | index | 默认的模块 |
| application.dispatcher.throwException | True | 在出错的时候, 是否抛出异常 |
| application.dispatcher.catchException | False | 是否使用默认的异常捕获Controller, 如果开启, 在有未捕获的异常的时候, 控制权会交给ErrorController的errorAction方法, 可以通过$request->getException()获得此异常对象 |
| application.dispatcher.defaultController | index | 默认的控制器 |
| application.dispatcher.defaultAction | index | 默认的动作 |
| application.view.ext | phtml | 视图模板扩展名 |
| application.modules | modules | 声明存在的模块名, 请注意, 如果你要定义这个值, 一定要定义Index Module |
//application.ini
[mysql]
mysql.master.user_name = word
mysql.master.pass_word = 1234
mysql.slave.user_name = word
mysql.slave.pass_word = 1234
[database : mysql]
database.master.host = 127.0.0.1
database.slave.host = 127.0.0.2,127.0.0.3
[product : database]
yaf.directory = APP_PATH "/app/"
yaf.libray = APP_PATH "/libray/
可以看到在application.ini配置文件里面除了配置框架本身的配置项，还可以添加一些我们自定义的配置项，同时支持继承配置功能，在框架启动的时候会根据yaf.environ设定的节点名字去读取.
配置文件解析完毕后读取到内存的状态
Yaf_Config_Ini Object
(
[_config:protected] => Array
(
[mysql] => Array
(
[master] => Array
(
[user_name] => word
)
[slave] => Array
(
[user_name] => word
)
)
[database] => Array
(
[master] => Array
(
[host] => 127.0.0.1
)
[slave] => Array
(
[host] => 127.0.0.2,127.0.0.3
)
)
[yaf] => Array
(
[directory] => C:\huan\apache\htdocs\yaf/app/
[libray] => C:\huan\apache\htdocs\yaf/libray/
)
)
[_readonly:protected] => 1
)
调用Yaf框架
//入口文件index.php
define("APP_PATH", '/home/test/yaf');
$app = new Yaf_Application(APP_PATH . "/conf/application.ini");
$app->bootstrap()->run();
Bootstrap.php 类文件
class Bootstrap extends Yaf_Bootstrap_Abstract{
public function _initConfig(Yaf_Dispatcher $dispatcher) {
//存放全局数据
$config = Yaf_Application::app()->getConfig();
Yaf_Registry::set("config", $config);
//读取配置
$dispatcher->getConfig()->get('database')->master->host
//关闭自动渲染
$dispatcher->autoRender(false);
//设置自定的模板引擎类如smarty
$dispatcher->setView( Yaf_View_Interface $request );
}
public function _initDefaultName(Yaf_Dispatcher $dispatcher) {
$dispatcher->setDefaultModule("Index")->setDefaultController("Index")->setDefaultAction("index");
}
public function _initPlugin(Yaf_Dispatcher $dispatcher){
//注册插件
$objPlugin = new Test_Plugin();
$dispatcher->registerPlugin($objPlugin);
}
public function _initRegistLocalLib(Yaf_Dispatcher $dispatcher){
//注册本地类前缀, 是的对于以这些前缀开头的本地类, 都从本地类库路径中加载.
Yaf_Loader::getInstance()->registerLocalNamespace(array('Foo','Msn'));
}
}
Plugin.php 插件类文件
class Test_Plugin extends Yaf_Plugin_Abstract {
public function routerStartup(Yaf_Request_Abstract $request, Yaf_Response_Abstract $response) {
}
public function routerShutdown(Yaf_Request_Abstract $request, Yaf_Response_Abstract $response) {
}
}
Controller.php 类文件
class Index_Controller extends Yaf_Controller_Abstract {
//第二种action实现方式
public $actions = array(
'one' => 'actions/index/One.php',
'two' => 'actions/index/Two.php',
);
//初始化方法
public function ini(){
}
//第一种action实现方式
public function index_Action() {
$this->getView()->assign("content", "Hello World");
$this->getView()->display();
}
}
Action.php 类文件
Class One_Action extends Yaf_Action_Abstract{
public function execute(){
}
}
Model 类文件
class Base_Model {
public function getDataList(){
}
}
注意： Yaf并没有实现Model层，需要自己实现或者调用现成的Model库.
扩展-核心功能模块实现
扩展 Yaf_Application 类注册
YAF_STARTUP_FUNCTION(application) { //宏替换一下 ZEND_MINIT_FUNCTION(yaf_##module)
//PHP内核中对PHP类的实现是通过zend_class_entry结构体实现的
zend_class_entry ce;
//相当于对ce初始化，指定一个类名称 Ap_Application
//指定类的成员方法列表 ap_application_methods 结构体数组指针
YAF_INIT_CLASS_ENTRY(ce, "Yaf_Application", "Yaf\\Application", yaf_application_methods);
//向PHP注册类，PHP中由class_table维护全局的类数组
//可以简单理解为把类添加到这个数组中，这样就可以在
//PHP中找到这个类了，内核中有一组类似的注册函数
//用来注册接口、类、子类、接口实现、抽象类等
yaf_application_ce = zend_register_internal_class_ex(&ce, NULL, NULL TSRMLS_CC);
//指定类的属性
yaf_application_ce->ce_flags |= ZEND_ACC_FINAL_CLASS;
//设置类内部的一些变量和属性
zend_declare_property_null(yaf_application_ce, ZEND_STRL(YAF_APPLICATION_PROPERTY_NAME_CONFIG), ZEND_ACC_PROTECTED TSRMLS_CC);
zend_declare_property_null(yaf_application_ce, ZEND_STRL(YAF_APPLICATION_PROPERTY_NAME_DISPATCHER), ZEND_ACC_PROTECTED TSRMLS_CC);
zend_declare_property_null(yaf_application_ce, ZEND_STRL(YAF_APPLICATION_PROPERTY_NAME_APP), ZEND_ACC_STATIC | ZEND_ACC_PROTECTED TSRMLS_CC);
zend_declare_property_null(yaf_application_ce, ZEND_STRL(YAF_APPLICATION_PROPERTY_NAME_MODULES), ZEND_ACC_PROTECTED TSRMLS_CC);
zend_declare_property_bool(yaf_application_ce, ZEND_STRL(YAF_APPLICATION_PROPERTY_NAME_RUN), 0, ZEND_ACC_PROTECTED TSRMLS_CC);
zend_declare_property_string(yaf_application_ce, ZEND_STRL(YAF_APPLICATION_PROPERTY_NAME_ENV), YAF_G(environ), ZEND_ACC_PROTECTED TSRMLS_CC);
zend_declare_property_long(yaf_application_ce, ZEND_STRL(YAF_APPLICATION_PROPERTY_NAME_ERRNO), 0, ZEND_ACC_PROTECTED TSRMLS_CC);
zend_declare_property_string(yaf_application_ce, ZEND_STRL(YAF_APPLICATION_PROPERTY_NAME_ERRMSG), "", ZEND_ACC_PROTECTED TSRMLS_CC);
//内核中有一组这样的属性标记来指定类和变量的性质
/* method flags (types)
#define ZEND_ACC_STATIC 0x01
#define ZEND_ACC_ABSTRACT 0x02
#define ZEND_ACC_FINAL 0x04
#define ZEND_ACC_IMPLEMENTED_ABSTRACT 0x08
class flags (types)
#define ZEND_ACC_IMPLICIT_ABSTRACT_CLASS 0x10
#define ZEND_ACC_EXPLICIT_ABSTRACT_CLASS 0x20
#define ZEND_ACC_FINAL_CLASS 0x40
#define ZEND_ACC_INTERFACE 0x80 */
return SUCCESS;
}
//类成员函数的声明
zend_function_entry yaf_application_methods[] = {
PHP_ME(yaf_application, __construct, yaf_application_construct_arginfo, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
PHP_ME(yaf_application, run, yaf_application_run_arginfo, ZEND_ACC_PUBLIC)
PHP_ME(yaf_application, execute, yaf_application_execute_arginfo, ZEND_ACC_PUBLIC)
PHP_ME(yaf_application, app, yaf_application_app_arginfo, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
YAF_ME(yaf_application_environ, "environ", yaf_application_environ_arginfo, ZEND_ACC_PUBLIC)
PHP_ME(yaf_application, bootstrap, yaf_application_bootstrap_arginfo, ZEND_ACC_PUBLIC)
PHP_ME(yaf_application, getConfig, yaf_application_getconfig_arginfo, ZEND_ACC_PUBLIC)
PHP_ME(yaf_application, getModules, yaf_application_getmodule_arginfo, ZEND_ACC_PUBLIC)
PHP_ME(yaf_application, getDispatcher, yaf_application_getdispatch_arginfo, ZEND_ACC_PUBLIC)
PHP_ME(yaf_application, setAppDirectory, yaf_application_setappdir_arginfo, ZEND_ACC_PUBLIC)
PHP_ME(yaf_application, getAppDirectory, yaf_application_void_arginfo, ZEND_ACC_PUBLIC)
PHP_ME(yaf_application, getLastErrorNo, yaf_application_void_arginfo, ZEND_ACC_PUBLIC)
PHP_ME(yaf_application, getLastErrorMsg, yaf_application_void_arginfo, ZEND_ACC_PUBLIC)
PHP_ME(yaf_application, clearLastError, yaf_application_void_arginfo, ZEND_ACC_PUBLIC)
PHP_ME(yaf_application, __destruct, NULL, ZEND_ACC_PUBLIC | ZEND_ACC_DTOR)
PHP_ME(yaf_application, __clone, NULL, ZEND_ACC_PRIVATE | ZEND_ACC_CLONE)
PHP_ME(yaf_application, __sleep, NULL, ZEND_ACC_PRIVATE)
PHP_ME(yaf_application, __wakeup, NULL, ZEND_ACC_PRIVATE)
{NULL, NULL, NULL}
};
上面这个就是在扩展里面注册一个类的实现，Yaf其他的类文件在注册类的时候也几乎和上面方式一致，具体看下源码就可以了，下面将从实例化一个Yaf_Application类开始分析。
扩展 Yaf_Application 类构造函数 __construct 实现
PHP_METHOD(yaf_application, __construct) {
yaf_config_t *zconfig;
yaf_request_t *request;
yaf_dispatcher_t *zdispatcher;
yaf_application_t *app, *self;
yaf_loader_t *loader;
zval *config;
zval *section = NULL;
//获取yaf_application::_app变量值,默认为0
app = zend_read_static_property(yaf_application_ce, ZEND_STRL(YAF_APPLICATION_PROPERTY_NAME_APP), 1 TSRMLS_CC);
#if PHP_YAF_DEBUG
php_error_docref(NULL TSRMLS_CC, E_STRICT, "Yaf is running in debug mode");
#endif
//如果app有值则报错，也就是当前类只能被实例化一次
if (!ZVAL_IS_NULL(app)) {
yaf_trigger_error(YAF_ERR_STARTUP_FAILED TSRMLS_CC, "Only one application can be initialized");
RETURN_FALSE;
}
//获取当前的对象，也就是php里面的$this
self = getThis();
//获取参数，把配置文件路径或者配置数组传递进来
//section配置文件中的节点名字，默认product
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &config, §ion) == FAILURE) {
YAF_UNINITIALIZED_OBJECT(getThis());
return;
}
if (!section || Z_TYPE_P(section) != IS_STRING || !Z_STRLEN_P(section)) {
MAKE_STD_ZVAL(section);
ZVAL_STRING(section, YAF_G(environ), 0);
//获取config对象
zconfig = yaf_config_instance(NULL, config, section TSRMLS_CC);
efree(section);
} else {
//获取config对象
zconfig = yaf_config_instance(NULL, config, section TSRMLS_CC);
}
//解析配置文件，并将配置信息保存在zconfig对象中
if (zconfig == NULL
|| Z_TYPE_P(zconfig) != IS_OBJECT
|| !instanceof_function(Z_OBJCE_P(zconfig), yaf_config_ce TSRMLS_CC)
|| yaf_application_parse_option(zend_read_property(yaf_config_ce,
zconfig, ZEND_STRL(YAF_CONFIG_PROPERT_NAME), 1 TSRMLS_CC) TSRMLS_CC) == FAILURE) {
YAF_UNINITIALIZED_OBJECT(getThis());
yaf_trigger_error(YAF_ERR_STARTUP_FAILED TSRMLS_CC, "Initialization of application config failed");
RETURN_FALSE;
}
//获取 request 对象，请求的信息保存在里面
request = yaf_request_instance(NULL, YAF_G(base_uri) TSRMLS_CC);
if (YAF_G(base_uri)) {
efree(YAF_G(base_uri));
YAF_G(base_uri) = NULL;
}
if (!request) {
YAF_UNINITIALIZED_OBJECT(getThis());
yaf_trigger_error(YAF_ERR_STARTUP_FAILED TSRMLS_CC, "Initialization of request failed");
RETURN_FALSE;
}
//获取dispatcher对象，主要在里面调用插件、路由、分发等
zdispatcher = yaf_dispatcher_instance(NULL TSRMLS_CC);
if (NULL == zdispatcher
|| Z_TYPE_P(zdispatcher) != IS_OBJECT
|| !instanceof_function(Z_OBJCE_P(zdispatcher), yaf_dispatcher_ce TSRMLS_CC)) {
YAF_UNINITIALIZED_OBJECT(getThis());
yaf_trigger_error(YAF_ERR_STARTUP_FAILED TSRMLS_CC, "Instantiation of application dispatcher failed");
RETURN_FALSE;
}
//把request对象保存在zdispatcher对像属性中
yaf_dispatcher_set_request(zdispatcher, request TSRMLS_CC);
//保存zconfig对象到当前yaf_application对象属性中
zend_update_property(yaf_application_ce, self, ZEND_STRL(YAF_APPLICATION_PROPERTY_NAME_CONFIG), zconfig TSRMLS_CC);
//保存zdispatcher对象到当前yaf_application对象属性中
zend_update_property(yaf_application_ce, self, ZEND_STRL(YAF_APPLICATION_PROPERTY_NAME_DISPATCHER), zdispatcher TSRMLS_CC);
zval_ptr_dtor(&request);
zval_ptr_dtor(&zdispatcher);
zval_ptr_dtor(&zconfig);
//是否指定本地类库地址
if (YAF_G(local_library)) {
//获取一个load加载类，并同时向内核注册一个自动加载器__autoload
//之后在代码中new class()都会调用扩展中注册的自动加载器
loader = yaf_loader_instance(NULL, YAF_G(local_library),
strlen(YAF_G(global_library))? YAF_G(global_library) : NULL TSRMLS_CC);
efree(YAF_G(local_library));
YAF_G(local_library) = NULL;
} else {
char *local_library;
//获取一个默认的本地类库地址
spprintf(&local_library, 0, "%s%c%s", YAF_G(directory), DEFAULT_SLASH, YAF_LIBRARY_DIRECTORY_NAME);
//同上面解释一致
loader = yaf_loader_instance(NULL, local_library,
strlen(YAF_G(global_library))? YAF_G(global_library) : NULL TSRMLS_CC);
efree(local_library);
}
if (!loader) {
YAF_UNINITIALIZED_OBJECT(getThis());
yaf_trigger_error(YAF_ERR_STARTUP_FAILED TSRMLS_CC, "Initialization of application auto loader failed");
RETURN_FALSE;
}
//赋值对象属性
zend_update_property_bool(yaf_application_ce, self, ZEND_STRL(YAF_APPLICATION_PROPERTY_NAME_RUN), 0 TSRMLS_CC);
zend_update_property_string(yaf_application_ce, self, ZEND_STRL(YAF_APPLICATION_PROPERTY_NAME_ENV), YAF_G(environ) TSRMLS_CC);
//这个modules一定会存在，默认是Index
if (YAF_G(modules)) {
zend_update_property(yaf_application_ce, self, ZEND_STRL(YAF_APPLICATION_PROPERTY_NAME_MODULES), YAF_G(modules) TSRMLS_CC);
Z_DELREF_P(YAF_G(modules));
YAF_G(modules) = NULL;
} else {
zend_update_property_null(yaf_application_ce, self, ZEND_STRL(YAF_APPLICATION_PROPERTY_NAME_MODULES) TSRMLS_CC);
}
//yaf_application::_app 赋值成当前self对象
zend_update_static_property(yaf_application_ce, ZEND_STRL(YAF_APPLICATION_PROPERTY_NAME_APP), self TSRMLS_CC);
}
PHP_METHOD(Yaf_application, bootstrap) 扩展实现
PHP_METHOD(yaf_application, bootstrap) {
char *bootstrap_path;
uint len, retval = 1;
zend_class_entry **ce;
yaf_application_t *self = getThis();
//判断 Bootstrap 类是否存在，默认第一次肯定不存在
//因为还没有加载注册进来
if (zend_hash_find(EG(class_table), YAF_DEFAULT_BOOTSTRAP_LOWER, YAF_DEFAULT_BOOTSTRAP_LEN, (void **) &ce) != SUCCESS) {
//判断是否指定了bootstrap文件路径
if (YAF_G(bootstrap)) {
bootstrap_path = estrdup(YAF_G(bootstrap));
len = strlen(YAF_G(bootstrap));
} else {
//没有指定则使用默认路径
len = spprintf(&bootstrap_path, 0, "%s%c%s.%s", YAF_G(directory), DEFAULT_SLASH, YAF_DEFAULT_BOOTSTRAP, YAF_G(ext));
}
//导入bootstrap文件，内核如果发现是类，则会自动注册上
if (!yaf_loader_import(bootstrap_path, len + 1, 0 TSRMLS_CC)) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Couldn't find bootstrap file %s", bootstrap_path);
retval = 0;
//获取 bootstrap 类
} else if (zend_hash_find(EG(class_table), YAF_DEFAULT_BOOTSTRAP_LOWER, YAF_DEFAULT_BOOTSTRAP_LEN, (void **) &ce) != SUCCESS) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Couldn't find class %s in %s", YAF_DEFAULT_BOOTSTRAP, bootstrap_path);
retval = 0;
//判断该类是否继承Yaf_Bootstrap_Abstract
} else if (!instanceof_function(*ce, yaf_bootstrap_ce TSRMLS_CC)) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Expect a %s instance, %s give", yaf_bootstrap_ce->name, (*ce)->name);
retval = 0;
}
efree(bootstrap_path);
}
if (!retval) {
RETURN_FALSE;
} else {
zval *bootstrap;
HashTable *methods;
yaf_dispatcher_t *dispatcher;
//实例化一个bootstrap对象
MAKE_STD_ZVAL(bootstrap);
object_init_ex(bootstrap, *ce);
//获取dispatcher 对象
dispatcher = zend_read_property(yaf_application_ce, self, ZEND_STRL(YAF_APPLICATION_PROPERTY_NAME_DISPATCHER), 1 TSRMLS_CC);
//获取bootstrap类里面所有的方法，每个类都用一个函数表function_table来记录
//方法名和对应结构体指针
methods = &((*ce)->function_table);
//循环bootstrap类里面所有的方法
//内核中对array的实现是通过hash_table实现的，内核中会
//看到到处使用hash_table的地方，可以简单理解为数组的操作
for(zend_hash_internal_pointer_reset(methods);
zend_hash_has_more_elements(methods) == SUCCESS;
zend_hash_move_forward(methods)) {
char *func;
uint len;
ulong idx;
//获取第一个方法名字
zend_hash_get_current_key_ex(methods, &func, &len, &idx, 0, NULL);
/* cann't use ZEND_STRL in strncasecmp, it cause a compile failed in VS2009 */
#define YAF_BOOTSTRAP_INITFUNC_PREFIX "_init"
//Bootstrap类实现了一系列的_init开头的方法
//这里是比较函数func是否以_init开头
if (strncasecmp(func, YAF_BOOTSTRAP_INITFUNC_PREFIX, sizeof(YAF_BOOTSTRAP_INITFUNC_PREFIX)-1)) {
continue;
}
//调用所有以_init开头的函数，入参统一为dispatcher对象
zend_call_method(&bootstrap, *ce, NULL, func, len - 1, NULL, 1, dispatcher, NULL TSRMLS_CC);
/** an uncaught exception threw in function call */
if (EG(exception)) {
zval_ptr_dtor(&bootstrap);
RETURN_FALSE;
}
}
zval_ptr_dtor(&bootstrap);
}
//最后会返回application对象自身
RETVAL_ZVAL(self, 1, 0);
}
PHP_METHOD(yaf_application, run) 扩展实现
PHP_METHOD(yaf_application, run) {
zval *running;
yaf_dispatcher_t *dispatcher;
yaf_response_t *response;
yaf_application_t *self = getThis();
//获取属性值，默认第一次为0
running = zend_read_property(yaf_application_ce, self, ZEND_STRL(YAF_APPLICATION_PROPERTY_NAME_RUN), 1 TSRMLS_CC);
if (IS_BOOL == Z_TYPE_P(running)
&& Z_BVAL_P(running)) {
yaf_trigger_error(YAF_ERR_STARTUP_FAILED TSRMLS_CC, "An application instance already run");
RETURN_TRUE;
}
//赋值为1，可以看出来当前application对象中的run函数只能被调用一次
ZVAL_BOOL(running, 1);
zend_update_property(yaf_application_ce, self, ZEND_STRL(YAF_APPLICATION_PROPERTY_NAME_RUN), running TSRMLS_CC);
//获取dispatcher对象
dispatcher = zend_read_property(yaf_application_ce, self, ZEND_STRL(YAF_APPLICATION_PROPERTY_NAME_DISPATCHER), 1 TSRMLS_CC);
//进行路由分发等工作
if ((response = yaf_dispatcher_dispatch(dispatcher TSRMLS_CC))) {
RETURN_ZVAL(response, 1, 1);
}
RETURN_FALSE;
}
yaf_dispatcher_dispatch() 方法里面主要分两部分，路由+分发，其中夹杂着一些插件调用，就是上图中双横线标出的环节，先看下官方对插件的说明。
| 触发顺序 | 名称 | 触发时机 |
|---|---|---|
| 1 | routerStartup | 在路由之前触发 |
| 2 | routerShutdown | 路由结束之后触发 |
| 3 | dispatchLoopStartup | 分发循环开始之前被触发 |
| 4 | preDispatch | 分发之前触发 |
| 5 | postDispatch | 分发结束之后触发 |
| 6 | dispatchLoopShutdown | 分发循环结束之后触发 |
扩展中插件方法名用宏表示
#define YAF_PLUGIN_HOOK_ROUTESTARTUP "routerstartup"
#define YAF_PLUGIN_HOOK_ROUTESHUTDOWN "routershutdown"
#define YAF_PLUGIN_HOOK_LOOPSTARTUP "dispatchloopstartup"
#define YAF_PLUGIN_HOOK_PREDISPATCH "predispatch"
#define YAF_PLUGIN_HOOK_POSTDISPATCH "postdispatch"
#define YAF_PLUGIN_HOOK_LOOPSHUTDOWN "dispatchloopshutdown"
#define YAF_PLUGIN_HOOK_PRERESPONSE "preresponse"
yaf_dispatcher_dispatch(yaf_dispatcher_t *dispatcher TSRMLS_DC)
yaf_response_t * yaf_dispatcher_dispatch(yaf_dispatcher_t *dispatcher TSRMLS_DC) {
zval *return_response, *plugins, *view;
yaf_response_t *response;
yaf_request_t *request;
uint nesting = YAF_G(forward_limit);
//获取response对象
response = yaf_response_instance(NULL, sapi_module.name TSRMLS_CC);
//获取request对象
request = zend_read_property(yaf_dispatcher_ce, dispatcher, ZEND_STRL(YAF_DISPATCHER_PROPERTY_NAME_REQUEST), 1 TSRMLS_CC);
//获取插件数组对象，这是一个数组，里面每个值都是一个插件对象
//但前提是我们创建插件类，实例化之后，注册进dispatcher对象里
plugins = zend_read_property(yaf_dispatcher_ce, dispatcher, ZEND_STRL(YAF_DISPATCHER_PROPERTY_NAME_PLUGINS), 1 TSRMLS_CC);
//如果不是对象则报错
if (IS_OBJECT != Z_TYPE_P(request)) {
yaf_trigger_error(YAF_ERR_TYPE_ERROR TSRMLS_CC, "Expect a %s instance", yaf_request_ce->name);
zval_ptr_dtor(&response);
return NULL;
}
/* route request */
//是否已经路由过
if (!yaf_request_is_routed(request TSRMLS_CC)) {
//调用插件routerstartup方法，如果注册的情况
YAF_PLUGIN_HANDLE(plugins, YAF_PLUGIN_HOOK_ROUTESTARTUP, request, response);
//捕获异常 Error_Controller，开启的情况下，对应配置项为 catchException
YAF_EXCEPTION_HANDLE(dispatcher, request, response);
//进行路由，就是找到 controller、action、model
if (!yaf_dispatcher_route(dispatcher, request TSRMLS_CC)) {
//抛出异常
yaf_trigger_error(YAF_ERR_ROUTE_FAILED TSRMLS_CC, "Routing request failed");
//捕获异常 Error_Controller
YAF_EXCEPTION_HANDLE_NORET(dispatcher, request, response);
zval_ptr_dtor(&response);
return NULL;
}
//设置Controller、action、model
yaf_dispatcher_fix_default(dispatcher, request TSRMLS_CC);
//调用插件routerShutdown方法
YAF_PLUGIN_HANDLE(plugins, YAF_PLUGIN_HOOK_ROUTESHUTDOWN, request, response);
//捕获异常
YAF_EXCEPTION_HANDLE(dispatcher, request, response);
//已经路由完毕标识
(void)yaf_request_set_routed(request, 1 TSRMLS_CC);
} else {
//设置Controller、action、model
yaf_dispatcher_fix_default(dispatcher, request TSRMLS_CC);
}
//调用插件dispatchLoopStartup方法
YAF_PLUGIN_HANDLE(plugins, YAF_PLUGIN_HOOK_LOOPSTARTUP, request, response);
//捕获异常
YAF_EXCEPTION_HANDLE(dispatcher, request, response);
//获取view对象
view = yaf_dispatcher_init_view(dispatcher, NULL, NULL TSRMLS_CC);
if (!view) {
return NULL;
}
do {
//调用插件preDispatch方法
YAF_PLUGIN_HANDLE(plugins, YAF_PLUGIN_HOOK_PREDISPATCH, request, response);
//捕获异常
YAF_EXCEPTION_HANDLE(dispatcher, request, response);
//开始分发
if (!yaf_dispatcher_handle(dispatcher, request, response, view TSRMLS_CC)) {
YAF_EXCEPTION_HANDLE(dispatcher, request, response);
zval_ptr_dtor(&response);
return NULL;
}
yaf_dispatcher_fix_default(dispatcher, request TSRMLS_CC);
//调用插件postDispatch方法
YAF_PLUGIN_HANDLE(plugins, YAF_PLUGIN_HOOK_POSTDISPATCH, request, response);
//捕获异常
YAF_EXCEPTION_HANDLE(dispatcher, request, response);
//这个就是控制分发次数，配置项中的forward_limit
} while (--nesting > 0 && !yaf_request_is_dispatched(request TSRMLS_CC));
//调用插件dispatchLoopShutdown方法
YAF_PLUGIN_HANDLE(plugins, YAF_PLUGIN_HOOK_LOOPSHUTDOWN, request, response);
//捕获异常
YAF_EXCEPTION_HANDLE(dispatcher, request, response);
//如果分发次数全部耗尽，且还有异常的话
if (0 == nesting && !yaf_request_is_dispatched(request TSRMLS_CC)) {
yaf_trigger_error(YAF_ERR_DISPATCH_FAILED TSRMLS_CC, "The max dispatch nesting %ld was reached", YAF_G(forward_limit));
YAF_EXCEPTION_HANDLE_NORET(dispatcher, request, response);
zval_ptr_dtor(&response);
return NULL;
}
//最后返回一个 response 对象
return_response = zend_read_property(yaf_dispatcher_ce, dispatcher, ZEND_STRL(YAF_DISPATCHER_PROPERTY_NAME_RETURN), 1 TSRMLS_CC);
if (!Z_BVAL_P(return_response)) {
(void)yaf_response_send(response TSRMLS_CC);
yaf_response_clear_body(response, NULL, 0 TSRMLS_CC);
}
return response;
}
yaf_dispatcher_route() 路由入口
int yaf_dispatcher_route(yaf_dispatcher_t *dispatcher, yaf_request_t *request TSRMLS_DC) {
zend_class_entry *router_ce;
//获取路由器对象，dispatcher初始化时会创建内置路由器
yaf_router_t *router = zend_read_property(yaf_dispatcher_ce, dispatcher, ZEND_STRL(YAF_DISPATCHER_PROPERTY_NAME_ROUTER), 1 TSRMLS_CC);
if (IS_OBJECT == Z_TYPE_P(router)) {
//是否内置的路由器
if ((router_ce = Z_OBJCE_P(router)) == yaf_router_ce) {
//执行路由器里面的路由协议
yaf_router_route(router, request TSRMLS_CC);
} else {
//自定义路由器
/* user custom router */
zval *ret = zend_call_method_with_1_params(&router, router_ce, NULL, "route", &ret, request);
if (Z_TYPE_P(ret) == IS_BOOL && Z_BVAL_P(ret) == 0) {
yaf_trigger_error(YAF_ERR_ROUTE_FAILED TSRMLS_CC, "Routing request faild");
return 0;
}
}
return 1;
}
return 0;
}
这段代码是路由环节的入口，dispatcher初始化时会创建内置路由器，这里只涉及路由器概念，上面的自定义并不是自定义路由协议，而是你可以重新写一个路由器，我们通常在项目中自定义路由协议就可以了，没有必要自己实现一个路由器。而且框架中其实也是写死了内置路由器，没有给你set自定义路由器的接口。
yaf_router_route() 执行路由
int yaf_router_route(yaf_router_t *router, yaf_request_t *request TSRMLS_DC) {
zval *routers, *ret;
yaf_route_t **route;
HashTable *ht;
//获取路由协议，可以添加多层路由协议，类似于多重插件
//通过addRoute方法向路由器注册自己的路由协议，默认的
//路由协议是Yaf_Route_Static
routers = zend_read_property(yaf_router_ce, router, ZEND_STRL(YAF_ROUTER_PROPERTY_NAME_ROUTES), 1 TSRMLS_CC);
ht = Z_ARRVAL_P(routers);
//for循环依次调用路由协议的route方法，成功则记下当前
//生效的这个路由协议的索引位置，并设置request为已路由
//不成功则继续调用下一个路由协议。
for(zend_hash_internal_pointer_end(ht);
zend_hash_has_more_elements(ht) == SUCCESS;
zend_hash_move_backwards(ht)) {
if (zend_hash_get_current_data(ht, (void**)&route) == FAILURE) {
continue;
}
//调用路由协议对象的route方法
zend_call_method_with_1_params(route, Z_OBJCE_PP(route), NULL, "route", &ret, request);
if (IS_BOOL != Z_TYPE_P(ret) || !Z_BVAL_P(ret)) {
zval_ptr_dtor(&ret);
continue;
} else {
char *key;
uint len = 0;
ulong idx = 0;
//记录当前路由协议的索引
switch(zend_hash_get_current_key_ex(ht, &key, &len, &idx, 0, NULL)) {
case HASH_KEY_IS_LONG:
zend_update_property_long(yaf_router_ce, router, ZEND_STRL(YAF_ROUTER_PROPERTY_NAME_CURRENT_ROUTE), idx TSRMLS_CC);
break;
case HASH_KEY_IS_STRING:
if (len) {
zend_update_property_string(yaf_router_ce, router, ZEND_STRL(YAF_ROUTER_PROPERTY_NAME_CURRENT_ROUTE), key TSRMLS_CC);
}
break;
}
//设置为已路由
yaf_request_set_routed(request, 1 TSRMLS_CC);
zval_ptr_dtor(&ret);
break;
}
}
return 1;
}
内置的路由协议
- Yaf_Route_Static
- Yaf_Route_Simple
- Yaf_Route_Supervar
- Yaf_Route_Rewrite
- Yaf_Route_Regex
- Yaf_Route_Map
上面几种路由协议源代码列表
yaf_route_static.c
yaf_route_simple.c
yaf_route_supervar.c
yaf_route_rewrite.c
yaf_route_regex.c
yaf_route_map.c
无路是哪个路由协议最后功能都是为了设置module，controller，action的名称
yaf_dispatcher_handle() 开始分发
//只看下主逻辑
int yaf_dispatcher_handle(yaf_dispatcher_t *dispatcher, yaf_request_t *request, yaf_response_t *response, yaf_view_t *view TSRMLS_DC) {
zend_class_entry *request_ce;
//代码根目录
char *app_dir = YAF_G(directory);
request_ce = Z_OBJCE_P(request);
//代表request开始，如果出现异常，则会在把当前状态改成0
//在分发循环while会判断这个值，如果为0则代表之前分发中
//存在异常所以保证在分发forward_limit次数内再继续分发
//如果等于1则代表没有异常情况，分发完毕.
yaf_request_set_dispatched(request, 1 TSRMLS_CC);
if (!app_dir) {
yaf_trigger_error(YAF_ERR_STARTUP_FAILED TSRMLS_CC, "%s requires %s(which set the application.directory) to be initialized first",
yaf_dispatcher_ce->name, yaf_application_ce->name);
return 0;
} else {
int is_def_module = 0;
/* int is_def_ctr = 0; */
zval *module, *controller, *dmodule, /* *dcontroller,*/ *instantly_flush;
zend_class_entry *ce;
yaf_controller_t *executor;
zend_function *fptr;
//获取module
module = zend_read_property(request_ce, request, ZEND_STRL(YAF_REQUEST_PROPERTY_NAME_MODULE), 1 TSRMLS_CC);
//获取controller
controller = zend_read_property(request_ce, request, ZEND_STRL(YAF_REQUEST_PROPERTY_NAME_CONTROLLER), 1 TSRMLS_CC);
//获取默认module默认为Index
dmodule = zend_read_property(yaf_dispatcher_ce, dispatcher, ZEND_STRL(YAF_DISPATCHER_PROPERTY_NAME_MODULE), 1 TSRMLS_CC);
if (Z_TYPE_P(module) != IS_STRING
|| !Z_STRLEN_P(module)) {
yaf_trigger_error(YAF_ERR_DISPATCH_FAILED TSRMLS_CC, "Unexcepted a empty module name");
return 0;
//判断当前请求的model是否在modules里面，默认情况modules里面也是Index
//如果自定义其他的model，就需要添加在modules这个选项里面，添加的无论是
//什么model都需要存在Index这个model，类似于:Index,Admin,Main这样，不添
//加的话会提示错误.
} else if (!yaf_application_is_module_name(Z_STRVAL_P(module), Z_STRLEN_P(module) TSRMLS_CC)) {
yaf_trigger_error(YAF_ERR_NOTFOUND_MODULE TSRMLS_CC, "There is no module %s", Z_STRVAL_P(module));
return 0;
}
if (Z_TYPE_P(controller) != IS_STRING
|| !Z_STRLEN_P(controller)) {
yaf_trigger_error(YAF_ERR_DISPATCH_FAILED TSRMLS_CC, "Unexcepted a empty controller name");
return 0;
}
//判断当前的model是否等于默认的model
//如果等于就去默认的Controllers目录下找
//控制器，如果不等于这个值就为0则就去
//modules/model/controllers/下面找控制器
//后面会有体现
if (strncasecmp(Z_STRVAL_P(dmodule), Z_STRVAL_P(module), Z_STRLEN_P(module)) == 0) {
is_def_module = 1;
}
//找到对应的controller类
ce = yaf_dispatcher_get_controller(app_dir, Z_STRVAL_P(module), Z_STRVAL_P(controller), Z_STRLEN_P(controller), is_def_module TSRMLS_CC);
if (!ce) {
return 0;
} else {
zval *action, *render, *ret = NULL;
char *action_lower, *func_name, *view_dir;
uint func_name_len;
yaf_controller_t *icontroller;
//实例化controoller对象
MAKE_STD_ZVAL(icontroller);
object_init_ex(icontroller, ce);
yaf_controller_construct(ce, icontroller, request, response, view, NULL TSRMLS_CC);
if (EG(exception)) {
zval_ptr_dtor(&icontroller);
return 0;
}
//获取view路径，如果这个is_def_module为1
//则取默认的views目录，如果为0，则取 modules/model/views 这个目录
if (is_def_module) {
spprintf(&view_dir, 0, "%s%c%s", app_dir, DEFAULT_SLASH, "views");
} else {
spprintf(&view_dir, 0, "%s%c%s%c%s%c%s", app_dir, DEFAULT_SLASH, "modules", DEFAULT_SLASH, Z_STRVAL_P(module), DEFAULT_SLASH, "views");
}
if (YAF_G(view_directory)) {
efree(YAF_G(view_directory));
}
YAF_G(view_directory) = view_dir;
zend_update_property(ce, icontroller, ZEND_STRL(YAF_CONTROLLER_PROPERTY_NAME_NAME), controller TSRMLS_CC);
//获取action
action = zend_read_property(request_ce, request, ZEND_STRL(YAF_REQUEST_PROPERTY_NAME_ACTION), 1 TSRMLS_CC);
action_lower = zend_str_tolower_dup(Z_STRVAL_P(action), Z_STRLEN_P(action));
/* because the action might call the forward to override the old action */
Z_ADDREF_P(action);
//拼接一个action函数名
func_name_len = spprintf(&func_name, 0, "%s%s", action_lower, "action");
efree(action_lower);
//判断在controller对象里面是否有这个action函数，如 indexaction
if (zend_hash_find(&((ce)->function_table), func_name, func_name_len + 1, (void **)&fptr) == SUCCESS) {
//省略......
executor = icontroller;
//如果存在这个action函数则调用
zend_call_method(&icontroller, ce, NULL, func_name, func_name_len, &ret, 0, NULL, NULL TSRMLS_CC);
efree(func_name);
//省略......
//如果不存在这个action函数则按第二种action方式去获
//取看看在这个controller里面是否存在actions变量，因
//为有可能在这个actions数组变量里面记录所有的action
//类方法地址
} else if ((ce = yaf_dispatcher_get_action(app_dir, icontroller,
Z_STRVAL_P(module), is_def_module, Z_STRVAL_P(action), Z_STRLEN_P(action) TSRMLS_CC))
&& (zend_hash_find(&(ce)->function_table, YAF_ACTION_EXECUTOR_NAME,
sizeof(YAF_ACTION_EXECUTOR_NAME), (void **)&fptr) == SUCCESS)) {
//省略......
//实例化这个Action类
MAKE_STD_ZVAL(iaction);
object_init_ex(iaction, ce);
executor = iaction;
//省略......
//调用这个Action类里面的execute方法，可以看到这个方法是固定的
zend_call_method_with_0_params(&iaction, ce, NULL, "execute", &ret);
//省略......
} else {
efree(func_name);
zval_ptr_dtor(&icontroller);
return 0;
}
//下面这部分就是视图view自动渲染部分，不在详细分析了
if (executor) {
int auto_render = 1;
render = zend_read_property(ce, executor, ZEND_STRL(YAF_CONTROLLER_PROPERTY_NAME_RENDER), 1 TSRMLS_CC);
instantly_flush = zend_read_property(yaf_dispatcher_ce, dispatcher, ZEND_STRL(YAF_DISPATCHER_PROPERTY_NAME_FLUSH), 1 TSRMLS_CC);
if (render == EG(uninitialized_zval_ptr)) {
render = zend_read_property(yaf_dispatcher_ce, dispatcher, ZEND_STRL(YAF_DISPATCHER_PROPERTY_NAME_RENDER), 1 TSRMLS_CC);
auto_render = Z_BVAL_P(render);
} else if (Z_TYPE_P(render) <= IS_BOOL && !Z_BVAL_P(render)) {
auto_render = 0;
}
//是否自动渲染view
if (auto_render) {
ret = NULL;
if (!Z_BVAL_P(instantly_flush)) {
zend_call_method_with_1_params(&executor, ce, NULL, "render", &ret, action);
zval_ptr_dtor(&executor);
if (!ret) {
zval_ptr_dtor(&action);
return 0;
} else if (IS_BOOL == Z_TYPE_P(ret) && !Z_BVAL_P(ret)) {
zval_ptr_dtor(&ret);
zval_ptr_dtor(&action);
return 0;
}
if (Z_TYPE_P(ret) == IS_STRING && Z_STRLEN_P(ret)) {
yaf_response_alter_body(response, NULL, 0, Z_STRVAL_P(ret), Z_STRLEN_P(ret), YAF_RESPONSE_APPEND TSRMLS_CC);
}
zval_ptr_dtor(&ret);
} else {
zend_call_method_with_1_params(&executor, ce, NULL, "display", &ret, action);
zval_ptr_dtor(&executor);
if (!ret) {
zval_ptr_dtor(&action);
return 0;
}
if ((Z_TYPE_P(ret) == IS_BOOL && !Z_BVAL_P(ret))) {
zval_ptr_dtor(&ret);
zval_ptr_dtor(&action);
return 0;
}
zval_ptr_dtor(&ret);
}
} else {
zval_ptr_dtor(&executor);
}
}
zval_ptr_dtor(&action);
}
return 1;
}
return 0;
}
yaf_dispatcher_get_controller() 获取 controller 类
zend_class_entry * yaf_dispatcher_get_controller(char* app_dir, char *module, char *controller, int len, int def_module TSRMLS_DC) {
char *directory = NULL;
int directory_len = 0;
//这块之前说过，如果def_module等于1走默认的路径
//如果等于0则走modules下的路径
if (def_module) {
// directory = app_dir/controllers
directory_len = spprintf(&directory, 0, "%s%c%s", app_dir, DEFAULT_SLASH, YAF_CONTROLLER_DIRECTORY_NAME);
} else {
// directory = app_dir/modules/model/controllers
directory_len = spprintf(&directory, 0, "%s%c%s%c%s%c%s", app_dir, DEFAULT_SLASH,
YAF_MODULE_DIRECTORY_NAME, DEFAULT_SLASH, module, DEFAULT_SLASH, YAF_CONTROLLER_DIRECTORY_NAME);
}
if (directory_len) {
char *class = NULL;
char *class_lowercase = NULL;
int class_len = 0;
zend_class_entry **ce = NULL;
// 这里根据配置区分前缀模式还是后缀模式
// Controller_Index 或者 Index_Controller
// ControllerIndex 或者 IndexController
if (YAF_G(name_suffix)) {
class_len = spprintf(&class, 0, "%s%s%s", controller, YAF_G(name_separator), "Controller");
} else {
class_len = spprintf(&class, 0, "%s%s%s", "Controller", YAF_G(name_separator), controller);
}
//转小写
class_lowercase = zend_str_tolower_dup(class, class_len);
//是否存在这个Controller类
if (zend_hash_find(EG(class_table), class_lowercase, class_len + 1, (void **)&ce) != SUCCESS) {
//加载这个Controller类
if (!yaf_internal_autoload(controller, len, &directory TSRMLS_CC)) {
yaf_trigger_error(YAF_ERR_NOTFOUND_CONTROLLER TSRMLS_CC, "Failed opening controller script %s: %s", directory, strerror(errno));
efree(class);
efree(class_lowercase);
efree(directory);
return NULL;
//获取这个Controller类指针
} else if (zend_hash_find(EG(class_table), class_lowercase, class_len + 1, (void **) &ce) != SUCCESS) {
yaf_trigger_error(YAF_ERR_AUTOLOAD_FAILED TSRMLS_CC, "Could not find class %s in controller script %s", class, directory);
efree(class);
efree(class_lowercase);
efree(directory);
return 0;
//判断是否继承 Yaf_Controller_Abstract
} else if (!instanceof_function(*ce, yaf_controller_ce TSRMLS_CC)) {
yaf_trigger_error(YAF_ERR_TYPE_ERROR TSRMLS_CC, "Controller must be an instance of %s", yaf_controller_ce->name);
efree(class);
efree(class_lowercase);
efree(directory);
return 0;
}
}
efree(class);
efree(class_lowercase);
efree(directory);
return *ce;
}
return NULL;
}
yaf_dispatcher_get_action() 获取 action 类
zend_class_entry * yaf_dispatcher_get_action(char *app_dir, yaf_controller_t *controller, char *module, int def_module, char *action, int len TSRMLS_DC) {
zval **ppaction, *actions_map;
//获取actions数组
actions_map = zend_read_property(Z_OBJCE_P(controller), controller, ZEND_STRL(YAF_CONTROLLER_PROPERTY_NAME_ACTIONS), 1 TSRMLS_CC);
if (IS_ARRAY == Z_TYPE_P(actions_map)) {
zend_class_entry **ce;
uint class_len;
char *class_name, *class_lowercase;
char *action_upper = estrndup(action, len);
//将action名字首字母转为大写
*(action_upper) = toupper(*action_upper);
//前后缀模式
//Index_Action 或 Action_Index
//IndexAction 或 ActionIndex
if (YAF_G(name_suffix)) {
class_len = spprintf(&class_name, 0, "%s%s%s", action_upper, YAF_G(name_separator), "Action");
} else {
class_len = spprintf(&class_name, 0, "%s%s%s", "Action", YAF_G(name_separator), action_upper);
}
//类名转换为小写
class_lowercase = zend_str_tolower_dup(class_name, class_len);
//是否存在这个Action类
if (zend_hash_find(EG(class_table), class_lowercase, class_len + 1, (void **) &ce) == SUCCESS) {
efree(action_upper);
efree(class_lowercase);
//是否继承Yaf_Action_Abstract
if (instanceof_function(*ce, yaf_action_ce TSRMLS_CC)) {
efree(class_name);
return *ce;
} else {
yaf_trigger_error(YAF_ERR_TYPE_ERROR TSRMLS_CC, "Action %s must extends from %s", class_name, yaf_action_ce->name);
efree(class_name);
return NULL;
}
}
//在数组中找到对应的key（action名称）
if (zend_hash_find(Z_ARRVAL_P(actions_map), action, len + 1, (void **)&ppaction) == SUCCESS) {
char *action_path;
uint action_path_len;
//把值（后面的文件路径）赋给action_path
//也就是得到了action类所在的文件了
action_path_len = spprintf(&action_path, 0, "%s%c%s", app_dir, DEFAULT_SLASH, Z_STRVAL_PP(ppaction));
//导入这个类文件
if (yaf_loader_import(action_path, action_path_len, 0 TSRMLS_CC)) {
//action类是否存在
if (zend_hash_find(EG(class_table), class_lowercase, class_len + 1, (void **) &ce) == SUCCESS) {
efree(action_path);
efree(action_upper);
efree(class_lowercase);
//是否继承Yaf_Action_Abstract
if (instanceof_function(*ce, yaf_action_ce TSRMLS_CC)) {
efree(class_name);
//返回Action类指针
return *ce;
} else {
yaf_trigger_error(YAF_ERR_TYPE_ERROR TSRMLS_CC, "Action %s must extends from %s", class_name, yaf_action_ce->name);
efree(class_name);
}
} else {
yaf_trigger_error(YAF_ERR_NOTFOUND_ACTION TSRMLS_CC, "Could not find action %s in %s", class_name, action_path);
}
efree(action_path);
efree(action_upper);
efree(class_name);
efree(class_lowercase);
} else {
yaf_trigger_error(YAF_ERR_NOTFOUND_ACTION TSRMLS_CC, "Failed opening action script %s: %s", action_path, strerror(errno));
efree(action_path);
}
} else {
yaf_trigger_error(YAF_ERR_NOTFOUND_ACTION TSRMLS_CC, "There is no method %s%s in %s::$%s",
action, "Action", Z_OBJCE_P(controller)->name, YAF_CONTROLLER_PROPERTY_NAME_ACTIONS);
}
} else if (YAF_G(st_compatible)) {
//省略.....
//这部分不说了，大概就是在 actions 里面没有找到这个action的路径
//那么就尝试自己拼接路径去加载
if (def_module) {
spprintf(&directory, 0, "%s%c%s", app_dir, DEFAULT_SLASH, "actions");
} else {
spprintf(&directory, 0, "%s%c%s%c%s%c%s", app_dir, DEFAULT_SLASH,
"modules", DEFAULT_SLASH, module, DEFAULT_SLASH, "actions");
}
//省略.....
}
}
上面也看到action的路径是按照你所填写的映射中地址加载，但是类名却是action的名称拼接的，所以虽然类文件不需要按照Yaf的标准路径设定，但是类名必须和action一致，在这个环节可能会因为action的特殊性出现找不到类的问题.
Yaf 自动加载
在实例化 application 类的时候，内部会自动实例化一个 Yaf_Loader 对象，同时往内核注册了一个自动加载器 autoload 这里注册自动加载器也是用内核提供的 spl_autoload_register
yaf_loader_register() 注册自动加载器
int yaf_loader_register(yaf_loader_t *loader TSRMLS_DC) {
zval *autoload, *method, *function, *ret = NULL;
zval **params[1] = {&autoload};
//设置autoload为一个数组
MAKE_STD_ZVAL(autoload);
array_init(autoload);
#define YAF_AUTOLOAD_FUNC_NAME "autoload"
#define YAF_SPL_AUTOLOAD_REGISTER_NAME "spl_autoload_register"
//设置method = autoload
MAKE_STD_ZVAL(method);
ZVAL_STRING(method, YAF_AUTOLOAD_FUNC_NAME, 1);
//把loader对象添加到autoload数组里面
zend_hash_next_index_insert(Z_ARRVAL_P(autoload), &loader, sizeof(yaf_loader_t *), NULL);
//把method添加到autoload数组里面
zend_hash_next_index_insert(Z_ARRVAL_P(autoload), &method, sizeof(zval *), NULL);
//设置function = spl_autoload_register
MAKE_STD_ZVAL(function);
ZVAL_STRING(function, YAF_SPL_AUTOLOAD_REGISTER_NAME, 0);
//这里注册自动加载器跟php中调用spl_autoload_register形式几乎差不多
//spl_autoload_register(array(loader,autoload))
do {
zend_fcall_info fci = {
sizeof(fci),
EG(function_table),
function,
NULL,
&ret,
1,
(zval ***)params,
NULL,
1
};
// 调用 spl_autoload_register 注册
if (zend_call_function(&fci, NULL TSRMLS_CC) == FAILURE) {
if (ret) {
zval_ptr_dtor(&ret);
}
efree(function);
zval_ptr_dtor(&autoload);
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to register autoload function %s", YAF_AUTOLOAD_FUNC_NAME);
return 0;
}
if (ret) {
zval_ptr_dtor(&ret);
}
efree(function);
zval_ptr_dtor(&autoload);
} while (0);
return 1;
}
PHP_METHOD(yaf_loader, autoload) 自动加载器
PHP_METHOD(yaf_loader, autoload) {
char *class_name, *origin_classname, *app_directory, *directory = NULL, *file_name = NULL;
#ifdef YAF_HAVE_NAMESPACE
char *origin_lcname = NULL;
#endif
uint separator_len, class_name_len, file_name_len = 0;
//获取类名
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &class_name, &class_name_len) == FAILURE) {
return;
}
//分隔符长度
separator_len = YAF_G(name_separator_len);
//根目录
app_directory = YAF_G(directory);
origin_classname = class_name;
do {
if (!class_name_len) {
break;
}
//命名空间处理方式
#ifdef YAF_HAVE_NAMESPACE
{
int pos = 0;
origin_lcname = estrndup(class_name, class_name_len);
class_name = origin_lcname;
while (pos < class_name_len) {
if (*(class_name + pos) == '\\') {
*(class_name + pos) = '_';
}
pos += 1;
}
}
#endif
#define YAF_LOADER_RESERVERD "Yaf_"
//不允许类名Yaf打头
if (strncmp(class_name, YAF_LOADER_RESERVERD, YAF_LOADER_LEN_RESERVERD) == 0) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "You should not use '%s' as class name prefix", YAF_LOADER_RESERVERD);
}
#define YAF_LOADER_MODEL "Model"
//是否属于Model类
if (yaf_loader_is_category(class_name, class_name_len, YAF_LOADER_MODEL, YAF_LOADER_LEN_MODEL TSRMLS_CC)) {
#define YAF_MODEL_DIRECTORY_NAME "models"
//获取类文件的路径
//app_directory/models
spprintf(&directory, 0, "%s/%s", app_directory, YAF_MODEL_DIRECTORY_NAME);
//获取文件名字的长度，减去分隔符和后缀Index_Model
file_name_len = class_name_len - separator_len - YAF_LOADER_LEN_MODEL;
//是否配置后缀式
if (YAF_G(name_suffix)) {
//获取文件名字
file_name = estrndup(class_name, file_name_len);
} else {
//获取文件名字
file_name = estrdup(class_name + YAF_LOADER_LEN_MODEL + separator_len);
}
break;
}
#define YAF_LOADER_PLUGIN "Plugin"
//是否属于plugin类，流程跟上面一样
if (yaf_loader_is_category(class_name, class_name_len, YAF_LOADER_PLUGIN, YAF_LOADER_LEN_PLUGIN TSRMLS_CC)) {
//获取类文件的路径
//app_directory/plugins
spprintf(&directory, 0, "%s/%s", app_directory, YAF_PLUGIN_DIRECTORY_NAME);
file_name_len = class_name_len - separator_len - YAF_LOADER_LEN_PLUGIN;
if (YAF_G(name_suffix)) {
file_name = estrndup(class_name, file_name_len);
} else {
file_name = estrdup(class_name + YAF_LOADER_LEN_PLUGIN + separator_len);
}
break;
}
#define YAF_LOADER_CONTROLLER "Controller"
//是否属于Controller类，流程跟上面一样
if (yaf_loader_is_category(class_name, class_name_len, YAF_LOADER_CONTROLLER, YAF_LOADER_LEN_CONTROLLER TSRMLS_CC)) {
//获取类文件的路径
//app_directory/controllers
//可以看到这里只能获取Controllers目录下的控制器
//不能获取models/model/controllers/这种形式
spprintf(&directory, 0, "%s/%s", app_directory, YAF_CONTROLLER_DIRECTORY_NAME);
file_name_len = class_name_len - separator_len - YAF_LOADER_LEN_CONTROLLER;
if (YAF_G(name_suffix)) {
file_name = estrndup(class_name, file_name_len);
} else {
file_name = estrdup(class_name + YAF_LOADER_LEN_CONTROLLER + separator_len);
}
break;
}
/* {{{ This only effects internally */
if (YAF_G(st_compatible) && (strncmp(class_name, YAF_LOADER_DAO, YAF_LOADER_LEN_DAO) == 0
|| strncmp(class_name, YAF_LOADER_SERVICE, YAF_LOADER_LEN_SERVICE) == 0)) {
/* this is a model class */
spprintf(&directory, 0, "%s/%s", app_directory, YAF_MODEL_DIRECTORY_NAME);
}
/* }}} */
file_name_len = class_name_len;
file_name = class_name;
} while(0);
if (!app_directory && directory) {
efree(directory);
#ifdef YAF_HAVE_NAMESPACE
if (origin_lcname) {
efree(origin_lcname);
}
#endif
if (file_name != class_name) {
efree(file_name);
}
php_error_docref(NULL TSRMLS_CC, E_WARNING,
"Couldn't load a framework MVC class without an %s initializing", yaf_application_ce->name);
RETURN_FALSE;
}
if (!YAF_G(use_spl_autoload)) {
//加载这个类
if (yaf_internal_autoload(file_name, file_name_len, &directory TSRMLS_CC)) {
//把类名转成小写
char *lc_classname = zend_str_tolower_dup(origin_classname, class_name_len);
//是否存在这个类，如果存在则代表加载成功
if (zend_hash_exists(EG(class_table), lc_classname, class_name_len + 1)) {
#ifdef YAF_HAVE_NAMESPACE
if (origin_lcname) {
efree(origin_lcname);
}
#endif
if (directory) {
efree(directory);
}
if (file_name != class_name) {
efree(file_name);
}
efree(lc_classname);
//返回成功
RETURN_TRUE;
} else {
efree(lc_classname);
php_error_docref(NULL TSRMLS_CC, E_STRICT, "Could not find class %s in %s", class_name, directory);
}
} else {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed opening script %s: %s", directory, strerror(errno));
}
#ifdef YAF_HAVE_NAMESPACE
if (origin_lcname) {
efree(origin_lcname);
}
#endif
if (directory) {
efree(directory);
}
if (file_name != class_name) {
efree(file_name);
}
RETURN_TRUE;
} else {
//跟上面流程差不多
char *lower_case_name = zend_str_tolower_dup(origin_classname, class_name_len);
if (yaf_internal_autoload(file_name, file_name_len, &directory TSRMLS_CC) &&
zend_hash_exists(EG(class_table), lower_case_name, class_name_len + 1)) {
#ifdef YAF_HAVE_NAMESPACE
if (origin_lcname) {
efree(origin_lcname);
}
#endif
if (directory) {
efree(directory);
}
if (file_name != class_name) {
efree(file_name);
}
efree(lower_case_name);
RETURN_TRUE;
}
#ifdef YAF_HAVE_NAMESPACE
if (origin_lcname) {
efree(origin_lcname);
}
#endif
if (directory) {
efree(directory);
}
if (file_name != class_name) {
efree(file_name);
}
efree(lower_case_name);
RETURN_FALSE;
}
}
yaf_internal_autoload() 加载类文件
int yaf_internal_autoload(char *file_name, uint name_len, char **directory TSRMLS_DC) {
zval *library_dir, *global_dir;
char *q, *p, *seg;
uint seg_len, directory_len, status;
char *ext = YAF_G(ext);
smart_str buf = {0};
//判断传递的路径是否为空
//如果为空则代表要加载的类文件不属于yaf框架规定的目录
//有可能是公共库文件目录
if (NULL == *directory) {
char *library_path;
uint library_path_len;
yaf_loader_t *loader;
loader = yaf_loader_instance(NULL, NULL, NULL TSRMLS_CC);
if (!loader) {
/* since only call from userspace can cause loader is NULL, exception throw will works well */
php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s need to be initialize first", yaf_loader_ce->name);
return 0;
} else {
//获取本地类库地址
library_dir = zend_read_property(yaf_loader_ce, loader, ZEND_STRL(YAF_LOADER_PROPERTY_NAME_LIBRARY), 1 TSRMLS_CC);
//获取全局类库地址
global_dir = zend_read_property(yaf_loader_ce, loader, ZEND_STRL(YAF_LOADER_PROPERTY_NAME_GLOBAL_LIB), 1 TSRMLS_CC);
//判断类名前缀是否已经注册过，如果已经注册过则在本地类库去找
//就是调用 Yaf_Loader::registerLocalNamespace() 注册
//如果不注册的话全部去公共类库下寻找
if (yaf_loader_is_local_namespace(loader, file_name, name_len TSRMLS_CC)) {
library_path = Z_STRVAL_P(library_dir);
library_path_len = Z_STRLEN_P(library_dir);
} else {
library_path = Z_STRVAL_P(global_dir);
library_path_len = Z_STRLEN_P(global_dir);
}
}
if (NULL == library_path) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s requires %s(which set the library_directory) to be initialized first", yaf_loader_ce->name, yaf_application_ce->name);
return 0;
}
smart_str_appendl(&buf, library_path, library_path_len);
} else {
smart_str_appendl(&buf, *directory, strlen(*directory));
efree(*directory);
}
directory_len = buf.len;
/* aussume all the path is not end in slash */
smart_str_appendc(&buf, DEFAULT_SLASH);
//如果这个文件名或者类名是这种形式的Service_Http_Post
//下面这段代码就会把这个类名切分成路径
//directory/Service/Http/Post.php 这样
p = file_name;
q = p;
while (1) {
while(++q && *q != '_' && *q != '\0');
if (*q != '\0') {
seg_len = q - p;
seg = estrndup(p, seg_len);
smart_str_appendl(&buf, seg, seg_len);
efree(seg);
smart_str_appendc(&buf, DEFAULT_SLASH);
p = q + 1;
} else {
break;
}
}
if (YAF_G(lowcase_path)) {
/* all path of library is lowercase */
zend_str_tolower(buf.c + directory_len, buf.len - directory_len);
}
smart_str_appendl(&buf, p, strlen(p));
smart_str_appendc(&buf, '.');
smart_str_appendl(&buf, ext, strlen(ext));
smart_str_0(&buf);
if (directory) {
*(directory) = estrndup(buf.c, buf.len);
}
//这里最后把类文件导入并调用内核接口进行编译
status = yaf_loader_import(buf.c, buf.len, 0 TSRMLS_CC);
smart_str_free(&buf);
if (!status)
return 0;
return 1;
}
结束
上面介绍的大致就是 Yaf 框架一个运行流程，并且把框架的主要代码都分析了一遍，可以以此作为引导，在阅读分析源码的时候可以边看源码边对照 Yaf 框架官方文档 或者在用Yaf框架搭建一个环境，运行下，在对照源码分析即可。
