ThinkPHP3.2应用扩展

Published on 2016 - 11 - 28

ThinkPHP的类库主要包括公共类库和应用类库,都是基于命名空间进行定义和扩展的。只要按照规范定义,都可以实现自动加载。

类库扩展

公共类库

公共类库通常是指ThinkPHP/Library目录下面的类库,例如:

Think目录:系统核心类库
Org目录:第三方公共类库

这些目录下面的类库都可以自动加载,你只要把相应的类库放入目录中,然后添加或者修改命名空间定义。 你可以在Org/Util/目录下面添加一个Image.class.php 文件,然后添加命名空间如下:

namespace Org\Util;
class Image {
}

这样,就可以用下面的方式直接实例化Image类了:

$image = new \Org\Util\Image;

除了这些目录之外,你完全可以在ThinkPHP/Library目录下面添加自己的类库目录,例如,我们添加一个Com目录用于企业类库扩展:
Com\Sina\App类(位于Com/Sina/App.class.php )

namespace Com\Sina;
class App {
}

Com\Sina\Rank类(位于Com/Sina/Rank.class.php)

namespace Com\Sina;
class Rank {
}

公共类库除了在系统的Library目录之外,还可以自定义其他的命名空间,我们只需要注册一个新的命名空间,在应用或者模块配置文件中添加下面的设置参数:

'AUTOLOAD_NAMESPACE' => array(
    'Lib'     => APP_PATH.'Lib',
)

我们在应用目录下面创建了一个Lib目录用于放置公共的Lib扩展,如果我们要把上面两个类库放到Lib\Sina目录下面,只需要调整为:

Lib\Sina\App类(位于Lib/Sina/App.class.php )

namespace Lib\Sina;
class App {
}

Lib\Sina\Rank类(位于Lib/Sina/Rank.class.php)

namespace Lib\Sina;
class Rank {
}

如果你的类库没有采用命名空间的话,需要使用import方法先加载类库文件,然后再进行实例化,例如: 我们定义了一个Counter类(位于Com/Sina/Util/Counter.class.php):

class Counter {
}

在使用的时候,需要按下面方式调用:

import('Com.Sina.Util.Couter');
$object = new \Counter();

应用类库

应用类库通常是在应用或者模块目录下面的类库,应用类库的命名空间一般就是模块的名称为根命名空间,例如: Home\Model\UserModel类(位于Application\Home\Model)

namespace Home\Model;
use Think\Model;
class UserModel extends Model{
}

Common\Util\Pay类(位于Application\Common\Util)

namespace Common\Util;
class Pay {
}

Admin\Api\UserApi类(位于Application\Admin\Api)

namespace Admin\Api;
use Think\Model;
class UserApi extends Model{
}

记住一个原则,命名空间的路径和实际的文件路径对应的话 就可以实现直接实例化的时候自动加载。

驱动扩展

这里说的驱动扩展是一种泛指,ThinkPHP采用驱动式设计,很多功能的扩展都是基于驱动的思想,包括数据库驱动、缓存驱动、标签库驱动和模板引擎驱动等。

事实上,每个类库都可以设计自己的驱动,因此3.2版本的驱动目录没有独立出来,而是放到各个类库的命名空间下面,例如:Think\Log类的驱动放到 Think\Log\Driver 命名空间下面,Think\Db类的驱动放到了 Think\Db\Driver 命名空间下面。

当然,这只是建议的位置,你完全可以根据项目的需要,把自己的驱动独立存放,例如: Home\Driver\Cache\Sae.class.php 则是一种把Cache驱动独立存放的方式(内置的核心类库都支持给驱动指定单独的命名空间)。

缓存驱动

缓存驱动默认位于Think\Cache\Driver命名空间下面,目前已经提供了包括APC、Db、Memcache、Shmop、Sqlite、Redis、Eaccelerator和Xcache缓存方式的驱动扩展,缓存驱动必须继承Think\Cache类,并实现下面的驱动接口:

方法说明 接口方法
架构方法 __construct($options='')
读取缓存 get($name)
写入缓存 set($name,$value,$expire=null)
删除缓存 rm($name)
清空缓存 clear()

下面是一个典型的缓存驱动类定义:

namespace Think\Cache\Driver;
use Think\Cache;
/**
 * Test缓存驱动
 */
class Test extends Cache {
    /**
     * 读取缓存
     * @access public
     * @param string $name 缓存变量名
     * @return mixed
     */
     public function get($name) {
        // 获取名称为name的缓存
     }
    /**
     * 写入缓存
     * @access public
     * @param string $name 缓存变量名
     * @param mixed $value  存储数据
     * @param integer $expire  有效时间(秒)
     * @return boolean
     */
     public function set($name, $value, $expire = null) {
        // 设置缓存
     }
    /**
     * 删除缓存
     * @access public
     * @param string $name 缓存变量名
     * @return boolean
     */
     public function rm($name) {
        // 删除名称为name的缓存
     }

    /**
     * 清除缓存
     * @access public
     * @return boolean
     */
    public function clear() {
        // 清空缓存
    }
}

注意:缓存驱动的有效期参数约定,如果设置为0 则表示永久缓存。

如果要让缓存驱动支持缓存队列功能,需要在缓存接口的set操作方法设置成功后添加如下代码:

if($this->options['length']>0) {
       // 记录缓存队列
       $this->queue($name);
 }

要配置当前默认的缓存驱动类型可以使用CACHE_TYPE参数,例如:

'CACHE_TYPE'=>'test'

数据库驱动

默认的数据库驱动位于Think\Db\Driver命名空间下面,驱动类必须继承Think\Db类,每个数据库驱动必须要实现的接口方法包括(具体参数可以参考现有的数据库驱动类库):

驱动方法 方法说明
架构方法 __construct($config='')
数据库连接方法 connect($config='',$linkNum=0,$force=false)
释放查询方法 free()
查询操作方法 query($str)
执行操作方法 execute($str)
开启事务方法 startTrans()
事务提交方法 commit()
事务回滚方法 rollback()
获取查询数据方法 getAll()
获取字段信息方法 getFields($tableName)
获取数据库的表 getTables($dbName='')
关闭数据库方法 close()
获取错误信息方法 error()
SQL安全过滤方法 escapeString($str)

数据库的CURD接口方法(通常这些方法无需重新定义)

方法 说明
写入 insert($data,$options=array(),$replace=false)
更新 update($data,$options)
删除 delete($options=array())
查询 select($options=array())

介于不同数据库的查询方法存在区别,所以经常需要对查询的语句进行重新定义,这就需要修改针对查询的selectSql属性。该属性定义了当前数据库驱动的查询表达式,默认的定义是:

'SELECT%DISTINCT% %FIELD% FROM %TABLE%%JOIN%%WHERE%%GROUP%%HAVING%%ORDER%%LIMIT% %UNION%'

驱动可以更改或者删除个别查询定义,或者更改某个替换字符串的解析方法,这些方法包括:

方法名 说明 对应
parseTable 数据库表名解析 %TABLE%
parseWhere 数据库查询条件解析 %WHERE%
parseLimit 数据库查询Limit解析 %LIMIT%
parseJoin 数据库JOIN查询解析 %JOIN%
parseOrder 数据库查询排序解析 %ORDER%
parseGroup 数据库group查询解析 %GROUP%
parseHaving 数据库having解析 %HAVING%
parseDistinct 数据库distinct解析 %DISTINCT%
parseUnion 数据库union解析 %UNION%
parseField 数据库字段解析 %FIELD%

驱动的其他方法根据自身驱动需要和特性进行添加,例如,有些数据库的特殊性,需要覆盖父类Db类中的解析和过滤方法,包括:

方法名 说明
parseKey 数据库字段名解析
parseValue 数据库字段值解析
parseSet 数据库set分析
parseLock 数据库锁机制

定义了驱动扩展后,需要使用的时候,设置相应的数据库类型即可:

'DB_TYPE'=>'odbc', // 数据库类型配置不区分大小写

日志驱动

日志驱动默认的命名空间位于Think\Log\Driver,驱动类需要实现的接口方法包括:

方法 说明
架构方法 __construct($config=array())
写入方法 write($log,$destination='')

日志驱动只需要实现写入方法即可,log参数是日志信息字符串。

Session驱动

默认的session驱动的命名空间是Think\Session\Driver,并实现下面的驱动接口:

方法说明 接口方法
打开Session open($savePath, $sessionName)
关闭Session close()
读取Session read($id)
写入Session write($id, $data)
删除Session destory($id)
Session 过期回收 gc($maxlifetime)

假设我们实现了一个Db类型的session驱动,那么只需要在配置文件中使用:

'SESSION_TYPE'=>'Db'
// 或者
'SESSION_OPTIONS'=>array(
    'type'=>'Db',
)

系统在初始化Session的时候会自动处理,采用Db机制来处理session。

存储驱动

存储驱动完成了不同环境下面的文件存取操作,也是ThinkPHP支持分布式和云平台的基础。

默认的存储驱命名空间位于Think\Storage\Driver,每个存储驱动必须继承Think\Storage,并且实现下列接口方法(具体参数可以参考现有的存储驱动类库):

驱动方法 方法说明
架构方法 __construct($config='')
读取文件内容 read($filename,$type='')
写文件 put($filename,$content,$type='')
文件追加 append($filename,$content,$type='')
加载文件 load($filename,$vars=null,$type='')
判断文件是否存在 has($filename,$type='')
删除文件 unlink($filename,$type='')
读取文件信息 get($filename,$name,$type='')

其中type参数是为了区分不同的读写场景而设置的。

目前使用到的场景包括 runtime(用于编译缓存的文件操作)、html(用于静态缓存的文件操作)和F(用于F函数的文件操作)。

要使用自己定义的存储驱动的话,需要在应用入口文件定义:

define('STORAGE_TYPE',  'MyStorage');

存储类型的特殊性决定了我们只能在入口文件中改变存储类型。

模板引擎驱动

模板引擎驱动完成了第三方模板引擎的支持,通过定义模板引擎驱动,我们可以支持Smarty、TemplateLite、SmartTemplate和EaseTemplate等第三方模板引擎。

默认的模板引擎驱动的命名空间位于 Think\Template\Driver,需要实现的接口方法只有一个 fetch($templateFile,$var) 用于渲染模板文件并输出。

下面是一个Smarty模板引擎扩展的示例:

namespace Think\Template\Driver;
class Smarty {

    /**
     * 渲染模板输出
     * @access public
     * @param string $templateFile 模板文件名
     * @param array $var 模板变量
     * @return void
     */
    public function fetch($templateFile,$var) {
        $templateFile   =   substr($templateFile,strlen(THEME_PATH));
        vendor('Smarty.Smarty#class');
        $tpl            =   new \Smarty();
        $tpl->caching       = C('TMPL_CACHE_ON');
        $tpl->template_dir  = THEME_PATH;
        $tpl->compile_dir   = CACHE_PATH ;
        $tpl->cache_dir     = TEMP_PATH ;        
        if(C('TMPL_ENGINE_CONFIG')) {
            $config  =  C('TMPL_ENGINE_CONFIG');
            foreach ($config as $key=>$val){
                $tpl->{$key}   =  $val;
            }
        }
        $tpl->assign($var);
        $tpl->display($templateFile);
        }
    }

如果要使用Smarty模板引擎的话,只需要配置

'TMPL_ENGINE_TYPE'=>'Smarty',
'TMPL_ENGINE_CONFIG'=>array(
    'plugins_dir'=>'./Application/Smarty/Plugins/',
),

标签库驱动

任何一个模板引擎的功能都不可能是为你量身定制的,具有一个良好的可扩展机制也是模板引擎的另外一个考量,Smarty采用的是插件方法来实现扩展,Think\Template由于采用了标签库技术,比Smarty提供了更为强大的定制功能,和Java的TagLibs一样可以支持自定义标签库和标签,每个标签都有独立的解析方法,所以可以根据标签库的定义规则来增加和修改标签解析规则。

