Zend Framework - Guía rápida
Un PHP Web Framework es una colección de clases que ayuda a desarrollar una aplicación web. Zend es uno de los frameworks PHP más populares. Es unopen-source MVC frameworkpara aplicaciones web modernas de rápido desarrollo. Zend Framework tiene varios componentes débilmente acoplados, por lo que se conoce como "Biblioteca de componentes". Zend Framework proporciona cualquier pila PHP y servidor Zend para ejecutar aplicaciones de marco Zend.
Zend Studio es un IDE que incluye funciones para integrarse con Zend Framework. Proporciona vista MVC y generación de código. El framework Zend 3.0 actual incluye nuevos componentes como el servidor JSON RPC, un conversor de XML a JSON, funcionalidad PSR-7 y compatibilidad con PHP 7.
Zend Framework 2 es un marco de código abierto para desarrollar aplicaciones y servicios web utilizando PHP 5.3+. Zend Framework 2 utiliza código 100% orientado a objetos y utiliza la mayoría de las nuevas características de PHP 5.3, a saberNamespaces, Lambda Functions y Closures.
Zend Framework 2 evolucionó de Zend Framework 1, un framework PHP exitoso con más de 15 millones de descargas. Zend Server tiene una versión comunitaria gratuita y una versión comercial.
Características de Zend Framework
Algunas de las características más destacadas de Zend Framework son las siguientes:
- Marco de aplicación web orientado a objetos puro
- Implementación avanzada de MVC
- Admite múltiples bases de datos, incluidas PostgreSQL, SQLite, etc.
- API de nube simple
- Gestión de sesiones
- Cifrado de datos
- Enrutamiento URI flexible
- Zend proporciona soporte para el desarrollo de API RESTful.
- Código reutilizable y más fácil de mantener.
¿Por qué Zend Framework?
Lo que hace que Zend Framework sea uno de los principales marcos utilizados por los desarrolladores de PHP es que proporciona un código limpio y estable completo con derechos de propiedad intelectual. También facilita la programación. Es un marco rápido, fácil de aprender y conveniente. Zend admite sólidas herramientas de criptografía y técnicas de hash de contraseñas.
Metas de Zend
Los siguientes son los objetivos del Zend Framework.
- Flexibility
- Simple y productivo
- Compatibility
- Extensibilidad: el programador puede extender fácilmente todas las clases de framework.
- Portabilidad: admite múltiples entornos
Aplicaciones Zend
Los siguientes productos populares se desarrollan utilizando Zend Framework.
- Sitio web de McAfee Company
- Sitio web de IBM Company
- Magento: uno de los sitios web de carritos de compras más populares.
Ventajas de Zend Framework
Algunas de las ventajas de Zend Framework se enumeran a continuación.
Loosely Coupled - Zend brinda la opción de eliminar módulos o componentes que no necesitamos en la aplicación.
Performance- Zend Framework está altamente optimizado para el rendimiento. Zend Framework 3 es 4 veces más rápido que su versión anterior.
Security - Framework admite el cifrado estándar de la industria.
Testing - PHPUnit está integrado con Zend para que pueda probar fácilmente el marco.
En el próximo capítulo, aprenderemos cómo instalar Zend Framework.
Para instalar Zend Framework, primero debemos instalar Composer y la última versión de PHP como se muestra en los siguientes pasos.
Install Composer- Zend usa Composer para administrar sus dependencias, así que asegúrese de tener Composer instalado en su máquina. Si Composer no está instalado, visite el sitio web oficial de Composer e instálelo.
Install the latest version of PHP- Para obtener el máximo beneficio de Zend Framework, instale la última versión de PHP. La versión mínima requerida para Zend Framework 3 es PHP 5.6 o posterior.
Instalar Zend Framework
Zend Framework se puede instalar de dos formas. Son los siguientes:
- Instalación manual
- Instalación basada en Composer
Analicemos estas dos instalaciones en detalle.
Instalación manual
Descargue la última versión de Zend Framework visitando el siguiente enlace: https://framework.zend.com/downloads/archives
Extraiga el contenido del archivo de almacenamiento descargado a la carpeta que le gustaría conservar. Una vez que tenga una copia de Zend Framework disponible en su máquina local, su aplicación web basada en Zend Framework puede acceder a las clases de framework. Aunque hay varias formas de lograr esto, su PHPinclude_pathdebe contener la ruta a las clases de Zend Framework en el directorio / library en la distribución. Este método se aplica solo a Zend Framework versión 2.4 y anteriores.
Instalación basada en Composer
Para instalar fácilmente Zend Framework, use la herramienta Composer. Este es el método preferido para instalar la última versión de Zend Framework. Para instalar todos los componentes de Zend Framework, use el siguiente comando de Composer:
$ composer require zendframework/zendframeworkCada módulo / componente de Zend Framework también se puede instalar individualmente. Por ejemplo, para instalar elMVC component del Zend Framework, utilice lo siguiente composer comando -
$ composer require zendframework/zend-mvcCreemos una aplicación esqueleto utilizando los sistemas de módulos y capas MVC de Zend Framework.
Instalación usando Composer
La forma más sencilla de crear un nuevo proyecto de Zend Framework es utilizar un Compositor. Se define a continuación:
$ cd /path/to/install $ composer create-project -n -sdev zendframework/skeleton-application myappVería el siguiente resultado en su pantalla:
Installing zendframework/skeleton-application (dev-master
941da45b407e4f09e264f000fb537928badb96ed)
- Installing zendframework/skeleton-application (dev-master master)
Cloning master
Created project in myapp
Loading composer repositories with package information
Installing dependencies (including require-dev) from lock file
- Installing zendframework/zend-component-installer (0.3.0)
Loading from cache
- Installing zendframework/zend-stdlib (3.0.1)
Loading from cache
- Installing zendframework/zend-config (2.6.0)
Loading from cache
- Installing zendframework/zend-loader (2.5.1)
Loading from cache
- Installing zendframework/zend-eventmanager (3.0.1)
Loading from cache
- Installing zendframework/zend-view (2.8.0)
Loading from cache
- Installing container-interop/container-interop (1.1.0)
Loading from cache
- Installing zendframework/zend-servicemanager (3.1.0)
Loading from cache
- Installing zendframework/zend-validator (2.8.1)
Loading from cache
- Installing zendframework/zend-escaper (2.5.1)
Loading from cache
- Installing zendframework/zend-uri (2.5.2)
Loading from cache
- Installing zendframework/zend-http (2.5.4)
Loading from cache
- Installing zendframework/zend-router (3.0.2)
Loading from cache
- Installing zendframework/zend-modulemanager (2.7.2)
Loading from cache
- Installing zendframework/zend-mvc (3.0.1)
Loading from cache
- Installing zendframework/zend-skeleton-installer (0.1.3)
Loading from cache
- Installing zfcampus/zf-development-mode (3.0.0)
Loading from cache
zendframework/zend-config suggests installing zendframework/zend-filter
(Zend\Filter component)
zendframework/zend-config suggests installing zendframework/zend-i18n
(Zend\I18n component)
zendframework/zend-config suggests installing zendframework/zend-json
(Zend\Json to use the Json reader or writer classes)
zendframework/zend-view suggests installing zendframework/zend-authentication
(Zend\Authentication component)
zendframework/zend-view suggests installing zendframework/zend-feed
(Zend\Feed component)
zendframework/zend-view suggests installing zendframework/zend-filter
(Zend\Filter component)
zendframework/zend-view suggests installing zendframework/zend-i18n
(Zend\I18n component)
zendframework/zend-view suggests installing zendframework/zend-json
(Zend\Json component)
zendframework/zend-view suggests installing zendframework/zend-navigation
(Zend\Navigation component)
zendframework/zend-view suggests installing zendframework/zend-paginator
(Zend\Paginator component)
zendframework/zend-view suggests installing zendframework/zend-permissions-acl
(Zend\Permissions\Acl component)
zendframework/zend-servicemanager suggests installing ocramius/proxy-manager
(ProxyManager 1.* to handle lazy initialization of services)
zendframework/zend-validator suggests installing zendframework/zend-db
(Zend\Db component)
zendframework/zend-validator suggests installing zendframework/zend-filter
(Zend\Filter component, required by the Digits validator)
zendframework/zend-validator suggests installing zendframework/zend-i18n
(Zend\I18n component to allow translation of validation error messages as well as
to use the various Date validators)
zendframework/zend-validator suggests installing zendframework/zend-i18nresources
(Translations of validator messages)
zendframework/zend-validator suggests installing zendframework/zend-math
(Zend\Math component)
zendframework/zend-validator suggests installing zendframework/zend-session
(Zend\Session component)
zendframework/zend-router suggests installing zendframework/zend-i18n
(^2.6, if defining translatable HTTP path segments)
zendframework/zend-modulemanager suggests installing zendframework/zend-console
(Zend\Console component)
zendframework/zend-mvc suggests installing zendframework/zend-json ((^2.6.1 ||
^3.0) To auto-deserialize JSON body content in AbstractRestfulController
extensions, when json_decode is unavailable)
zendframework/zend-mvc suggests installing zendframework/zend-mvc-console
(zend-mvc-console provides the ability to expose zend-mvc as a console application)
zendframework/zend-mvc suggests installing zendframework/zend-mvc-i18n
(zendmvc-i18n provides integration with zend-i18n, including a translation bridge
and translatable route segments)
zendframework/zend-mvc suggests installing zendframework/zend-mvc-pluginfileprg
(To provide Post/Redirect/Get functionality around forms that container
file uploads)
zendframework/zend-mvc suggests installing zendframework/zend-mvc-pluginflashmessenger
(To provide flash messaging capabilities between requests)
zendframework/zend-mvc suggests installing zendframework/zend-mvc-pluginidentity
(To access the authenticated identity (per zend-authentication) in controllers)
zendframework/zend-mvc suggests installing zendframework/zend-mvc-plugin-prg
(To provide Post/Redirect/Get functionality within controllers)
zendframework/zend-mvc suggests installing zendframework/zend-psr7bridge
((^0.2) To consume PSR-7 middleware within the MVC workflow)
zendframework/zend-mvc suggests installing zendframework/zend-servicemanager-di
(zend-servicemanager-di provides utilities for integrating zend-di and
zendservicemanager in your zend-mvc application)
Generating autoload files
Removing optional packages from composer.json
Updating composer.json
Removing zendframework/zend-skeleton-installer...
- Removing zendframework/zend-skeleton-installer (0.1.3)
Removed plugin zendframework/zend-skeleton-installer.
Removing from composer.json
Complete!
> zf-development-mode enable
You are now in development mode.Ahora que la aplicación está instalada, puede probarla inmediatamente usando el PHP's built-in web server -
$ cd path/to/install/myapp $ composer serveEntonces vería la siguiente respuesta:
> php -S 0.0.0.0:8080 -t public/ public/index.phpEsto iniciará el servidor CLI integrado de PHP en el puerto 8080. Una vez que se inicia el servidor de desarrollo, puede visitar el sitio en (http://localhost:8080/). El servidor CLI integrado es solo para desarrollo.
Pruebas unitarias
Para ejecutar las pruebas unitarias de esqueleto, escriba el siguiente comando en su terminal.
$ composer require --dev zendframework/zend-testProducirá la siguiente respuesta:
Using version ^3.0 for zendframework/zend-test
./composer.json has been updated
Loading composer repositories with package information
Updating dependencies (including require-dev)
- Installing zendframework/zend-dom (2.6.0)
Loading from cache
- Installing zendframework/zend-console (2.6.0)
Loading from cache
- Installing sebastian/version (2.0.1)
Loading from cache
- Installing symfony/yaml (v3.2.1)
Downloading: 100%
- Installing sebastian/resource-operations (1.0.0)
Loading from cache
- Installing sebastian/recursion-context (2.0.0)
Loading from cache
- Installing sebastian/object-enumerator (2.0.0)
Loading from cache
- Installing sebastian/global-state (1.1.1)
Loading from cache
- Installing sebastian/exporter (2.0.0)
Loading from cache
- Installing sebastian/environment (2.0.0)
Loading from cache
- Installing sebastian/diff (1.4.1)
Loading from cache
- Installing sebastian/comparator (1.2.2)
Loading from cache
- Installing phpunit/php-text-template (1.2.1)
Loading from cache
- Installing doctrine/instantiator (1.0.5)
Loading from cache
- Installing phpunit/phpunit-mock-objects (3.4.3)
Downloading: 100%
- Installing phpunit/php-timer (1.0.8)
Loading from cache
- Installing phpunit/php-file-iterator (1.4.2)
Loading from cache
- Installing sebastian/code-unit-reverse-lookup (1.0.0)
Loading from cache
- Installing phpunit/php-token-stream (1.4.9)
Loading from cache
- Installing phpunit/php-code-coverage (4.0.4)
Downloading: 100%
- Installing webmozart/assert (1.2.0)
Loading from cache
- Installing phpdocumentor/reflection-common (1.0)
Loading from cache
- Installing phpdocumentor/type-resolver (0.2.1)
Loading from cache
- Installing phpdocumentor/reflection-docblock (3.1.1)
Loading from cache
- Installing phpspec/prophecy (v1.6.2)
Loading from cache
- Installing myclabs/deep-copy (1.5.5)
Loading from cache
- Installing phpunit/phpunit (5.7.4)
Downloading: 100%
- Installing zendframework/zend-test (3.0.2)
Loading from cache
zendframework/zend-console suggests installing zendframework/zend-filter
(To support DefaultRouteMatcher usage)
symfony/yaml suggests installing symfony/console (For validating YAML files
using the lint command)
sebastian/global-state suggests installing ext-uopz (*)
phpunit/phpunit-mock-objects suggests installing ext-soap (*)
phpunit/php-code-coverage suggests installing ext-xdebug (>=2.4.0)
phpunit/phpunit suggests installing phpunit/php-invoker (~1.1)
phpunit/phpunit suggests installing ext-xdebug (*)
zendframework/zend-test suggests installing zendframework/zend-mvc-console
(^1.1.8, to test MVC <-> console integration)
Writing lock file
Generating autoload filesAhora el soporte de prueba está habilitado para que pueda ejecutar la prueba usando el siguiente comando.
$ ./vendor/bin/phpunitServidor web Apache
Alojar la aplicación basada en Zend Framework en el entorno de producción es muy simple y directo. Solo crea unVirtualHost en el archivo de configuración de Apache y apunte el DocumentRoot al Public carpeta de la aplicación Zend Framework.
A continuación se proporciona una configuración de muestra (myapp):
<VirtualHost *:80>
ServerName myapp.localhost
DocumentRoot /path/to/install/myapp/public
<Directory /path/to/install/myapp/public>
DirectoryIndex index.php
AllowOverride All
Order allow,deny
Allow from all
<IfModule mod_authz_core.c>
Require all granted
</IfModule>
</Directory>
</VirtualHost>Antes de continuar con este capítulo, comprendamos brevemente MVC. UNModel View Controlleres un enfoque de software que separa la lógica de la aplicación de la presentación. En la práctica, permite que las páginas web contengan un mínimo de secuencias de comandos PHP, ya que la presentación es independiente de ella.
La breve descripción de los componentes MVC es la siguiente
Model- El modelo representa la estructura de los datos de la aplicación. Normalmente, las clases modelo contienen funciones que ayudan aretrieve, insert y update business data en la base de datos back-end (MySQL, PostgreSQL, etc.).
View- Ver es la capa de presentación de la aplicación MVC. Obtiene los datos de los modelos a través del controlador y los muestra según sea necesario. Está débilmente acoplado alController y el Model y así, se puede cambiar sin afectar ni al Modelo ni al Controlador.
Controller- El controlador es el componente principal de la arquitectura MVC. Cada solicitud llega primero al controlador. En otras palabras, el controlador procesa toda la solicitud y actúa como intermediario entre el modelo, la vista y cualquier otro recurso necesario paraprocess the HTTP request y generar la respuesta.
En el próximo capítulo, entenderemos los diferentes conceptos del Zend Framework.
Zend Framework es una colección de más de 60 componentes. Están débilmente conectados entre sí. Se pueden utilizar tanto como componentes independientes como como un grupo de componentes que funcionan como una sola unidad.
Zend Framework proporciona los tres componentes más importantes, que son:
- zend-servicemanager
- zend-eventmanager y
- zend-modulemanager.
Proporcionan a los componentes de Zend la capacidad de integrarse con otros componentes de manera eficiente.
Event Manager- Da la capacidad de crear programación basada en eventos. Esto ayuda a crear, inyectar y gestionar nuevos eventos.
Service Manager - Da la posibilidad de consumir cualquier servicio (clases PHP) desde cualquier lugar con un poco de esfuerzo.
Module Manager - Capacidad para convertir una colección de clases PHP con una funcionalidad similar en una sola unidad llamada como module. Los módulos recién creados se pueden utilizar, mantener y configurar como una sola unidad.
Cubriremos estos conceptos en detalle en los capítulos siguientes.
Zend Framework incluye una poderosa implementación de patrones de localización de servicios llamada zend-servicemanager. Zend framework utiliza ampliamente el administrador de servicios para todas sus funcionalidades. Service Manager proporciona una abstracción de alto nivel para Zend Framework. También se integra muy bien con todos los demás componentes de Zend Framework.
Instalar Service Manager
El componente Service Manager se puede instalar utilizando el composer herramienta.
composer require zendframework/zend-servicemanagerEjemplo
Primero, todos los servicios deben registrarse en el administrador de servicios. Una vez que los servicios están registrados en el sistema de administración del servidor, se puede acceder a él en cualquier momento con un mínimo de esfuerzo. El administrador de servicios ofrece muchas opciones para registrar el servicio. Un ejemplo simple es el siguiente:
use Zend\ServiceManager\ServiceManager;
use Zend\ServiceManager\Factory\InvokableFactory;
use stdClass;
$serviceManager = new ServiceManager([
'factories' => [stdClass::class => InvokableFactory::class,],
]);El código anterior registra el stdClass en el sistema usando el Factoryopción. Ahora, podemos obtener una instancia de stdClass en cualquier momento usando elget() método del administrador de servicios como se muestra a continuación.
use Zend\ServiceManager\ServiceManager;
$object = $serviceManager->get(stdClass::class);El método get () comparte el objeto recuperado y, por lo tanto, el objeto devuelto al llamar al método get () varias veces es una y la misma instancia. Para obtener una instancia diferente cada vez, el administrador de servicios proporciona otro método, que es elbuild() método.
use Zend\ServiceManager\ServiceManager;
$a = $serviceManager->build(stdClass::class); $b = $serviceManager->build(stdClass::class);Registro de administrador de servicios
El administrador de servicios proporciona un conjunto de métodos para registrar un componente. Algunos de los métodos más importantes son los que se indican a continuación:
- Método de fábrica
- Método de fábrica abstracto
- Método de inicialización
- Método de fábrica del delegador
Discutiremos cada uno de estos en detalle en los próximos capítulos.
Método de fábrica
Una fábrica es básicamente cualquier invocable o cualquier clase que implemente el FactoryInterface (Zend \ ServiceManager \ Factory \ FactoryInterface).
FactoryInterface tiene un solo método:
public function __invoke(ContainerInterface $container, $requestedName, array $options = null)Los detalles de los argumentos de FactoryInterface son los siguientes:
container (ContainerInterface)- Es la interfaz base del ServiceManager. Brinda una opción para obtener otros servicios.
requestedName - Es el nombre del servicio.
options - Brinda opciones adicionales necesarias para el servicio.
Creemos una clase simple implementando FactoryInterface y veamos cómo registrar la clase.
Prueba de clase - Objeto a recuperar
use stdClass;
class Test {
public function __construct(stdClass $sc) { // use $sc
}
}los Test la clase depende de stdClass.
Class TestFactory - Clase para inicializar el objeto de prueba
class TestFactory implements FactoryInterface {
public function __invoke(ContainerInterface $container, $requestedName,
array $options = null) { $dep = $container->get(stdClass::class); return new Test($dep);
}
}TestFactory usa un contenedor para recuperar stdClass, crea la instancia de la clase Test y la devuelve.
Registro y uso de Zend Framework
Ahora entendamos cómo registrar y utilizar Zend Framework.
serviceManager $sc = new ServiceManager([ 'factories' => [stdClass::class => InvokableFactory::class, Test::class => TestFactory::class] ]); $test = $sc->get(Test::class);El gerente de servicio proporciona una fábrica especial llamada InvokableFactorypara recuperar cualquier clase que no tenga dependencia. Por ejemplo, elstdClass se puede configurar usando InvokableFactory ya que stdClass no depende de ninguna otra clase.
serviceManager $sc = new ServiceManager([
'factories' => [stdClass::class => InvokableFactory::class]
]);
$stdC = $sc->get(stdClass::class);Otra forma de recuperar un objeto sin implementar la FactoryInterface o usando el InvokableFactory está utilizando el método en línea como se indica a continuación.
$serviceManager = new ServiceManager([ 'factories' => [ stdClass::class => InvokableFactory::class, Test::class => function(ContainerInterface $container, $requestedName) { $dep = $container->get(stdClass::class); return new Test($dep);
},
],
]);Método de fábrica abstracta
A veces, es posible que necesitemos crear objetos, que llegamos a conocer solo en tiempo de ejecución. Esta situación se puede manejar utilizando elAbstractFactoryInterface, que se deriva de FactoryInterface.
AbstractFactoryInterface define un método para verificar si el objeto se puede crear en la instancia solicitada o no. Si la creación de objetos es posible, creará el objeto usando el__invokemethod de FactoryInterface y devuélvalo.
La firma de AbstractFactoryInterface es la siguiente:
public function canCreate(ContainerInterface $container, $requestedName)Método de inicialización
El método de inicialización es una opción especial para inyectar dependencia adicional para servicios ya creados. Implementa laInitializerInterface y la firma del único método disponible es la siguiente:
public function(ContainerInterface $container, $instance)
function(ContainerInterface $container, $instance) {
if (! $instance instanceof EventManagerAwareInterface) { return; } $instance->setEventManager($container->get(EventManager::class));
}En el ejemplo anterior, el método comprueba si la instancia es de tipo EventManagerAwareInterface. Si es de tipoEventManagerAwareInterface, establece el objeto del administrador de eventos, de lo contrario no. Dado que el método puede o no establecer la dependencia, no es confiable y produce muchos problemas de tiempo de ejecución.
Método de fábrica del delegador
Zend Framework admite el patrón de delegadores a través de DelegatorFactoryInterface. Se puede utilizar para decorar el servicio.
La firma de esta función es la siguiente:
public function __invoke(ContainerInterface $container,
$name, callable $callback, array $options = null
);Aquí el $callback es responsable de decorar la instancia de servicio.
Servicios perezosos
El servicio Lazy es uno de esos servicios que no se inicializará por completo en el momento de su creación. Solo se hace referencia a ellos y solo se inicializan cuando es realmente necesario. Uno de los mejores ejemplos es la conexión a la base de datos, que puede no ser necesaria en todos los lugares. Es un recurso costoso y su creación requiere mucho tiempo. Zend Framework proporcionaLazyServiceFactory derivado de la DelegatorFactoryInterface, que puede producir un servicio perezoso con la ayuda del Delegator concepto y un administrador de proxy de terceros, que se denomina como el ocramius proxy manager.
Plugin Manager
Plugin Manager amplía el administrador de servicios y proporciona funciones adicionales como la validación de instancias. Zend Framework utiliza ampliamente el administrador de complementos.
Por ejemplo, todos los servicios de validación se encuentran bajo el ValidationPluginManager.
Opción de configuración
El administrador de servicios ofrece algunas opciones para ampliar la función de un administrador de servicios. Sonshared, shared_by_default y aliases. Como discutimos anteriormente, los objetos recuperados se comparten entre los objetos solicitados de forma predeterminada y podemos usar elbuild()método para obtener un objeto distinto. También podemos utilizar elsharedopción para especificar qué servicio se va a compartir. losshared_by_default es igual que el shared característica, excepto que se aplica a todos los servicios.
$serviceManager = new ServiceManager([
'factories' => [
stdClass::class => InvokableFactory::class
],
'shared' => [
stdClass::class => false // will not be shared
],
'shared_by_default' => false, // will not be shared and applies to all service
]);los aliasesLa opción se puede utilizar para proporcionar un nombre alternativo a los servicios registrados. Esto tiene ventajas y desventajas. En el lado positivo, podemos proporcionar nombres cortos alternativos para un servicio. Pero, al mismo tiempo, el nombre puede quedar fuera de contexto e introducir errores.
aliases' => ['std' => stdClass::class, 'standard' => 'std']Todas las aplicaciones modernas necesitan componentes de eventos sólidos y flexibles. Zend Framework proporciona uno de esos componentes,zend-eventmanager. El zend-eventmanager ayuda a diseñar una arquitectura de alto nivel y es compatible con el patrón sujeto / observador y la programación orientada a aspectos.
Instalar Event Manager
El administrador de eventos se puede instalar usando el Composer como se especifica a continuación -
composer require zendframework/zend-eventmanagerConceptos del administrador de eventos
Los conceptos centrales del administrador de eventos son los siguientes:
Event - El evento se denomina acción arbitrariamente, digamos greet.
Listener- Cualquier devolución de llamada de PHP. Se adjuntan a los eventos y se llaman cuando se activa el evento. La firma predeterminada de Listener es:
function(EventInterface $e)EventInterface Class- Se utiliza para especificar el evento en sí. Tiene métodos para establecer y obtener información de eventos como nombre (set / getName), objetivo (get / setTarget) y parámetro (get / setParams).
EventManager class- La instancia de EventManager rastrea todos los eventos definidos en una aplicación y sus correspondientes oyentes. EventManager proporciona un método,attach para adjuntar un oyente a un evento y proporciona un método, triggerpara activar cualquier evento predefinido. Una vez que se llama al disparador, EventManager llama al oyente adjunto.
EventManagerAwareInterface- Para que una clase admita la programación basada en eventos, debe implementar EventManagerAwareInterface. Proporciona dos métodos,setEventManager y getEventManager para obtener y configurar el administrador de eventos.
Ejemplo
Escribamos una aplicación de consola PHP simple para comprender el concepto de administrador de eventos. Siga los pasos que se indican a continuación.
Cree una carpeta "eventapp".
Instalar en pc zend-eventmanager usando el compositor.
Crea un archivo PHP Greeter.php dentro de la carpeta "eventapp".
Crear clase Greeter e implementar el EventManagerAwareInterface.
require __DIR__ . '/vendor/autoload.php';
class Greeter implements EventManagerAwareInterface {
// code
}Aquí, require se utiliza para cargar automáticamente todos los componentes instalados en Composer.
Escribe el setEventManager método en clase Greeter como se muestra a continuación -
public function setEventManager(EventManagerInterface $events) { $events->setIdentifiers([ __CLASS__, get_called_class(),]);
$this->events = $events;
return $this;
}Este método establece la clase actual en el administrador de eventos dado (argumento $ eventos) y luego establece el administrador de eventos en la variable local $events.
El siguiente paso es escribir el getEventManager método en clase Greeter como se muestra a continuación -
public function getEventManager() {
if (null === $this->events) {
$this->setEventManager(new EventManager()); } return $this->events;
}El método obtiene el administrador de eventos de una variable local. si no está disponible, crea una instancia de administrador de eventos y la devuelve.
Escribe un método greet, en la clase Greeter.
public function greet($message) { printf("\"%s\" from class\n", $message);
$this->getEventManager()->trigger(__FUNCTION__, $this, $message ]);
}Este método obtiene el administrador de eventos y dispara / desencadena eventos adjuntos a él.
El siguiente paso es crear una instancia del Greeter class y adjuntar un oyente a su método, greet.
$greeter = new Greeter();
$greeter->getEventManager()->attach('greet', function($e) {
$event_name = $e->getName();
$target_name = get_class($e->getTarget());
$params_json = json_encode($e->getParams());
printf("\"%s\" event of class \"%s\" is called." .
" The parameter supplied is %s\n",
$event_name, $target_name,
$params_json);
});La devolución de llamada del oyente simplemente imprime el nombre del evento, el objetivo y los parámetros proporcionados.
La lista completa de los Greeter.php es como sigue -
<?php
require __DIR__ . '/vendor/autoload.php';
use Zend\EventManager\EventManagerInterface;
use Zend\EventManager\EventManager;
use Zend\EventManager\EventManagerAwareInterface;
class Greeter implements EventManagerAwareInterface {
protected $events;
public function setEventManager(EventManagerInterface $events) { $events->setIdentifiers([__CLASS__, get_called_class(), ]);
$this->events = $events;
return $this; } public function getEventManager() { if (null === $this->events) {
$this->setEventManager(new EventManager()); } return $this->events;
}
public function greet($message) { printf("\"%s\" from class\n", $message);
$this->getEventManager()->trigger(__FUNCTION__, $this, [$message ]); } } $greeter = new Greeter();
$greeter->greet("Hello"); $greeter->getEventManager()->attach('greet', function($e) { $event_name = $e->getName(); $target_name = get_class($e->getTarget()); $params_json = json_encode($e->getParams()); printf("\"%s\" event of class \"%s\" is called." . " The parameter supplied is %s\n", $event_name,
$target_name, $params_json);
});
$greeter->greet("Hello");Ahora, ejecute la aplicación en el símbolo del sistema php Greeter.php y el resultado será el siguiente:
"Hello" from class
"Hello" from class
"greet" event of class "Greeter" is called. The parameter supplied is ["Hello"]La aplicación de muestra anterior explica solo los conceptos básicos de un administrador de eventos. El administrador de eventos ofrece muchas opciones más avanzadas, comoListener Priority, Custom Callback Prototype / Signature, Short Circuiting, etc. El administrador de eventos se utiliza ampliamente en el marco Zend MVC.
Zend Framework proporciona un potente sistema de módulos. El sistema de módulos tiene tres componentes. Son los siguientes:
Module Autoloader- Un autocargador de módulos es responsable de ubicar y cargar módulos de una variedad de fuentes. Puede cargar módulos empaquetados comoPhar archivestambién. La implementación del autocargador de módulos se encuentra en myapp / vendor / zendframework / zend-loader / src / ModuleAutoloader.php.
Module Manager- Una vez que el autocargador de módulos localiza los módulos, el administrador de módulos dispara una secuencia de eventos para cada módulo. La implementación del Administrador de módulos se encuentra en myapp / vendor / zendframework / zendmodulemanager / src / ModuleManager.php.
Module Manager Listeners- Se pueden adjuntar a los eventos disparados por el Administrador de módulos. Al adjuntarse a los eventos del administrador de módulos, pueden hacer de todo, desde resolver y cargar módulos hasta realizar un trabajo complejo para cada módulo.
Sistema de módulo web MVC
La aplicación web MVC en Zend Framework generalmente se escribe como módulos. Un solo sitio web puede contener uno o más módulos agrupados por funcionalidad. La estructura recomendada para el módulo orientado a MVC es la siguiente:
module_root/
Module.php
autoload_classmap.php
autoload_function.php
autoload_register.php
config/
module.config.php
public/
images/
css/
js/
src/
<module_namespace>/
<code files>
test/
phpunit.xml
bootstrap.php
<module_namespace>/
<test code files>
view/
<dir-named-after-module-namespace>/
<dir-named-after-a-controller>/
<.phtml files>La estructura es la misma que se discutió en el capítulo anterior, pero aquí es genérica. losautoload_ files se puede usar como un mecanismo predeterminado para cargar automáticamente las clases disponibles en el módulo sin usar el avanzado Module Manager disponible en el zend-modulemanager.
autoload_classmap.php - Devuelve una matriz de nombre de clase y su nombre de archivo correspondiente.
autoload_function.php- Devuelve una devolución de llamada de PHP. Esto puede utilizar clases devueltas por autoload_classmap.php.
autoload_register.php - Registra la devolución de llamada PHP que es devuelta por autoload_function.php.
Estos archivos de carga automática no son obligatorios, pero se recomiendan. En la aplicación de esqueleto, no hemos utilizado elautoload_ files.
Clase de módulo
La clase Module debe llamarse Module y el espacio de nombres de la clase del módulo debe ser Module name. Esto ayudará a Zend Framework a resolver y cargar el módulo fácilmente. losApplication El código del módulo en la aplicación esqueleto (myapp), myapp / module / Application / src / Module.php es el siguiente:
namespace Application;
class Module {
const VERSION = '3.0.2dev';
public function getConfig() {
return include __DIR__ . '/../config/module.config.php';
}
}El administrador del módulo Zend Framework llamará al getConfig() funcionará automáticamente y realizará los pasos necesarios.
En este capítulo, entendamos la estructura de la aplicación Zend Framework. La estructura de lamyapp la aplicación es la siguiente:
├── composer.json
├── composer.lock
├── CONDUCT.md
├── config
│ ├── application.config.php
│ ├── autoload
│ │ ├── development.local.php
│ │ ├── development.local.php.dist
│ │ ├── global.php
│ │ ├── local.php.dist
│ │ ├── README.md
│ │ └── zend-developer-tools.local-development.php
│ ├── development.config.php
│ ├── development.config.php.dist
│ └── modules.config.php
├── CONTRIBUTING.md
├── data
│ └── cache
│ └── module-classmap-cache.application.module.cache.php ├── docker-compose.yml
├── Dockerfile
├── LICENSE.md
├── module
│ └── Application
│ ├── config
│ ├── src
│ ├── test
│ └── view
├── phpcs.xml
├── phpunit.xml.dist
├── public
│ ├── css
│ │ ├── bootstrap.css
│ │ ├── bootstrap.css.map
│ │ ├── bootstrap.min.css
│ │ ├── bootstrap.min.css.map
│ │ ├── bootstrap-theme.css
│ │ ├── bootstrap-theme.css.map
│ │ ├── bootstrap-theme.min.css
│ │ ├── bootstrap-theme.min.css.map
│ │ └── style.css
│ ├── fonts
│ │ ├── glyphicons-halflings-regular.eot
│ │ ├── glyphicons-halflings-regular.svg
│ │ ├── glyphicons-halflings-regular.ttf
│ │ ├── glyphicons-halflings-regular.woff
│ │ └── glyphicons-halflings-regular.woff2
│ ├── img
│ │ ├── favicon.ico
│ │ └── zf-logo-mark.svg
│ ├── index.php
│ ├── js
│ │ ├── bootstrap.js
│ │ ├── bootstrap.min.js
│ │ └── jquery-3.1.0.min.js
│ └── web.config
├── README.md
├── TODO.md
├── Vagrantfile
└── vendor
├── autoload.php
├── bin
│ ├── phpunit -> ../phpunit/phpunit/phpunit
│ ├── templatemap_generator.php -> ../zendframework/zend-
view/bin/templatemap_generator.php
│ └── zf-development-mode -> ../zfcampus/zf-development-mode/bin/zf-
development-mode
├── composer
│ ├── autoload_classmap.php
│ ├── autoload_namespaces.php
│ ├── autoload_psr4.php
│ ├── autoload_real.php
│ ├── ClassLoader.php
│ ├── installed.json
│ └── LICENSE
├── container-interop
│ └── container-interop
├── doctrine
│ └── instantiator
├── myclabs
│ └── deep-copy
├── phpdocumentor
│ ├── reflection-common
│ ├── reflection-docblock
│ └── type-resolver
├── phpspec
│ └── prophecy
├── phpunit
│ ├── php-code-coverage
│ ├── php-file-iterator
│ ├── php-text-template
│ ├── php-timer
│ ├── php-token-stream
│ ├── phpunit
│ └── phpunit-mock-objects
├── sebastian
│ ├── code-unit-reverse-lookup
│ ├── comparator
│ ├── diff
│ ├── environment
│ ├── exporter
│ ├── global-state
│ ├── object-enumerator
│ ├── recursion-context
│ ├── resource-operations
│ └── version
├── symfony
│ └── yaml
├── webmozart
│ └── assert
├── zendframework
│ ├── zend-component-installer
│ ├── zend-config
│ ├── zend-console
│ ├── zend-dom
│ ├── zend-escaper
│ ├── zend-eventmanager
│ ├── zend-http
│ ├── zend-loader
│ ├── zend-modulemanager
│ ├── zend-mvc
│ ├── zend-router
│ ├── zend-servicemanager
│ ├── zend-stdlib
│ ├── zend-test
│ ├── zend-uri
│ ├── zend-validator
│ └── zend-view
└── zfcampus
└── zf-development-mode
73 directories, 55 filesLa aplicación Zend Framework consta de diferentes carpetas. Son los siguientes:
Application- Este directorio contiene su aplicación. Albergará el sistema MVC, así como las configuraciones, los servicios utilizados y su archivo de arranque.
Config - Este directorio contiene los archivos de configuración de una aplicación.
Data - Este directorio proporciona un lugar para almacenar datos de aplicaciones que son volátiles y posiblemente temporales.
Module - Los módulos permiten a un desarrollador agrupar un conjunto de controladores relacionados en un grupo organizado lógicamente.
Public- Esta es la raíz del documento de la aplicación. Inicia la aplicación Zend. También contiene los activos de la aplicación como JavaScript, CSS, imágenes, etc.
Vendor - Este directorio contiene dependencias del compositor.
Estructura de los módulos de aplicación
Este es el directorio principal de su aplicación. Zend Framework 2 presenta un sistema de módulos potente y flexible para organizar la aplicación de manera eficiente. losApplicationEl módulo de la aplicación esqueleto (myapp) proporciona configuración de arranque, error y enrutamiento a toda la aplicación. La estructura de laApplication módulo es como se muestra a continuación -
├── module
│ └── Application
│ ├── config
│ │ └── module.config.php
│ ├── src
│ │ ├── Controller
│ │ │ └── IndexController.php
│ │ └── Module.php
│ ├── test
│ │ └── Controller
│ │ └── IndexControllerTest.php
│ └── view
│ ├── application
│ │ └── index
│ │ └── index.phtml
│ ├── error
│ │ ├── 404.phtml
│ │ └── index.phtml
│ └── layout
│ └── layout.phtmlCubramos cada uno de estos directorios de módulos en detalle:
Application- Este es el directorio raíz del módulo. El nombre de la carpeta coincidirá con el nombre del módulo y el nombre también se usa como el espacio de nombres PHP de toda la clase definida dentro del módulo. Albergará el sistema MVC, así como las configuraciones, los servicios utilizados y su archivo de arranque.
Config - Configuración independiente del módulo.
Src - Lógica empresarial principal de la aplicación.
View- Contiene archivos de diseño / presentación (HTML). Por ejemplo, index.phtml.
src/Module.php- Es el corazón del módulo. Funciona como un "controlador frontal" para el módulo. El proceso Zendsrc/Module.php archivo antes de procesar cualquier clase PHP en este módulo.
Application/config/module.config.php - Está implementado para la configuración del enrutador y la carga automática de archivos.
Application/view/layout- Los diseños representan las partes comunes de varias vistas. Por ejemplo, encabezado y pie de página. Por defecto, los diseños deben almacenarse en elviews/layoutsfolder.
Todos los módulos comparten la misma estructura o una estructura similar a la del módulo de aplicación anterior .
En este capítulo, aprenderemos cómo crear un módulo basado en MVC en Zend Framework. Creemos un módulo llamado comoTutorial comprender el proceso de creación del módulo.
Crea una nueva clase PHP llamada Module dentro del directorio –myapp / module / Tutorial / src / e implementar ConfigProviderInterface.
Conjunto Tutorial como el espacio de nombres para el Module clase.
Escribe una función pública getConfig en el Module class y devolver el archivo de configuración para el Tutorial Módulo.
El código completo para el Module la clase es la siguiente:
<?php
namespace Tutorial;
use Zend\ModuleManager\Feature\ConfigProviderInterface;
class Module implements ConfigProviderInterface {
public function getConfig() {
return include __DIR__ . '/../config/module.config.php';
}
}Configurar el Tutorial módulo en el composer.json bajo la autoload sección utilizando el siguiente código.
"autoload": {
"psr-4": {
"Application\\": "module/Application/src/",
"Tutorial\\": "module/Tutorial/src/"
}
}Actualiza la aplicación usando el compositor update comando como se muestra a continuación.
composer updatelos composer El comando hará los cambios necesarios en la aplicación y mostrará los registros en el símbolo del sistema como se muestra a continuación:
Loading composer repositories with package information
Updating dependencies (including require-dev)
- Removing zendframework/zend-component-installer (0.3.0)
- Installing zendframework/zend-component-installer (0.3.1)
Downloading: 100%
- Removing zendframework/zend-stdlib (3.0.1)
- Installing zendframework/zend-stdlib (3.1.0)
Loading from cache
- Removing zendframework/zend-eventmanager (3.0.1)
- Installing zendframework/zend-eventmanager (3.1.0)
Downloading: 100%
- Removing zendframework/zend-view (2.8.0)
- Installing zendframework/zend-view (2.8.1)
Loading from cache
- Removing zendframework/zend-servicemanager (3.1.0)
- Installing zendframework/zend-servicemanager (3.2.0)
Downloading: 100%
- Removing zendframework/zend-escaper (2.5.1)
- Installing zendframework/zend-escaper (2.5.2)
Loading from cache
- Removing zendframework/zend-http (2.5.4)
- Installing zendframework/zend-http (2.5.5)
Loading from cache
- Removing zendframework/zend-mvc (3.0.1)
- Installing zendframework/zend-mvc (3.0.4)
Downloading: 100%
- Removing phpunit/phpunit (5.7.4)
- Installing phpunit/phpunit (5.7.5)
Downloading: 100%
Writing lock file
Generating autoload filesCree el archivo de configuración del módulo, "module.config.php" en /config/ con el siguiente código -
<?php
namespace Tutorial;
use Zend\ServiceManager\Factory\InvokableFactory;
use Zend\Router\Http\Segment;
return [
'controllers' => [
'factories' => [Controller\TutorialController::class => InvokableFactory::class,],
],
'view_manager' => [
'template_path_stack' => ['tutorial' => __DIR__ . '/../view',],
],
];El archivo de configuración tiene tres partes y son las siguientes:
Controller configuration - Especifique los controladores disponibles dentro del Módulo.
Routing configuration - Especifique cómo los controladores del módulo deben resolverse en URL.
View configuration - Especifique la configuración relacionada para ver el motor, como la ubicación de las vistas, etc.
Configurar el Tutorial módulo en el archivo de configuración de nivel de aplicación - myapp / config / modules.config.php.
return ['Zend\Router', 'Zend\Validator', 'Application', 'Tutorial'];Ejecute la aplicación ejecutando el composer serve en la raíz de la carpeta de la aplicación.
Hemos agregado con éxito un nuevo módulo, pero aún necesitamos agregar el Controller, Routing y Views para ejecutar con éxito el Tutorial módulo.
Como se discutió anteriormente, el controllerjuega un papel importante en Zend MVC Framework. Todas las páginas web de una aplicación deben ser manejadas por un controlador.
En Zend MVC Framework, los controladores son objetos que implementan - Zend / Stdlib / DispatchableInterface. losDispatchableInterface tiene un solo método, dispatch, que obtiene el Request objeto como entrada, hacer algo de lógica y devuelve Response un objeto como salida.
dispatch(Request $request, Response $response = null)Un ejemplo simple de un objeto Controller para devolver "Hello World" es el siguiente:
use Zend\Stdlib\DispatchableInterface;
use Zend\Stdlib\RequestInterface as Request;
use Zend\Stdlib\ResponseInterface as Response;
class HelloWorld implements DispatchableInterface {
public function dispatch(Request $request, Response $response = null) { $response->setContent("Hello World!");
}
}los DispatchableInterfacees básico y necesita muchas otras interfaces para escribir controladores de alto nivel. Algunas de estas interfaces son las siguientes:
InjectApplicationEventInterface - Se utiliza para inyectar eventos (Zend EventManager)
ServiceLocatorAwareInterface - Se utiliza para localizar servicios (Zend ServiceManager)
EventManagerAwareInterface - Se utiliza para gestionar eventos (Zend EventManager)
Teniendo esto en cuenta, Zend Framework proporciona muchos controladores listos para usar que implementan estas interfaces. Los controladores más importantes se explican a continuación.
ResumenAcciónControlador
AbstractActionController (Zend / Mvc / Controller / AbstractActionController) es el controlador más utilizado en Zend MVC Framework. Tiene todas las características necesarias para escribir una página web típica. Permite que las rutas (el enrutamiento coincida con la URL de solicitud con un controlador y uno de sus métodos) coincidan con unaaction. Cuando coincida, el controlador llamará a un método con el nombre de la acción.
Por ejemplo, si una ruta test se empareja y la ruta, test devoluciones hello para la acción, entonces el helloAction se invocará el método.
Escribamos nuestro TutorialController utilizando el AbstractActionController.
Crea una nueva clase PHP llamada TutorialController extendiendo el AbstractActionController y colóquelo en el module/Tutorial/src/Controller/ directorio.
Selecciona el Tutorial\Controller como espacio de nombres.
Escribe un indexAction método.
Devuelve el ViewModel objeto de indexActionmétodo. losViewModel El objeto se utiliza para enviar datos desde el controlador al motor de visualización, que veremos en los capítulos siguientes.
La lista completa de códigos es la siguiente:
?php
namespace Tutorial\Controller;
use Zend\Mvc\Controller\AbstractActionController;
use Zend\View\Model\ViewModel;
class TutorialController extends AbstractActionController {
public function indexAction() {
return new ViewModel();
}
}Hemos agregado con éxito el nuevo TutorialController.
ResumenRestfulController
AbstractRestfulController (Zend \ Mvc \ Controller \ AbstractRestfulController) inspecciona el HTTP method de la solicitud entrante y coincide con la acción (método) considerando los métodos HTTP
Por ejemplo, la solicitud con el método GET HTTP coincide con el getList() método o el get() método, si el id El parámetro se encuentra en la solicitud.
ResumenConsolaControlador
AbstractConsoleController (Zend \ Mvc \ Controller \ AbstractConsoleController) es como AbstractActionController excepto que solo se ejecuta en el entorno de la consola en lugar de en un navegador.
Mapas de enrutamiento Request URIal método de un controlador específico. En este capítulo, veremos cómo implementar las rutas en un Zend Framework.
En general, cualquier URI tiene tres partes:
- Segmento de nombre de host,
- Segmento de ruta, y
- Segmento de consulta.
Por ejemplo, en URI / URL - http://www.example.com/index?q=data, www.example.com es el segmento de nombre de host, index es el segmento de ruta y q=dataes el segmento de consulta. Generalmente, el enrutamiento verificaPage segmentcontra un conjunto de restricciones. Si alguna restricción coincide, devuelve un conjunto de valores. Uno de los principales valores es el controlador.
El enrutamiento también verifica el segmento de host, el segmento de consulta, los métodos HTTP de solicitud, los encabezados HTTP de solicitud, etc., en una situación determinada.
Ruta y RouteStack
La ruta es el objeto principal del enrutamiento. Zend Framework tiene una interfaz especial para el objeto de ruta,RouteInterface. Todo el objeto de ruta necesita implementar RouteInterface. La lista completa de RouteInterface es la siguiente:
namespace Zend\Mvc\Router;
use Zend\Stdlib\RequestInterface as Request;
interface RouteInterface {
public static function factory(array $options = []); public function match(Request $request);
public function assemble(array $params = [], array $options = []);
}El método principal es match. Este método de coincidencia compara la solicitud dada con la restricción definida en ella. Si se encuentra alguna coincidencia, devuelve elRouteMatchobjeto. Este objeto RouteMatch proporciona los detalles de la solicitud coincidente como parámetros. Estos parámetros se pueden extraer deRouteObject utilizando el getParams método.
La lista completa de RouteObject es la siguiente:
namespace Zend\Mvc\Router;
class RouteMatch {
public function __construct(array $params); public function setMatchedRouteName($name);
public function getMatchedRouteName();
public function setParam($name, $value);
public function getParams();
public function getParam($name, $default = null);
}En general, una aplicación MVC típica tiene muchas rutas. Cada una de estas rutas se procesará en orden LIFO y se comparará y devolverá una sola ruta. Si ninguna ruta coincide / devuelve, la aplicación devuelve el error "Página no encontrada". Zend Framework proporciona una interfaz para procesar las rutas,RouteStackInterface. Esta RouteStackInterface tiene la opción de agregar / eliminar rutas.
La lista completa de RouteStackInterface es la siguiente:
namespace Zend\Mvc\Router;
interface RouteStackInterface extends RouteInterface {
public function addRoute($name, $route, $priority = null); public function addRoutes(array $routes);
public function removeRoute($name); public function setRoutes(array $routes);
}Zend framework proporciona dos implementaciones del RouteStack interfaz y son los siguientes:
- SimpleRouteStack
- TreeRouteStack
Tipo de rutas
Zend framework proporciona muchos objetos de ruta listos para usar para todas las situaciones en el espacio de nombres "Zend \ Mvc \ Router \ Http". Es suficiente seleccionar y usar el objeto de ruta adecuado para la situación dada.
Las rutas disponibles son las siguientes:
Hostname - Se utiliza para hacer coincidir la parte del host del URI.
Literal - Se utiliza para coincidir con el URI exacto.
Method - Se utiliza para hacer coincidir el método HTTP de la solicitud entrante.
Part - Se utiliza para hacer coincidir la parte del segmento de ruta de URI mediante lógica personalizada.
Regex - Se utiliza para hacer coincidir el segmento de ruta de URI por patrón Regex.
Schema - Se utiliza para coincidir con el esquema de URI como http, https, etc.
Segment - Se utiliza para hacer coincidir la ruta de URI dividiéndola en varios segmentos.
Veamos cómo escribir la ruta literal y de segmento más utilizada. Las rutas generalmente se especifican en el archivo de configuración de cada módulo:module.config.php.
Ruta literal
Normalmente, las rutas se consultan en un orden LIFO. La ruta literal es para hacer la coincidencia exacta de la ruta URI.
Se define como se muestra a continuación:
$route = Literal::factory(array(
'route' => '/path',
'defaults' => array('controller' => 'Application\Controller\IndexController',
'action' => 'index',),
));La ruta anterior coincide con la /path en la URL de solicitud y devuelve index como el action y IndexController como controlador.
Ruta del segmento
Una ruta segmentada se utiliza siempre que se supone que su URL contiene parámetros variables.
Se describe como se indica a continuación:
$route = Segment::factory(array(
'route' => '/:controller[/:action]',
'constraints' => array(
'controller' => '[a-zA-Z][a-zA-Z0-9_-]+',
'action' => '[a-zA-Z][a-zA-Z0-9_-]+',
),
'defaults' => array(
'controller' => 'Application\Controller\IndexController',
'action' => 'index',),
));Aquí, los segmentos se indican con dos puntos y seguidos de caracteres alfanuméricos. Si mantiene un segmento como opcional, se encierra entre corchetes. Cada segmento puede tener limitaciones asociadas. Cada restricción es una expresión regular.
Configuración de ruta en el módulo tutorial
Agreguemos una ruta de segmento en nuestro módulo Tutorial. Actualice el archivo de configuración del módulo tutorial -module.config.php disponible en myapp/module/Tutorial/config.
<?php
namespace Tutorial;
use Zend\ServiceManager\Factory\InvokableFactory;
use Zend\Router\Http\Segment;
return [
'controllers' => [
'factories' => [
Controller\TutorialController::class => InvokableFactory::class,
],
],
'router' => [
'routes' => [
'tutorial' => [
'type' => Segment::class,
'options' => [
'route' => '/tutorial[/:action[/:id]]',
'constraints' => [
'action' => '[a-zA-Z][a-zA-Z0-9_-]*',
'id' => '[0-9]+',
],
'defaults' => [
'controller' => Controller\TutorialController::class,
'action' => 'index',
],
],
],
],
],
'view_manager' => [
'template_path_stack' => ['tutorial' => __DIR__ . '/../view',],
],
];Hemos agregado con éxito el enrutamiento para nuestro Tutorialmódulo. Estamos a un paso de completar nuestro módulo Tutorial. Necesitamos agregarView para nuestro módulo, que aprenderemos en el capítulo siguiente.
Una capa de vista es la capa de presentación de la aplicación MVC. Separa la lógica de la aplicación de la lógica de presentación. En una aplicación web PHP típica, toda la lógica empresarial y el diseño están mezclados. La mezcla permite un desarrollo más rápido en un proyecto pequeño. Pero falla miserablemente en proyectos grandes, donde se involucra mucha arquitectura de alto nivel. Para cambiar el diseño de la aplicación web, el desarrollador también debe trabajar en la lógica empresarial. Esto puede ser catastrófico y provocar la ruptura de la lógica empresarial.
Zend Framework proporciona una capa de visualización bien pensada, limpia, flexible y ampliable. La capa Ver está disponible como un módulo separado,Zend/View e integrar bien con Zend/Mvcmódulo. La capa de vista de Zend está separada en varios componentes que interactúan muy bien entre sí.
Sus diversos componentes son los siguientes:
Variables Containers - Contiene los datos de la capa de vista.
View Models - Contiene contenedores variables y plantilla de diseño.
Renderers - Procese los datos y la plantilla de View Model y genere una representación de diseño, tal vez la salida html final.
Resolvers - Resuelve la plantilla disponible en el Modelo de Vista de tal manera que el Renderer pueda consumir.
View (Zend\View\View) - Solicitud de mapas al renderizador y luego el renderizador a la respuesta.
Rendering Strategies - Utilizado por Vista para mapear la solicitud al renderizador.
Response Strategies - Utilizado por Vista para asignar el renderizador a la respuesta.
La capa de vista, View procesa el ViewModel, resuelve la plantilla usando un Resolver, renderícelo usando Rendering Strategy y finalmente lo emite usando el Response Renderer.
Ver configuración de capa
Al igual que el controlador, una capa de vista se puede configurar en el archivo de configuración de un módulo llamado como - module.config.php. La configuración principal es especificar dónde se colocarán las plantillas. Esto se puede lograr agregando la siguiente configuración en el "module.config.php".
'view_manager' => [
'template_path_stack' => ['tutorial' => __DIR__ . '/../view',],
]De forma predeterminada, la capa Ver tiene un comportamiento predeterminado para todos sus componentes. Por ejemplo, unViewModelresuelve el nombre de plantilla de la acción de un controlador dentro de la raíz de la plantilla mediante la regla “nombre-módulo-minúsculas / nombre-controlador-minúsculas / nombre-acción-minúsculas”. Sin embargo, esto puede ser anulado porsetTemplate() método de ViewModel.
Controladores y capa de vista
De forma predeterminada, un controlador no necesita enviar ningún dato a la capa de visualización. Basta con escribir la plantilla en el lugar adecuado.
Por ejemplo, en nuestro ejemplo, TutorialController, la plantilla debe colocarse en myapp/module/Tutorial/view/tutorial/tutorial/index.phtml. losindex.phtmlhace referencia a la plantilla basada en PHP y será renderizada por PHPRenderer. Hay otros renderizadores comoJsonRenderer para json salida y FeedRenderer para rss y atom salida.
La lista completa es la siguiente:
<?php
namespace Tutorial\Controller;
use Zend\Mvc\Controller\AbstractActionController;
use Zend\View\Model\ViewModel;
class TutorialController extends AbstractActionController {
public function indexAction() {
}
}Plantilla de aplicación Zend
<div class = "row content">
<h3>This is my first Zend application</h3>
</div>Finalmente, hemos completado con éxito el Tutorial módulo y podemos acceder a él usando url - http://localhost:8080/tutorial.
Pasar datos a la capa de visualización
La forma más sencilla de enviar los datos a una capa de vista es utilizar el ViewModelargumentos. El cambiadoindexAction El método es el siguiente:
public function indexAction() {
$view = new ViewModel([ 'message' => 'Hello, Tutorial' ]); return $view;
}Ahora, cambie el index.phtml archivo de la siguiente manera:
<div class = "row content">
<h3>This is my first Zend application</h3>
<h4><?php echo $this->message?></h4>
</div>Ver ayudantes
Un View Helper se usa para escribir pequeñas funciones atómicas que se usarán en plantillas. Zend framework proporciona una interfaz, Zend \ View \ Helper \ HelperInterface para escribir ayudantes de vista estándar.
Una HelperInterface tiene solo dos métodos,
setView() - Este método acepta una instancia / implementación de Zend \ View \ Renderer \ RendererInterface.
getView() - Se usa para recuperar esa instancia.
La lista completa de códigos de HelperInterface es como sigue -
namespace Zend\View\Helper;
use Zend\View\Renderer\RendererInterface as Renderer;
interface HelperInterface {
/**
* Set the View object
*
* @param Renderer $view
* @return HelperInterface
*/
public function setView(Renderer $view);
/**
* Get the View object
*
* @return Renderer
*/
public function getView();
}Para usar un ayudante en su script de vista, acceda a él usando $this->helperName().
Ayudantes incorporados
Zend Framework proporciona una gran cantidad de funciones de ayuda incorporadas para varios propósitos. Algunos de los ayudantes de vista disponibles enzend-mvc son los siguientes:
URL
El asistente de URL se utiliza para generar las URL que coinciden con las rutas definidas en la aplicación.
La definición del asistente de URL es:
$this->url($name, $params, $options, $reuseMatchedParameters)Por ejemplo, en el módulo tutorial, la ruta se denomina como tutorial y tiene dos parámetros action y id. Podemos usar el asistente de URL para generar dos URL diferentes como se muestra a continuación:
<a href = "<? = $this->url('tutorial'); ?>">Tutorial Index</a>
<a href = "<? = $this->url('tutorial', ['action' => 'show', 'id' =>10]); ?>">
Details of Tutorial #10
</a>El resultado será el siguiente:
<a href = "/tutorial">Tutorial Index</a>
<a href = "/tutorial/show/10"> Details of Tutorial #10</a>Marcador de posición
El asistente de marcador de posición se utiliza para conservar contenido entre scripts de vista e instancias de vista. Proporciona la opción de configurar los datos inicialmente y luego usarlos en etapas posteriores.
Por ejemplo, podemos establecer, digamos company name y luego úselo en todos los demás lugares.
<?php $this->placeholder('companyname')->set("TutorialsPoint") ?>
<?= $this->placeholder('companyname'); ?>Un marcador de posición proporciona algunas de las opciones avanzadas para generar contenido complejo a partir de objetos y matrices PHP. También tiene la opción de capturar cierta sección de la propia plantilla.
Por ejemplo, el siguiente código captura el resultado de la plantilla en el medio y lo almacena en el productlist marcador de posición.
Class – Product
class Product {
public $name;
public $description;
}Controller
$p1 = new Product();
$p1->name = 'Car'; $p1->description = 'Car';
$p2 = new Product(); $p2->name = 'Cycle';
$p2->description = 'Cycle'; $view = new ViewModel(['products' => $products]);Template
<!-- start capture -->
<?php $this->placeholder('productlist')->captureStart();
foreach ($this->products as $product): ?>
<div>
<h2><?= $product->name ?></h2> <p><?= $product->description ?></p>
</div>
<?php endforeach; ?>
<?php $this->placeholder('productlist')->captureEnd() ?> <!-- end capture --> <?= $this->placeholder('productlist') ?>Result
<div class = "foo">
<h2>Car</h2>
<p>Car</p>
</div>
<div class = "foo">
<h2>Cycle</h2>
<p>Cycle</p>
</div>Doctype
El ayudante de Doctype se utiliza para generar varios tipos de documento HTML. Es la implementación concreta delPlaceholderayudante. El tipo de documento se puede configurar en un archivo de arranque y un archivo de configuración.
El uso básico se muestra a continuación:
Application Bootstrap file
use Zend\View\Helper\Doctype;
$doctypeHelper = new Doctype(); $doctypeHelper->doctype('XHTML5');Module Configuration
// module/Application/config/module.config.php:
return [
/* ... */
'view_manager' => [
'doctype' => 'html5',
/* ... */
],
];Template
<?php echo $this->doctype() ?>HeadTitle
El ayudante HeadTitle se utiliza para generar el elemento de título html. Es la implementación concreta dePlaceholderayudante. Zend proporciona una opción para establecer el título en el archivo de configuración del módulo y se puede establecer en cualquier nivel como sitio, módulo, controlador, acción, etc. Un código parcial para HeadTitle es el siguiente:
Module
headTitleHelper->append($action);
$headTitleHelper->append($controller);
$headTitleHelper->append($module);
$headTitleHelper->append($siteName);Template
<?= $this->headTitle() ?>Result
action - controller - module - Zend FrameworkHeadMeta
El ayudante HeadMeta se utiliza para generar etiquetas meta html. Es una implementación concreta del asistente de marcador de posición.
Template -
<?php
$this->headMeta()->appendName('keywords', 'turorialspoint, zend framework, php');
echo $this->headMeta()
?>Result
<meta name = "keywords" content = "tutorialspoint, zend framework, php" />HeadLink
El asistente HeadLink se utiliza para generar enlaces html para incluir recursos externos. Es una implementación concreta del asistente de marcador de posición.
Template
<?php
// setting links in a view script:
$this->headLink(['rel' => 'icon', 'href' => '/img/favicon.ico'], 'PREPEND')
->appendStylesheet('/styles/site.css')
->prependStylesheet('/styles/mystyle.css', 'screen', true, ['id' => 'mystyle']);
// rendering the links from the layout:
echo $this->headLink();
?>Result
<link href = "/styles/mystyle.css" media = "screen" rel = "stylesheet"
type = "text/css" id = "mystyle">
<link href = "/img/favicon.ico" rel = "icon">
<link href = "/styles/site.css" media = "screen" rel = "stylesheet" type = "text/css">HeadStyle
El ayudante HeadStyle se utiliza para generar estilos CSS en línea. Es una implementación concreta del asistente de marcador de posición.
Template
<?php $this->headStyle()->appendStyle($styles); ?> <?php echo $this->headStyle() ?>HeadScript
El HeadScript se utiliza para generar secuencias de comandos en línea o para incluir secuencias de comandos externas. Es una implementación concreta del asistente de marcador de posición.
Template
<? $this->headScript()->appendFile(‘/js/sample.js’);?> <?php echo $this->headScript() ?>InlineScript
El InlineScript se utiliza para generar un script tanto en la sección principal como en la del cuerpo de la plantilla html. Se deriva de HeadScript.
HTMLList
La HTMLList se utiliza para generar listas ordenadas y desordenadas. La definición de HTMLList es la siguiente:
Definition
htmlList($items, $ordered, $attribs, $escape)Template
$items = [ '2015', ['March', 'November'], '2016', ]; echo $this->htmlList($items);Result
<ul>
<li>2015
<ul>
<li>March</li>
<li>November</li>
</ul>
</li>
<li>2016</li>
</ul>Ciclo
Un ciclo se utiliza para generar alternativas en un entorno de bucle. Tiene función de asignación, siguiente y anterior.
Controller
$view = new ViewModel(['message' => 'Hello, Tutorial', 'data' => array('One', 'Two')]);Template
<?php $this->cycle()->assign(['#F0F0F0', '#FFF'], 'colors'); ?> <table> <?php foreach ($this->data as $datum): ?> <tr style = "background-color: <?= $this->cycle()->setName('colors')>next() ?>">
<td><?= $this->escapeHtml($datum) ?></td>
</tr>
<?php endforeach ?>
</table>Result
<table>
<tr style = "background-color: #F0F0F0">
<td>One</td>
</tr>
<tr style = "background-color: #FFF">
<td>Two</td>
</tr>
</table>Algunos otros ayudantes incorporados importantes son los siguientes:
BasePath - BasePath se utiliza para generar la ruta de la carpeta pública de la raíz de la aplicación.
Partial - Parcial se utiliza para representar una plantilla específica en su propio ámbito variable.
PartialLoop - PartialLoop es como Partial, pero se usa en el entorno de bucle.
Identity - La identidad se utiliza para recuperar la identidad del usuario que inició sesión del Servicio de autenticación.
JSON- JSON se utiliza en un entorno tranquilo, donde la salida está en formato JSON. Emite un encabezado HTTP adecuado y deshabilita el concepto de diseño.
Todavía hay muchos ayudantes disponibles en Zend Framework, como el i18n helper, form helpers, pagination helpers, navigation helpersetc.
Crear ayudantes de vista
Zend Framework proporciona una función AbstractHelper implementar HelperInterface para escribir ayudantes de vista.
Los pasos necesarios para escribir un nuevo ayudante son los siguientes:
Step 1 - Amplíe la clase Zend \ View \ Helper \ AbstractHelper.
Step 2 - Anular el __invoke() función.
Step 3 - Establecer la configuración en el module.config.php file.
Step 4 - Utilice el asistente de visualización en los scripts de visualización.
Creemos ahora un TestHelper
Crear carpeta de ayuda en myapp/module/Tutorial/src/View directory. EscribirTestHelper dentro del directorio de ayuda, TestHelper.php.
La lista completa es la siguiente:
<?php
namespace Tutorial\View\Helper;
use Zend\View\Helper\AbstractHelper;
class TestHelper extends AbstractHelper {
public function __invoke() {
$output = "I am from test helper"; return htmlspecialchars($output, ENT_QUOTES, 'UTF-8');
}
}Establecer configuración en module.config.php.
'view_helpers' => [
'aliases' => [
'testHelper' => View\Helper\TestHelper::class,
],
'factories' => [
View\Helper\TestHelper::class => InvokableFactory::class,
],
],Utilice el recién creado TestHelper en el about ver guión.
<?= $this->testHelper() ?>Un diseño representa las partes comunes de varias vistas, por ejemplo, encabezado y pie de página. Por defecto, los diseños deben almacenarse en elview/layout carpeta.
Una configuración de diseño se define en el view_manager en la sección module.config.php.
La configuración predeterminada de la aplicación esqueleto es la siguiente:
'view_manager' => array(
'display_not_found_reason' => true,
'display_exceptions' => true,
'doctype' => 'HTML5',
'not_found_template' => 'error/404',
'exception_template' => 'error/index',
'template_map' => array(
'layout/layout' => __DIR__ . '/../view/layout/layout.phtml',
'application/index/index' => __DIR__ . '/../view/application/index/index.phtml',
'error/404' => __DIR__ . '/../view/error/404.phtml',
'error/index' => __DIR__ . '/../view/error/index.phtml',
),
'template_path_stack' => array(
__DIR__ . '/../view',
),Aquí el template_mapse utiliza para especificar el diseño. Si no se encuentra el diseño, devolverá un error. Echemos un vistazo al diseño principal de la aplicación esqueleto.
Layout.phtml
<?= $this->doctype() ?>
<html lang = "en">
<head>
<meta charset = "utf-8">
<?= $this->headTitle('ZF Skeleton Application')->setSeparator(' - ')> setAutoEscape(false) ?> <?= $this->headMeta()
->appendName('viewport', 'width = device-width, initial-scale = 1.0')
->appendHttpEquiv('X-UA-Compatible', 'IE = edge')
?>
<!-- Le styles -->
<?= $this->headLink(['rel' => 'shortcut icon', 'type' => 'image/vnd.microsoft.icon', 'href' => $this->basePath() . '/img/favicon.ico'])
->prependStylesheet($this->basePath('css/style.css')) ->prependStylesheet($this->basePath('css/bootstraptheme.min.css'))
->prependStylesheet($this->basePath('css/bootstrap.min.css')) ?> <!-- Scripts --> <?= $this->headScript()
->prependFile($this->basePath('js/bootstrap.min.js')) ->prependFile($this->basePath('js/jquery-3.1.0.min.js'))
?>
</head>
<body>
<nav class = "navbar navbar-inverse navbar-fixed-top" role = "navigation">
<div class = "container">
<div class = "navbar-header">
<button type = "button" class = "navbar-toggle" data-
toggle = "collapse" data-target = ".navbar-collapse">
<span class = "icon-bar"></span>
<span class = "icon-bar"></span>
<span class = "icon-bar"></span>
</button>
<a class = "navbar-brand" href = "<?= $this->url('home') ?>"> <img src = "<?= $this->basePath('img/zf-logo-mark.svg') ?>
" height = "28" alt = "Zend Framework <?= \Application\Module::
VERSION ?>"/> Skeleton Application
</a>
</div>
<div class = "collapse navbar-collapse">
<ul class = "nav navbar-nav">
<li class = "active"><a href = "<?=
$this->url('home') ?>">Home</a></li> </ul> </div> </div> </nav> <div class = "container"> <?= $this->content ?>
<hr>
<footer>
<p>© 2005 - <?= date('Y') ?> by Zend Technologies Ltd.
All rights reserved.</p>
</footer>
</div>
<?= $this->inlineScript() ?>
</body>
</html>A medida que analiza el diseño, utiliza principalmente los ayudantes de vista, que discutimos en el capítulo anterior. Al mirar más de cerca, el diseño usa una variable especial,$this->content. Esta variable es importante ya que será reemplazada por el script de vista (plantilla) de la página solicitada real.
Creando un nuevo diseño
Creemos un nuevo diseño para nuestro módulo Tutorial.
Para empezar, creemos un tutorial.css file en el directorio "public / css".
body {
background-color: lightblue;
}
h1 {
color: white;
text-align: center;
}Crea un nuevo archivo de diseño newlayout.phtmlen / myapp / module / Tutorial / view / layout / y copie el contenido del diseño existente. Luego, agregue eltutorial.css hoja de estilo usando el HeadLink helper class dentro de la sección de encabezado de diseño.
<?php echo $this->headLink()->appendStylesheet('/css/tutorial.css');?>Agregar una nueva about enlace en la sección de navegación usando el URL ayudante.
<li><a href = "<?= $this->url('tutorial', ['action' => 'about']) ?>">About</a></li>Esta página de diseño es común para la aplicación del módulo de tutorial. Actualizar elview_manager sección del archivo de configuración del módulo tutorial.
'view_manager' => array(
'template_map' => array(
'layout/layout' => __DIR__ . '/../view/layout/newlayout.phtml'),
'template_path_stack' => array('tutorial' => __DIR__ . '/../view',),
)Añade el aboutAction función en el TutorialController.
public function aboutAction() {
}Añade el about.phtml en myapp / module / Tutorial / view / tutorial / tutorial / con el siguiente contenido.
<h2>About page</h2>Ahora, está listo para ejecutar finalmente la aplicación: http://localhost:8080/tutorial/about.
En este capítulo, discutiremos los distintos modelos y la base de datos del Zend Framework.
Modelos en Zend Framework
Un modelo define la representación de datos lógicos de la aplicación. Por ejemplo, en una aplicación de carrito de compras: Producto, Cliente, Carrito y Pedidos son modelos. Definen las propiedades de la entidad que posee. Algunos de los conceptos de modelos son los siguientes:
Los controladores se comunican con los modelos y les piden que recuperen la información que necesitan. Esta información recuperada es luego pasada por el controlador a la Vista. Finalmente, View representará el modelo como datos de presentación consumibles por el usuario.
Es muy raro que un modelo interactúe directamente con una vista, pero a veces puede suceder.
Los modelos pueden hablar entre sí y no son autónomos. Tienen relaciones entre ellos. Estas relaciones hacen que sea más fácil y rápido para un controlador obtener información, ya que no tiene que interactuar con diferentes modelos; los modelos pueden hacerlo ellos mismos.
Echemos un vistazo a un modelo simple: MyModel
<?php
namespace Tutorial\Model;
class Book {
public $id; public $author;
public $title;
}Base de datos en Zend Framework
Zend framework proporciona una clase simple y rica en funciones, Zend \ Db \ TableGateway \ TableGateway para buscar, insertar, actualizar y eliminar datos de una tabla de base de datos.
Veamos cómo conectar el MySqlservice a través del controlador PDO de PHP en el marco Zend a través de los siguientes pasos.
Paso 1: crear una base de datos en MySQL
Crear base de datos tutorialsen el servidor MySQL local. Nosotros podemos usarphpmyadmino cualquier otra herramienta GUI de MySQL para este propósito. Usemos elMySQL clienten el símbolo del sistema. Conéctese al servidor mysql y ejecute el siguiente comando para crear eltutorial base de datos.
create database tutorialsPaso 2: crear una tabla en la base de datos de tutoriales
Creemos ahora una base de datos book en el tutorials db utilizando el siguiente comando SQL.
use tutorials;
CREATE TABLE book (
id int(11) NOT NULL auto_increment,
author varchar(100) NOT NULL,
title varchar(100) NOT NULL,
PRIMARY KEY (id)
);Paso 3: completar datos en la tabla del libro
Poblar el booktabla con datos de muestra. Utilice el siguiente comando SQL.
INSERT INTO book (author, title) VALUES ('Dennis Ritchie', 'C Programming');
INSERT INTO book (author, title) VALUES ('James gosling', 'Java Programming');
INSERT INTO book (author, title) VALUES ('Rasmus Lerdorf', 'Programming PHP');Paso 4: Actualizar la conexión de la base de datos
Actualice el archivo de configuración global, que es - myapp / config / autoload / global.php con la información de unidad de base de datos necesaria.
<?php
return array(
'db' => array(
'driver' => 'Pdo',
'dsn' => 'mysql:dbname = tutorials;host = localhost',
'driver_options' => array(
PDO::MYSQL_ATTR_INIT_COMMAND => 'SET NAMES \'UTF8\''
),
),
'service_manager' => array(
'factories' => array(
'Zend\Db\Adapter\Adapter' => 'Zend\Db\Adapter\AdapterServiceFactory',
),
),
);Paso 5: actualice las credenciales de la base de datos
Actualice las credenciales de la base de datos en el archivo de configuración local, que es - myapp / config / autoload / local.php. De esta manera, podemos separar las credenciales de conexión de la base de datos local y en vivo.
<?php
return array(
'db' => array(
'username' => '<user_name>',
'password' => '<password>',
),
);Paso 6: crear modelo para libro
Creemos un modelo, Book en nuestro módulo srcdirectorio. Generalmente, los modelos se agrupan en la carpeta Modelo - /myapp/module/Tutorial/src/Model/Book.php.
<?php
namespace Tutorial\Model;
class Book {
public $id;
public $author; public $title;
}Paso 7: implementar exchangeArray en el modelo de libro
los TableGateway interactúa con un modelo a través del exchangeArrayfunción. El argumento estándar de la función exchangeArray es el conjunto de resultados de la base de datos almacenado como matriz PHP. Utilizando elexchangeArrayfunction, la propiedad de un modelo se puede sincronizar fácilmente con la tabla de base de datos correspondiente.
Actualiza el modelo, Book como se muestra a continuación -
<?php
namespace Tutorial\Model;
class Book {
public $id; public $author;
public $title; public function exchangeArray($data) {
$this->id = (!empty($data['id'])) ? $data['id'] : null; $this->Author = (!empty($data['author'])) ? $data['author'] : null;
$this->Title = (!empty($data['title'])) ? $data['title'] : null;
}
}Paso 8: use TableGateway para buscar el libro
Crear una clase, BookTablepara recuperar la información del libro de la base de datos. Cree la clase, BookTable en elModel carpeta en sí.
<?php
namespace Tutorial\Model;
use Zend\Db\TableGateway\TableGatewayInterface;
class BookTable {
protected $tableGateway;
public function __construct(TableGatewayInterface $tableGateway) { $this->tableGateway = $tableGateway; } public function fetchAll() { $resultSet = $this->tableGateway->select(); return $resultSet;
}
}Hemos usado select()método de la clase TableGateway para obtener la información del libro de la base de datos. Pero, no hemos utilizado ninguna referencia a la tabla:booken el código. TableGateway es de naturaleza genérica y puede obtener datos de cualquier tabla usando cierta configuración. Por lo general, estas configuraciones se realizan en elmodule.config.php archivo, que discutiremos en los pasos siguientes.
Paso 9: configurar la clase BookTable
Actualiza el módulo tutorial, Module.php con el getServiceConfig() método.
<?php
namespace Tutorial;
use Zend\Db\Adapter\AdapterInterface;
use Zend\Db\ResultSet\ResultSet;
use Zend\Db\TableGateway\TableGateway;
use Zend\ModuleManager\Feature\ConfigProviderInterface;
class Module implements ConfigProviderInterface {
public function getConfig() {
return include __DIR__ . '/../config/module.config.php';
}
public function getServiceConfig() {
return [
'factories' => [
Model\BookTable::class => function ($container) { $tableGateway = $container->get(Model\BookTableGateway::class); $table = new Model\BookTable($tableGateway); return $table;
},
Model\BookTableGateway::class => function ($container) { $dbAdapter = $container->get(AdapterInterface::class); $resultSetPrototype = new ResultSet();
$resultSetPrototype->setArrayObjectPrototype(new Model\Book()); return new TableGateway('book', $dbAdapter, null, $resultSetPrototype);
},
],
];
}
}Aquí, hemos registrado el BookTableclase utilizando el administrador de servicios. La clase BookTable se utiliza para obtener la información del libro y, al registrarla, podemos acceder a ella donde sea necesario. Dado que los servicios registrados se comparten, aumentan el rendimiento, reducen el consumo de memoria, etc.
Otro elemento, Model \ BookTableGateway :: class es el objeto TableGateway especializado para Book modelo y es una dependencia del BookTable.
Paso 10: Actualice la configuración del TutorialController
Necesitamos el BookTableservice en el controlador del tutorial para obtener la información del libro. Para obtener el servicio BookTable, regístrelo como dependencia del constructor en TutorialController.
Esta dependencia de Constructor ayuda a obtener el servicio BookTable mientras el propio controlador está en la etapa de inicialización. Actualice la sección del controlador de la configuración del módulo tutorial,module.config.php Como se muestra abajo.
'controllers' => [
'factories' => [
Controller\TutorialController::class => function($container) {
return new Controller\TutorialController(
$container->get(Model\BookTable::class)
);
},
],
],Paso 11: Actualizar el controlador del tutorial
Esto se hace siguiendo los siguientes tres pasos.
- Agregue el constructor con BookTable como argumento.
private $table;
public function __construct(BookTable $table) { $this->table = $table;
}Obtener información del libro mediante el BookTable's fetchAll() y regístrelo en la vista.
public function indexAction() {
$view = new ViewModel([
'data' => $this->table->fetchAll(), ]); return $view;
}Muestra la información del libro en el script de visualización.
<table class = "table">
<tr>
<th>Author</th>
<th>Title</th>
<th> </th>
</tr>
<?php foreach ($data as $sampledata) : ?>
<tr>
<td><?php echo $this->escapeHtml($data->author);?></td>
<td><?php echo $this->escapeHtml($data->title);?></td>
</tr>
<?php endforeach ?>
</table>Paso 12: ejecuta la aplicación
Verifique la aplicación ejecutando - http://localhost:8080/tutorial.
Como se discutió en el último capítulo, el marco Zend proporciona una forma genérica de acceder a la base de datos utilizando Database Driverconcepto. Trabajar con una base de datos depende únicamente de la información del controlador y, por lo tanto, conectarse con una base de datos diferente implica simplemente cambiar la información del controlador.
Cambiemos ahora el book ejemplo para conectarse al postgresql base de datos con los siguientes pasos.
Step 1 - Cree una base de datos, tutoriales en la base de datos local de postgresql usando el siguiente comando -
CREATE DATABASE tutorialsStep 2 - Agregar bookmesa. Vaya a la nueva base de datos y ejecute el script de creación de la tabla.
\c tutorials
CREATE TABLE book (
id SERIAL NOT NULL,
author varchar(100) NOT NULL,
title varchar(100) NOT NULL,
PRIMARY KEY (id)
);Step 3 - Agregue información del libro de muestra usando el siguiente script -
INSERT INTO book (author, title) VALUES ('Dennis Ritchie', 'C Programming');
INSERT INTO book (author, title) VALUES ('James gosling', 'Java Programming');
INSERT INTO book (author, title) VALUES ('Rasmus Lerdorf', 'Programming PHP');Step 4 - Cambie la información del conductor en el global.config file.
<?php
return array (
'db' => array (
'driver' => 'Pdo',
'dsn' => 'pgsql:dbname = tutorials;host = localhost',
'driver_options' => array (
),
),
);Step 5 - Cambie las credenciales de la base de datos en el local.config archivo.
return array (
'db' => array(
'username' => '<username>',
'password' => '<password>',
),
);Step 6 - Finalmente, ejecuta la aplicación. http://localhost:8080/tutorial. El resultado es el mismo que el de la aplicación MySQL.
Zend Framework proporciona un componente separado, zend-formpara acelerar el proceso de creación y validación de formularios. Conecta el modelo y la capa de vista. Proporciona un conjunto de elementos de formulario para crear un formulario html completo a partir de modelos predefinidos, unInputFilter class para validar el modelo contra el formulario y opciones para vincular los datos del formulario al modelo y viceversa.
Instalar componente de formulario
El componente de formulario Zend se puede instalar utilizando el Composer comando como se especifica a continuación -
composer require zendframework/zend-formUn marco de formulario Zend tiene tres subcomponentes para administrar los formularios. Son los que se explican a continuación en detalle:
Elements - Se utiliza para definir un único control de entrada html asignado a una propiedad en el modelo.
Fieldset - Se utiliza para agrupar elementos y otros fieldset de manera anidada.
Form - Se utiliza para crear un formulario html y consta de elementos y conjuntos de campos.
Los formularios Zend generalmente se crean bajo el module//src/Form directorio.
Ejemplo
Creemos ahora un formulario simple para agregar booken la base de datos. Para hacer esto, debemos seguir los siguientes pasos:
Paso 1: Cree BookForm
Cree el "BookForm.php" en el directorio * myapp / module / Tutorial / src / Form ". Agregue los siguientes cambios en el archivo:
<?php
namespace Tutorial\Form;
use Zend\Form\Form;
class BookForm extends Form {
public function __construct($name = null) { parent::__construct('book'); $this->add(array(
'name' => 'id',
'type' => 'Hidden',
));
$this->add(array( 'name' => 'author', 'type' => 'Text', 'options' => array( 'label' => 'Author', ), )); $this->add(array(
'name' => 'title',
'type' => 'Text',
'options' => array(
'label' => 'Title',
),
));
$this->add(array(
'name' => 'submit',
'type' => 'Submit',
'attributes' => array(
'value' => 'Go',
'id' => 'submitbutton',
),
));
}
}los Form la clase proporciona un add methodpara mapear el modelo y sus detalles de formulario correspondientes. hemos creado elBookForm extendiendo el Form class y agregó los detalles del formulario para Book modelo.
Paso 2: actualiza el modelo de libro, Book.php
Actualiza el modelo, ‘Book’ con filtro y validación como se especifica a continuación -
<?php
namespace Tutorial\Model;
use Zend\InputFilter\InputFilterInterface;
use Zend\InputFilter\InputFilterAwareInterface;
use Zend\InputFilter\InputFilter;
class Book implements InputFilterAwareInterface {
public $id;
public $author; public $title;
protected $inputFilter; public function setInputFilter(InputFilterInterface $inputFilter) {
throw new \Exception("Not used");
}
public function getInputFilter() {
if (!$this->inputFilter) { $inputFilter = new InputFilter();
$inputFilter->add(array( 'name' => 'id', 'required' => true, 'filters' => array( array('name' => 'Int'), ), )); $inputFilter->add(array(
'name' => 'author',
'required' => true,
'filters' => array(
array('name' => 'StripTags'),
array('name' => 'StringTrim'),
),
'validators' => array(
array(
'name' => 'StringLength',
'options' => array(
'encoding' => 'UTF-8',
'min' => 1,
'max' => 100,
),
),
),
));
$inputFilter->add(array( 'name' => 'title', 'required' => true, 'filters' => array( array('name' => 'StripTags'), array('name' => 'StringTrim'), ), 'validators' => array( array( 'name' => 'StringLength', 'options' => array( 'encoding' => 'UTF-8', 'min' => 1, 'max' => 100, ), ), ), )); $this->inputFilter = $inputFilter; } return $this->inputFilter;
}
public function exchangeArray($data) { $this->id = (!empty($data['id'])) ? $data['id'] : null;
$this->author = (!empty($data['author'])) ? $data['author'] : null; $this->title = (!empty($data['title'])) ? $data['title'] : null;
}
}Cada modelo debe implementar el InputFilterAwareInterface. InputFilterAwareInterface proporciona dos métodos,setInputFilter() y getInputFilter().
GetInputFilter se utiliza para obtener los detalles de validación del modelo. Zend framework proporciona un amplio conjunto de filtros y validadores para validar el formulario. Algunos de los filtros y validadores utilizados en el modelo de libro son los siguientes:
StripTags - Eliminar HTML no deseado.
StringTrim - Elimina los espacios en blanco innecesarios.
StringLength validator - Asegúrese de que el usuario no ingrese más caracteres que el límite especificado.
Paso 3: actualice la clase BookTable
Incluir la saveBook método para agregar un libro a la base de datos.
BookTable.php
<?php
namespace Tutorial\Model;
use Zend\Db\TableGateway\TableGatewayInterface;
class BookTable {
protected $tableGateway; public function __construct(TableGatewayInterface $tableGateway) {
$this->tableGateway = $tableGateway;
}
public function fetchAll() {
$resultSet = $this->tableGateway->select();
return $resultSet; } public function getBook($id) {
$id = (int) $id;
$rowset = $this->tableGateway->select(array('id' => $id)); $row = $rowset->current(); if (!$row) {
throw new \Exception("Could not find row $id"); } return $row;
}
public function saveBook(Book $book) { $data = array (
'author' => $book->author, 'title' => $book->title,
);
$id = (int) $book->id;
if ($id == 0) { $this->tableGateway->insert($data); } else { if ($this->getBook($id)) { $this->tableGateway->update($data, array('id' => $id));
} else {
throw new \Exception('Book id does not exist');
}
}
}
}Paso 4: actualiza la clase TutorialController
Agregue una nueva acción addAction en el controlador del tutorial: myapp / module / Tutorial / src / Controller / TutorialController.php.
public function addAction() {
$form = new BookForm(); $form->get('submit')->setValue('Add');
$request = $this->getRequest();
if ($request->isPost()) { $book = new Book();
$form->setInputFilter($book->getInputFilter());
$form->setData($request->getPost());
if ($form->isValid()) { $book->exchangeArray($form->getData()); $this->bookTable->saveBook($book); // Redirect to list of Tutorial return $this->redirect()->toRoute('tutorial');
}
}
return array('form' => $form);
}los addAction El método realiza los siguientes procesos:
Obtiene el objeto de solicitud.
Comprueba si el método http de la solicitud es un post método.
Si el método http de la solicitud no es post, solo renderiza la plantilla, add.phtml
Si el método http de la solicitud no es post, luego establece el inputfilter, obtiene los datos de la solicitud y los coloca en el archivo de entrada.
Comprueba si el formulario es válido mediante el isValid() método de la clase Form.
Si el formulario no es válido, vuelve a representar la plantilla, add.phtml
Si el formulario es válido, guarda el libro en la base de datos y lo redirecciona a la página de inicio.
Paso 5: agregue la plantilla add.phtml
Cree una plantilla: add.phtml en myapp / module / Tutorial / view / tutorial / tutorial / add.phtml
Add.phtml
<?php
$title = 'Add new Book';
$this->headTitle($title);
?>
<h1><?php echo $this->escapeHtml($title); ?></h1>
<?php
if(!empty($form)) { $form->setAttribute('action', $this->url('tutorial', array('action' => 'add'))); $form->prepare();
echo $this->form()->openTag($form);
echo $this->formHidden($form->get('id'));
echo $this->formRow($form->get('author'))."<br>";
echo $this->formRow($form->get('title'))."<br>";
echo $this->formSubmit($form->get('submit'));
echo $this->form()->closeTag();
}Aquí, estamos renderizando el formulario de libro usando el Form ejemplo, $form.
Paso 6: ejecutar la aplicación
Ahora, podemos ejecutar la aplicación: http://localhost:8080/tutorial/add.
Form Page
Validate Error Page
La carga de archivos es uno de los conceptos principales en la programación de formularios. Zend framework proporciona todos los elementos necesarios para cargar archivos a través delzend-form y el zend-inputfilter componente.
Clase FileInput
El componente zend-inputfilter proporciona la clase Zend \ InputFilter \ FileInput para manejar el elemento de entrada del archivo html - <input type = 'file' />. losFileInputes como los otros filtros de entrada con algunas excepciones. Son los siguientes:
Dado que PHP guarda los detalles del archivo cargado en $_FILES matriz global, FileInput recopila la información del archivo cargado solo a través de $ _FILES.
La validación debe realizarse antes de que la clase FileInput procese los datos. Es el comportamiento opuesto de los otros filtros de entrada.
Zend \ Validator \ File \ UploadFile es el validador predeterminado que se utilizará. losUploadFile valida los detalles de entrada del archivo.
Para agregar un tipo de carga de archivo en un formulario, necesitamos usar el tipo de entrada File. El código parcial es el siguiente:
$form->add(array(
'name' => 'imagepath',
'type' => 'File',
'options' => array('label' => 'Picture',),
));Otra clase utilizada en la carga de archivos es Zend \ Filter \ File \ RenameUpload. losRenameUploadse utiliza para mover el archivo cargado a la ubicación deseada. La clase parcial para usar el filtro de archivos es la siguiente:
$file = new FileInput('imagepath');
$file->getValidatorChain()->attach(new UploadFile()); $file->getFilterChain()->attach(
new RenameUpload([
'target' => './public/tmpuploads/file',
'randomize' => true,
'use_upload_extension' => true
]));
$inputFilter->add($file);Aquí, las opciones de RenameUpload son los siguientes:
target - La ruta de destino del archivo cargado.
randomize - Agregue una cadena aleatoria para evitar la duplicación del archivo cargado.
use_upload_extension - Agregue la extensión del archivo al archivo cargado al destino.
Carga de archivos: ejemplo de trabajo
Modifiquemos el módulo tutorial e incluyamos una función de carga de imágenes.
Modificar la tabla de la base de datos
Agreguemos el imagepath columna a la tabla del libro ejecutando el siguiente comando SQL:
ALTER TABLE `book` ADD `imagepath` VARCHAR(255) NOT NULL AFTER 'imagepath';Actualizar BookForm.php
Agregue el elemento de entrada de archivo para cargar una imagen en el formulario de libro: myapp / module / Tutorial / src / Model / BookForm.php.
Incluya el siguiente código en el __constructmethod de la clase BookForm.
$this->add(array(
'name' => 'imagepath',
'type' => 'File',
'options' => array ('label' => 'Picture',),
));Actualizar Book.php
Realice los siguientes cambios en la clase Libro: myapp / module / Tutorial / src / Model / Book.php.
Agregar una nueva propiedad imagepath para la foto.
public $imagepath;Actualizar el getInputFilter método como se muestra a continuación -
Añade el FileInput filtro para elemento de entrada de archivo.
Selecciona el UploadFile validación para validar el elemento de entrada del archivo.
Configurar el RenameUpload para mover el archivo cargado al destino adecuado.
La lista de códigos parcial es la siguiente:
$file = new FileInput('imagepath'); $file->getValidatorChain()->attach(new UploadFile());
$file->getFilterChain()->attach( new RenameUpload([ 'target' => './public/tmpuploads/file', 'randomize' => true, 'use_upload_extension' => true ])); $inputFilter->add($file);Actualizar el exchangeArray método para incluir el imagepathpropiedad. La ruta de la imagen puede provenir de un formulario o una base de datos. Si la ruta de la imagen proviene de un formulario, el formato será una matriz con la siguiente especificación:
array(1) {
["imagepath"] => array(5) {
["name"] => string "myimage.png"
["type"] => string "image/png"
["tmp_name"] => string
"public/tmpuploads/file_<random_string>.<image_ext>"
["error"] => int <error_number>
["size"] => int <size>
}
}Si la ruta de la imagen proviene de una base de datos, será una cadena simple. La lista de código parcial para analizar una ruta de imagen es la siguiente:
if(!empty($data['imagepath'])) {
if(is_array($data['imagepath'])) { $this->imagepath = str_replace("./public", "", $data['imagepath']['tmp_name']); } else { $this->imagepath = $data['imagepath']; } } else { $data['imagepath'] = null;
}La lista completa de los Book El modelo es el siguiente:
<?php
namespace Tutorial\Model;
use Zend\InputFilter\InputFilterInterface;
use Zend\InputFilter\InputFilterAwareInterface;
use Zend\Filter\File\RenameUpload;
use Zend\Validator\File\UploadFile;
use Zend\InputFilter\FileInput;
use Zend\InputFilter\InputFilter;
class Book implements InputFilterAwareInterface {
public $id; public $author;
public $title; public $imagepath;
protected $inputFilter; public function setInputFilter(InputFilterInterface $inputFilter) {
throw new \Exception("Not used");
}
public function getInputFilter() {
if (!$this->inputFilter) { $inputFilter = new InputFilter();
$inputFilter->add(array( 'name' => 'id', 'required' => true, 'filters' => array( array('name' => 'Int'), ), )); $inputFilter->add(array(
'name' => 'author',
'required' => true,
'filters' => array(
array('name' => 'StripTags'),
array('name' => 'StringTrim'),
),
'validators' => array(
array(
'name' => 'StringLength',
'options' => array(
'encoding' => 'UTF-8',
'min' => 1,
'max' => 100,
),
),
),
));
$inputFilter->add(array( 'name' => 'title', 'required' => true, 'filters' => array( array('name' => 'StripTags'), array('name' => 'StringTrim'), ), 'validators' => array( array( 'name' => 'StringLength', 'options' => array( 'encoding' => 'UTF-8', 'min' => 1, 'max' => 100, ), ), ), )); $file = new FileInput('imagepath');
$file->getValidatorChain()->attach(new UploadFile()); $file->getFilterChain()->attach(
new RenameUpload([
'target' => './public/tmpuploads/file',
'randomize' => true,
'use_upload_extension' => true
]));
$inputFilter->add($file);
$this->inputFilter = $inputFilter;
}
return $this->inputFilter; } public function exchangeArray($data) {
$this->id = (!empty($data['id'])) ? $data['id'] : null; $this->author = (!empty($data['author'])) ? $data['author'] : null;
$this->title = (!empty($data['title'])) ? $data['title'] : null; if(!empty($data['imagepath'])) {
if(is_array($data['imagepath'])) { $this->imagepath = str_replace("./public", "",
$data['imagepath']['tmp_name']); } else { $this->imagepath = $data['imagepath']; } } else { $data['imagepath'] = null;
}
}
}Actualizar BookTable.php
Hemos actualizado BookForm y el Book model. Ahora, actualizamos elBookTable y modificar el saveBookmétodo. Esto es suficiente para incluir la entrada imagepath en la matriz de datos,$data.
La lista de códigos parcial es la siguiente:
$data = array('author' => $book->author, 'title' => $book->title,
'imagepath' => $book->imagepath
);La lista de códigos completa del BookTable la clase es la siguiente:
<?php
namespace Tutorial\Model;
use Zend\Db\TableGateway\TableGatewayInterface;
class BookTable {
protected $tableGateway;
public function __construct(TableGatewayInterface $tableGateway) { $this->tableGateway = $tableGateway; } public function fetchAll() { $resultSet = $this->tableGateway->select(); return $resultSet;
}
public function getBook($id) { $id = (int) $id; $rowset = $this->tableGateway->select(array('id' => $id));
$row = $rowset->current();
if (!$row) { throw new \Exception("Could not find row $id");
}
return $row; } public function saveBook(Book $book) {
$data = array ( 'author' => $book->author,
'title' => $book->title, 'imagepath' => $book->imagepath
);
$id = (int) $book->id;
if ($id == 0) { $this->tableGateway->insert($data); } else { if ($this->getBook($id)) { $this->tableGateway->update($data, array('id' => $id));
} else {
throw new \Exception('Book id does not exist');
}
}
}
}Update addAction in the TutorialController.php: La información de carga de archivos estará disponible en el $_FILES matriz global y se puede acceder mediante el Request's getFiles()método. Por lo tanto, combine los datos publicados y la información de carga de archivos como se muestra a continuación.
$post = array_merge_recursive(
$request->getPost()->toArray(), $request->getFiles()->toArray()
);La lista completa de los addAction() El método es el siguiente:
public function addAction() {
$form = new BookForm(); $form->get('submit')->setValue('Add');
$request = $this->getRequest();
if ($request->isPost()) { $book = new Book();
$form->setInputFilter($book->getInputFilter());
$post = array_merge_recursive( $request->getPost()->toArray(),
$request->getFiles()->toArray() ); $form->setData($post); if ($form->isValid()) {
$book->exchangeArray($form->getData());
$this->bookTable->saveBook($book);
// Redirect to list of Tutorial
return $this->redirect()->toRoute('tutorial'); } } return array('form' => $form);
}Actualizar vista de add.phtml
Por último, cambie "add.phtml" e incluya el elemento de entrada del archivo imagepath como se muestra a continuación:
echo $this->formRow($form->get('imagepath'))."<br>";La lista completa es la siguiente:
<?php
$title = 'Add new Book'; $this->headTitle($title); ?> <h1><?php echo $this->escapeHtml($title); ?></h1> <?php if(!empty($form)) {
$form->setAttribute('action', $this->url('tutorial', array('action' => 'add')));
$form->prepare(); echo $this->form()->openTag($form); echo $this->formHidden($form->get('id')); echo $this->formRow($form->get('author'))."<br>"; echo $this->formRow($form->get('title'))."<br>"; echo $this->formRow($form->get('imagepath'))."<br>"; echo $this->formSubmit($form->get('submit')); echo $this->form()->closeTag();
}Ejecutar la aplicación
Finalmente, ejecute la aplicación en http://localhost:8080/tutorial/add y agregue los nuevos registros.
El resultado será el que se muestra en las siguientes capturas de pantalla:
Form Page
Index Page
AJAX es una tecnología moderna en programación web. Proporciona opciones para enviar y recibir datos en una página web de forma asincrónica, sin actualizar la página. Zend framework ofrece una opción para trabajar conjson modelo a través zend-view y zend-jsoncomponente. Aprendamos la programación Zend AJAX en este capítulo.
Instalar el componente json
El componente Zend json se puede instalar utilizando el Composer comando como se especifica a continuación -
composer require zendframework/zend-jsonConcepto
Zend framework proporciona dos métodos para escribir fácilmente una aplicación web habilitada para AJAX. Son los siguientes:
los isXmlHttpRequest() método en el Requestobjeto: si se realiza una solicitud AJAX, el método isXmlHttpRequest () del objeto de solicitud devuelve verdadero, de lo contrario falso. Este método se usa para manejar una solicitud AJAX correctamente en el lado del servidor.
if ($request->isXmlHttpRequest()) {
// Ajax request
} else {
// Normal request
}Zend / View / Model / JsonModel - El JsonModel es una alternativa para ViewModelpara ser utilizado exclusivamente para AJAX y los escenarios de API REST. El JsonModel junto conJsonStrategy (que se configurará en el bloque del administrador de vistas del módulo) codifica los datos del modelo en Json y lo devuelve como respuesta en lugar de vistas (phtml).
AJAX - Ejemplo de trabajo
Agreguemos una nueva página ajax, ajaxen el módulo de tutorial y obtener la información del libro de forma asincrónica. Para hacer esto, debemos seguir los siguientes pasos.
Paso 1: agregue JsonStrategy en la configuración del módulo
Actualice el bloque del administrador de vistas en el archivo de configuración del módulo del tutorial: myapp / module / Tutorial / config / module.config.php. Luego,JsonStrategy trabajará con JsonModel para codificar y enviar los datos json.
'view_manager' => [
'template_map' => array
('layout/layout' => __DIR__ . '/../view/layout/newlayout.phtml'),
'template_path_stack' => [
'tutorial' => __DIR__ . '/../view',
],
'strategies' => array('ViewJsonStrategy',),
],Paso 2: agregue el método ajaxAction en TutorialController.php
Agregue el método ajaxAction en TutorialController.php con el siguiente código:
public function ajaxAction() {
$data = $this->bookTable->fetchAll(); $request = $this->getRequest(); $query = $request->getQuery(); if ($request->isXmlHttpRequest() || $query->get('showJson') == 1) { $jsonData = array();
$idx = 0; foreach($data as $sampledata) { $temp = array(
'author' => $sampledata->author, 'title' => $sampledata->title,
'imagepath' => $sampledata->imagepath ); $jsonData[$idx++] = $temp;
}
$view = new JsonModel($jsonData);
$view->setTerminal(true); } else { $view = new ViewModel();
}
return $view;
}Aquí, ajaxAction comprobará si la solicitud entrante es AJAX o no. Si la solicitud entrante es AJAX, entonces elJsonModelse creará. De lo contrario, una normalViewModel se creará.
En ambos casos, la información del libro se obtendrá de la base de datos y se completará en el modelo. Si el modelo es un JsonModel, entoncesJsonStrategy se invocará y codificará los datos como json y los devolverá como respuesta.
los $query->get('showJson') == 1se utiliza con fines de depuración. Solo agregashowJson=1 en la url y la página mostrará los datos json.
Paso 3: agregue ajax.phtml
Ahora, agregue el script de vista ajax.phtmlpara el método ajaxAction. Esta página tendrá un enlace con la etiqueta -Load book information.
Al hacer clic en ese enlace, se realizará una solicitud AJAX, que obtendrá la información del libro como datos Json y mostrará la información del libro como una tabla formateada. El procesamiento AJAX se realiza utilizando elJQuery.
La lista completa de códigos es la siguiente:
<a id = "loadbook" href = "#">Load book information</a>
</br> </br>
<table class = "table">
<tbody id = "book">
</tbody>
</table>
<script language = "javascript">
$(document).ready(function(){ $("#loadbook").on("click", function(event){
$.ajax({ url: '/tutorial/ajax', type: 'POST', dataType: 'json', async: true, success: function(data, status) { var e = $('<tr><th>Author</th><th>Title</th><th>Picture</th></tr>');
$('#book').html(''); $('#book').append(e);
for(i = 0; i < data.length; i++) {
book = data[i];
var e = $('<tr><td id = "author"></td><td id = "title"></td> <td id="imagepath"><img src = ""/></td></tr>'); $('#author', e).html(book['author']);
$('#title', e).html(book['title']); $('#imagepath img', e).attr('src', book['imagepath']);
$('#book').append(e);
}
},
error : function(xhr, textStatus, errorThrown) {
alert('Ajax request failed.');
}
});
});
});
</script>Paso 4: ejecuta la aplicación
Finalmente, ejecute la aplicación - http://localhost:8080/tutorial/ajax y haga clic en el enlace Cargar información del libro.
El resultado será el que se muestra a continuación:
Ajax Page -
Ajax Page with Book Information
Ajax page with debugging information
La Cookie es un concepto muy importante en una aplicación web. Brinda la opción de conservar los datos del usuario, generalmente una pequeña información en el navegador durante un período limitado.
Se utiliza una cookie para mantener el estado de la aplicación web. Zend framework proporciona un módulo de cookies dentro delzend-httpcomponente. Este zend-http proporciona la abstracción HTTP y su implementación.
Instalación del componente HTTP
El componente HTTP se puede instalar fácilmente utilizando el Composer como se especifica en el código siguiente.
composer require zendframework/zend-httpConcepto
El zend-http proporciona Zend\Http\Cookiesclase para administrar las cookies. Se utiliza junto con elZend\Http\Clientclass, que se utiliza para enviar una solicitud a un servidor web. Las cookies se pueden inicializar como se muestra en el siguiente código:
use Zend\Http\Cookies
$c = new Cookies();Cuando el cliente HTTP (Zend \ Http \ Client) envía por primera vez una solicitud URI al servidor web, no tiene ninguna cookie. Una vez que el servidor web recibe la solicitud, incluye la cookie en su objeto de respuesta como elHTTP Header, Set-Cookiey lo envía al cliente HTTP. El cliente HTTP extraerá la cookie de la respuesta http y la reenviará como el mismo encabezado HTTP en la solicitud posterior. Generalmente, cada cookie se asignará a un dominio y una ruta del dominio.
Los métodos disponibles en Cookies clase son los siguientes:
addCookie(uri) - Se usa para agregar una cookie al objeto de solicitud del URI dado.
getCookie(cookieName, $cookieForm) - Se utiliza para obtener la cookie, $ cookieName disponible en el URI dado, $uri. El tercer argumento es cómo se devolverá la cookie, ya sea una cadena o una matriz.
fromResponse(uri) - Se utiliza para extraer cookies del objeto de respuesta del URI dado.
addCookiesFromResponse - Es lo mismo que fromResponse, pero lo extrae y lo agrega nuevamente al objeto de solicitud del URI dado.
isEmpty() - Se utiliza para encontrar si el Cookie el objeto tiene alguna cookie o no.
reset() - Se utiliza para borrar todas las cookies en el URI dado.
En el próximo capítulo, analizaremos la gestión de sesiones en Zend Framework.
Una sesión es un concepto muy importante en una aplicación web. Proporciona la opción de conservar los datos del usuario en el servidor web durante un período de tiempo limitado. Zend framework proporciona un componente separado,zend-session para manejar la información de la sesión.
Instalar un componente de sesión
El componente de sesión se puede instalar usando el Composer como se especifica a continuación -
composer require zendframework/zend-sessionComponentes de la sesión
Zend framework proporciona seis componentes para manejar la gestión de sesiones. Todos estos componentes se han explicado a continuación:
Zend\Session\Container - La API principal para leer y escribir la información de la sesión.
Zend\Session\SessionManager - Se utiliza para gestionar todo el ciclo de vida de una sesión.
Zend\Session\Storage - Se utiliza para especificar cómo se almacenarán los datos de la sesión en la memoria.
Zend\Session\SaveHandler - Se utiliza para almacenar y recuperar los datos de la sesión en una ubicación física como RDBMS, Redis, MangoDB, etc.
Zend\Session\Validator - Esto se utiliza para proteger la sesión contra el secuestro mediante la verificación cruzada de la dirección remota y el agente de usuario de la solicitud inicial y posterior.
Zend\Session\Config\SessionConfig - Se utiliza para configurar cómo debe comportarse la sesión.
La configuración predeterminada es suficiente para trabajar con una sesión. Con los componentes anteriores, todos los aspectos de una sesión se pueden manejar fácilmente.
Ejemplo de componente de sesión
Adhiéramos a los siguientes puntos para crear una nueva página para entender una sesión en el marco Zend. De forma predeterminada, es suficiente crear una instancia de unContainer clase para gestionar sesiones.
Crea una nueva acción, sessionAction en TutorialController.
Inicializar un Container objeto.
$c = new Container();Compruebe si una clave arbitraria countexiste. Si la clave no está disponible, inicialice lacount con valor 1. Si está disponible, incremente el valor como se muestra en el siguiente código.
if (!isset($c->count)) { $c->count = 0;
} else {
$c->count++;
}Registre el recuento en ViewModel.
Cree un archivo de plantilla para - sessionAction, session.phtml en myapp / module / Tutorial / view / tutorial / tutorial / session.phtml y luego renderice el count valor.
Actualizar la página aumentará el valor de counten la sesión. La lista completa es la siguiente:
TutorialController.php
public function sessionAction() {
$c = new Container();
if (!isset($c->count)) { $c->count = 0;
} else {
$c->count++; } $view = new ViewModel([
'count' => $c->count, ]); return $view;
}session.pthml
Session data, COUNT = <?= $this->count ?>Sample Result
Session data, Count = 5La autenticación es una de las características más importantes e imprescindibles de cualquier aplicación web. Zend Framework proporciona un componente separado para manejar la autenticación, que se denomina comozend-authentication.
Instalar un componente de autenticación
El componente de autenticación se puede instalar utilizando los siguientes Composer mando.
composer require zendframework/zend-authenticationConcepto
Por lo general, un desarrollador escribe una función php para autenticar los detalles del usuario en una fuente de datos. Una vez que se realiza la autenticación, los detalles de autenticación se conservan para solicitudes posteriores. Zend Framework generaliza este concepto y proporciona dos clases, que se explican a continuación:
Zend \ Authentication \ Adapter \ AdaptorInterface de clase 1
Esta clase proporciona un solo método, authenticatepara escribir la lógica de autenticación. El método de autenticación devuelve una instancia deZend\Authentication\Result clase.
Esta Resultel objeto tiene el estado de autenticación; identidad si la autenticación tiene éxito y un mensaje de error, si la autenticación falla. La firma de la interfaz de autenticación y la clase de resultado es la siguiente:
AdaptorInterface
namespace Zend\Authentication\Adaptor;
public function authenticate() {
// code
}Result class
namespace Zend\Authentication;
class Result {
public function __construct($code, $identity, array $messages = []);
}Zend Framework proporciona una implementación predeterminada para autenticarse contra las credenciales de base de datos, ldap, http basic y digest. UnAdaptor autentica pero no conserva los detalles para futuras solicitudes.
Zend \ Authentication \ AuthenticationService de clase 2
AuthenticationService es el componente principal, que utiliza el adaptador ya configurado para fines de autenticación. Una vez que se realiza la autenticación, conserva los detalles de autenticación y proporciona métodos,hasIdentity() para comprobar si hay una identidad disponible, getIdentity() para obtener los detalles de autenticación y clearIdentity() para borrar los detalles de autenticación.
La lista de código parcial para usar este AuthenticationService es la siguiente:
$adap = new Adapter($username, $password); $auth = new AuthenticationService();
$result = $auth->authenticate($adap); if($result->isValid) {
$identity = $auth->getIdentity();
} else {
// process $result->getMessages() } // clear $auth->clearIdentity();Las cosas relacionadas con la autorización están empaquetadas como dos módulos separados, que son: zend-permissions-acl y zend-permissions-rbac. El zend-permissions-acl se basa en la lista de control de acceso y el zend-permissions-rbac se basa en la lista de control de acceso basado en roles. Proporcionan una abstracción de alto nivel del concepto de ACL y RBAC y ayudan a escribir la aplicación de nivel empresarial.
Zend Framework proporciona un componente separado llamado zend-mailpara enviar mensajes de correo electrónico. El componente zend-mail también proporciona una opción para leer y escribir mensajes de correo electrónico con archivos adjuntos tanto en formato de texto como html. Enviar un correo electrónico en Zend es mucho más fácil y sencillo de configurar.
Repasemos los conceptos de correo electrónico, la configuración básica, la configuración avanzada como el transporte SMTP, etc., en este capítulo.
Instalar componente de correo
El componente de correo se puede instalar usando el siguiente comando de Composer.
composer require zendframework/zend-mailConfiguración básica de correo electrónico
Un correo electrónico básico consta de uno o más destinatarios, un asunto, un cuerpo y un remitente. Zend proporcionaZend\Mail\Messageclass para crear un nuevo mensaje de correo electrónico. Para enviar un correo electrónico usando elzend-mail, debe especificar al menos un destinatario y el cuerpo del mensaje.
El código parcial para crear un nuevo mensaje de correo es el siguiente:
use Zend\Mail;
$mail = new Mail\Message(); $mail->setSubject('Zend email sample');
$mail->setBody('This is content of the mail message'); $mail->setFrom('[email protected]', "sender-name");
$mail->addTo('[email protected]', "recipient-name");Zend proporciona la clase Zend \ Mail \ Sendmail para enviar el mensaje de correo. Sendmail usa la función de correo nativo de php, mail para enviar el mensaje de correo y podemos configurar la capa de transporte usando el archivo de configuración php.
La codificación parcial usando Sendmail es la siguiente:
$transport = new Mail\Transport\Sendmail();
$transport->send($mail);los zend-mail proporciona muchas capas de transporte y cada una puede requerir muchos parámetros adicionales como nombre de usuario, contraseña, etc.
Métodos de gestión de correo electrónico
Algunos de los métodos de gestión de correo electrónico notables son los siguientes:
isValid - Los mensajes sin una dirección "De" no son válidos.
isValid() : boolsetEncoding - Establecer la codificación del mensaje.
setEncoding(string $encoding) : voidgetEncoding - Obtener la codificación del mensaje.
getEncoding() : stringsetHeaders - Redactar encabezados.
setHeaders(Zend\Mail\Headers $headers) : voidgetHeaders - Acceder a la colección de encabezados.
getHeaders() : Zend\Mail\HeaderssetFrom- Establecer (sobrescribir) Desde direcciones. Contiene pares clave / valor donde la clave es el nombre legible por humanos y el valor es la dirección de correo electrónico.
setFrom(
string|AddressInterface|array|AddressList|Traversable $emailOrAddressList, string|null $name
) : voidaddFrom - Agregue una dirección 'De'.
addFrom(
string|AddressInterface|array|AddressList|Traversable $emailOrAddressOrList, string|null $name
) : voidgetFrom - Recuperar lista de remitentes 'De'.
getFrom() : AddressList
setTo - Overwrite the address list in the To recipients.
setTo(
string|AddressInterface|array|AddressList|Traversable $emailOrAddressList, null|string $name
) : voidsetSubject - Establecer el valor del encabezado del asunto del mensaje.
setSubject(string $subject) :voidsetBody - Establecer el cuerpo del mensaje.
setBody(null|string|Zend\Mime\Message|object $body) : voidCapa de transporte SMTP
los zend-mail proporciona opciones para enviar un correo electrónico utilizando el servidor SMTP a través del Zend\Mail\Transport\Smtpclass. Es comoSendmail excepto que tiene algunas opciones adicionales para configurar el host SMTP, puerto, nombre de usuario, contraseña, etc.
El código parcial es el siguiente:
use Zend\Mail\Transport\Smtp as SmtpTransport;
use Zend\Mail\Transport\SmtpOptions;
$transport = new SmtpTransport(); $options = new SmtpOptions([
'name' => 'localhost',
'host' =>'smtp.gmail.com',
'port' => 465,
]);
$transport->setOptions($options);Aquí,
name - Nombre del host SMTP.
host - Nombre de host remoto o dirección IP.
port - Puerto en el que escucha el host remoto.
Concepto de correo - Ejemplo
Sigamos los siguientes puntos para escribir una aplicación de consola PHP simple para entender el concepto de correo.
Cree una carpeta "mailapp".
Instalar en pc zend-mail utilizando la herramienta de redacción.
Crea un archivo php Mail.php dentro de la carpeta "mailapp".
Crea el mensaje usando el Zend\Mail\Message.
$message = new Message(); $message->addTo('[email protected]');
$message->addFrom('[email protected]'); $message->setSubject('Hello!');
$message->setBody("My first Zend-mail application!");Cree la capa de transporte SMTP y agregue la configuración necesaria.
// Setup SMTP transport using LOGIN authentication
$transport = new SmtpTransport();
$options = new SmtpOptions([ 'name' => 'localhost', 'host' => 'smtp.gmail.com', // or any SMTP server 'port' => 465, // port on which the SMTP server is listening 'connection_class' => 'login', 'connection_config' => [ username' => '<your username>', 'password' => '<your password>', 'ssl' => 'ssl'], ]); $transport->setOptions($options);Envíe el correo electrónico utilizando el send método.
$transport->send($message);La lista completa, Mail.php es la siguiente:
<?php
require __DIR__ . '/vendor/autoload.php';
use Zend\Mail\Message;
use Zend\Mail\Transport\Smtp as SmtpTransport;
use Zend\Mail\Transport\SmtpOptions;
$message = new Message();
$message->addTo('[email protected]'); $message->addFrom('[email protected]');
$message->setSubject('Hello!'); $message->setBody("My first Zend-mail application!");
// Setup SMTP transport using LOGIN authentication
$transport = new SmtpTransport(); $options = new SmtpOptions([
'name' => 'localhost',
'host' => 'smtp.gmail.com', // or any SMTP server
'port' => 465, // port on which the SMTP server is listening
'connection_class' => 'login',
'connection_config' => [
'username' => '<your username>', 'password' => '<your password>',
'ssl' => 'ssl'],
]);
$transport->setOptions($options);
$transport->send($message);Ahora, ejecute la aplicación en el símbolo del sistema. php Mail.php. Esto enviará el correo según lo configurado en la aplicación.
En general, podemos depurar una aplicación PHP usando el advanced debugger tool o usando comandos simples como echo y die. En un escenario web, necesitamos probar la lógica empresarial y la capa de presentación. Los formularios en una aplicación web se pueden probar ingresando datos de prueba relevantes para garantizar que los formularios funcionen como se espera.
El diseño de un sitio web se puede probar manualmente mediante un navegador. Este tipo de procesos de prueba se pueden automatizar mediante pruebas unitarias. Una prueba unitaria es fundamental en grandes proyectos. Estas pruebas unitarias ayudarán a automatizar el proceso de prueba y alertarán al desarrollador cuando algo salga mal.
Configuración de PHPUnit
Zend framework se integra con el framework de pruebas unitarias PHPUnit. Para escribir una prueba unitaria para el marco Zend, necesitamos configurar PHPUnit, lo cual se puede hacer fácilmente usando el siguiente comando Composer.
$ composer require --dev phpunit/phpunitDespués de ejecutar el comando anterior, obtendrá una respuesta como se muestra en el siguiente bloque de código.
Using version ^5.7 for phpunit/phpunit
./composer.json has been updated
Loading composer repositories with package information
Updating dependencies (including require-dev)
Nothing to install or update
Writing lock file
Generating autoload filesAhora, cuando abra el archivo "composer.json", verá los siguientes cambios:
"require-dev": {
"phpunit/phpunit": "^5.7"
}TestCase y afirmaciones
El marco Zend proporciona clases auxiliares para realizar pruebas unitarias del controlador. losTestCase es el componente principal en un PHPUnit marco para escribir los casos de prueba y Zend Framework proporciona una implementación abstracta de TestCase que se llama como AbstractHttpControllerTestCase.
Este AbstractHttpControllerTestCase proporciona varios Assertmétodos y pueden agruparse por funcionalidad. Son los siguientes:
Request Assertions- Se usa para afirmar la solicitud http. Por ejemplo, assertControllerName.
CSS Select Assertions - Se usa para verificar el HTML de respuesta usando el modelo DOM de HTML.
XPath Assertions - Una alternativa a las aserciones de selección de CSS basadas en XPath.
Redirect Assertions - Se utiliza para comprobar la redirección de la página.
Response Header Assertions - Se usa para verificar el encabezado de respuesta como el código de estado (assertResponseStatusCode)
Crear directorio de pruebas
Se puede escribir una prueba unitaria por separado para cada módulo. Toda la codificación relacionada con la prueba debe crearse dentro deltest carpeta en el directorio raíz del módulo.
Por ejemplo, para escribir una prueba para el TutorialController disponible en el módulo Tutorial, la clase de prueba debe colocarse en el directorio myapp / module / Tutorial / test / Controller /.
Ejemplo
Escribamos una clase de prueba para probar unitariamente el TutorialController.
Para empezar, debemos escribir una clase llamada TutorialControllerTest y extenderla a AbstractHttpControllerTestCase.
El siguiente paso es escribir un Setupmétodo para configurar el entorno de prueba. Esto se puede hacer llamando alsetApplicationConfig y pasando nuestro archivo de configuración de la aplicación principal myapp / config / application.config.php
public function setUp() {
$configOverrides = [];
$this->setApplicationConfig(ArrayUtils::merge( include __DIR__ . '/../../../../config/application.config.php', $configOverrides
));
parent::setUp();
}Escriba uno o más métodos y llame a varios métodos de aserción según el requisito.
$this->assertMatchedRouteName('tutorial');Hemos escrito la clase de prueba y la lista completa es la siguiente:
<?php
namespace TutorialTest\Controller;
use Tutorial\Controller\TutorialController;
use Zend\Stdlib\ArrayUtils;
use Zend\Test\PHPUnit\Controller\AbstractHttpControllerTestCase;
class TutorialControllerTest extends AbstractHttpControllerTestCase {
public function setUp() {
$configOverrides = [];
$this->setApplicationConfig(ArrayUtils::merge( include __DIR__ . '/../../../../config/application.config.php', $configOverrides
));
parent::setUp();
}
public function testIndexActionCanBeAccessed() {
$this->dispatch('/tutorial', 'GET'); $this->assertResponseStatusCode(200);
$this->assertModuleName('tutorial'); $this->assertControllerName(TutorialController::class);
$this->assertControllerClass('TutorialController'); $this->assertMatchedRouteName('tutorial');
}
}Ahora, abra un símbolo del sistema, vaya al directorio raíz de la aplicación y ejecute el phpunit ejecutable disponible dentro del vendor carpeta.
cd /path/to/app
./vendor/bin/phpunit ./vendor/bin/phpunit module/
Tutorial/test/Controller/TutorialControllerTest.phpEl resultado será el que se muestra en el siguiente bloque de código:
PHPUnit 5.7.5 by Sebastian Bergmann and contributors.
.1 / 1 (100%)
Time: 96 ms, Memory: 8.00MB
OK (1 test, 5 assertions)La falla del sistema debe manejarse de manera efectiva para el buen funcionamiento del sistema. Zend Framework viene con undefault error trappingque imprime y registra el error a medida que se produce. Este mismo controlador de errores se utiliza para detectarExceptions.
El controlador de errores muestra errores cuando la depuración es verdadera y registra el error cuando la depuración es falsa. Zend Framework tiene varias clases de excepciones y el manejo de excepciones incorporado capturará cualquier excepción no detectada y generará una página útil.
Manejo de errores predeterminado
Podemos configurar los ajustes de error predeterminados en el archivo de configuración de la aplicación, myapp / module / Application / config / module.config.php.
La muestra de código parcial es la siguiente:
'view_manager' => [
'display_not_found_reason' => true,
'display_exceptions' => true,
'doctype' => 'HTML5',
'not_found_template' => 'error/404',
'exception_template' => 'error/index',
'template_map' => [
'layout/layout' => __DIR__ . '/../view/layout/layout.phtml',
'application/index/index' => __DIR__ . '/../view/application/index/index.phtml',
'error/404' => __DIR__ . '/../view/error/404.phtml',
'error/index' => __DIR__ . '/../view/error/index.phtml',
],
'template_path_stack' => [
__DIR__ . '/../view',
],
],Aquí, display_exception, not_found_template, exception_template, error / 404 y error / index son elementos de configuración relacionados con errores y se explican por sí mismos.
El elemento más importante entre ellos es el error/index. Esta es la plantilla que se muestra cuando ocurre una excepción en el sistema. Podemos modificar esta plantilla, myapp / module / Application / view / error / index.phtml para controlar la cantidad de error que se mostrará.
En este capítulo, aprenderemos cómo crear una aplicación de empleado completa basada en MVC en Zend Framework. Siga los pasos que se indican a continuación.
Paso 1: Module.php
Primero, debemos crear un módulo Employee dentro del directorio - myapp / module / Employee / src / y luego implementar la interfaz ConfigProviderInterface.
El código completo para la clase Module es el siguiente:
<?php
namespace Employee;
use Zend\ModuleManager\Feature\ConfigProviderInterface;
class Module implements ConfigProviderInterface {
public function getConfig() {
return include __DIR__ . '/../config/module.config.php';
}
}Paso 2: composer.json
Configurar el Tutorial módulo en composer.json en la sección de carga automática utilizando el siguiente código.
"autoload": {
"psr-4": {
"Application\\": "module/Application/src/",
"Tutorial\\": "module/Tutorial/src/",
"Employee\\": "module/Employee/src/"
}
}Ahora, actualice la aplicación usando un comando de actualización del compositor.
composer updateEl comando Composer hará los cambios necesarios en la aplicación y mostrará los registros como se muestra en el símbolo del sistema a continuación.
Loading composer repositories with package information
Updating dependencies (including require-dev)
- Removing zendframework/zend-component-installer (0.3.0)
- Installing zendframework/zend-component-installer (0.3.1)
Downloading: 100%
- Removing zendframework/zend-stdlib (3.0.1)
- Installing zendframework/zend-stdlib (3.1.0)
Loading from cache
- Removing zendframework/zend-eventmanager (3.0.1)
- Installing zendframework/zend-eventmanager (3.1.0)
Downloading: 100%
- Removing zendframework/zend-view (2.8.0)
- Installing zendframework/zend-view (2.8.1)
Loading from cache
- Removing zendframework/zend-servicemanager (3.1.0)
- Installing zendframework/zend-servicemanager (3.2.0)
Downloading: 100%
- Removing zendframework/zend-escaper (2.5.1)
- Installing zendframework/zend-escaper (2.5.2)
Loading from cache
- Removing zendframework/zend-http (2.5.4)
- Installing zendframework/zend-http (2.5.5)
Loading from cache
- Removing zendframework/zend-mvc (3.0.1)
- Installing zendframework/zend-mvc (3.0.4)
Downloading: 100%
- Removing phpunit/phpunit (5.7.4)
- Installing phpunit/phpunit (5.7.5)
Downloading: 100%
Writing lock file
Generating autoload filesPaso 3: module.config.php para el módulo de empleado
Cree el archivo de configuración del módulo, "module.config.php" en myapp / module / Employee / config con el siguiente código.
<?php
namespace Employee;
use Zend\ServiceManager\Factory\InvokableFactory;
use Zend\Router\Http\Segment;
return [
'controllers' => [
'factories' => [
Controller\EmployeeController::class => InvokableFactory::class,
],
],
'view_manager' => [
'template_path_stack' => ['employee' => __DIR__ . '/../view',],
],
];Ahora, configure el módulo Empleado en el archivo de configuración de nivel de aplicación: myapp / config / modules.config.php.
return ['Zend\Router', 'Zend\Validator', 'Application', 'Tutorial', 'Employee'];Paso 4: EmployeeController
Cree una nueva clase PHP, EmployeeController, extendiendo AbstractActionController y colóquelo en el directorio myapp / module / Employee / src / Controller.
La lista completa de códigos es la siguiente:
<?php
namespace Employee\Controller;
use Zend\Mvc\Controller\AbstractActionController;
use Zend\View\Model\ViewModel;
class EmployeeController extends AbstractActionController {
public function indexAction() {
return new ViewModel();
}
}Paso 5: configuración del enrutador
Agreguemos una ruta de segmento en nuestro módulo Empleado. Actualice el archivo de configuración del módulo del empleado, module.config.php disponible en myapp / module / Employee / config.
<?php
namespace Employee;
use Zend\ServiceManager\Factory\InvokableFactory;
use Zend\Router\Http\Segment;
return [
'controllers' => [
'factories' => [
Controller\EmployeeController::class => InvokableFactory::class,
],
],
'router' => [
'routes' => [
'employee' => [
'type' => Segment::class,
'options' => [
'route' => '/employee[/:action[/:id]]',
'constraints' => [
'action' => '[a-zA-Z][a-zA-Z0-9_-]*',
'id' => '[0-9]+',
],
'defaults' => [
'controller' => Controller\EmployeeController::class,
'action' => 'index',
],
],
],
],
],
'view_manager' => [
'template_path_stack' => [
'employee' => __DIR__ . '/../view',
],
],
];Hemos agregado con éxito el enrutamiento para nuestro módulo Empleado. El siguiente paso es crear un script de vista para la aplicación Empleado.
Paso 6: crear ViewModel
Cree un archivo llamado "index.phtml" en el directorio myapp / module / Employee / view / employee / employee.
Agregue los siguientes cambios en el archivo:
<div class = "row content">
<h3>This is my first Zend application</h3>
</div>
Move to “EmployeeController.php” file and edit the following changes,
<?php
namespace Employee\Controller;
use Zend\Mvc\Controller\AbstractActionController;
use Zend\View\Model\ViewModel;
class EmployeeController extends AbstractActionController {
public function indexAction() {
return new ViewModel();
}
}Finalmente, hemos completado con éxito el módulo Empleado. podemos acceder a él usando la siguiente URL:http://localhost:8080/employee.
Resultado
En el siguiente paso, realizaremos add, edit y deleteoperaciones de datos en la aplicación del empleado. Para realizar estas operaciones, primero debemos crear un modelo de base de datos. Se describe en el siguiente paso.
Paso 7: crear un modelo
Creemos un modelo, Empleado en nuestro módulo src directory. Generalmente, los modelos se agrupan en la carpeta Modelo (myapp / module / Employee / src / Model / Employee.php)
<?php
namespace Employee\Model;
class Employee {
public $id; public $emp_name;
public $emp_job;
}Paso 8: tabla MySQL
Crea una base de datos con el nombre tutorials en el servidor MYSQL local usando el siguiente comando:
create database tutorials;Creemos una tabla llamada employee en la base de datos usando el siguiente comando SQL -
use tutorials;
CREATE TABLE employee (
id int(11) NOT NULL auto_increment,
emp_name varchar(100) NOT NULL,
emp_job varchar(100) NOT NULL,
PRIMARY KEY (id)
);Inserte datos en el employee tabla usando la siguiente consulta -
INSERT INTO employee (emp_name, emp_job) VALUES ('Adam', 'Tutor');
INSERT INTO employee (emp_name, emp_job) VALUES ('Bruce', 'Programmer');
INSERT INTO employee (emp_name, emp_job) VALUES ('David', 'Designer');Paso 9: actualice la configuración de la base de datos
Actualice el archivo de configuración global, myapp / config / autoload / global.php con la información necesaria de la unidad de base de datos.
return [
'db' => [
'driver' => 'Pdo',
'dsn' => 'mysql:dbname = tutorials;host=localhost',
'driver_options' => [PDO::MYSQL_ATTR_INIT_COMMAND => 'SET NAMES \'UTF8\''],
],
];Ahora, actualice las credenciales de la base de datos en el archivo de configuración local: myapp / config / autoload / local.php. De esta manera, podemos separar las credenciales de conexión de la base de datos local y en vivo.
<?php
return array(
'db' => array('username' => '<user_name>', 'password' => '<password>',),
);Paso 10: implementar exchangeArray
Implementar la función exchangeArray en el modelo Employee.
<?php
namespace Employee\Model;
class Employee {
public $id;
public $emp_name; public $emp_job;
public function exchangeArray($data) { $this->id = (!empty($data['id'])) ? $data['id'] : null;
$this->emp_name = (!empty($data['emp_name'])) ? $data['emp_name'] : null; $this->emp_job = (!empty($data['emp_job'])) ? $data['emp_job'] : null;
}
}Paso 11: use TableGateway para obtener los datos del empleado
Cree la clase, EmployeeTable en la propia carpeta Modelo. Se define en el siguiente bloque de código.
<?php
namespace Employee\Model;
use Zend\Db\TableGateway\TableGatewayInterface;
class EmployeeTable {
protected $tableGateway; public function __construct(TableGatewayInterface $tableGateway) {
$this->tableGateway = $tableGateway;
}
public function fetchAll() {
$resultSet = $this->tableGateway->select();
return $resultSet;
}
}Paso 12: Configurar la clase EmployeeTable
Actualice el servicio del empleado en Module.php usando el método getServiceConfig ()
<?php
namespace Employee;
use Zend\Db\Adapter\AdapterInterface;
use Zend\Db\ResultSet\ResultSet;
use Zend\Db\TableGateway\TableGateway;
use Zend\ModuleManager\Feature\ConfigProviderInterface;
class Module implements ConfigProviderInterface {
public function getConfig() {
return include __DIR__ . '/../config/module.config.php';
}
public function getServiceConfig() {
return [
'factories' => [
Model\EmployeeTable::class => function ( $container) {
$tableGateway = $container>get( Model\EmployeeTableGateway::class);
$table = new Model\EmployeeTable($tableGateway);
return $table; }, Model\EmployeeTableGateway::class => function ($container) {
$dbAdapter = $container->get(AdapterInterface::class);
$resultSetPrototype = new ResultSet(); $resultSetPrototype->setArrayObjectPrototype(new Model\Employee());
return new TableGateway('employee', $dbAdapter, null, $resultSetPrototype);
},
],
];
}
}Paso 13: agregar el servicio de empleado en el controlador
Actualice la sección del controlador de la Configuración del módulo del empleado en - myapp / module / config / module.config.php como se muestra a continuación.
'controllers' => [
'factories' => [
Controller\EmployeeController::class => function($container) { return new Controller\EmployeeController( $container->get(Model\EmployeeTable::class)
);
},
],
]Paso 14: agregar constructor para EmployeeController
Agrega el constructor con EmployeeTable como argumento y edite los siguientes cambios.
<?php
namespace Employee\Controller;
use Zend\Mvc\Controller\AbstractActionController;
use Zend\View\Model\ViewModel;
use Employee\Model\Employee;
use Employee\Model\EmployeeTable;
class EmployeeController extends AbstractActionController {
private $table; public function __construct(EmployeeTable $table) {
$this->table = $table;
}
public function indexAction() {
$view = new ViewModel([ 'data' => $this->table->fetchAll(),
]);
return $view;
}
}Paso 15: muestra la información del empleado en el script de visualización "index.phtml"
Mover al archivo - index.phtml y realice los siguientes cambios:
<?php
$title = 'Employee application';
$this->headTitle($title);
?>
<table class="table">
<tr>
<th>Employee Name</th>
<th>Employee Job</th>
<th>Edit/Delete operations</th>
</tr>
<?php foreach ($data as $empdata) : ?>
<tr>
<td><?php echo $this->escapeHtml($empdata->emp_name);?></td>
<td><?php echo $this->escapeHtml($empdata->emp_job);?></td>
<td>
<a href="<?php echo $this->url('employee', array('action'=>'edit', 'id' =>$empdata->id));?>">Edit</a>
<a href="<?php echo $this->url('employee', array('action'=>'delete', 'id' => $empdata->id));?>">Delete</a>
</td>
</tr>
<?php endforeach; ?>
</table>Ahora hemos creado con éxito un modelo de base de datos y podemos recuperar los registros dentro de la aplicación.
Solicite la aplicación utilizando la url - http://localhost:8080/employee.
Resultado
El siguiente paso explica sobre el insert, edit y delete operaciones de datos en el módulo de empleados.
Paso 16: Cree un formulario de empleado
Crea un archivo llamado EmployeeForm.phpen el directorio myapp / module / Employee / src / Form. Se describe en el bloque de código a continuación.
<?php
namespace Employee\Form;
use Zend\Form\Form;
class EmployeeForm extends Form {
public function __construct($name = null) { / / we want to ignore the name passed parent::__construct('employee'); $this->add(array(
'name' => 'id',
'type' => 'Hidden',
));
$this->add(array( 'name' => 'emp_name', 'type' => 'Text', 'options' => array( 'label' => 'Name', ), )); $this->add(array(
'name' => 'emp_job',
'type' => 'Text',
'options' => array(
'label' => 'Job',
),
));
$this->add(array(
'name' => 'submit',
'type' => 'Submit',
'attributes' => array(
'value' => 'Go',
'id' => 'submitbutton',
),
));
}
}Paso 17: actualice el modelo de empleado
Actualice el modelo de empleado e implemente InputFilterAwareInterface. Vaya al directorio myapp / module / Employee / src / Employee / Model y agregue los siguientes cambios en elEmployee.phpfile.
<?php
namespace Employee\Model;
// Add these import statements
use Zend\InputFilter\InputFilter;
use Zend\InputFilter\InputFilterAwareInterface;
use Zend\InputFilter\InputFilterInterface;
class Employee implements InputFilterAwareInterface {
public $id;
public $emp_name; public $emp_job;
protected $inputFilter; public function exchangeArray($data) {
$this->id = (isset($data['id'])) ? $data['id'] : null; $this->emp_name = (isset($data['emp_name'])) ? $data['emp_name'] : null;
$this->emp_job = (isset($data['emp_job'])) ? $data['emp_job'] : null; } // Add content to these methods: public function setInputFilter(InputFilterInterface $inputFilter) {
throw new \Exception("Not used");
}
public function getInputFilter() {
if (!$this->inputFilter) { $inputFilter = new InputFilter();
$inputFilter->add(array( 'name' => 'id', 'required' => true, 'filters' => array( array('name' => 'Int'), ), )); $inputFilter->add(array(
'name' => 'emp_name',
'required' => true,
'filters' => array(
array('name' => 'StripTags'),
array('name' => 'StringTrim'),
),
'validators' => array(
array('name' => 'StringLength',
'options' => array(
'encoding' => 'UTF-8',
'min' => 1,
'max' => 50,
),
),
),
));
$inputFilter->add(array( 'name' => 'emp_job', 'required' => true, 'filters' => array( array('name' => 'StripTags'), array('name' => 'StringTrim'), ), 'validators' => array( array('name' => 'StringLength', 'options' => array( 'encoding' => 'UTF-8', 'min' => 1, 'max' => 50, ), ), ), )); $this->inputFilter = $inputFilter; } return $this->inputFilter;
}
}Paso 18: agregue addAction en el controlador de empleados
Agregue los siguientes cambios en el EmployeeController clase.
<?php
use Zend\Mvc\Controller\AbstractActionController;
use Zend\View\Model\ViewModel;
use Employee\Model\Employee;
use Employee\Model\EmployeeTable;
use Employee\Form\EmployeeForm;
public function addAction() {
$form = new EmployeeForm(); $form->get('submit')->setValue('Add');
$request = $this->getRequest();
if ($request->isPost()) { $employee = new Employee();
$form->setInputFilter($employee->getInputFilter());
$form->setData($request->getPost());
if ($form->isValid()) { $employee->exchangeArray($form->getData()); $this->table->saveEmployee($employee); // Redirect to list of employees return $this->redirect()->toRoute('employee');
}
}
return array('form' => $form);
}Paso 19: agregue la funcionalidad de guardar en la clase EmployeeTable
Agregue las siguientes dos funciones en la clase EmployeeTable: myapp / module / Employee / src / Model / EmployeeTable.php
public function getEmployee($id) {
$id = (int) $id;
$rowset = $this->tableGateway->select(array('id' => $id)); $row = $rowset->current(); if (!$row) {
throw new \Exception("Could not find row $id"); } return $row;
}
public function saveEmployee(Employee $employee) { $data = array (
'emp_name' => $employee->emp_name, 'emp_job' => $employee->emp_job,
);
$id = (int) $employee->id;
if ($id == 0) { $this->tableGateway->insert($data); } else { if ($this->getEmployee($id)) { $this->tableGateway->update($data, array('id' => $id));
} else {
throw new \Exception('Employee id does not exist');
}
}
}Paso 20: Crear script de vista para el método AddAction, Add.phtml
Agregue los siguientes cambios en el archivo "Add.phtml" en - myapp / module / view / employee / employee.
<?php
$title = 'Add new employee'; $this->headTitle($title); ?> <h1><?php echo $this->escapeHtml($title); ?></h1> <?php $form->setAttribute('action', $this->url('employee', array('action' => 'add'))); $form->prepare();
echo $this->form()->openTag($form);
echo $this->formHidden($form->get('id'));
echo $this->formRow($form->get('emp_name'))."<br>";
echo $this->formRow($form->get('emp_job'))."<br>";
echo $this->formSubmit($form->get('submit'));
echo $this->form()->closeTag();
Request the application using the url, http://localhost:8080/employee/addResultado
Una vez que se hayan agregado los datos, se redirigirá a la página de inicio.
Paso 21: Editar registros de empleados
Realicemos las operaciones de edición de datos en el módulo Empleado. Actualice los siguientes cambios en elEmployeecontroller.php.
public function editAction() {
$id = (int) $this->params()->fromRoute('id', 0); if (!$id) {
return $this->redirect()->toRoute('employee', array( 'action' => 'add' )); } try { $employee = $this->table->getEmployee($id);
} catch (\Exception $ex) { return $this->redirect()->toRoute('employee', array(
'action' => 'index'
));
}
$form = new EmployeeForm(); $form->bind($employee); $form->get('submit')->setAttribute('value', 'Edit');
$request = $this->getRequest();
if ($request->isPost()) { $form->setInputFilter($employee->getInputFilter()); $form->setData($request->getPost()); if ($form->isValid()) {
$this->table->saveEmployee($employee);
// Redirect to list of employees
return $this->redirect()->toRoute('employee'); } } return array('id' => $id, 'form' => $form,);
}Aquí buscamos el id, que se encuentra en la ruta coincidente y luego cargue los detalles del empleado para la operación de edición.
Paso 22: Employee.php
Ahora agregue los siguientes cambios en el archivo "Employee.php", que reside en el directorio - myapp / module / Employee / src / Employee / Model /.
public function getArrayCopy() {
return get_object_vars($this);
}Aquí, Zend \ Stdlib \ Hydrator \ ArraySerializable espera encontrar dos métodos en el modelo: getArrayCopy() y exchangeArray().
En el cual, el exchangeArray () se usa para la iteración. Esta función se utiliza para vincular los datos de la tabla de empleados.
Ahora, necesitamos crear un script de vista para editAction().
Paso 23: Crea Edit.phtml
Cree un archivo de script de vista en el módulo / Empleado / vista / empleado / empleado / edit.phtml
<?php
$title = 'Edit employee records'; $this->headTitle($title); ?> <h1><?php echo $this->escapeHtml($title); ?></h1> <?php $form = $this->form; $form->setAttribute('action', $this->url( 'employee', array('action' => 'edit', 'id' => $this->id,)
));
$form->prepare(); echo $this->form()->openTag($form); echo $this->formHidden($form->get('id')); echo $this->formRow($form->get('emp_name'))."<br>"; echo $this->formRow($form->get('emp_job'))."<br>"; echo $this->formSubmit($form->get('submit')); echo $this->form()->closeTag();La edición de los detalles del empleado se muestra en la siguiente captura de pantalla.
Una vez que se han editado los datos, se redirigirá a la página de inicio.
Paso 24: agregue el método deleteEmployee
Agregue el método deleteEmployee en la clase EmployeeTable - myapp / module / Employee / src / Model / EmployeeTable.php
public function deleteEmployee($id) { $this->tableGateway->delete(['id' => (int) $id]);
}Paso 25: Eliminar los registros de empleados
Realicemos ahora las operaciones de eliminación de datos en el módulo Empleado. Agregue el siguiente método,deleteAction en la clase EmployeeController.
public function deleteAction() {
$id = (int) $this->params()->fromRoute('id', 0); if (!$id) {
return $this->redirect()->toRoute('employee'); } $request = $this->getRequest(); if ($request->isPost()) {
$del = $request->getPost('del', 'No');
if ($del == 'Yes') { $id = (int) $request->getPost('id'); $this->table->deleteEmployee($id); } return $this->redirect()->toRoute('employee');
}
return array(
'id' => $id, 'employee' => $this->table->getEmployee($id)
);
}Aquí, el método deleteEmployee () elimina al empleado por su id y redirige a la página de la lista de empleados (página de inicio).
Creemos ahora los scripts de vista correspondientes para el método deleteAction ().
Paso 26: Cree un script de vista
Cree un archivo llamado delete.phtml en - myapp / module / Employee / view / employee / employee / delete.phtml y agregue el siguiente código en él.
<?php
$title = 'Delete an employee record';
$this->headTitle($title);
?>
<h1><?php echo $this->escapeHtml($title); ?></h1>
'<?php echo $this->escapeHtml($employee->emp_name); ?>' by
'<?php echo $this->escapeHtml($employee->emp_job); ?&'?
<?php
$url = $this->url('employee', array('action' => 'delete', 'id' => $this->id,)); ?> <form action ="<?php echo $url; ?>" method = "post">
<div>
<input type = "hidden" name = "id" value = "<?php echo (int) $employee->id; ?>" />
<input type = "submit" name = "del" value = "Yes" />
<input type = "submit" name = "del" value = "No" />
</div>
</form>Ahora, elimine cualquier empleado que utilice edit enlace en la página de inicio y el resultado será como se muestra en la siguiente captura de pantalla.
Resultado
Hemos completado con éxito el módulo Empleado implementando todas las funciones necesarias.
Conclusión
En el entorno competitivo actual, el desarrollador coloca a Zend en el primer lugar. Proporciona abstracciones a cualquier programa o cualquier tipo de aplicación en el lenguaje PHP. Es un marco maduro y es compatible con las características modernas del lenguaje PHP. Es divertido, profesional, evoluciona y sigue el ritmo de la tecnología actual.