Bonjour,

Dans mon framework, j'ai un CRUDController générique, une classe abstraite à étendre.

J'hésite entre 2 approches :

Approche classique :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
class CRUDController extends ActionController {
 
    protected $modelClassname; //le nom qualifié de la classe du modèle
    protected $modelName; //le nom court du modèle, pour les variables...
 
    public function doAdd() {
        $modelClassName = $this->modelClassname;
        $model = new $modelClassName( $this->request->getArray( $this->modelName ) ); //récupère $_POST[$modelName]
        if ( $model->save() ) {
            $this->flash->success( $i18n->__( $this->modelName . '_successfully_created' ) );
        } else {
            //...
        }
    }
 
    //...
}
 
namespace controllers;
 
class PageController extend \CRUDController {
 
    protected $modelClassName = 'models\Page';
    protected $modelName = 'page';
    protected $pluralModelName = 'pages';
}
 
namespace plugins\blog\controllers;
 
class PostController extend \CRUDController {
 
    protected $modelClassName = 'plugins\blog\models\Post';
    protected $modelName = 'post';
    protected $pluralModelName = 'posts';
}

Approche de type "convention plutôt que configuration", utilisant la réflexion :
Par convention, tous les contrôleurs d'un module sont dans un répertoire controllers et les modèle dans un répertoire models.

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
class CRUDController extends ActionController {
 
    protected $modelClassName;
 
    protected function getModelClassname() {
        if ( isset( $this->modelClassName ) ) {
            $class = new ReflectionClass( get_called_class() );
            $this->modelClassName = substr( $class->getNamespaceName(), 0, -11 ) . 'models\\' . $class->getShortName();
        }
        return $this->modelClassName;
    }
 
    protected function getModelName() {
        $class = new ReflectionClass( get_called_class() );
        return substr( $class->getShortName() );
    }
 
    public function doAdd() {
        $modelClassName = $this->getModelClassName();
        $model = new $modelClassName( $this->request->getArray( $this->getModelName() ) );
        if ( $model->save() ) {
            $this->flash->success( $i18n->__( $this->getModelName() . '_successfully_created' ) );
        } else {
            //...
        }
    }
}
 
namespace controllers;
 
class PageController extend \CRUDController {
}
 
namespace plugins\blog\controllers;
 
class PostController extends \CRUDController {
}
 
 
namespace plugins\blog\models;
 
class Post extend \ActiveRecord {
}
Je n'ai plus besoin de redéfinir les variables $modelClassname et $modelName dans les classes filles. J'ai moins de code à écrire.

Selon, vous, sur quelle approche faut-il partir ? L'approche 2 est-elle une bonne solution, où est-ce que j'abuse de la réflexion ? J'imagine que la réflexion n'est pas gratuite en terme de performances.