Zend Framework - Esempio di lavoro
In questo capitolo impareremo come creare un'applicazione per dipendenti basata su MVC completa in Zend Framework. Segui i passaggi indicati di seguito.
Passaggio 1: Module.php
Innanzitutto, dovremmo creare un modulo Employee all'interno della directory - myapp / module / Employee / src / e quindi implementare l'interfaccia ConfigProviderInterface.
Il codice completo per la classe Module è il seguente:
<?php
namespace Employee;
use Zend\ModuleManager\Feature\ConfigProviderInterface;
class Module implements ConfigProviderInterface {
public function getConfig() {
return include __DIR__ . '/../config/module.config.php';
}
}
Passaggio 2: composer.json
Configura il Tutorial modulo in composer.json nella sezione autoload utilizzando il codice seguente.
"autoload": {
"psr-4": {
"Application\\": "module/Application/src/",
"Tutorial\\": "module/Tutorial/src/",
"Employee\\": "module/Employee/src/"
}
}
Ora aggiorna l'applicazione utilizzando un comando di aggiornamento del compositore.
composer update
Il comando Composer apporterà le modifiche necessarie all'applicazione e mostrerà i log come mostrato nel prompt dei comandi di seguito.
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
Passaggio 3: module.config.php per il modulo Employee
Crea il file di configurazione del modulo, "module.config.php" sotto myapp / module / Employee / config con il codice seguente.
<?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',],
],
];
Ora, configura il modulo Employee nel file di configurazione a livello di applicazione - myapp / config / modules.config.php.
return ['Zend\Router', 'Zend\Validator', 'Application', 'Tutorial', 'Employee'];
Passaggio 4: EmployeeController
Crea una nuova classe PHP, EmployeeController estendendo AbstractActionController e posizionalo nella directory myapp / module / Employee / src / Controller.
L'elenco completo del codice è il seguente:
<?php
namespace Employee\Controller;
use Zend\Mvc\Controller\AbstractActionController;
use Zend\View\Model\ViewModel;
class EmployeeController extends AbstractActionController {
public function indexAction() {
return new ViewModel();
}
}
Passaggio 5: configurazione del router
Aggiungiamo un percorso di segmento nel nostro modulo Employee. Aggiorna il file di configurazione del modulo dei dipendenti, module.config.php disponibile su 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',
],
],
];
Abbiamo aggiunto con successo il routing per il nostro modulo Employee. Il passaggio successivo consiste nel creare uno script di visualizzazione per l'applicazione Employee.
Passaggio 6: creare ViewModel
Crea un file chiamato "index.phtml" nella directory myapp / module / Employee / view / dipendente / dipendente.
Aggiungi le seguenti modifiche nel file:
<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();
}
}
Infine, abbiamo completato con successo il modulo Employee. possiamo accedervi utilizzando il seguente URL -http://localhost:8080/employee.
Risultato
Nella fase successiva, eseguiremo add, edit e deleteoperazioni sui dati nell'applicazione dipendente. Per eseguire queste operazioni, dobbiamo prima creare un modello di database. È descritto nel passaggio successivo.
Passaggio 7: creare un modello
Creiamo un modello, Dipendente nel nostro modulo src directory. Generalmente, i modelli sono raggruppati nella cartella Model (myapp / module / Employee / src / Model / Employee.php)
<?php
namespace Employee\Model;
class Employee {
public $id; public $emp_name;
public $emp_job;
}
Passaggio 8: tabella MySQL
Crea un database denominato come tutorials nel server MYSQL locale utilizzando il seguente comando:
create database tutorials;
Creiamo una tabella denominata come employee nel database utilizzando il seguente 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)
);
Inserisci i dati nel file employee tabella utilizzando la seguente query:
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');
Passaggio 9: aggiorna la configurazione del database
Aggiorna il file di configurazione globale, myapp / config / autoload / global.php con le informazioni necessarie sull'unità del database.
return [
'db' => [
'driver' => 'Pdo',
'dsn' => 'mysql:dbname = tutorials;host=localhost',
'driver_options' => [PDO::MYSQL_ATTR_INIT_COMMAND => 'SET NAMES \'UTF8\''],
],
];
Ora, aggiorna le credenziali del database nel file di configurazione locale - myapp / config / autoload / local.php. In questo modo, possiamo separare le credenziali di connessione del database locale e live.
<?php
return array(
'db' => array('username' => '<user_name>', 'password' => '<password>',),
);
Passaggio 10: implementare exchangeArray
Implementa la funzione exchangeArray nel modello 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;
}
}
Passaggio 11: utilizzare TableGateway per recuperare i dati dei dipendenti
Crea la classe, EmployeeTable nella cartella Model stessa. È definito nel seguente blocco di codice.
<?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;
}
}
Passaggio 12: configurare la classe EmployeeTable
Aggiorna il servizio dei dipendenti in Module.php utilizzando il metodo 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);
},
],
];
}
}
Passaggio 13: aggiungere il servizio dei dipendenti in Controller
Aggiorna la sezione controller della Configurazione modulo dipendente in - myapp / module / config / module.config.php come mostrato di seguito.
'controllers' => [
'factories' => [
Controller\EmployeeController::class => function($container) { return new Controller\EmployeeController( $container->get(Model\EmployeeTable::class)
);
},
],
]
Passaggio 14: aggiungere il costruttore per EmployeeController
Aggiungi il costruttore con EmployeeTable come argomento e modificare le seguenti modifiche.
<?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;
}
}
Passaggio 15: visualizza le informazioni sui dipendenti nello script di visualizzazione "index.phtml"
Sposta nel file - index.phtml e apporta le seguenti modifiche:
<?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>
Ora abbiamo creato con successo un modello di database e possiamo recuperare i record all'interno dell'applicazione.
Richiedi l'applicazione utilizzando l'url - http://localhost:8080/employee.
Risultato
Il passaggio successivo spiega il insert, edit e delete operazioni sui dati nel modulo dei dipendenti.
Passaggio 16: creare un modulo dipendente
Crea un file chiamato EmployeeForm.phpnella directory myapp / module / Employee / src / Form. È descritto nel blocco di codice seguente.
<?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',
),
));
}
}
Passaggio 17: aggiorna il modello dipendente
Aggiorna il modello dei dipendenti e implementa InputFilterAwareInterface. Spostati nella directory myapp / module / Employee / src / Employee / Model e aggiungi le seguenti modifiche nel fileEmployee.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;
}
}
Passaggio 18: aggiungere addAction in Employee Controller
Aggiungi le seguenti modifiche nel file 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);
}
Passaggio 19: aggiungere la funzionalità di salvataggio nella classe EmployeeTable
Aggiungi le seguenti due funzioni nella 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');
}
}
}
Passaggio 20: creare lo script di visualizzazione per il metodo AddAction, Add.phtml
Aggiungere le seguenti modifiche nel file "Add.phtml" in - miaapp / modulo / visualizzazione / dipendente / dipendente.
<?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
Risultato
Una volta aggiunti i dati, verrà reindirizzato alla home page.
Passaggio 21: modificare i record dei dipendenti
Eseguiamo le operazioni di modifica dei dati nel modulo Employee. Aggiorna le seguenti modifiche inEmployeecontroller.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,);
}
Qui cerchiamo il file id, che si trova nel percorso abbinato e quindi carica i dettagli del dipendente per l'operazione di modifica.
Passaggio 22: Employee.php
Ora aggiungi le seguenti modifiche nel file "Employee.php", che risiede nella directory - myapp / module / Employee / src / Employee / Model /.
public function getArrayCopy() {
return get_object_vars($this);
}
Qui, Zend \ Stdlib \ Hydrator \ ArraySerializable si aspetta di trovare due metodi nel modello: getArrayCopy() e exchangeArray().
In cui, exchangeArray () viene utilizzato per l'iterazione. Questa funzione viene utilizzata per associare i dati dalla tabella dei dipendenti.
Ora, dobbiamo creare uno script di visualizzazione per editAction().
Passaggio 23: creare Edit.phtml
Crea un file di script di visualizzazione nel modulo / Employee / view / dipendente / dipendente / 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 modifica dei dettagli del dipendente è mostrata nella seguente schermata.
Una volta modificati i dati, verranno reindirizzati alla home page.
Passaggio 24: aggiungere il metodo deleteEmployee
Aggiungi il metodo deleteEmployee nella classe EmployeeTable: myapp / module / Employee / src / Model / EmployeeTable.php
public function deleteEmployee($id) { $this->tableGateway->delete(['id' => (int) $id]);
}
Passaggio 25: eliminare i record dei dipendenti
Eseguiamo ora le operazioni di eliminazione dei dati nel modulo Employee. Aggiungi il seguente metodo,deleteAction nella 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)
);
}
Qui, il metodo deleteEmployee () elimina il dipendente dal suo id e reindirizza alla pagina dell'elenco dei dipendenti (home page).
Creiamo ora uno script di visualizzazione corrispondente per il metodo deleteAction ().
Passaggio 26: creare uno script di visualizzazione
Crea un file denominato delete.phtml in - myapp / module / Employee / view / dipendente / dipendente / delete.phtml e aggiungi il seguente codice al suo interno.
<?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>
Ora, elimina qualsiasi dipendente utilizzando il file edit link nella home page e il risultato sarà come mostrato nello screenshot seguente.
Risultato
Abbiamo completato con successo il modulo Employee implementando tutte le funzionalità necessarie.
Conclusione
Nell'attuale ambiente competitivo, il framework Zend è posizionato al primo posto dallo sviluppatore. Fornisce astrazioni a qualsiasi programma o qualsiasi tipo di applicazione nel linguaggio PHP. È un framework maturo e supporta le moderne funzionalità del linguaggio PHP. È divertente, professionale, in evoluzione e al passo con la tecnologia attuale.