Zend Framework2-从数据库创建Select option选项几种方法

One of the most common questions currently is how one is able to populate a Zend\Form\Element\Select with data from the database. In this blog I am going to demonstrate to you guys how you can achieve this using three different ways. First will be the very barebone way using Zend\Db\Adapter\AdapterInterface, another way will be using the Zend\Db\TableGateway\TableGatewayInterface and the third option to make this possible using a Doctrine\Common\Persistence\ObjectManager.

Understanding Dependencies

Let’s start with trying to understand what we actually need. We are going to have one Zend\Form. This form, somehow needs to be inserted some data from a Database. Without this, the form is not functional. If i am going to express those facts using a different terminology it will be this:
The form is dependant on the database!

What we’re ultimately going to do is to inject a dependency into our form. This is pretty simple if you know how to do it. We have two options, Setter-Injection and Constructor-Injection. Given the circumstances that the form will not be usable without the dependency, hence the dependency is a requirement, I will choose Constructor-Injection.

Choose your method

This blog will cover three possible ways to achieve our goal. Please choose which method fits you the best.

All of the Methods follow a common Workflow.

Create a form with a database-dependency
Inject the dependency into the form
Query database for data
Fill data into form element

Please note: all of the examples require you to have correctly configured your DB connection. Namely those will be either the doctrine-adapter or Zend\Db\Adapter\Adapter. If those examples don’t work for you, please check ALL your Code and Configuration with the project over at my GitHub-Playground-Repository.

All code will be inside a Module called FormDependencies. If you try out the codes, make sure you adjust the namespace and the paths correctly!

Element\Select via Db\Adapter

Let’s start by taking a look at our Controller.

public function formDbAdapterAction ( )

{

$vm = new ViewModel ( ) ;

$vm -> setTemplate ( 'form-dependencies/form/form-db-adapter.phtml' ) ;

$dbAdapter = $this -> getServiceLocator ( ) -> get ( 'Zend\Db\Adapter\Adapter' ) ;

$form = new DbAdapterForm ( $dbAdapter ) ;

return $vm -> setVariables ( array (

'form' = > $form

) ) ;

}

The highlighted lines show the interesting part. In line #6 we call the ServiceLocator and ask for the Zend\Db\Adapter\Adapter. This adapter will then be injected into our Form called DbAdapterForm using Constructor-Injection.

So let’s take now take a look at how to create our form.

<?php

namespace FormDependencies \ Form ;

use Zend \ Form \ Form ;

use Zend \ Db \ Adapter \ AdapterInterface ;

class DbAdapterForm extends Form

{

protected $dbAdapter ;

public function __construct ( AdapterInterface $dbAdapter )

{

$this -> setDbAdapter ( $dbAdapter ) ;

parent :: __construct ( 'db-adapter-form' ) ;

$this -> add ( array (

'name' = > 'db-select' ,

'type' = > 'Zend\Form\Element\Select' ,

'options' = > array (

'label' = > 'Dynamic DbAdapter Select' ,

'value_options' = > $this -> getOptionsForSelect ( ) ,

'empty_option' = > '--- please choose ---'

)

) ) ;

}

// more later...

// Also: create SETTER and GETTER for $dbAdapter!

}

As you can see we are overwriting the __construct() of Zend\Form to require a parameter compatible with the Zend\Db\Adapter\AdapterInterface. With this we can make sure that no matter what adapter you guys choose to use, the following code would work. Please create a setter- and getter-function for the protected $dbAdapter.

The next highlighted line would be where we assign the value_options. We call for a function which we yet have to define. This is where we will query the database and return a key-value paired array to populate the Zend\Form\Element\Select.

public function getOptionsForSelect ( )

{

$dbAdapter = $this -> getDbAdapter ( ) ;

$sql = 'SELECT t0.id, t0.title FROM selectoptions t0 ORDER BY t0.title ASC' ;

$statement = $dbAdapter -> query ( $sql ) ;

$result = $statement -> execute ( ) ;

$selectData = array ( ) ;

foreach ( $result as $res ) {

$selectData [ $res [ 'id' ] ] = $res [ 'title' ] ;

}

return $selectData ;

}

And this is all the magic. We fire a query to our database, we iterate through the result, push the data into an array and return it. That’s all!

Once again, if this is not working for you, please check in with my GitHub-Playground-Repository.

Element\Select via Db\TableGateway

