Yii Framework Official Guide Series 41 - Sujet spécial : Génération automatique de code

Depuis la version 1.1.2, Yii est équipé d'un outil de génération de code basé sur une interface Web Gii. Il remplace l'outil de génération de code en ligne de commande précédent yiic shell. Dans cette partie, nous expliquerons comment utiliser Gii et comment étendre Gii pour augmenter nos résultats de développement.

1. Utilisation de Gii

Gii est implémenté en tant que module et doit être utilisé dans une application Yii existante. Pour utiliser Gii, on change d'abord la configuration de l'application comme suit :

return array(
    ......
    'modules'=>array(
        'gii'=>array(
            'class'=>'system.gii.GiiModule',
            'password'=>'在这里填写密码',
            // 'ipFilters'=>array(...IP 列表...),
            // 'newFileMode'=>0666,
            // 'newDirMode'=>0777,
        ),
    ),
);

Ci-dessus, on déclare un fichier nommé gii module, sa classe est GiiModule. Nous définissons également un mot de passe pour ce module. Lorsque nous accédons à Gii, il y aura une zone de saisie demandant de remplir le mot de passe.

Pour des raisons de sécurité, seul l'accès local à Gii est autorisé par défaut. Pour permettre à d'autres machines de confiance d'y accéder, nous devons configurer la propriété GiiModule :: ipFilters comme indiqué ci-dessus.

Étant donné que Gii générera et enregistrera de nouveaux fichiers dans l'application, nous devons nous assurer que le processus du serveur Web est autorisé à le faire. Les propriétés GiiModule::newFileMode et GiiModule::newDirMode ci-dessus contrôlent la manière dont les nouveaux fichiers et répertoires sont générés.

Remarque : Gii est principalement utilisé comme outil de développement. Par conséquent, il doit être installé uniquement sur les machines de développement. Parce qu'il peut générer de nouveaux fichiers PHP dans l'application, nous devons accorder suffisamment d'attention aux problèmes de sécurité (tels que la définition de mots de passe, le filtrage IP).

Gii est désormais accessible via l'URL http://www.php.cn/ . Ici, nous supposons que http://www.php.cn/ est l'URL pour accéder à l'application Yii.

Si l'application Yii utilise le format URL path (voir gestion des URL), nous pouvons accéder à Gii via l'URL http://www.php.cn/. Nous devrons peut-être ajouter les règles d'URL suivantes devant les règles d'URL existantes :

'components'=>array(
    ......
    'urlManager'=>array(
        'urlFormat'=>'path',
        'rules'=>array(
            'gii'=>'gii',
            'gii/<controller:\w+>'=>'gii/<controller>',
            'gii/<controller:\w+>/<action:\w+>'=>'gii/<controller>/<action>',
            ...已有的规则...
        ),
    ),
)

Gii a des générateurs de code par défaut. Chaque générateur de code est chargé de générer un type spécifique de code. Par exemple, le générateur de contrôleur génère une classe de contrôleur et certains scripts de vue d'action ; le générateur de modèle génère une classe ActiveRecord pour la table de données spécifiée.

Le processus de base d'utilisation d'un générateur est le suivant :

1. Entrez dans la page du générateur

2. Remplissez les champs spécifiés ; Zone de saisie des paramètres de génération de code. Par exemple, pour utiliser Module Generator pour créer un nouveau module, vous devez spécifier l'ID du module

3. Cliquez sur le bouton Preview pour prévisualiser le code qui sera généré ; Vous verrez un tableau répertoriant les fichiers qui seront générés. Vous pouvez cliquer sur l'un des fichiers pour prévisualiser le code ;

4. Cliquez sur le bouton Generate pour générer ces fichiers de code

5. Afficher ; le journal de génération de code.

2. Extension de Gii

Bien que les générateurs de code Gii par défaut puissent générer du code très puissant, nous souhaitons souvent les personnaliser ou en créer un nouveau en fonction de nos besoins et de nos goûts. et les besoins. Par exemple, nous voulons que le code généré soit dans le style que nous aimons ou que le code prenne en charge plusieurs langues. Tout cela est très simple à mettre en œuvre dans Gii.

