Zend Framework - Exemple de travail

Dans ce chapitre, nous allons apprendre à créer une application d'employé complète basée sur MVC dans Zend Framework. Suivez les étapes ci-dessous.

Étape 1: Module.php

Tout d'abord, nous devons créer un module Employee dans le répertoire - myapp / module / Employee / src /, puis implémenter l'interface ConfigProviderInterface.

Le code complet de la classe Module est le suivant -

<?php  
namespace Employee;  
use Zend\ModuleManager\Feature\ConfigProviderInterface;  
class Module implements ConfigProviderInterface { 
   public function getConfig() {    
      return include __DIR__ . '/../config/module.config.php'; 
   }    
}

Étape 2: composer.json

Configurer le Tutorial module dans composer.json sous la section de chargement automatique en utilisant le code suivant.

"autoload": { 
   "psr-4": { 
      "Application\\": "module/Application/src/", 
      "Tutorial\\": "module/Tutorial/src/", 
      "Employee\\": "module/Employee/src/" 
   } 
}

Maintenant, mettez à jour l'application à l'aide d'une commande de mise à jour du compositeur.

composer update

La commande Composer apportera les modifications nécessaires à l'application et affichera les journaux comme indiqué dans l'invite de commande ci-dessous.

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 files

Étape 3: module.config.php pour le module Employee

Créez le fichier de configuration du module, «module.config.php» sous myapp / module / Employee / config avec le code suivant.

<?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',], 
   ], 
];

Maintenant, configurez le module Employé dans le fichier de configuration au niveau de l'application - myapp / config / modules.config.php.

return ['Zend\Router', 'Zend\Validator', 'Application', 'Tutorial', 'Employee'];

Étape 4: EmployeeController

Créez une nouvelle classe PHP, EmployeeController en étendant le AbstractActionController et placez-le dans le répertoire myapp / module / Employee / src / Controller.

La liste complète des codes est la suivante -

<?php  
namespace Employee\Controller;  
use Zend\Mvc\Controller\AbstractActionController; 
use Zend\View\Model\ViewModel;  
class EmployeeController extends AbstractActionController { 
   public function indexAction() { 
      return new ViewModel(); 
   } 
}

Étape 5: Configuration du routeur

Ajoutons une route de segment dans notre module Employé. Mettez à jour le fichier de configuration du module employé, module.config.php disponible dans 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', 
      ], 
   ], 
];

Nous avons ajouté avec succès le routage de notre module Employé. L'étape suivante consiste à créer un script de vue pour l'application Employé.

Étape 6: Créer ViewModel

Créez un fichier appelé «index.phtml» dans le répertoire myapp / module / Employee / view / employee / employee.

Ajoutez les modifications suivantes dans le fichier -

<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();  
   } 
}

Enfin, nous avons terminé avec succès le module Employé. nous pouvons y accéder en utilisant l'url suivante -http://localhost:8080/employee.

Résultat

Dans la prochaine étape, nous effectuerons add, edit et deleteopérations de données dans l'application employé. Pour effectuer ces opérations, nous devons d'abord créer un modèle de base de données. Il est décrit à l'étape suivante.

Étape 7: créer un modèle

Créons un modèle, Employé dans notre module src directory. Généralement, les modèles sont regroupés dans le dossier Model (myapp / module / Employee / src / Model / Employee.php)

<?php  
namespace Employee\Model;  
class Employee { 
   public $id; public $emp_name; 
   public $emp_job; 
}

Étape 8: Table MySQL

Créez une base de données nommée comme tutorials dans le serveur MYSQL local à l'aide de la commande suivante -

create database tutorials;

Créons une table nommée employee dans la base de données en utilisant la commande SQL suivante -

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) 
);

Insérez des données dans le employee table à l'aide de la requête suivante -

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');

Étape 9: mettre à jour la configuration de la base de données

Mettez à jour le fichier de configuration globale, myapp / config / autoload / global.php avec les informations nécessaires sur le lecteur de base de données.

return [
   'db' => [
      'driver' => 'Pdo',
      'dsn' => 'mysql:dbname = tutorials;host=localhost',
      'driver_options' => [PDO::MYSQL_ATTR_INIT_COMMAND => 'SET NAMES \'UTF8\''],
   ],
];

Maintenant, mettez à jour les informations d'identification de la base de données dans le fichier de configuration local - myapp / config / autoload / local.php. De cette façon, nous pouvons séparer les informations d'identification de connexion à la base de données locale et en direct.

<?php 
return array( 
   'db' => array('username' => '<user_name>', 'password' => '<password>',), 
);

Étape 10: implémenter exchangeArray

Implémentez la fonction exchangeArray dans le modèle 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; 
   } 
}

Étape 11: Utilisez TableGateway pour récupérer les données des employés

Créez la classe EmployeeTable dans le dossier Model lui-même. Il est défini dans le bloc de code suivant.

<?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; 
   } 
}

Étape 12: Configurer la classe EmployeeTable

Mettre à jour le service des employés dans Module.php à l' aide de la méthode 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);
            },
         ],
      ];
   }
}