The method to populate a Select-Element using the TableGateway-Pattern is very similar to the one above. Let’s once again take a look at our Controller first.

public function formTableAction ( )

{

$vm = new ViewModel ( ) ;

$vm -> setTemplate ( 'form-dependencies/form/form-table.phtml' ) ;

$tableGateway = $this -> getServiceLocator ( ) -> get ( 'formdependencies-model-selecttable' ) ;

$form = new TableForm ( $tableGateway ) ;

return $vm -> setVariables ( array (

'form' = > $form

) ) ;

}

As you can see we get the TableGateway-Access from the ServiceLocator and inject this into the form. I will not explain how the TableGateway-Pattern functions here, but i’ll show you the configuration i have set up to make this work.

<?php
namespace FormDependencies;

use Zend\Db\ResultSet\ResultSet;
use Zend\Db\TableGateway\TableGateway;
use FormDependencies\Model\SelectTable;
use FormDependencies\Model\SelectOption;

class Module
{
    public function getServiceConfig()
    {
        return array(
            'invokables' => array(),
            'factories'  => array(
    
                'formdependencies-model-selecttable' => function ($sm) {
                    $tableGateway = $sm->get('selecttable-gateway');
                    $table        = new SelectTable($tableGateway);
    
                    return $table;
                },
                'selecttable-gateway' => function ($sm) {
                    $dbAdapter          = $sm->get('Zend\Db\Adapter\Adapter');
                    $resultSetPrototype = new ResultSet();
                    $resultSetPrototype->setArrayObjectPrototype(new SelectOption());
    
                    return new TableGateway('selectoptions', $dbAdapter, null, $resultSetPrototype);
                },
            )
        );
    }
}

<?php

namespace FormDependencies ;

use Zend \ Db \ ResultSet \ ResultSet ;

use Zend \ Db \ TableGateway \ TableGateway ;

use FormDependencies \ Model \ SelectTable ;

use FormDependencies \ Model \ SelectOption ;

class Module

