Yii Framework Analysis (3) - Mécanisme de chargement de classe et gestion, configuration, accès et création de composants d'application

Le script d'entrée de l'application Yii fait référence à la classe Yii. La définition de la classe Yii :

class Yii extends YiiBase
{
}

Dans l'application créée par yiic, la classe Yii n'est que le "gilet" de la YiiBase. classe Nous pouvons également le personnaliser en fonction des besoins.

Yii (c'est-à-dire YiiBase) est une "classe d'assistance" qui fournit un accès statique et global à l'ensemble de l'application.

Plusieurs membres statiques de la classe Yii :
$_aliases : stocke les chemins réels correspondant aux alias système
$_imports :
$_classes :
$_includePaths php include paths
$_app : objet CWebApplication, accessible via Yii::app()
$_logger : objet de journal système
L'objet $_app est créé par la méthode Yii::createWebApplication().

Chargement automatique des classes

Yii est basé sur le mécanisme de chargement automatique de php5 pour fournir la fonction de chargement automatique des classes. L'autoloader est la méthode statique autoload() de la classe YiiBase.

Lorsque le programme utilise new pour créer un objet ou accéder à un membre statique d'une classe, PHP transmet le nom de la classe au chargeur de classe, et le chargeur de classe termine l'inclusion du fichier de classe.

Le mécanisme de chargement automatique implémente "l'importation à la demande" des classes, ce qui signifie que le système inclut les fichiers de la classe uniquement lorsqu'il accède à la classe.

Le membre statique $_coreClasses de la classe YiiBase pré-stocke le nom de la classe principale de Yii et le chemin du fichier de classe correspondant. Les classes utilisées dans d'autres applications Yii peuvent être importées à l'aide de Yii::import(). Yii::import() stocke la classe unique et les fichiers de classe correspondants dans $_classes, et ajoute le chemin représenté par le caractère générique * à php include_path . Les fichiers de classe ou les répertoires importés par Yii::import() sont enregistrés dans $_imports pour éviter plusieurs importations.

/* Yii::import()
* $alias: 要导入的类名或路径
* $forceInclude false：只导入不include类文件，true则导入并include类文件
*/
public static function import($alias,$forceInclude=false)
{
    // 先判断$alias是否存在于YiiBase::$_imports[] 中，已存在的直接return， 避免重复import。
    if(isset(self::$_imports[$alias])) // previously imported
        return self::$_imports[$alias];
    // $alias类已定义，记入$_imports[]，直接返回
    if(class_exists($alias,false) || interface_exists($alias,false))
        return self::$_imports[$alias]=$alias;
    // 已定义于$_coreClasses[]的类，或名字中不含.的类，记入$_imports[]，直接返回
    if(isset(self::$_coreClasses[$alias]) || ($pos=strrpos($alias,’.'))===false) // a simple class name
    {
        self::$_imports[$alias]=$alias;
        if($forceInclude)
        {
            if(isset(self::$_coreClasses[$alias])) // a core class
                require(YII_PATH.self::$_coreClasses[$alias]);
            else
                require($alias.’.php’);
        }
        return $alias;
    }
    // 产生一个变量 $className，为$alias最后一个.后面的部分
    // 这样的：’x.y.ClassNamer’
    // $className不等于 ‘*’, 并且ClassNamer类已定义的，????? ClassNamer’ 记入 $_imports[]，直接返回
    if(($className=(string)substr($alias,$pos+1))!==’*’ 
            && (class_exists($className,false) || interface_exists($className,false)))
        return self::$_imports[$alias]=$className;
    // $alias里含有别名，并转换真实路径成功
    if(($path=self::getPathOfAlias($alias))!==false)
    {
        // 不是以*结尾的路径（单类）
        if($className!==’*')
        {
            self::$_imports[$alias]=$className;
            if($forceInclude)
                require($path.’.php’);
            else
                // 类名与真实路径记入$_classes数组
                self::$_classes[$className]=$path.’.php’;
            return $className;
        }
        // $alias是’system.web.*’这样的已*结尾的路径，将路径加到include_path中
        else // a directory
        {
            if(self::$_includePaths===null)
            {
                self::$_includePaths=array_unique(explode(PATH_SEPARATOR,get_include_path()));
                if(($pos=array_search(‘.’,self::$_includePaths,true))!==false)
                    unset(self::$_includePaths[$pos]);
             }
            array_unshift(self::$_includePaths,$path);
            set_include_path(‘.’.PATH_SEPARATOR.implode(PATH_SEPARATOR,self::$_includePaths));
            return self::$_imports[$alias]=$path;
         }
    }
    else
        throw new CException(Yii::t(‘yii’,'Alias “{alias}” is invalid. Make sure it points to an existing directory or file.’,array(‘{alias}’=>$alias)));
}

Jetez ensuite un œil au traitement de la fonction YiiBase::autoload() :

public static function autoload($className)
{
    // $_coreClasses中配置好的类直接引入
    if(isset(self::$_coreClasses[$className]))
        include(YII_PATH.self::$_coreClasses[$className]);
    // $_classes 中登记的单类直接引入
    else if(isset(self::$_classes[$className]))
        include(self::$_classes[$className]);
    else
    {
        // 其他的认为文件路径以记入 include_path 里，以$className.’.php’直接引入
        include($className.’.php’);
        return class_exists($className,false) || interface_exists($className,false);
    }
    return true;
}

Les classes ou chemins dans l'élément d'importation dans le fichier de configuration système seront automatiquement chargé lors du démarrage du script Import. Pour les classes qui doivent être importées dans des classes individuelles dans les applications utilisateur, l'instruction Yii::import() peut être ajoutée avant la définition de la classe.

Gestion des composants d'application

Comme mentionné précédemment, la classe CComponent de Yii fournit des interfaces d'accès aux propriétés, événements et comportements des composants, et la sous-classe de CComponent, CModule, fournit également la gestion des composants d'application.

Le composant d'application doit être une instance de l'interface IApplicationComponent et doit implémenter les méthodes init() et getIsInitialized() de l'interface. init() sera automatiquement appelé après avoir appliqué les paramètres d'initialisation du composant.

Les propres modules fonctionnels de Yii sont fournis via des composants d'application, tels que la requête commune Yii::app()->user, Yii::app()->, etc. Les utilisateurs peuvent également définir des composants d'application.

En tant que classe parent de l'objet Yii::app() (CWebApplication), CModule fournit une gestion complète du cycle de vie des composants, y compris la création de composants, l'initialisation, le stockage d'objets, etc.

Chaque composant d'application est identifié par un nom de chaîne et accessible via la méthode __get() de la classe CModule.

Le membre $_components[] de la classe CModule stocke l'instance d'objet du composant d'application ($name => $object), et $_componentConfig[] stocke le nom de classe et les paramètres d'initialisation du composant d'application.

Lors de l'utilisation d'un composant d'application, définissez d'abord le nom de classe et les paramètres d'initialisation du composant dans $_componentConfig Lors du premier accès au composant, CModule créera automatiquement une instance d'objet de composant d'application et initialisera les paramètres donnés. . Ensuite, la méthode init() du composant applicatif est appelée.

La classe de l'objet Yii::app() CWebApplication et sa classe parent CApplication sont préconfigurées avec les composants d'application utilisés par le système lui-même : urlManager, request, session, AssetManager, user, themeManager, authManager, clientScript, coreMessages , base de données, messages, errorHandler, securityManager, statePersister.

Nous pouvons modifier les paramètres des composants de l'application système ou configurer de nouveaux composants d'application dans le projet de composants du fichier de configuration du système.

CModule n'est pas responsable de la création des instances de composants d'application, mais est effectué par la méthode statique Yii::createComponent().

Le paramètre $config de createComponent() peut être une chaîne de nom de classe ou un tableau stockant le nom de classe et les paramètres d'initialisation.

Configuration des composants de l'application

La configuration des composants de l'application est stockée dans l'élément composants de la variable système $config (config/main.php) :

// application components
‘components’=>array(
    ‘log’=>array(
        ‘class’=>’CLogRouter’,
        ‘routes’=>array(
            array(
                ‘class’=>’CFileLogRoute’,
                ‘levels’=>’error, warning’,
            ),
         ),
    ),
    ‘user’=>array(
    // enable cookie-based authentication
        ‘allowAutoLogin’=>true,
    ),
),

$ Les éléments des composants dans config sont traités dans le constructeur de CApplication :

$this->configure($config);

Le traitement de la fonction configure() est très simple :

public function configure($config)
{
    if(is_array($config))
    {
        foreach($config as $key=>$value)
            $this->$key=$value;
    }
}

Chaque élément de $config est passé en tant qu'attribut à la méthode de définition d'attribut setXXX() de l'objet $_app, où l'élément « composants » est traité par setComponents(), la classe parent de CModule. dans CWebApplication.

setComponents() stocke le nom de la classe et les paramètres d'initialisation dans l'élément 'components' dans $_componentConfig[] :

public function setComponents($components)
{
    // $config 里的’components’每一项
    foreach($components as $id=>$component)
    {
        if($component instanceof IApplicationComponent)
            $this->setComponent($id,$component);
        // $_componentConfig里已经存在配置，合并$component
        else if(isset($this->_componentConfig[$id]))
            $this->_componentConfig[$id]=CMap::mergeArray($this->_componentConfig[$id],$component);
        // 在$_componentConfig里新建项目
        else
            $this->_componentConfig[$id]=$component;
    }
}

Accès aux composants de l'application

CModule类重载了CComponent的__get()方法，优先访问应用组件对象。

public function __get($name)
{
    if($this->hasComponent($name))
        return $this->getComponent($name);
    else
        return parent::__get($name);
}

hasComponent() 判断$_components[]中是否已存在组件实例，或$_componentConfig[]中存在组件配置信息。

public function hasComponent($id)
{
    return isset($this->_components[$id]) || isset($this->_componentConfig[$id]);
}

getComponent() 判断组件实例已经存在于$_components[]中，则直接返回对象。
否则根据$_componentConfig[]里的组件配置数据调用 Yii::createComponent() 来创建组件，并将对象存入$_components[]中然后返回。

public function getComponent($id,$createIfNull=true)
{
    if(isset($this->_components[$id]))
        return $this->_components[$id];
    else if(isset($this->_componentConfig[$id]) && $createIfNull)
    {
        $config=$this->_componentConfig[$id];
        unset($this->_componentConfig[$id]);
        if(!isset($config['enabled']) || $config['enabled'])
        {
            Yii::trace(“Loading \”$id\” application component”,’system.web.CModule’);
            unset($config['enabled']);
            $component=Yii::createComponent($config);
            $component->init();
            return $this->_components[$id]=$component;
        }
    }
}

应用组件的创建

Yii::createComponent() 来完成应用组件的创建

public static function createComponent($config)
{
    if(is_string($config))
    {
        $type=$config;
        $config=array();
    }
    else if(isset($config['class']))
    {
        $type=$config['class'];
        unset($config['class']);
    }
    else
        throw new CException(Yii::t(‘yii’,'Object configuration must be an array containing a “class” element.’));
 
    if(!class_exists($type,false))
        $type=Yii::import($type,true);
 
    if(($n=func_num_args())>1)
    {
        $args=func_get_args();
        if($n===2)
            $object=new $type($args[1]);
        else if($n===3)
            $object=new $type($args[1],$args[2]);
        else if($n===4)
            $object=new $type($args[1],$args[2],$args[3]);
        else
        {
            unset($args[0]);
            $class=new ReflectionClass($type);
            // Note: ReflectionClass::newInstanceArgs() is available for PHP 5.1.3+
            // $object=$class->newInstanceArgs($args);
            $object=call_user_func_array(array($class,’newInstance’),$args);
        }
    }
    else
        $object=new $type;
 
    foreach($config as $key=>$value)
    $object->$key=$value;
 
    return $object;
}

 以上就是Yii框架分析(三)——类加载机制及应用组件的管理、配置、访问、创建的内容，更多相关内容请关注PHP中文网（www.php.cn）！