zend-framework2Aan de slag met zend-framework2


Opmerkingen

Zend Framework 2 (ZF2) is een modern en flexibel PHP-framework waarmee webontwikkelaars webapplicaties van verschillende complexiteit kunnen bouwen. De hoofdsponsor van het bedrijf Zend Framework is Zend Technologies , waardoor het zeer sterk en stabiel is. Er zijn twee belangrijke verbeteringen van deze tweede versie over ZF1. Ten eerste is standaard een op modules gebaseerde architectuur zonder enige aanpassing aangenomen. Dit is handig bij het ontwikkelen van een grote webtoepassing die een ontleding van modules vereist. Ten tweede implementeert ZF2 alle functies die PHP5.3 + biedt, met name de naamruimten. In de vorige versies heeft een controllerklasse de volgende naam:

class IndexController extends Zend_Controller_Action
{

}

Deze zelfde klasse wordt als volgt herschreven in ZF2:

namespace Application\Controller;
use Zend\Mvc\Controller\AbstractActionController;

class IndexController extends AbstractActionController
{

}

Hier volgen enkele andere opwindende functies van ZF2:

  • Afhankelijkheid injectie
  • Eventmanager
  • Service Manager

Een eenvoudige Hallo wereld

composer create-project zendframework/skeleton-application helloWorldTest uw opdrachtregel naar de map waarin u het project wilt maken en typ vervolgens: composer create-project zendframework/skeleton-application helloWorldTest . Tijdens de installatie wordt u gevraagd of u een minimale installatie wilt: laten we nu ja zeggen, we testen alleen maar.

Voor de eenvoud gebruiken we de ingebouwde PHP CLI-server. helloWorldTest vanaf de opdrachtregel naar de hoofdmap van uw project ( helloWorldTest ) en voer vervolgens: php -S 0.0.0.0:8080 -t public/ public/index.php . Open nu uw webbrowser en ga naar http: // localhost / , u zou de welkomstpagina van de ZF2 Skeleton-toepassing moeten zien.

Als u dit doet, zullen we nu een nieuwe pagina instellen. In module/Application/config/module.config.php kun je zien dat er al een dynamische route is ingesteld voor de submap van de applicatie:

return [
    'router' => [
        'routes' => [
            'home' => [
                ...
            ],
            'application' => [
                'type'    => Segment::class,
                'options' => [
                    'route'    => '/application[/:action]',
                    'defaults' => [
                        'controller'    => Controller\IndexController::class,
                        'action'        => 'index',
                    ],
                ],
            ],
        ],
    ],
 

Stel een nieuwe actie " helloWorldAction() " in in module/Applicaiton/src/Controller/IndexController.php :

class IndexController extends AbstractActionController
{
    public function indexAction()
    {
        ...
    }
    
    public function helloWorldAction()
    {
        return new ViewModel();
    }
}
 

Maak ten slotte de module/Application/view/application/index/hello-world.phtml met de volgende inhoud:

<?php
echo "Hello World !";
 

Ga nu naar http: // localhost / application / hallo-world en zeg hallo tegen ZF2!

Hoe een fabriek te creëren

Wanneer een klasse van harde afhankelijkheden moet worden voorzien, is het best om een constructor-injectiepatroon te gebruiken waarbij die afhankelijkheden worden geïnjecteerd met behulp van een fabriek.

Laten we aannemen dat MyClass hard afhankelijk is van een waarde $dependency die moet worden opgelost vanuit de applicatieconfiguratie.

<?php
namespace Application\Folder;

use Zend\ServiceManager\FactoryInterface;
use Zend\ServiceManager\ServiceLocatorInterface;

class MyClass
{
    protected $dependency;

    public function __construct($dependency)
    { 
        $this->dependency = $dependency;
    }
}
 

Om deze afhankelijkheid te injecteren, wordt een fabrieksklasse gemaakt. Deze fabriek lost de afhankelijkheid van de configuratie op en injecteert de configuratiewaarde bij de constructie van de klasse en retourneert het resultaat:

<?php
namespace Application\Factory;

use Zend\ServiceManager\FactoryInterface;
use Zend\ServiceManager\ServiceLocatorInterface;

class MyClassFactory implements FactoryInterface
{
    public function createService(ServiceLocatorInterface $serviceLocator)
    { 
        $config = $servicelocator->get('Config');
        $dependency = $config['dependency'];
        $myClass = new MyClass($dependency);
        return $myClass;
    }
}
 

Nu de fabrieksklasse is gemaakt, moet deze worden geregistreerd in de servicemanager-configuratie in het module-configuratiebestand module.config.php onder de belangrijkste fabrieken. Het is een goede gewoonte om dezelfde namen te gebruiken voor zowel de klasse als de fabriek, dus het is gemakkelijk om ze te vinden in de mapstructuur van het project:

<?php

namespace Application;

return array(
    //...
    'service_manager' => [
        'factories' => [
            'Application\Folder\MyClass' => 'Application\Factory\MyClassFactory'
        ]
    ],
    //...
);
 

Als alternatief kunnen de klassenaamconstanten worden gebruikt om ze te registreren:

<?php

namespace Application;

use Application\Folder\MyClass;
use Application\Factory\MyClassFactory;

return array(
    //...
    'service_manager' => [
        'factories' => [
            MyClass::class => MyClassFactory::class'
        ]
    ],
    //...
);
 

Nu kan de klasse worden verzameld bij de servicemanager met behulp van de sleutel die we hebben gebruikt bij het registreren van de fabriek voor die klasse:

 $serviceManager->get('Application\Folder\MyClass');
 

of

 $serviceManager->get(MyClass::class);
 

De servicemanager zal de fabriek vinden, verzamelen en runnen en retourneert vervolgens uw klasse-instantie met de geïnjecteerde afhankelijkheid.

Installatie of instellingen

Gedetailleerde instructies voor het instellen of installeren van Zend Framework 2. Er zijn verschillende manieren om het framework te installeren. Hieronder zijn enkele van hen:

Composer gebruiken - aanbevolen manier

Ervan uitgaande dat composer op de doeldoos is geïnstalleerd .

Om een skelet MVC-applicatie te installeren, voer je in je terminal uit om een nieuw zend framework 2-project op een specifieke locatie te maken:

php composer.phar create-project -sdev \
    --repository-url="https://packages.zendframework.com" \
    zendframework/skeleton-application path/to/install
 

om handmatig een minimale ZF2 (Zend MVC + zijn handvol afhankelijkheden) te installeren, voer je in je opdrachtregel uit:

composer require zendframework/zend-mvc
 

of voor een full-fledge d ZF2 (+64 modules):

composer require zendframework/zendframework`
 

Houd er rekening mee dat de eerste optie een installatieprogramma uitvoert dat u een volledig functionele toepassing biedt, samen met de gebruikelijke structuur van de toepassingsmappen. Met andere opties kunt u de hele applicatie helemaal opnieuw bouwen, omdat deze eenvoudig ZF2-modules biedt om op te bouwen.

Git-submodules gebruiken

Voer de onderstaande opdracht uit om zf2 en zijn afhankelijkheden recursief van Github te klonen:

git clone git://github.com/zendframework/ZendSkeletonApplication.git --recursive
 

HTTP-server instellen

Een typische webtoepassing vereist een HTTP-service die een speciale poort (meestal: 80) afluistert om inkomende aanvragen door te geven aan de toepassing, de uitvoer (reactie) te verwerken en terug te sturen.

Opmerking: u kunt ook console-bewuste toepassingen schrijven in Zend Framework 2 zonder dat u een HTTP-server nodig hebt.

OPTIE 1 - PHP CLI-server

De eenvoudigste manier om aan de slag te gaan als u PHP 5.4 of hoger gebruikt, is door de interne PHP cli-server in de hoofdmap te starten.

Ga naar projectmap en voer uit:

php -S 0.0.0.0:8080 -t public/ public/index.php`.
 

Hiermee wordt de ingebouwde cli-server op poort 8080 gestart en aan alle netwerkinterfaces gekoppeld.

OPTIE 2 - Een aangepaste HTTP-server

Configureer een virtualhost op Apache of Microsoft IIS Server of Nginx en geef binnenkomende HTTP-aanvragen door aan de applicatie.