在Think\Template中标签库的体现是采用XML命名空间的方式。每个标签库对应一个标签库驱动类,每个驱动类负责对标签库中的所有标签的解析。

标签库驱动类的作用其实就是把某个标签定义解析成为有效的模版文件(可以包括PHP语句或者HTML标签),标签库驱动的命名空间位于 Think\Template\TagLib,标签库驱动必须继承Think\Template\TagLib类,例如:

namespace Think\Template\Taglib;
use Think\Template\TagLib;
Class Test extends TagLib{
}

首先需要定义标签库的标签定义,标签定义包含了所有标签库中支持的所有标签,定义方式如下:

protected $tags   =  array(
  // 定义标签
 'input'    =>    array('attr'=>'type,name,id,value','close'=>0), // input标签
 'textarea' =>    array('attr'=>'name,id')
 );

标签库的所有支持标签都在tags属性中进行定义,tags属性是一个二维数组,每个元素就是一个标签定义,索引名就是标签名,采用小写定义,调用的时候不区分大小写。

每个标签定义支持的属性包括:

属性名 说明
attr 标签支持的属性列表,用逗号分隔
close 标签是否为闭合方式 (0闭合 1不闭合),默认为不闭合
level 标签的嵌套层次(只有不闭合的标签才有嵌套层次)
alias 标签别名

定义了标签属性后,就需要定义每个标签的解析方法了,每个标签的解析方法在定义的时候需要添加“_”前缀,传入两个参数,对应属性数组和内容字符串(针对非闭合标签)。必须返回标签的字符串解析输出,在标签解析类中可以调用模板类的实例。下面是一个input解析方法的定义:

// input标签解析
public function _input($tag,$content)   {
    $name   =   $tag['name'];
    $id    =    $tag['id'];
    $type   =   $tag['type'];
    $value   =   $this->autoBuildVar($tag['value']);
    $str = "<input type='".$type."' id='".$id."' name='".$name."' value='".$value."' />";
    return $str;
}
// textarea标签解析
public function _textarea($tag,$content)   {
    $name  =   $tag['name'];
    $id    =   $tag['id'];
    $str   =   '<textarea id="'.$id.'" name="'.$name.'">'.$content.'</textarea>';
    return $str;
}

定义好标签库扩展之后,我们就可以在模板中使用了,首先我们必须要告诉模板申明Test标签库,用taglib标签,例如:

<taglib name='Test' />

name属性支持申明多个标签库,用逗号分隔即可。申明Test标签库之后,就可以使用Test标签库中的所有标签库了,调用方式如下:

<test:input type='radio' id='test' name='mail' value='value' />
<test:textarea id="content" name="content">$value</test:textarea>

注意:调用扩展标签库的标签的时候,必须加上标签库的XML命名空间前缀。

Input标签定义value属性可以支持变量传入,所以value被认为是一个变量名,如果在控制器中已经给value模板变量赋值,例如:

$this->assign('value','my test value');

最后标签被模板引擎编译后,就会输出:

<input type='radio' id='test' name='mail' value='my test value' />
<textarea id="content" name="content">my test vale</textarea>

行为扩展

可参加设计模式中的CBD模式

Widge扩展

Widget扩展一般用于页面组件的扩展。

举个例子,我们在页面中实现一个分类显示的Widget,首先我们要定义一个Widget控制器层 CateWidget,如下:

namespace Home\Widget;
use Think\Controller;
class CateWidget extends Controller {
    public function menu(){
        echo 'menuWidget';
    }
}

然后,我们在模版中通过W方法调用这个Widget。

{:W('Cate/Menu')} 

执行后的输出结果是: menuWidget

传入参数

如果需要在调用Widget的时候 使用参数,可以这样定义:

namespace Home\Widget;
use Think\Controller;
class CateWidget extends Controller {
    public function menu($id,$name){
        echo $id.':'.$name;
    }
}