Gii peut être étendu de 2 manières : en personnalisant les modèles de code pour les générateurs de code existants et en écrivant de nouveaux générateurs de code.

Architecture du générateur de code

Un générateur de code est stocké dans un répertoire, et le nom de ce répertoire est considéré comme le nom du générateur. Le répertoire se compose généralement des éléments suivants :

model/                       the model generator root folder
   ModelCode.php             the code model used to generate code
   ModelGenerator.php        the code generation controller
   views/                    containing view scripts for the generator
      index.php              the default view script
   templates/                containing code template sets
      default/               the 'default' code template set
         model.php           the code template for generating model class code

Chemin de recherche du générateur

Gii recherche les générateurs disponibles dans le répertoire spécifié par la propriété GiiModule::generatorPaths. Lorsque la personnalisation est requise, nous pouvons effectuer la configuration suivante dans le fichier de configuration de l'application,

return array(
    'modules'=>array(
        'gii'=>array(
            'class'=>'system.gii.GiiModule',
            'generatorPaths'=>array(
                'application.gii',   // a path alias
            ),
        ),
    ),
);

La configuration ci-dessus indique à Gii Look pour le générateur dans le répertoire avec l'alias application.gii et l'emplacement par défaut system.gii.generators.

Il est également possible d'avoir des générateurs portant le même nom dans des chemins de recherche différents. Dans ce cas, le générateur qui apparaît en premier dans le répertoire spécifié par GiiModule::generatorPaths est prioritaire.

Modèles de code personnalisés

C'est le moyen le plus simple et le plus courant d'étendre Gii. Nous utilisons un exemple pour présenter comment personnaliser le modèle de code. Supposons que nous souhaitions personnaliser le code généré par le générateur de modèle.

Nous créons d'abord un répertoire appelé protected/gii/model/templates/compact . Le model ici signifie que nous allons remplacer le générateur de modèle par défaut. templates/compact signifie que nous ajouterons un nouvel ensemble de modèles de code nommé compact.

Ensuite, nous ajoutons application.gii à GiiModule::generatorPaths dans la configuration de l'application. Comme indiqué ci-dessus.

现在打开 model 代码生成器页面。点击 Code Template 输入框。我们应当看到一个下拉列表，这个列表包含了我们新建的模板目录 compact。可是，若我们选择此模板生成代码，我们将看到错误。这是因为我们还没有在新的 compact 模板集中放入任何实际的代码模板文件。

复制文件 framework/gii/generators/model/templates/default/model.php 到protected/gii/model/templates/compact。若我们再次尝试以 compact 模板生成，我们会成功。但是，生成的代码和以 default 模板集生成的代码没什么不同。

现在是时候做点真正的工作了。打开文件 protected/gii/model/templates/compact/model.php 以编辑它。记得这个文件将作为类似一个视图文件被使用，意味着它可以包含 PHP 表达式和语句。让我们更改模板以便生成的代码里 attributeLabels() 方法使用 Yii::t() 来翻译属性标签：

public function attributeLabels()
{
    return array(
<?php foreach($labels as $name=>$label): ?>
            <?php echo "&#39;$name&#39; => Yii::t('application', '$label'),\n"; ?>
<?php endforeach; ?>
    );
}

在每个代码模板中，我们可以访问一些预定义的变量，例如上面例子中的 $labels。这些变量由对应的代码生成器提供。不同的代码生成器可能在他们的代码模板中提供不同的变量。请认真阅读默认代码模板中的描述。

创建新的生成器

In this sub-section, we show how to create a new generator that can generate a new widget class.

We first create a directory named protected/gii/widget. Under this directory, we will create the following files:

• WidgetGenerator.php: contains the WidgetGenerator controller class. This is the entry point of the widget generator.

• WidgetCode.php: contains the WidgetCode model class. This class has the main logic for code generation.

• views/index.php: the view script showing the code generator input form.

• templates/default/widget.php: the default code template for generating a widget class file.

Creating WidgetGenerator.php

The WidgetGenerator.php file is extremely simple. It only contains the following code:

class WidgetGenerator extends CCodeGenerator
{
    public $codeModel='application.gii.widget.WidgetCode';
}

