En pocas palabras, la función del controlador es aceptar solicitudes. Utiliza el método get, en este caso a través de URI, para cargar un módulo de función para actualizar o enviar una capa de presentación. El controlador utilizará la variable global automática $_GET para determinar qué módulo cargar.
Un ejemplo de solicitud se vería así:
http://example.com/index.php?module=login
Esto parece simple, pero en el proceso de implementación no lo es. Estas son las partes de los argumentos que pueden ser reconocidas por varios controladores:
módulo define qué módulo usar, como usuarios. La clase de módulo define qué clase funcional usar, como si desea que los usuarios inicien o cierren sesión.
event define qué evento específico usar.
que
en última instancia se compone de cada argumento anterior:
http://example.com/index.php?module=users&class=login.
debería cargar el módulo de usuarios, luego la clase de inicio de sesión y finalmente ejecutar el evento predeterminado login::__default() porque no hay ningún evento específico definido.
La siguiente es la parte del código específico:
<?php
/**
*índice.php
*
* @autor Joe Stump ＜ [email protected] ＞
* @copyright Joe Stump ＜ [email protected] ＞
* @license http://www.opensource.org/licenses/gpl-license.php
* @paqueteFramework
*/
require_once('config.php');
// {{{ __autoload($clase)
/**
* __autocarga
*
* PHP ejecuta la carga automática cuando no puede encontrar una clase que está intentando cargar.
* Al nombrar nuestras clases de manera inteligente deberíamos poder cargar la mayoría de las clases.
* dinámicamente.
*
* @autor Joe Stump ＜ [email protected] ＞
* @param string $class Nombre de clase que estamos intentando cargar
* @retorno nulo
* @paqueteFramework
*/
función __autoload($clase)
{
$archivo = str_replace('_','/',substr($clase,2)).'.php';
require_once(FR_BASE_PATH.'/includes/'.$file);
}
// }}}
if (isset($_GET['módulo'])) {
$módulo = $_GET['módulo'];
si (isset($_GET['evento'])) {
$evento = $_GET['evento'];
} demás {
$evento = '__predeterminado';
}
si (isset($_GET['clase'])) {
$clase = $_GET['clase'];
} demás {
$clase = $módulo;
}
$classFile = FR_BASE_PATH.'/modules/'.$module.'/'.$class.'.php';
if (file_exists($archivoclase)) {
require_once($archivoclase);
si (class_exists($clase)) {
intentar {
$instancia = nueva $clase();
if (!FR_Module::isValid($instancia)) {
die("¡El módulo solicitado no es un módulo de marco válido!");
}
$instancia->nombredelmódulo = $módulo;
si ($instancia->autenticar()) {
intentar {
$resultado = $instancia->$evento();
si (!PEAR::isError($resultado)) {
$presentador = FR_Presenter::factory($instancia->presentador,$instancia
if (!PEAR::isError($presentador)) {
$presentador->display();
} demás {
morir($presentador->getMessage());
}
}
} captura (Excepción $error) {
morir($error->getMessage());
}
} demás {
die("¡No tienes acceso a la página solicitada!");
}
} captura (Excepción $error) {
morir($error->getMessage());
}
} demás {
die("No se encontró un módulo válido para su solicitud");
}
} demás {
die("No se pudo encontrar: $classFile");
}
} demás {
die("No se especificó un módulo válido");
}
?＞
Los siguientes son los comentarios específicos sobre el código anterior:
cargue "config.php"
para definir la función __autoload(). Esta es una nueva función en PHP5, que facilita la carga dinámica de varias clases.
Si se define un argumento, se cargan los módulos, clases y eventos específicos relevantes,
seguidos de algunos juicios y operaciones de error específicas.
Finalmente, después de que todo esté correcto, se carga la capa de presentación
[URL amigable]
,si cree que es la URL de solicitud. Lo mencionado en el ejemplo anterior es: Si te hace sentir incómodo, usa mod_rewrite para implementar URL amigables. El siguiente es el código estándar de reescritura real escrito por el autor para este marco:
RewriteEngine On
# Cambie el URI aquí a lo que desee que sea su página de inicio
RewriteRule ^/$ /index.php?module=welcome [L,QSA]
# Cambios / index.php?module=bienvenido a /bienvenido
RewriteCond %{DOCUMENT_ROOT}/
%{REQUEST_FILENAME} !-d RewriteCond %{DOCUMENT_ROOT}/%{REQUEST_FILENAME} !-f
RewriteRule ^/([^/]*)$ /index. php?module=$1 [L,QSA]
# Cambia /index.php?module=users&class=login a /users/login
RewriteCond %{DOCUMENT_ROOT}/%{REQUEST_FILENAME} !-d
RewriteCond %{DOCUMENT_ROOT}/%{REQUEST_FILENAME} !-f
RewriteRule ^/([^/]*)/([^/]*)$ /index.php?module=$1&class=$2 [L,QSA]
# Cambios /index.php?module=users&class=login&event =foo
# a /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]
Ampliación del controlador
[Controlador extendido]
tiene un controlador centralizado Uno de La ventaja es que después de agregar algunas funciones, se pueden reflejar inmediatamente a través del controlador. Aquí hay algunas ideas para extender este controlador y hacer que el marco sea más poderoso en general:
Puede usar SoapServer, una novedad en PHP5, para detectar automáticamente si una solicitud es SOAP.
Puede usar controladores para filtrar todas las variables globales automáticas como $_GET y $_POST para evitar código HTML malicioso, etc.
Puede usar controladores para Para convertir expresiones sobre la marcha, por ejemplo, del modo predeterminado al modo PDF
,
puede agregar directamente el mecanismo de almacenamiento en caché en el controlador. La ventaja de esto es que toda la aplicación puede usar el caché para mejorar la eficiencia.
Una cosa a tener en cuenta es que estás en el controlador. La funcionalidad agregada se reflejará en el programa general. Por ejemplo, desea filtrar todas las variables globales automáticas, pero muchos administradores de aplicaciones necesitan usar algún código HTML, lo que se vuelve complicado (Nota del traductor: mi idea es agregar una declaración condicional if para cargar un módulo específico sin aplicar el filtrado función).