Creare ed eseguire un progetto Zend Framework (Laminas) in ServBay
Panoramica
Zend Framework (ora parte del Laminas Project) è un potente framework PHP open source che offre una gamma di componenti di alta qualità orientati agli oggetti per la creazione di applicazioni e servizi Web moderni. È rinomato per la sua flessibilità, progettazione modulare e alte prestazioni, rendendolo la scelta ideale sia per siti semplici che per applicazioni aziendali complesse.
ServBay è un ambiente di sviluppo web locale progettato per macOS e Windows, che integra PHP, vari server web (come Caddy e Nginx), database (MySQL, PostgreSQL, MongoDB), servizi di caching (Redis, Memcached) e altri strumenti di sviluppo. ServBay semplifica la gestione e la configurazione di questi pacchetti, rendendo facile configurare ed eseguire progetti PHP localmente.
In questo documento troverai le istruzioni per creare ed eseguire un progetto Zend Framework (Laminas) su ServBay, oltre all'integrazione dei database e servizi cache forniti dalla piattaforma.
Prerequisiti
Prima di iniziare, assicurati di aver completato questi passaggi:
- Installazione di ServBay: ServBay deve essere installato e funzionante su macOS o Windows. Se non l’hai ancora installato, visita il sito ufficiale di ServBay per le istruzioni di download e installazione.
- Pacchetti necessari in ServBay: Assicurati che in ServBay siano installati e attivi i seguenti pacchetti:
- Almeno una versione PHP (consigliato PHP 8.x o superiore, dato che le versioni moderne di Zend Framework / Laminas richiedono PHP recente).
- Un server web (Caddy o Nginx).
- Composer (di solito già incluso in ServBay).
- I servizi database che intendi utilizzare (ad es. MySQL, PostgreSQL) e servizi cache (ad es. Memcached, Redis). Puoi avviarli facilmente dal pannello di controllo di ServBay.
Creazione di un progetto Zend Framework
ServBay consiglia di inserire tutti i tuoi progetti web nelle seguenti directory, per una gestione automatica ottimizzata:
- macOS:
/Applications/ServBay/www - Windows:
C:\ServBay\www
Accedi alla root del sito
Apri il terminale e naviga verso la directory suggerita da ServBay:
macOS:
bashcd /Applications/ServBay/www1Windows:
cmdcd C:\ServBay\www1Crea il progetto con Composer
Composer è già incluso in ServBay, quindi non ti serve installarlo separatamente. Usa il comando
create-projectdi Composer per creare una nuova applicazione Zend Framework (Laminas skeleton application). Qui la creeremo nella sottodirectoryservbay-zend-app:bashcomposer create-project laminas/laminas-skeleton-application servbay-zend-app1Questo comando scaricherà l'applicazione scheletro e installerà tutte le dipendenze nella cartella
servbay-zend-app.Accedi alla directory del progetto
Spostati nella cartella del progetto appena creato:
bashcd servbay-zend-app1
Configurazione del server web
Per accedere al tuo progetto Zend Framework tramite il browser, devi configurare un sito in ServBay.
- Apri il pannello di controllo di ServBay: Avvia ServBay.
- Vai alle impostazioni dei siti web: Nel pannello, trova e clicca sulla scheda Website (Siti web).
- Aggiungi un nuovo sito: Clicca sul pulsante
+in basso a sinistra per aggiungere una nuova configurazione. - Compila le informazioni del sito:
- Nome: Dai un nome identificativo, ad esempio
My Zend Dev Site. - Dominio: Inserisci il dominio che userai nel browser. Per evitare conflitti, usa un suffisso
.localo.test, ad esempioservbay-zend-test.local. ServBay configurerà automaticamente la risoluzione DNS locale. - Tipo di sito: Scegli
PHP. - Versione PHP: Seleziona la versione PHP desiderata (es.
8.3). Assicurati che sia installata e attiva su ServBay. - Root del documento: È la cartella esposta dal server web. L’entry point di Zend Framework è
index.phpnella cartellapublicdel progetto. Imposta la root supublic:/Applications/ServBay/www/servbay-zend-app/public.
- Nome: Dai un nome identificativo, ad esempio
- Salva e riavvia: Clicca su Salva. ServBay ti inviterà ad applicare le modifiche: conferma. Il server web verrà ricaricato e la nuova configurazione sarà attiva.
Per una guida dettagliata, consulta la sezione Aggiungere il primo sito web nella documentazione di ServBay.
Esempio base "Hello ServBay!"
Vediamo ora come modificare il progetto per mostrare "Hello ServBay!" all’URL di root (/).
Configura routing e controller (module.config.php)
Modifica
module/Application/config/module.config.phpnel progetto, assicurandoti che contenga la seguente configurazione base di routing e controller:php<?php declare(strict_types=1); namespace Application; use Laminas\Router\Http\Literal; use Laminas\Router\Http\Segment; use Laminas\ServiceManager\Factory\InvokableFactory; return [ 'router' => [ 'routes' => [ 'home' => [ 'type' => Literal::class, 'options' => [ 'route' => '/', 'defaults' => [ 'controller' => Controller\IndexController::class, 'action' => 'index', ], ], ], // ... altre configurazioni routing ], ], 'controllers' => [ 'factories' => [ Controller\IndexController::class => InvokableFactory::class, ], ], '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', ], ], // ... altre configurazioni ];1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49Nota: Il codice sopra è parte del contenuto di
module.config.php. Va integrato nell’array di configurazione già presente, assicurandosi che la rotta'home'e la factory del controller siano definite.Crea o modifica il controller (IndexController.php)
Modifica o crea
module/Application/src/Controller/IndexController.php, assicurandoti che il metodoindexActionrestituisca una ViewModel con il messaggio:php<?php declare(strict_types=1); namespace Application\Controller; use Laminas\Mvc\Controller\AbstractActionController; use Laminas\View\Model\ViewModel; class IndexController extends AbstractActionController { /** * Azione di default per mostrare la pagina di benvenuto. */ public function indexAction() { // Restituisce una ViewModel passando la variabile 'message' alla vista return new ViewModel([ 'message' => 'Hello ServBay!', ]); } // ... altri metodi azione }1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24Crea o modifica il file vista (index.phtml)
Modifica o crea
module/Application/view/application/index/index.phtml. Questo file riceverà la variabilemessagedal controller e la mostrerà:php<h1><?php echo $this->message; ?></h1>1Qui si usa l’helper di vista
$this->messageper accedere ai dati passati dal controller.
Accesso al sito
Apri il browser e visita il dominio configurato su ServBay, ad esempio https://servbay-zend-test.local.
Se tutto è configurato correttamente, vedrai la pagina con il messaggio Hello ServBay!. Questo conferma che il progetto Zend Framework è attivo su ServBay.
Esempi di integrazione con database e cache
ServBay offre vari database e servizi cache. I seguenti esempi mostrano come collegare e usare Memcached, Redis, MySQL e PostgreSQL in un progetto Zend Framework.
Nota importante: Questi esempi sono scollegati l’uno dall’altro; nella pratica sceglierai il database e la/le cache adatte al tuo progetto e gestirai le connessioni tramite dependency injection. Assicurati che i servizi corrispondenti (ad esempio MySQL, PostgreSQL, Memcached, Redis) siano attivi in ServBay prima di eseguire gli esempi.
Esempio di interazione con database - Creazione tabella
Vediamo come usare il componente Laminas DB per interagire con il database e creare una tabella. Questo snippet mostra la definizione e creazione manuale di una tabella, invece che utilizzare lo strumento Laminas Migrations.
Installa il componente Laminas DB
Dal terminale nella root del progetto:
bashcomposer require laminas/laminas-db1Crea il database manualmente
Prima di eseguire la prova, crea manualmente un database chiamato
servbay_zend_apptramite gli strumenti di gestione disponibili su ServBay (phpMyAdmin, pgAdmin, MongoDB Compass, ecc). Per MySQL/MariaDB l’utente di default èroote la passwordpassword; anche per PostgreSQL.Definisci ed esegui lo script di creazione tabella (esempio)
Crea un file PHP (
create_users_table.php) nella root del progetto o una posizione temporanea, con il seguente codice:php<?php // create_users_table.php use Laminas\Db\Adapter\Adapter; use Laminas\Db\Sql\Sql; // Supponiamo si usi MySQL/MariaDB $adapter = new Adapter([ 'driver' => 'Pdo_Mysql', // o 'Pdo_Pgsql' 'database' => 'servbay_zend_app', 'username' => 'root', 'password' => 'password', // password di default ServBay 'hostname' => '127.0.0.1', // 'port' => 3306, // porta di default MySQL // 'port' => 5432, // porta di default PostgreSQL ]); $sql = new Sql($adapter); // Definisci la query di creazione tabella 'users' $create = $sql->createTable('users') ->addColumn(new \Laminas\Db\Sql\Ddl\Column\Integer('id', false, null, ['AUTO_INCREMENT' => true])) ->addColumn(new \Laminas\Db\Sql\Ddl\Column\Varchar('name', 255)) ->addColumn(new \Laminas\Db\Sql\Ddl\Column\Varchar('email', 255, ['UNIQUE' => true])) ->addConstraint(new \Laminas\Db\Sql\Ddl\Constraint\PrimaryKey('id')); echo "Esecuzione SQL:\n"; echo $sql->buildSqlString($create, $adapter->getPlatform()) . "\n"; try { // Esegui SQL $adapter->query( $sql->buildSqlString($create, $adapter->getPlatform()), Adapter::QUERY_MODE_EXECUTE ); echo "Tabella 'users' creata con successo.\n"; } catch (\Exception $e) { echo "Errore nella creazione della tabella: " . $e->getMessage() . "\n"; }1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38Nota: Questo è solo uno script di esecuzione manuale. Per la gestione reale degli schemi, usa gli strumenti di migrazione dedicati.
Esegui lo script dal terminale tramite PHP CLI:
bashphp create_users_table.php1
Esempio di integrazione MySQL
Come collegarsi e interrogare MySQL da un controller Zend Framework.
Configura la connessione nel progetto
Modifica
config/autoload/global.php, inserendo i dettagli di connessione a MySQL:php<?php // config/autoload/global.php return [ 'db' => [ 'driver' => 'Pdo_Mysql', 'database' => 'servbay_zend_app', // deve esistere 'username' => 'root', // utente di default ServBay 'password' => 'password', // password di default 'hostname' => '127.0.0.1', 'port' => 3306, // porta di default MySQL 'charset' => 'utf8mb4', ], // ... altre configurazioni globali ];1
2
3
4
5
6
7
8
9
10
11
12
13
14Definisci la factory per il controller (module.config.php)
Per permettere l’iniezione di
Laminas\Db\Adapter\Adapternel controller, modifica il filemodule/Application/config/module.config.phpnella sezionecontrollers, aggiungendo la factory. Se già haiInvokableFactory, sostituiscila:php<?php // module/Application/config/module.config.php namespace Application; use Laminas\ServiceManager\Factory\InvokableFactory; use Laminas\Db\Adapter\AdapterInterface; return [ // ... altre configurazioni 'controllers' => [ 'factories' => [ Controller\IndexController::class => function($container) { // Ottieni l’adapter DB dal Service Manager $adapter = $container->get(AdapterInterface::class); // Crea il controller con l’adapter return new Controller\IndexController($adapter); }, // altre factories se necessario ], ], 'service_manager' => [ 'aliases' => [ // Alias per AdapterInterface AdapterInterface::class => 'Laminas\Db\Adapter\Adapter', ], 'factories' => [ // Factory per Adapter 'Laminas\Db\Adapter\Adapter' => \Laminas\Db\Adapter\AdapterServiceFactory::class, ], ], // ... altre configurazioni ];1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32Nota: Inserisci queste sezioni nell’array di configurazione esistente.
Definisci le nuove routes (module.config.php)
Aggiungi le rotte per l’esempio MySQL in
module/Application/config/module.config.php:php<?php // module/Application/config/module.config.php namespace Application; use Laminas\Router\Http\Literal; // ... altri use return [ 'router' => [ 'routes' => [ // ... rotte esistenti ('home') 'mysql-add' => [ 'type' => Literal::class, 'options' => [ 'route' => '/mysql-add', 'defaults' => [ 'controller' => Controller\IndexController::class, 'action' => 'mysqlAdd', ], ], ], 'mysql' => [ 'type' => Literal::class, 'options' => [ 'route' => '/mysql', 'defaults' => [ 'controller' => Controller\IndexController::class, 'action' => 'mysql', ], ], ], ], ], // ... altre configurazioni ];1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35Aggiungi i metodi nel controller (IndexController.php)
Modifica
module/Application/src/Controller/IndexController.php, aggiungendo il costruttore che riceve l’Adapter e i metodi:php<?php declare(strict_types=1); namespace Application\Controller; use Laminas\Mvc\Controller\AbstractActionController; use Laminas\View\Model\ViewModel; use Laminas\Db\Adapter\AdapterInterface; use Laminas\Db\Sql\Sql; class IndexController extends AbstractActionController { private $adapter; public function __construct(AdapterInterface $adapter) { $this->adapter = $adapter; } /** * Azione di default per la welcome page. */ public function indexAction() { return new ViewModel([ 'message' => 'Hello ServBay!', ]); } /** * Azione: aggiunge un utente alla tabella 'users' via MySQL. */ public function mysqlAddAction() { $sql = new Sql($this->adapter); $insert = $sql->insert('users') ->values([ 'name' => 'ServBay Demo User', 'email' => 'demo-mysql@servbay.test', ]); $statement = $sql->prepareStatementForSqlObject($insert); $result = $statement->execute(); $message = $result->getAffectedRows() > 0 ? 'Utente MySQL aggiunto con successo.' : 'Aggiunta utente MySQL non riuscita.'; return new ViewModel([ 'message' => $message, ]); } /** * Azione: recupera tutti gli utenti dalla tabella via MySQL. */ public function mysqlAction() { $sql = new Sql($this->adapter); $select = $sql->select('users'); $statement = $sql->prepareStatementForSqlObject($select); $result = $statement->execute(); $users = []; foreach ($result as $row) { $users[] = $row; } return new ViewModel([ 'users' => json_encode($users, JSON_PRETTY_PRINT), ]); } // ... altri metodi azione }1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74Crea i file vista
Crea
module/Application/view/application/index/mysql-add.phtml:php<h1><?php echo $this->message; ?></h1>1Crea
module/Application/view/application/index/mysql.phtml:php<h1>Utenti MySQL</h1> <pre><?php echo $this->users; ?></pre>1
2Prova l'esempio MySQL
Con MySQL attivo in ServBay, visita
https://servbay-zend-test.local/mysql-addper aggiungere un utente. Vedrai la notifica "Utente MySQL aggiunto con successo.". Poi visitahttps://servbay-zend-test.local/mysqlper visualizzare i dati della tabella. Gli utenti saranno mostrati in formato JSON.
Esempio di integrazione PostgreSQL
Vediamo come collegarsi e interrogare PostgreSQL da un controller Zend Framework.
Configura la connessione database
Modifica
config/autoload/global.phpinserendo i dati per PostgreSQL. Attenzione: Se vuoi usare sia MySQL che PostgreSQL, servono configurazioni distinte; qui si suppone che tu usi PostgreSQL:php<?php // config/autoload/global.php return [ 'db' => [ 'driver' => 'Pdo_Pgsql', 'database' => 'servbay_zend_app', 'username' => 'root', // utente di default 'password' => 'password', // password di default 'hostname' => '127.0.0.1', 'port' => 5432, // porta di default PostgreSQL ], // ... altre configurazioni globali ];1
2
3
4
5
6
7
8
9
10
11
12
13Definisci la factory del controller (module.config.php)
(Come nell’esempio MySQL) Assicurati che la configurazione di
controllerseservice_managerconsenta l’iniezione di AdapterInterface.Definisci le routes per PostgreSQL
In
module/Application/config/module.config.phpaggiungi:php<?php namespace Application; use Laminas\Router\Http\Literal; return [ 'router' => [ 'routes' => [ // ... rotte esistenti 'pgsql-add' => [ 'type' => Literal::class, 'options' => [ 'route' => '/pgsql-add', 'defaults' => [ 'controller' => Controller\IndexController::class, 'action' => 'pgsqlAdd', ], ], ], 'pgsql' => [ 'type' => Literal::class, 'options' => [ 'route' => '/pgsql', 'defaults' => [ 'controller' => Controller\IndexController::class, 'action' => 'pgsql', ], ], ], ], ], // ... altre configurazioni ];1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33Aggiungi i metodi nel controller
Modifica
module/Application/src/Controller/IndexController.php, aggiungendo:php<?php declare(strict_types=1); namespace Application\Controller; use Laminas\Mvc\Controller\AbstractActionController; use Laminas\View\Model\ViewModel; use Laminas\Db\Adapter\AdapterInterface; use Laminas\Db\Sql\Sql; class IndexController extends AbstractActionController { private $adapter; public function __construct(AdapterInterface $adapter) { $this->adapter = $adapter; } // ... altri metodi /** * Azione: aggiunge un utente alla tabella 'users' via PostgreSQL. */ public function pgsqlAddAction() { $sql = new Sql($this->adapter); $insert = $sql->insert('users') ->values([ 'name' => 'ServBay Demo User', 'email' => 'demo-pgsql@servbay.test', ]); $statement = $sql->prepareStatementForSqlObject($insert); $result = $statement->execute(); $message = $result->getAffectedRows() > 0 ? 'Utente PostgreSQL aggiunto con successo.' : 'Aggiunta utente PostgreSQL non riuscita.'; return new ViewModel([ 'message' => $message, ]); } /** * Azione: recupera tutti gli utenti dalla tabella via PostgreSQL. */ public function pgsqlAction() { $sql = new Sql($this->adapter); $select = $sql->select('users'); $statement = $sql->prepareStatementForSqlObject($select); $result = $statement->execute(); $users = []; foreach ($result as $row) { $users[] = $row; } return new ViewModel([ 'users' => json_encode($users, JSON_PRETTY_PRINT), ]); } }1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65Crea i file vista
Crea
module/Application/view/application/index/pgsql-add.phtml:php<h1><?php echo $this->message; ?></h1>1Crea
module/Application/view/application/index/pgsql.phtml:php<h1>Utenti PostgreSQL</h1> <pre><?php echo $this->users; ?></pre>1
2Prova l'esempio PostgreSQL
Assicurati che il servizio PostgreSQL sia attivo in ServBay. Visita
https://servbay-zend-test.local/pgsql-addper aggiungere un utente. Visualizzerai "Utente PostgreSQL aggiunto con successo.". Poi visitahttps://servbay-zend-test.local/pgsqlper vedere i dati utente in formato JSON.
Esempio di integrazione Memcached
Come utilizzare Memcached come cache da un controller Zend Framework.
Installa l'adapter Memcached
Aggiungi nel
composer.json:json// composer.json { "require": { "laminas/laminas-skeleton-application": "^1.0", "laminas/laminas-cache-storage-adapter-memcached": "^2.0" // ... altre dipendenze }, // ... altre configurazioni }1
2
3
4
5
6
7
8
9Poi esegui:
bashcomposer update1ServBay include già l’estensione PHP
memcached.Definisci la rotta Memcached
Nel file
module/Application/config/module.config.phpaggiungi:php<?php namespace Application; use Laminas\Router\Http\Literal; return [ 'router' => [ 'routes' => [ // ... rotte esistenti 'memcached' => [ 'type' => Literal::class, 'options' => [ 'route' => '/memcached', 'defaults' => [ 'controller' => Controller\IndexController::class, 'action' => 'memcached', ], ], ], ], ], // ... altre configurazioni ];1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23Aggiungi il metodo nel controller
In
module/Application/src/Controller/IndexController.php:php<?php declare(strict_types=1); namespace Application\Controller; use Laminas\Mvc\Controller\AbstractActionController; use Laminas\View\Model\ViewModel; use Laminas\Cache\StorageFactory; use Laminas\Cache\Storage\StorageInterface; class IndexController extends AbstractActionController { // ... altri metodi /** * Azione: esempio usage di Memcached. */ public function memcachedAction() { // Crea storage Memcached (ServBay: 127.0.0.1:11211) $cache = StorageFactory::factory([ 'adapter' => [ 'name' => 'memcached', 'options' => [ 'servers' => [ ['127.0.0.1', 11211], ], 'ttl' => 300, ], ], 'plugins' => [ 'serializer', 'exception_handler' => ['throw_exceptions' => false], ], ]); $cacheKey = 'my_memcached_data'; $cachedData = $cache->getItem($cacheKey, $success); if (!$success) { $cachedData = 'Hello Memcached! (Dati dalla fonte, cache a ' . date('Y-m-d H:i:s') . ')'; $cache->setItem($cacheKey, $cachedData); $cachedData .= ' - CACHE MISS'; } else { $cachedData .= ' - CACHE HIT'; } return new ViewModel([ 'message' => $cachedData, ]); } }1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53Crea il file vista
Crea
module/Application/view/application/index/memcached.phtml:php<h1>Esempio Memcached</h1> <p><?php echo $this->message; ?></p>1
2Prova l'esempio Memcached
Attiva Memcached in ServBay. Visita
https://servbay-zend-test.local/memcached. Il primo accesso mostra "CACHE MISS", i successivi (entro 300 secondi) "CACHE HIT" (il timestamp non cambia).
Esempio di integrazione Redis
Come utilizzare Redis per caching o storage da un controller Zend Framework.
Installa l'adapter Redis
Aggiungi nel
composer.json:json// composer.json { "require": { "laminas/laminas-skeleton-application": "^1.0", "laminas/laminas-cache-storage-adapter-redis": "^2.0", "ext-redis": "*" // ... altre dipendenze }, // ... altre configurazioni }1
2
3
4
5
6
7
8
9
10Poi esegui:
bashcomposer update1ServBay include già l’estensione PHP
redis.Definisci la rotta Redis
In
module/Application/config/module.config.phpaggiungi:php<?php namespace Application; use Laminas\Router\Http\Literal; return [ 'router' => [ 'routes' => [ // ... rotte esistenti 'redis' => [ 'type' => Literal::class, 'options' => [ 'route' => '/redis', 'defaults' => [ 'controller' => Controller\IndexController::class, 'action' => 'redis', ], ], ], ], ], // ... altre configurazioni ];1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23Aggiungi il metodo nel controller
In
module/Application/src/Controller/IndexController.php:php<?php declare(strict_types=1); namespace Application\Controller; use Laminas\Mvc\Controller\AbstractActionController; use Laminas\View\Model\ViewModel; use Laminas\Cache\StorageFactory; use Laminas\Cache\Storage\StorageInterface; class IndexController extends AbstractActionController { // ... altri metodi /** * Azione: esempio usage di Redis. */ public function redisAction() { // Crea storage Redis (ServBay: 127.0.0.1:6379) $cache = StorageFactory::factory([ 'adapter' => [ 'name' => 'redis', 'options' => [ 'server' => [ 'host' => '127.0.0.1', 'port' => 6379, // 'database' => 0, // 'password' => null, ], 'ttl' => 300, ], ], 'plugins' => [ 'serializer', 'exception_handler' => ['throw_exceptions' => false], ], ]); $cacheKey = 'my_redis_data'; $cachedData = $cache->getItem($cacheKey, $success); if (!$success) { $cachedData = 'Hello Redis! (Dati dalla fonte, cache a ' . date('Y-m-d H:i:s') . ')'; $cache->setItem($cacheKey, $cachedData); $cachedData .= ' - CACHE MISS'; } else { $cachedData .= ' - CACHE HIT'; } return new ViewModel([ 'message' => $cachedData, ]); } }1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56Crea il file vista
Crea
module/Application/view/application/index/redis.phtml:php<h1>Esempio Redis</h1> <p><?php echo $this->message; ?></p>1
2Prova l'esempio Redis
Attiva Redis in ServBay. Visita
https://servbay-zend-test.local/redis. Il primo accesso mostrerà "CACHE MISS", i successivi (entro 300 secondi) "CACHE HIT".
Conclusione
Seguendo questi passaggi hai creato, configurato ed eseguito con successo un progetto Zend Framework (Laminas) su ServBay. Hai visto come configurare il server web, integrare e utilizzare MySQL, PostgreSQL e i servizi di cache Memcached e Redis.
ServBay semplifica la gestione e la configurazione dell’ambiente locale, permettendoti di concentrarti sullo sviluppo. Con la vasta gamma di pacchetti e le opzioni di configurazione flessibili, puoi facilmente simulare l’ambiente produttivo e aumentare la produttività durante la fase di sviluppo.