In the above code, we specify that the generator will use the model class whose path alias isapplication.gii.widget.WidgetCode. The WidgetGenerator class extends from CCodeGenerator which implements a lot of functionalities, including the controller actions needed to coordinate the code generation process.

Creating WidgetCode.php

The WidgetCode.php file contains the WidgetCode model class that has the main logic for generating a widget class based on the user input. In this example, we assume that the only input we want from the user is the widget class name. Our WidgetCode looks like the following:

class WidgetCode extends CCodeModel
{
    public $className;

    public function rules()
    {
        return array_merge(parent::rules(), array(
            array('className', 'required'),
            array('className', 'match', 'pattern'=>'/^\w+$/'),
        ));
    }

    public function attributeLabels()
    {
        return array_merge(parent::attributeLabels(), array(
            'className'=>'Widget Class Name',
        ));
    }

    public function prepare()
    {
        $path=Yii::getPathOfAlias('application.components.' . $this->className) . '.php';
        $code=$this->render($this->templatepath.'/widget.php');

        $this->files[]=new CCodeFile($path, $code);
    }
}

The WidgetCode class extends from CCodeModel. Like a normal model class, in this class we can declarerules() and attributeLabels() to validate user inputs and provide attribute labels, respectively. Note that because the base class CCodeModel already defines some rules and attribute labels, we should merge them with our new rules and labels here.

The prepare() method prepares the code to be generated. Its main task is to prepare a list of CCodeFileobjects, each of which represent a code file being generated. In our example, we only need to create oneCCodeFile object that represents the widget class file being generated. The new widget class will be generated under the protected/components directory. We call CCodeFile::render method to generate the actual code. This method includes the code template as a PHP script and returns the echoed content as the generated code.

Creating views/index.php

Having the controller (WidgetGenerator) and the model (WidgetCode), it is time for us to create the viewviews/index.php.

<h1>Widget Generator</h1>

<?php $form=$this->beginWidget('CCodeForm', array('model'=>$model)); ?>

    <p class="row">
        <?php echo $form->labelEx($model,'className'); ?>
        <?php echo $form->textField($model,'className',array('size'=>65)); ?>
        <p class="tooltip">
            Widget class name must only contain word characters.
        </p>
        <?php echo $form->error($model,'className'); ?>
    </p>

<?php $this->endWidget(); ?>

In the above, we mainly display a form using the CCodeForm widget. In this form, we display the field to collect the input for the className attribute in WidgetCode.

When creating the form, we can exploit two nice features provided by the CCodeForm widget. One is about input tooltips. The other is about sticky inputs.

If you have tried any default code generator, you will notice that when setting focus in one input field, a nice tooltip will show up next to the field. This can easily achieved here by writing next to the input field a p whose CSS class is tooltip.

For some input fields, we may want to remember their last valid values so that the user can save the trouble of re-entering them each time they use the generator to generate code. An example is the input field collecting the controller base class name default controller generator. These sticky fields are initially displayed as highlighted static text. If we click on them, they will turn into input fields to take user inputs.

In order to declare an input field to be sticky, we need to do two things.

First, we need to declare a sticky validation rule for the corresponding model attribute. For example, the default controller generator has the following rule to declare that baseClass and actions attributes are sticky:

public function rules()
{
    return array_merge(parent::rules(), array(
        ......
        array('baseClass, actions', 'sticky'),
    ));
}

Second, we need to add a CSS class named sticky to the container p of the input field in the view, like the following:

<p class="row sticky">
    ...input field here...
</p>

Creating templates/default/widget.php

Finally, we create the code template templates/default/widget.php. As we described earlier, this is used like a view script that can contain PHP expressions and statements. In a code template, we can always access the $this variable which refers to the code model object. In our example, $this refers to the WidgetModelobject. We can thus get the user-entered widget class name via $this->className.

<?php echo &#39;<?php&#39;; ?>

class <?php echo $this->className; ?> extends CWidget
{
    public function run()
    {

    }
}

This concludes the creation of a new code generator. We can access this code generator immediately via the URL http://www.php.cn

 以上就是Yii框架官方指南系列41——专题：自动代码生成的内容，更多相关内容请关注PHP中文网（www.php.cn）！