模版中的参数调用,使用:

{:W('Cate/Menu',array(5,'thinkphp'))} 

传入的参数是一个数组,顺序对应了menu方法定义的参数顺序。
则会输出

5:thinkphp

模板支持

Widget可以支持使用独立的模板,例如:

namespace Home\Widget;
use Think\Controller;
class CateWidget extends Controller {
    public function menu(){
        $menu = M('Cate')->getField('id,title');
        $this->assign('menu',$menu);
        $this->display('Cate:menu');
    }
}

CateWiget类渲染了一个模版文件 View/Cate/menu.html。 在menu.html模版文件中的用法:

<foreach name="menu" item="title">
{$key}:{$title}
</foreach>

应用模式

应用模式提供了对核心框架进行改造的机会,可以让你的应用适应更多的环境和不同的要求。

每个应用模式有自己的模式定义文件,用于配置当前模式需要加载的核心文件和配置文件,以及别名定义、行为扩展定义等等。根据模式定义文件的定义位置和入口是否需要定义模式,可以分为显式应用模式和隐含应用模式。

显式应用模式

显式应用模式的模式定义文件位于ThinkPHP\Mode目录,如果我们要增加一个应用模式,只需要在该目录下面定义一个模式定义文件即可,下面是一个典型的模式定义文件(lite.php):

return array(
    // 配置文件
    'config'    =>  array(
        THINK_PATH.'Conf/convention.php',   // 系统惯例配置
        CONF_PATH.'config.php',      // 应用公共配置
    ),

    // 别名定义
    'alias'     =>  array(
        'Think\Exception'         => CORE_PATH . 'Exception'.EXT,
        'Think\Model'             => CORE_PATH . 'Model'.EXT,
        'Think\Db'                => CORE_PATH . 'Db'.EXT,
        'Think\Cache'             => CORE_PATH . 'Cache'.EXT,
        'Think\Cache\Driver\File' => CORE_PATH . 'Cache/Driver/File'.EXT,
        'Think\Storage'           => CORE_PATH . 'Storage'.EXT,
    ),

    // 函数和类文件
    'core'      =>  array(
        MODE_PATH.'Lite/functions.php',
        COMMON_PATH.'Common/function.php',
        MODE_PATH . 'Lite/App'.EXT,
        MODE_PATH . 'Lite/Dispatcher'.EXT,
        MODE_PATH . 'Lite/Controller'.EXT,
        MODE_PATH . 'Lite/View'.EXT,
        CORE_PATH . 'Behavior'.EXT,
    ),
    // 行为扩展定义
    'tags'  =>  array(
   'view_parse'    =>  array(
            'Behavior\ParseTemplate', // 模板解析 支持PHP、内置模板引擎和第三方模板引擎
        ),
        'template_filter'=> array(
            'Behavior\ContentReplace', // 模板输出替换
        ),
    ),
);

我们在ThinkPHP/Mode/Lite目录下面创建functions.php函数库文件,以及App.class.php、Dispatcher.class.php、Controller.class.php和View.class.php,这些类都是针对我们新的应用模式定制的核心类,但是和标准模式的命名空间是一致的,也就是说都在Think命名空间下面。

ThinkPHP/Mode/Lite目录用于存放该应用模式下面的所有自定义文件。
应用模式定义文件定义好后,我们就可以在应用中使用该模式了,例如:

define('MODE_NAME','lite');
define('APP_PATH','./Application/');
require './ThinkPHP/ThinkPHP.php';

隐含应用模式

隐含应用模式的模式定义文件位于应用的配置目录下面 Application/Common/Conf/core.php,模式定义文件和显式应用模式的定义文件一样。 使用隐含应用模式的时候,不需要在入口文件中定义MODE_NAME,或者说存在隐含应用模式定义文件的时候,MODE_NAME定义无效。

注意:如果应用中定义的应用模式需要使用其他的存储类型,需要在入口文件中定义。

define('STORAGE_TYPE','Bae');

参考文档