Étape 13: Ajouter un service aux employés dans le contrôleur

Mettez à jour la section contrôleur de la configuration du module employé dans - myapp / module / config / module.config.php comme indiqué ci-dessous.

'controllers' => [
   'factories' => [
      Controller\EmployeeController::class => function($container) { return new Controller\EmployeeController( $container->get(Model\EmployeeTable::class)
         ); 
      }, 
   ], 
]

Étape 14: Ajouter un constructeur pour EmployeeController

Ajoutez le constructeur avec EmployeeTable comme argument et modifiez les modifications suivantes.

<?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; 
   } 
}

Étape 15: Afficher les informations sur les employés dans le script de vue «index.phtml»

Déplacer vers le fichier - index.phtml et apportez les modifications suivantes -

<?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>

Nous avons maintenant créé avec succès un modèle de base de données et pouvons récupérer les enregistrements dans l'application.

Demandez l'application en utilisant l'url - http://localhost:8080/employee.

Résultat

L'étape suivante explique la insert, edit et delete opérations de données dans le module employé.

Étape 16: Créez un formulaire d'employé

Créez un fichier appelé EmployeeForm.phpdans le répertoire myapp / module / Employee / src / Form. Il est décrit dans le bloc de code ci-dessous.

<?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', 
         ), 
      )); 
   } 
}

Étape 17: mettre à jour le modèle d'employé

Mettez à jour le modèle d'employé et implémentez InputFilterAwareInterface. Accédez au répertoire myapp / module / Employee / src / Employee / Model et ajoutez les modifications suivantes dans leEmployee.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; 
   } 
}

Étape 18: Ajouter addAction dans le contrôleur des employés

Ajoutez les modifications suivantes dans le EmployeeController classe.

<?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); 
}

Étape 19: Ajouter une fonctionnalité d'enregistrement dans la classe EmployeeTable

Ajoutez les deux fonctions suivantes dans la classe 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'); 
      } 
   } 
}

Étape 20: Créer un script de vue pour la méthode AddAction, Add.phtml

Ajoutez les modifications suivantes dans le fichier «Add.phtml» dans - 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/add

Résultat

Une fois les données ajoutées, elles seront redirigées vers la page d'accueil.

Étape 21: Modifier les enregistrements des employés

Exécutons les opérations d'édition des données dans le module Employé. Mettez à jour les modifications suivantes dans leEmployeecontroller.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,); 
}

Ici, nous recherchons le id, qui se trouve dans l'itinéraire correspondant, puis chargez les détails de l'employé pour l'opération d'édition.

Étape 22: Employee.php

Ajoutez maintenant les modifications suivantes dans le fichier «Employee.php», qui se trouve dans le répertoire - myapp / module / Employee / src / Employee / Model /.

public function getArrayCopy() { 
   return get_object_vars($this); 
}

Ici, le Zend \ Stdlib \ Hydrator \ ArraySerializable s'attend à trouver deux méthodes dans le modèle: getArrayCopy() et exchangeArray().

Dans lequel, exchangeArray () est utilisé pour l'itération. Cette fonction est utilisée pour lier les données de la table des employés.

Maintenant, nous devons créer un script de vue pour editAction().

Étape 23: Créez Edit.phtml

Créez un fichier de script de vue dans le module / Employee / view / employee / employee / 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 modification des détails de l'employé est présentée dans la capture d'écran suivante.

Une fois les données modifiées, elles seront redirigées vers la page d'accueil.

Étape 24: Ajouter la méthode deleteEmployee

Ajoutez la méthode deleteEmployee dans la classe EmployeeTable - myapp / module / Employee / src / Model / EmployeeTable.php

public function deleteEmployee($id) { $this->tableGateway->delete(['id' => (int) $id]); 
}

Étape 25: supprimer les enregistrements d'employés

Exécutons maintenant les opérations de suppression de données dans le module Employé. Ajoutez la méthode suivante,deleteAction dans la classe 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) 
   ); 
}

Ici, la méthode deleteEmployee () supprime l'employé par son id et redirige vers la page de liste des employés (page d'accueil).

Créons maintenant un script de vue correspondant pour la méthode deleteAction ().

Étape 26: créer un script de vue

Créez un fichier nommé delete.phtml dans - myapp / module / Employee / view / employee / employee / delete.phtml et ajoutez-y le code suivant.

<?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>

Maintenant, supprimez tout employé utilisant le edit lien dans la page d'accueil et le résultat sera comme indiqué dans la capture d'écran suivante.

Résultat

Nous avons terminé avec succès le module Employé en implémentant toutes les fonctionnalités nécessaires.

Conclusion

Dans l'environnement concurrentiel actuel, le framework Zend est placé au premier rang par le développeur. Il fournit des abstractions à tout programme ou tout type d'application en langage PHP. Il s'agit d'un framework mature et prend en charge les fonctionnalités du langage PHP moderne. C'est amusant, professionnel, évolutif et en phase avec la technologie actuelle.