{

public function getServiceConfig ( )

{

return array (

'invokables' = > array ( ) ,

'factories' = > array (

'formdependencies-model-selecttable' = > function ( $sm ) {

$tableGateway = $sm -> get ( 'selecttable-gateway' ) ;

$table = new SelectTable ( $tableGateway ) ;

return $table ;

} ,

'selecttable-gateway' = > function ( $sm ) {

$dbAdapter = $sm -> get ( 'Zend\Db\Adapter\Adapter' ) ;

$resultSetPrototype = new ResultSet ( ) ;

$resultSetPrototype -> setArrayObjectPrototype ( new SelectOption ( ) ) ;

return new TableGateway ( 'selectoptions' , $dbAdapter , null , $resultSetPrototype ) ;

} ,

)

) ;

}

I will not show you guys the exact code for the SelectTable or SelectOption classes, as they are pretty common. You can however check the cover at my GitHub-Playground-Repository and read the relevant part of the official Zend Framework 2 Documentation about Database and Models.

Let’s now take a look at what’s happening inside our Form. I will first show you how the Form is constructed.

<?php

namespace FormDependencies \ Form ;

use Zend \ Form \ Form ;

use FormDependencies \ Model \ SelectTable ;

class TableForm extends Form

{

protected $selectTable ;

public function __construct ( SelectTable $selectTable )

{

$this -> setSelectTable ( $selectTable ) ;

parent :: __construct ( 'db-adapter-form' ) ;

$this -> add ( array (

'name' = > 'db-select' ,

'type' = > 'Zend\Form\Element\Select' ,

'options' = > array (

'label' = > 'Dynamic TableGateway Select' ,

'value_options' = > $this -> getOptionsForSelect ( ) ,

'empty_option' = > '--- please choose ---'

)

) ) ;

}

// more soon...

// Getter and Setter for $selectTable here

}

At line #11 you can see that we are overwriting the default __construct() of Zend\Form. With this we make sure that our form gets an injection of our TableGateway-Class called SelectTable.

Line #22 then shows you that we’re calling a function to populate the value_options. The functions task is to access the TableGateway and get the data that we want. So let’s take a look at how this is done.

public function getOptionsForSelect ( )

{

$table = $this -> getSelectTable ( ) ;

$data = $table -> fetchAll ( ) ;

$selectData = array ( ) ;

foreach ( $data as $selectOption ) {

$selectData [ $selectOption -> id ] = $selectOption -> title ;

}

return $selectData ;

}

The code is pretty similar to the DbAdapter-Example. Instead of writing a manual Query, we are using the fetchAll() function of the TableGateway. Next we are iterating through the ResultSet, push the data into an array, that we’re going to return in the end.

And that’s it. If there are any errors or some missing configuration, please check in with my GitHub-Playground-Module. I am only covering the critical points of this topic and leave out the documentation for configuration stuff.

Element\Select via Doctrine\ObjectManager

Now achieving the goal via DbAdapter or TableGateway was very similar. Using any implementation of Doctrines ObjectManager is similar as far as the Dependency-Injection goes, too, but since Doctrine ships with it’s own Form-Elements, we should be doing things the Doctrine-Way. But let’s first take a look at the Controller again.

public function formDoctrineAction ( )

{

$vm = new ViewModel ( ) ;

$vm -> setTemplate ( 'form-dependencies/form/form-doctrine.phtml' ) ;

$entityManager = $this -> getServiceLocator ( ) -> get ( 'Doctrine\ORM\EntityManager' ) ;

$form = new DoctrineForm ( $entityManager ) ;

return $vm -> setVariables ( array (

'form' = > $form

) ) ;

}

This code is pretty much identical with the above two methods. We query the ServiceLocator for our DB-Dependency, which in this case is the Doctrine\ORM\EntityManager and then use Constructor-Injection to inject it into our form called DoctrineForm. That’s boring, so let’s first check in with the DoctrineForm

<?php

namespace FormDependencies \ Form ;

use DoctrineModule \ Persistence \ ObjectManagerAwareInterface ;

use Doctrine \ Common \ Persistence \ ObjectManager ;

use Zend \ Form \ Form ;

class DoctrineForm extends Form implements ObjectManagerAwareInterface

{

protected $objectManager ;

public function __construct ( ObjectManager $objectManager )

{

$this -> setObjectManager ( $objectManager ) ;

parent :: __construct ( 'db-adapter-form' ) ;

// more later ...

}

public function setObjectManager ( ObjectManager $objectManager )

{

$this -> objectManager = $objectManager ;

return $this ;

}

public function getObjectManager ( )

{

return $this -> objectManager ;

}

This Form looks a little different. We are implementing the ObjectManagerAwareInterface. This is not required, but it’s a good thing to do if ever other people will require certain features or want to use the form elsewhere. The important part to note is that we are injecting the ObjectManager. And we need this ObjectManager to use the Form-Elements that are shipped within DoctrineModule. Namely ObjectSelect, ObjectRadio and ObjectMultiCheckbox. In our example we will make use of ObjectSelect. So let’s implement it.

public function __construct ( ObjectManager $objectManager )

{

// previous code

$this -> add ( array (

'type' = > 'DoctrineModule\Form\Element\ObjectSelect' ,

'name' = > 'name' ,

'options' = > array (

'label' = > 'Dynamic ObjectManager Select' ,

'object_manager' = > $this -> getObjectManager ( ) ,

'target_class' = > 'FormDependencies\Entity\SelectOption' ,

'property' = > 'title' ,

'empty_option' = > '--- please choose ---'

) ,

) ) ;

}

Now what’s that? First we define that this FormElement is of type ObjectSelect. The ObjectSelect requires some additional parameters to work. It requires the ObjectManager, it needs to know which Entity is represented by this Select-Element (in this case Entity\SelectOption) and it needs to know which property to display.

And this is all that is done here. In the Doctrine-Example we are not querying the database manually, that’s what the ObjectSelect is doing behind the scenes for us. All we have to make sure is that we are correctly adding the dependency to the form, inject it, and pass it over to the ObjectSelect Form-Element.

Final Words

With this code i hope to reach some people who are yet unable to do this kind of thing. There are other ways to inject the dependencies. Just to give an example, you can – and probably should – getch the whole form from the ServiceManager and inject the dependency in that process. It shouldn’t be the task of a Controller to handle the dependency. But for the sake of keeping this blogpost somewhat small and easy, i did it this way instead.

Furthermore i’ll say this again: the blogpost doesn’t cover all the configuration that are required, like setting up a database-connection or setting up doctrine the correct way. If you need help with this, please check in to my ZF2Playground as GitHub to see how it’s done.

Ultimately i hope this is of help to some of you guys. Feel free to ask me anything regarding this topic and I’m sure I’ll come up with an answer sooner or later ;