joomla源代码探析(1)：准备工作
用Joomla 建站一段时间了，由于采用了1.5RC3版，建站过程中发现了不少的问题，为了解决这些问题，看了不少的源代码，打算写一下源代码的学习过程。
首先是准备工作，源代码的学习过程其实也是一个不断测试代码的过程，所以：
1、搭建一个测试网站，我建议在本机上架一个WAMP环境，嘿嘿，为什么选择WAMP，主要个人习惯了，做了6年的linux下的程序员，还是不习惯emacs，呵呵，windows下的编辑器好用。
2、搭建测试网站建议直接采用SVN下来的代码，在windows上装一个tortoiseSVN，就可以了，joomla SVN reposity的地址是 http:///svn/joomla/development/trunk
3、编辑器，我觉得挺重要的，我推荐使用 UE Studio ，用上你就知道了，能自动根据源码中的内容，生成类和函数的标签，你就不需要寻找document的生成器了。
4、搭建完成后，用UE建一个project ,导入源代码，时间有点点长，它在分析代买生成TAG，生成后，你就点击“标签”，就可以看到全部的类和函数，习惯了VC的编辑环境的人，肯定喜欢这个。
5、搜寻代码学习的资源，目前我也没找到，我只在http://dev. 上查看了framework的文章，中文资源似乎就更少了，我是说1.5版的，1.0版的有几个中文网站谈到部分的代码问题，但是我没仔细看过质量到底如何。
到现在位置，已经建立了研究环境，下一步就是“开始”
joomla源代码探析(2)：目录结构
测试网站搭建完毕，首先来熟悉一下，1.5RC3版的目录结构：
1、componets 所有安装的组件的，前端用户界面相关程序都在这里，每个组件一个子目录，通常是com_***
2、plugins 所有的插件，涉及的程序文件和模板文件，资源等等
3、modules 所以安装的模块相关的程序和资源
4、includes 涉及重要的类，定义等等
5、 languages，下面是所有的语言文件，新的规范是一种语言一个目录，比如英文就是en-GB，中文简体就是zh-CN，目录下是相应的语言定义文件，命名规则是 语种.组件名字（插件名字）.ini ，比如 zh-CN.com_showcase.ini zh-CN.plg-***.ini等等。
6、templates 没说的，一种模板一个目录
7、library 最重要的目录之一了，下面都是重要的类文件，子目录结构对应类名称，比如
jimport( 'joomla.environment.uri' );
那么对应的是 joomla/environment/uri.hp 文件
其他的cache,logs目录就不说了，以后用的到。
joomla源代码探析(3)：万源之源
万源之源，这个名字非常有意思，老是让我想起小时候，玩的那种圆圆的纸牌，在土地中玩的，用自己的纸牌把别人的打翻了就赢了别人的，大部分都是纸壳剪的，偶尔也有用油毡纸，或者石棉纸做的，通常把这种好的牌或者那种连赢了几次的纸牌作为自己的镇家宝贝，在牌背面上写上“保家之宝”，也有“宝家之宝”，我曾经留了几张一直到高三毕业。哈哈哈！现在不知道去那里了，也许父母还留着吧。
documentroot/index.php ，以及 templateindex.php ，可以称为万源之源，因为可以说所有的页面都是这两个文件的成果。
/index.php 是所有页面程序的起点，让我们来看看这个文件到底做了什么？
define( '_JEXEC', 1 ); //标志这是一个跟文件
define('JPATH_BASE', dirname(__FILE__) ); //取得Document root,就是 /index.php所在的绝对路径
define( 'DS', DIRECTORY_SEPARATOR ); // 定义目录分隔符
require_once ( JPATH_BASE .DS.'includes'.DS.'defines.php' ); //defines.php定义了一些目录变量，以后详细的写
require_once ( JPATH_BASE .DS.'includes'.DS.'framework.php' );
//framework.php是另一个非常重要的文件，在framework.php读入了config.php中定义的变量，同时
//framework中引入了一些的基础类，例如JFactory,JUser等等
//全局对象,工厂类JFactory,JFactory符合设计模式中的工厂模式，基本生成的对象大部分是单例模式，接下来我详细描述JFactory，JFactory 在/libraries/joomla/factory.php中定义，
$mainframe =& JFactory::getApplication('site');
//取得JApplication 对象，JApplication是一个工厂类，提供了一些指定对象的生成，并提供了一系列的api函数
//application初始化过程，设置语言，并缺的editor的设置，并生成Juser对象
$mainframe->initialise();
//引入system 组的插件
JPluginHelper::importPlugin('system');
// 触发初始化完毕后定义的pluging响应事件
$mainframe->triggerEvent('onAfterInitialise');
//route()函数，根据url生成进行解析，设置JRequest
$mainframe->route();
// authorization
$Itemid = JRequest::getInt( 'Itemid');
$mainframe->authorize($Itemid);
//触发route后plugin
JDEBUG ? $_PROFILER->mark('afterRoute') : null;
$mainframe->triggerEvent('onAfterRoute');
//根据JRequest的的option参数，dispatch到那个组件，也就决定页面的内容部分是那个组件生成
$option = JRequest::getCmd('option');
$mainframe->dispatch($option);
//触发dispatch后的plugin
JDEBUG ? $_PROFILER->mark('afterDispatch') : null;
$mainframe->triggerEvent('onAfterDispatch');
//页面的渲染过程，生成整个页面html
$mainframe->render();
// trigger the onAfterDisplay events
JDEBUG ? $_PROFILER->mark('afterRender') : null;
$mainframe->triggerEvent('onAfterRender');
echo JResponse::toString($mainframe->getCfg('gzip'));
以上是 /index.php的内容，从这个index.php的引出了几个重要的文件需要我们去注意
/includes/defines.php
/includes/framework.php
/libraries/joomla/application.php
/libraries/joomla/factory.php
接下来我们主要看看这些文件。
joomla源代码探析(4)：defines.php
其实这个文件没什么好说的，主要就是定义一些路径，贴出来，主要是以后文件中提这些路径的时候，有一个印象
$parts = explode( DS, JPATH_BASE );
//Defines
define( 'JPATH_ROOT', implode( DS, $parts ) );
define( 'JPATH_SITE', JPATH_ROOT );
define( 'JPATH_CONFIGURATION', JPATH_ROOT );
define( 'JPATH_ADMINISTRATOR', JPATH_ROOT.DS.'administrator' );
define( 'JPATH_XMLRPC', JPATH_ROOT.DS.'xmlrpc' );
define( 'JPATH_LIBRARIES', JPATH_ROOT.DS.'libraries' );
define( 'JPATH_PLUGINS', JPATH_ROOT.DS.'plugins' );
define( 'JPATH_INSTALLATION', JPATH_ROOT.DS.'installation' );
define( 'JPATH_THEMES' , JPATH_BASE.DS.'templates' );
define( 'JPATH_CACHE', JPATH_BASE.DS.'cache');
这些路径在以后的文件中经常用到。
joomla源代码探析(5)：framework.php
/include/framework.php 这个文件在index.php中是最早引入的文件之一，这个文件主要实现了一些基本类的引入，下面我们逐一看一下：
require_once( JPATH_LIBRARIES . DS . 'loader.php' ); //loader.php 是一个载入类的基本工作，最重要的是Jimport
比如 jimport( 'joomla.environment.response' ); 实际上就include_once /libaries/jooma/environment/response.php
require_once( JPATH_CONFIGURATION . DS . 'configuration.php' ); //引入了configuration.php
jimport( 'joomla.base.object' );
jimport( 'joomla.environment.request' );
JRequest::clean(); //清空Jrequest
// System configuration
$CONFIG = new JConfig(); //读取配置文件，生成Jconfig对象
if (JDEBUG) {
jimport( 'joomla.utilities.profiler' );
$_PROFILER =& JProfiler::getInstance( 'Application' );
}
以上这段主要是如果配置处于debug状态，那么就生成$_PROFILER,这个对象主要要用来，记录页面执行到某一节点的执行时间，内存状态调试信息。
jimport( 'joomla.environment.response' );
jimport( 'joomla.application.menu' ); //needs to be loaded later
jimport( 'joomla.user.user');
jimport( 'joomla.environment.uri' );
jimport( 'joomla.factory' );
jimport( 'joomla.methods' );
jimport( 'joomla.html.html' ); //needs to be loaded later
jimport( 'joomla.utilities.array' ); //needs to be loaded later
jimport( 'joomla.utilities.error' );
jimport( 'joomla.utilities.utility' );
jimport( 'joomla.utilities.string' ); //needs to be loaded later
jimport( 'joomla.filter.output' );
jimport( 'joomla.version' ); //needs to be loaded later
jimport( 'joomla.event.*');
这些引入的类中，比较重要的是 factory user menu ，需要仔细研究一下，其他的用的时候，再仔细看文档就行啦,
当然，methods也包含了很多基本的函数和类，尤其是需要了解SEF的时候。
接下来，我们将仔细看看/index.php中 $mainframe =& JFactory::getApplication('site') 这句话到底完成了什么工作。
Joomla源代码解析(6)：JDocument 类的几个常用的方法
在google搜索我的网站就会发现一些，因为没有注意meta和title 所有的开源项目相关的页面title和meta都一样，对用户很不友好，根本无法分清那个链接是说什么内容的，那么这里就需要JDocuement类来解决问题
用法很简单，首先取得document对象 $document =& JFactory::getDocument();
然后：
$document->setTitle(*****);
$document->setDescription(*****); //添加 meta
$document->addStyleSheet(*****) //添加CSS文件
$document->addScript(*****) //添加js脚本
$document->setLanguage(***) //设置语言文件
其他还有一些 setModifiedDate 等，其他基本就不常用了，记住这些就行啦！
Joomla源代码解析(7)：JFactory 类
JFactory类，正如其名，这是一个工厂类，应该是简单工厂模式的标准实现。这个类几个重要的函数分别返回几个重要的实例。
1、getACL 调用_createACL 返回 joomla.user.authorization 的实例，数据来源
2、getApplication 调用 joomla.application.application 的实例获取函数JApplication::getInstance，也就是我们在index.php中提到的 $mainframework
3、getConfig 调用 _createConfig 返回 joomla.registry.registry 实例，返回配置参数
4、getDBO 调用 _createDBO，返回数据连接JDatabase的实例，这个是以后扩展模块要经常用到的
5、getDocument 调用 _createDocument 根据请求的格式，返回JDocumentRaw或者JDocumentHtml实例
6、返回 Juser 实例
7、getLanguage 调用 _createLanguage 返回 joomla.i18n.language的实例，以后在多语言环境经常用到。
其他的比如getMailer，getCache 等就不在写了
Joomla源代码解析(8)：JDatabase 类
这是数据库connector类，封装了与数据库操作的一系列操作。目前有两个子类，JDatabaseMysql,JDatabaseMysqli，这个类为以后扩展到其他数据库留出了接口。
关于一些具体函数没有什么特殊的，基本对应mysql的函数的一些特征，对于这个类应用基本都是首先 setquery ，然后load
或者直接执行 executequery ,主要还是不要混淆load开头的几个函数的具体功能：
1、loadObject 以对象的形式返回结果集的第一行数据
2、loadObjectList 对应上一个函数，返回一个对象的集合
3、loadResult 返回第一行的第一个字段或者NULL
4、loadResultArray 返回某一字段的数据到一个数组中
5、loadRow 返回第一行数据，应该是数组形式
6、loadRowList 对应上一个函数，返回行数据的集合
还有一个函数很重要就是 setUTF ，这个函数决定了数据库能显示中文。
Joomla源代码解析(9)：JUser 类
user 类处理所有程序中与用户交互的相关事情。
这个类的构造函数调用load函数，输入的参数是用户id,可以初始化用户的相关信息，这些信息包括 aid ,gid,usertype,username,name,id等等，这些信息在扩展中经常用到。
同时，在程序中，用刚刚说过的getUser，取得当前登录用户实例。具体用法如下：
$user =& JFactory::getUser();
$userId = (int) $user->get('id');
根据gid 可以判断用户的相关的组以及组权限。
了解了Juser类，还需要了解一下 JUserHelper类，这个类包括了与用户活动相关的几个函数，比如获得随机密码以及取得加密密码等。
同样 getUserId 根据用户名取得用户ID 也是经常用到的。
Joomla源代码解析(10)：JPath JFile JFolder 类
这几个类都是filesystem包中的重要类，具体的使用看我在模块快速生成器中的代码，函数意义都非常明确：
if(JFolder::exists($targetpath)) JFolder::delete($targetpath);
JFolder::create($targetpath);
JFolder::create($targetpath.DS.'tmpl');
以上是目录使用的例子
$sfile=$sourcepath.DS.'index.html';
$tfile=$targetpath.DS.'index.html';
JFile::copy($sfile,$tfile);
$files[]=$tfile;
文件拷贝
$sfile=$sourcepath.DS.'helper.php';
$data=JFile::read($sfile);
$tfile = $targetpath.'/helper.php';
JFile::write($tfile,$data);
$files[]=$tfile;
unset($data);
文件读取和写入
Joomla源代码解析(11)：JHtml 类
JHtml 没有几个函数，但是在组成页面已经模板书写过程中经常用到，比如：
JHTML::_('date', $this->item->date, JText::_('DATE_FORMAT_LC5'))
以及在后台管理中常用到的
来看看这几个函数：
calendar 显示一个日历插件
date 显示格式化日期
iframe 插入一个iframe
image 插入一个图片
link 插入一个超链
以上是常用的函数，函数的以用方式就如例子。
Joomla源代码解析(12)：JToolBarHelper JToolBar 类
这个两个类是后台管理过程经常用到的，比如：
JToolBarHelper::title( JText::_( '{{component}} Manager' ), 'generic.png' );
JToolBarHelper::deleteList();
JToolBarHelper::editListX();
JToolBarHelper::addNewX();
这几句就添加了三个按钮，添加，删除，修改
其实还有几个常用的
preview //预览
publish //发布
cancel //取消
比较常用的就这几个了，主要是在后台管理toolbar上的按钮。相关按钮的动作对应后台管理的task，相应的对做要在controller中生命。
Joomla源代码解析(13)：JText类
Joomla 最常用的类之一，使用方式JTEXT::_('JJJJJ')
JJJJJ对应语言文件中的相应字符串。
为了实现多语言这个是常用的。当然如果你以utf-8字符集存储php文件，对于中文就不用考虑那么多了，不过不够规范喓。
要是只是自己用，也无所谓啦，开发要快点。
呵呵！推荐还是用吧！
Joomla源代码解析(14)：JRequest类
这是另一个Joomla扩展中最常用的类，这个类封装了客户端提交的请求相关的信息，通过这个类你可以得到用户提交的相关信息和数据，有几个重要的函数：
首先是get($hash),我们看看部分源码就知道，get得到什么了
switch ($hash)
{
case 'GET' :
$input = $_GET;
break;
case 'POST' :
$input = $_POST;
break;
case 'FILES' :
$input = $_FILES;
break;
case 'COOKIE' :
$input = $_COOKIE;
break;
case 'ENV' :
$input = &$_ENV;
break;
case 'SERVER' :
$input = &$_SERVER;
break;
default:
$input = $_REQUEST;
break;
}
我们通过get('post') 等取得用户提交的数据数组。
还有getVar ，取得某一request变量
getURI ，返回请求的URI
setVar和set 则对应着getVar 和get
在程序中使用的方式是：JRequest::getVar('','');
Joomla源代码解析(15)：组件是如何被调用并渲染的
Joomla代码中， 组件是如何被调用并渲染的呢？
在描述 /index.php的时候，我们看到根据option参数，$mainframework->dispatch()，就进入了组件的调用并渲染的过程，我们来看看JSite 的dispatch都做了什么工作。
dispatch 最关键的是这几句话：
$document->setTitle( $params->get('page_title') ); //设置标题
$document->setDescription( $params->get('page_description') ); //设置meta
$contents = JComponentHelper::renderComponent($component);
$document->setBuffer( $contents, 'component');
可以看到最为关键的是 JComponentHelper::renderComponent($component);
再看看这一行程序完成了那些工作
$task = JRequest::getString( 'task' );
// Build the component path
$name = preg_replace('/[^A-Z0-9_\.-]/i', '', $name);
$file = substr( $name, 4 );
// Define component path
define( 'JPATH_COMPONENT', JPATH_BASE.DS.'components'.DS.$name);
define( 'JPATH_COMPONENT_SITE', JPATH_SITE.DS.'components'.DS.$name);
define( 'JPATH_COMPONENT_ADMINISTRATOR', JPATH_ADMINISTRATOR.DS.'components'.DS.$name);
// get component path
if ( $mainframe->isAdmin() && file_exists(JPATH_COMPONENT.DS.'admin.'.$file.'.php') ) {
$path = JPATH_COMPONENT.DS.'admin.'.$file.'.php';
} else {
$path = JPATH_COMPONENT.DS.$file.'.php';
}
这部分实际上确定了那个compoent下的组件文件被引入，并取得了task,中间一部分兼容代码就不看了
我们来看关键代码：
ob_start();
require_once $path;
$contents = ob_get_contents();
ob_end_clean();
这部分代码就是包含了组件的开始文件，而这个文件，我们在组件开发的时候用到的。这个文件引入了controller 文件，并根据task决定进入那个分支。
再深入下去就是组件的整个生成过程，以后再看了。
Joomla源代码解析(16)：JTable是什么
JTable是什么？肯定不是对应html中的table ，在做com_helloworld的时候，没有仔细理解，后来一位同事问我Jmodel,JTable,JDatabase有什么区别？一时语塞
JTable 是数据库中数据表在程序中的表达，不知道这句话怎么说，其实JTable更对应着表中的一行，以及相应的操作。Joomla中的JTable**对应中数据库中 **表，我们在使用的时候要针对我们自己所使用的表扩展自己的JTable.我们需要关注的是JTable的函数checkin,checkout ,着两个函数对更新的数据进行合法性检查，我个人觉得对于数据完整性的检查应该放在Jtable的check中。
Jtable 比较常用的函数，看名字就明白了，记住几个吧：
delete,store,bind,load,setError等，具体还是需要用的时候看看源代码吧。
Joomla源代码解析(17)：JModel是什么
我们经常提到MVC模式，JModel在Joomla的MVC组件中是重要的一个环节，JModel是MVC中的数据视图层，我们需要明白的是 JModel不同于JTable，数据视图是由一个或者几个table构成，或者多条数据记录构成的数据集合，以及数据集合的相关操作，对于JModel 我们不必了解太多的具体函数，在组件开发过程中，通常都要继承JModel，在子类中完成数据集合的生成以及相关的操作，保存，删除。
我个人倾向对于几个表之间的数据完整性，要在JModel中验证，而对于单一表的数据完整性要通过JTable check函数完成。
同事对于那些有逻辑操作的验证则最好在MVC的 controller层完成。
Joomla源代码解析(18)：Jview
MVC模式中，重要的一环，JView 和 tmpl目录中的模板，共同决定了，页面html的代码，Jview是在Jmodel和template之间的桥梁。我们扩展做自己的组件，都需要扩展Jview的子类。这个类其实需要看看它的变量和函数也就理解：
跟数据相关的部分：
_defaultModel 默认的model ，可以通过 setModel 进行设置。同时function &get 可以从指定的model调用函数返回相应的数据
_models 存贮model的数组，getModel，可以从中返回指定的Model
assign assignref，数据赋值函数，这两个函数的任务是赋值变量给模板。
跟模板相关部分：
loadTemplate，setLayout，setLayoutExt 看名字就知道了
还有一个函数：display ,大部分的view子类都要继承这个。
Joomla源代码解析(19)：JController
同样 JController 是MVC中重要的起点，正式这个类决定的动作的下一步流向，我们来看看表格提交数据的典型的controller的代码：
function edit()
{
JRequest::setVar( 'view', 'hello' );
JRequest::setVar( 'layout', 'form' );
JRequest::setVar('hidemainmenu', 1);
parent::display();
}
function save()
{
$model = $this->getModel('hello');
if ($model->store($post)) {
$msg = JText::_( 'Greeting Saved!' );
} else {
$msg = JText::_( 'Error Saving Greeting' );
}
// Check the table in so it can be edited.... we are done with it anyway
$link = 'index.php?option=com_hello';
$this->setRedirect($link, $msg);
}
function remove()
{
$model = $this->getModel('hello');
if(!$model->delete()) {
$msg = JText::_( 'Error: One or More Greetings Could not be Deleted' );
} else {
$msg = JText::_( 'Greeting(s) Deleted' );
}
$this->setRedirect( 'index.php?option=com_hello', $msg );
}
function cancel()
{
$msg = JText::_( 'Operation Cancelled' );
$this->setRedirect( 'index.php?option=com_hello', $msg );
}
实际上 controller 跟提交的task参数，调用controller中的不同的函数，当然默认会调用display ，我觉得还需要记住的就是
getModel ，和setRedirect ，其余函数用到再看就可以了。
Joomla源代码解析(20)：MVC组件的执行
以前的文章中，我们曾经说过 $mainframework->dispatch 是如何最终调用组件的，通过这个dispatch，最终 include 相应组件目录下的 组件名称.php 文件，现在我们来看看，这个文件是怎么按部就班的联系了MVC模式相关的各个文件。
require_once (JPATH_COMPONENT.DS.'controller.php');
// Require specific controller if requested
if($controller = JRequest::getVar('controller')) {
require_once (JPATH_COMPONENT.DS.'controllers'.DS.$controller.'.php');
}
// Create the controller
$classname = 'HelloController'.$controller;
$controller = new $classname( );
// Perform the Request task
$controller->execute( JRequest::getVar('task'));
// Redirect if set by the controller
$controller->redirect();
其实就是根据request提交的controller参数，创建相应的JController对象，然后由controoler对象执行相应的任务。
这样我们就完全理解了，一个组件是如何被调用，MVC组件是如何执行，并最后返回html代码的。
Joomla源代码解析(21)：模块是如何被调用执行并渲染？
以前的文章中，关于/index.php我们已经分析完了 $mainframe->dispatch()是引入了组件，并被执行。我们知道对于Joomla，一个页面只能有一个或者0个组件，而上，下左右的碎片都是module，module是页面丰富的有效补充。比如我们知道菜单是 mod_mainmenu,而footer是mod_footer等等，那么这些module是怎么被引入的，并最后执行的？
秘密都在$mainframe->render()这个函数上，我们看看这个函数都做了什么工作。
以下是JSite 的render 函数的内容
$document =& JFactory::getDocument();
$user =& JFactory::getUser();
// get the format to render
$format = $document->getType();
switch($format)
{
case 'feed' :
{
$params = array();
} break;
case 'html' :
default :
{
$template = $this->getTemplate();
$file = JRequest::getCmd('tmpl', 'index');
if ($this->getCfg('offline') && $user->get('gid') < '23' ) {
$file = 'offline';
}
if (!is_dir( JPATH_THEMES.DS.$template ) && !$this->getCfg('offline')) {
$file = 'component';
}
$params = array(
'template' => $template,
'file' => $file.'.php',
'directory' => JPATH_THEMES
);
} break;
}
$data = $document->render( $this->getCfg('caching'), $params);
JResponse::setBody($data);
其实重要的部分是引入了相应的模板文件（templateindex.php），并调用了 JDocumentHtml的 render 函数。
看到这里，我们终于明白了，模板的index.php原来是这个时候被引入的。
我们再看看 JDocumentHtml 的render函数。
这个函数中最重要的两句程序是
$data = $this->_loadTemplate($directory.DS.$template, $file); 载入模板文件
$data = $this->_parseTemplate($data); 解析模板
再继续看看解析模板是什么过程：
$replace = array();
$matches = array();
if(preg_match_all('##iU', $data, $matches))
{
$matches[0] = array_reverse($matches[0]);
$matches[1] = array_reverse($matches[1]);
$matches[2] = array_reverse($matches[2]);
$count = count($matches[1]);
for($i = 0; $i < $count; $i++)
{
$attribs = JUtility::parseAttributes( $matches[2][$i] );
$type = $matches[1][$i];
$name = isset($attribs['name']) ? $attribs['name'] : null;
$replace[$i] = $this->getBuffer($type, $name, $attribs);
}
$data = str_replace($matches[0], $replace, $data);
}
return $data;
}
对了，就是这部分，对模板中 JDOC标签进行了解析，获得了相应的module名称和参数，并调用getBuffer函数执行。
至此 调用 $renderer->render($name, $attribs, $result);
Joomla源代码解析(22)：模块是如何被调用执行并渲染
上一文章中提到了getBuffer函数，在函数中实际上调用了render ，这个对象是JDocumentRendererModule 类的实例，我们看看JDocumentRendererModule 的render函数。
if (!is_object($module))
{
$module =& JModuleHelper::getModule($module);
if (!is_object($module))
{
if (is_null($content)) {
return '';
} else {
$tmp = $module;
$module = new stdClass();
$module->params = null;
$module->module = $tmp;
$module->id = 0;
$module->user = 0;
}
}
}
// get the user and configuration object
$user =& JFactory::getUser();
$conf =& JFactory::getConfig();
// set the module content
if (!is_null($content)) {
$module->content = $content;
}
//get module parameters
$mod_params = new JParameter( $module->params );
$contents = '';
if ($mod_params->get('cache', 0) && $conf->getValue( 'config.caching' ))
{
$cache =& JFactory::getCache( $module->module );
$cache->setLifeTime( $mod_params->get( 'cache_time', $conf->getValue( 'config.cachetime' ) * 60 ) );
$cache->setCacheValidation(true);
$contents = $cache->get( array('JModuleHelper', 'renderModule'), array( $module, $params ), $module->id. $user->get('aid', 0) );
} else {
$contents = JModuleHelper::renderModule($module, $params);
}
这段代码完成了找到对应的module ，和helper文件，兑取参数，并最后由'JModuleHelper'执行，并渲染。
至此，我们也完全了解了模板是如何被调用，模块是如何并调用并渲染的。
joomla源代码探析(23)：完结篇
到此为止，我们基本上了解了Joomla重要的类以及整体的框架。在第三篇中我写了一个万源之源，在完结之篇中，一直想不到用那个词合适，不过我想还是应该说一句什么。
还是：支持开源，支持Joomla！
转载▼
