Comprendre le contrôleur de programmation MVC en PHP

En termes simples, le rôle du contrôleur est d'accepter les demandes. Il utilise la méthode get, dans ce cas via URI, pour charger un module fonction afin d'actualiser ou de soumettre une couche de présentation. Le contrôleur utilisera la variable globale automatique $_GET pour déterminer quel module charger.

Un exemple de requête ressemblerait à ceci :

http://example.com/index.php?module=login

Cela semble simple, mais dans le processus d'implémentation, ce n'est pas le cas. Voici les parties d'argument qui peuvent être reconnues par plusieurs contrôleurs :

module définit le module à utiliser, comme les utilisateurs. La classe de module définit la classe fonctionnelle à utiliser, par exemple si vous souhaitez que les utilisateurs se connectent ou se déconnectent.
event définit l'événement spécifique à utiliser.

qui

est finalement composée de chaque argument ci-dessus :

http://example.com/index.php?module=users&class=login.

il doit charger le module utilisateurs, puis la classe de connexion, et enfin exécuter l'événement par défaut login::__default() car aucun événement spécifique n'est défini.

Voici la partie de code spécifique :

<?php
/**
*index.php
*
* @auteur Joe Stump ＜ [email protected] ＞
* @copyright Joe Stump ＜ [email protected] ＞
* @license http://www.opensource.org/licenses/gpl-license.php
* @packageFramework
*/

require_once('config.php');

// {{{ __autoload($class)
/**
* __chargement automatique
*
* Le chargement automatique est exécuté par PHP lorsqu'il ne trouve pas une classe qu'il essaie de charger.
* En nommant intelligemment nos classes, nous devrions pouvoir charger la plupart des classes
* dynamiquement.
*
* @auteur Joe Stump ＜ [email protected] ＞
* @param string $class Nom de la classe que nous essayons de charger
* @retour nul
* @packageFramework
*/

fonction __autoload($class)
{
$file = str_replace('_','/',substr($class,2)).'.php';
require_once(FR_BASE_PATH.'/includes/'.$file);
}
// }}}

if (isset($_GET['module'])) {
$module = $_GET['module'];
if (isset($_GET['événement'])) {
$événement = $_GET['événement'];
} autre {
$événement = '__default';
}

if (isset($_GET['class'])) {
$classe = $_GET['classe'];
} autre {
$classe = $module ;
}

$classFile = FR_BASE_PATH.'/modules/'.$module.'/'.$class.'.php';
if (file_exists($classFile)) {
require_once($classFile);
si (class_exists($class)) {
essayer {
$instance = nouveau $class();
if (!FR_Module::isValid($instance)) {
die("Le module demandé n'est pas un module framework valide !");
}

$instance->moduleName = $module;
si ($instance->authenticate()) {
essayer {
$result = $instance->$event();
si (!PEAR::isError($result)) {
$presenter = FR_Presenter::factory($instance->presenter,$instance);

if (!PEAR::isError($presenter)) {
$présentateur->affichage();
} autre {
mourir($présentateur->getMessage());
}
}
} catch (Exception $erreur) {
mourir($erreur->getMessage());
}
} autre {
die("Vous n'avez pas accès à la page demandée !");
}
} catch (Exception $erreur) {
mourir($erreur->getMessage());
}
} autre {
die("Un module valide pour votre demande n'a pas été trouvé");
}
} autre {
die("Impossible de trouver : $classFile");
}
} autre {
die("Un module valide n'a pas été spécifié");
}

?＞

Voici les commentaires spécifiques sur le code ci-dessus :

chargez "config.php"

pour définir la fonction __autoload(). Il s'agit d'une nouvelle fonction de PHP5, qui facilite le chargement dynamique de diverses classes.

Si un argument est défini, alors les modules, classes et événements spécifiques pertinents sont chargés,

suivis de quelques jugements et opérations d'erreur spécifiques.

Enfin, une fois que tout est correct, la couche de présentation

[URL conviviale]

si vous pensez que l'URL de la demande

mentionné dans l'exemple ci-dessus est Si cela vous met mal à l'aise, utilisez mod_rewrite pour implémenter des URL conviviales. Vient ensuite le code standard de réécriture écrit par l'auteur pour ce framework :

RewriteEngine On

# Changez l'URI ici comme vous voulez que votre page d'accueil soit

RewriteRule ^/$ /index.php?module=welcome [L,QSA]

# Changements / index.php?module=bienvenue dans /welcome

RewriteCond %{DOCUMENT_ROOT}/

%{REQUEST_FILENAME} !-d RewriteCond %{DOCUMENT_ROOT}/%{REQUEST_FILENAME} !-f

RewriteRule ^/([^/]*)$ /index. php?module=$1 [L,QSA]

# Modifications de /index.php?module=users&class=login vers /users/login

RewriteCond %{DOCUMENT_ROOT}/%{REQUEST_FILENAME} !-d

RewriteCond %{DOCUMENT_ROOT}/%{REQUEST_FILENAME} !-f

RewriteRule ^/([^/]*)/([^/]*)$ /index.php?module=$1&class=$2 [L,QSA]

# Modifications /index.php?module=users&class=login&event =foo

# à /users/login/foo.html

RewriteCond %{DOCUMENT_ROOT}/%{REQUEST_FILENAME} !-d

RewriteCond %{DOCUMENT_ROOT}/%{REQUEST_FILENAME} !-f

RewriteRule ^/([^/]*)/( [^/]*)/([^/]*).html$

/index.php?module=$1&class=$2&event=$3 [L,QSA]

Extension du contrôleur

[Extended Controller]

possède un contrôleur centralisé L'un des L'avantage est qu'après avoir ajouté certaines fonctions, elles peuvent être immédiatement reflétées via le contrôleur. Voici quelques idées pour étendre ce contrôleur afin de rendre le framework globalement plus puissant :

Vous pouvez utiliser SoapServer, une nouveauté de PHP5, pour détecter automatiquement si une requête est SOAP.

Vous

pouvez utiliser des contrôleurs pour filtrer toutes les variables globales automatiques telles que $_GET et $_POST pour empêcher le code HTML malveillant, etc.

Pour convertir des expressions à la volée, par exemple, du mode par défaut au mode PDF

avantage

est que l'ensemble de l'application peut utiliser le cache pour améliorer l'efficacité.

une chose à noter est que vous êtes dans le contrôleur. Les fonctionnalités ajoutées seront reflétées dans l’ensemble du programme. Par exemple, vous souhaitez filtrer toutes les variables globales automatiques, mais de nombreux administrateurs d'applications doivent utiliser du code HTML, ce qui devient une chose délicate (Note du traducteur : mon idée est d'ajouter une instruction conditionnelle if pour charger un module spécifique sans appliquer le filtrage. fonction).