Doctrine2 and ZendFramework Integration

Time does not stand still, and we must run after time.
Now and ZF2 on the way. First milestone released. Zend Framework 2.0.0dev1 Release . Doctrine2 BETA3 - was on Friday.
A good programmer never stands still - there is no time. Will lag behind and forward - make the table - "Code for the Food".

It was evening, there was nothing…

Downloading the source code of the libraries began to play. The goal is to be able to create models while maintaining the ZF structure and work through the Doctrine2 connection.
First we need to put in the include_path classes that are part of Doctrine2.
')
library/Doctrine
libray/Symfony


Symfony will need to use the tool out of the box for Doctrine2 to work (two Console and Yaml components).
In configs / application.ini we register data for the auto loader.
autoloadernamespaces.doctrine = "Doctrine"
autoloadernamespaces.symfony = "Symfony"


Continued under the cut. What options need to register in the application.ini. How to connect Doctrine2, the source code of a resource plugin.


For my application, I chose
appnamespace = "Ecom"

At the moment I have not found a more "beautiful" way to prescribe the path to the resource plugins.
pluginpaths.Ecom\Application\Resources = APPLICATION_PATH "/resources"


Doctrine2 configuration parameters, for me this is just a connection to the database configuration (as long as I don’t need anything else).
resources.doctrine2.connection.driver = "pdo_mysql"
resources.doctrine2.connection.host = "localhost"
resources.doctrine2.connection.user = "root"
resources.doctrine2.connection.password = ""
resources.doctrine2.connection.dbname = "doctrinedb"


In the resource plugin there must be a namespace - Ecom \ Application \ Resources; And the class name must match the name in application.ini.

<? php

namespace Ecom \ Application \ Resources ;

use Doctrine \ Common \ Util ;

use Ecom \ Document ;

use Doctrine \ ORM ;
use Doctrine \ DBAL ;
use Doctrine \ Common ;
use Doctrine \ Common \ Cache ;
use Zend \ Application \ Resource ;

class Doctrine2 extends Resource \ AbstractResource {

public function init ( ) {

$ front = $ this -> getBootstrap ( ) -> getResource ( 'frontcontroller' ) ;
$ modules = $ front -> getControllerDirectory ( ) ;
$ entityModels = array ( ) ;
foreach ( $ modules as $ module => $ moduleDirectory ) {
$ dir = dirname ( $ moduleDirectory ) . "/ models" ;
if ( is_dir ( $ dir ) ) {
$ entityModels [ ] = $ dir ;
}
}

$ options = $ this -> getOptions ( ) ;

$ config = new ORM \ Configuration ( ) ;

$ config -> setProxyDir ( APPLICATION_PATH . '/ proxies' ) ;
$ config -> setProxyNamespace ( 'Ecom \ Proxy' ) ;
$ config -> setAutoGenerateProxyClasses ( $ this -> getBootstrap ( ) -> getEnvironment ( ) == "development" ) ;

$ driverImpl = $ config -> newDefaultAnnotationDriver ( $ entityModels ) ;
$ config -> setMetadataDriverImpl ( $ driverImpl ) ;

if ( $ this -> getBootstrap ( ) -> getEnvironment ( ) == "development" ) {
$ cache = new Cache \ ArrayCache ( ) ;
} else {
$ cache = new Cache \ ApcCache ( ) ;
}

$ config -> setMetadataCacheImpl ( $ cache ) ;
$ config -> setQueryCacheImpl ( $ cache ) ;

$ evm = new Common \ EventManager ( ) ;
$ entityManager = ORM \ EntityManager :: create ( $ options [ 'connection' ] , $ config , $ evm ) ;

$ eventDocument = new EventDocument ( $ entityManager -> getEventManager ( ) ) ;

return $ entityManager ;
}
}


class EventDocument {

private $ evm ;

public $ preFooInvoked = false ;
public $ postFooInvoked = false ;

public function __construct ( $ evm )
{
$ this -> evm = $ evm ;
// $ evm-> addEventListener (array (ORM \ Events :: preRemove), $ this);
// $ evm-> addEventListener (array (ORM \ Events :: postRemove), $ this);
// $ evm-> addEventListener (array (ORM \ Events :: prePersist), $ this);
$ evm -> addEventListener ( array ( ORM \ Events :: postPersist , ORM \ Events :: postUpdate ) , $ this ) ;
// $ evm-> addEventListener (array (ORM \ Events :: preUpdate), $ this);
// $ evm-> addEventListener (array (ORM \ Events :: postUpdate), $ this);
// $ evm-> addEventListener (array (ORM \ Events :: postLoad), $ this);
// $ evm-> addEventListener (array (ORM \ Events :: loadClassMetadata), $ this);
// $ evm-> addEventListener (array (ORM \ Events :: onFlush), $ this);
}

public function postPersist ( Common \ EventArgs $ e )
{
\ Doctrine \ Common \ Util \ Debug :: dump ( $ e -> getEntity ( ) ) ;
echo __METHOD__ ;
}

public function postUpdate ( Common \ EventArgs $ e )
{
echo __METHOD__ ;
}


}

$ entityModels contains a list of existing modules in the system; the same mechanism is used by the Frontcontroller plugin resource for loading modules.
$ options ['connection'] - database connection options for Doctrine2.
When generating a schema, Doctrine2 will search for data in the ModuleName / Model folder, use the schema for the database based on the php-doc model class.

Creating a controller and an example of creating a new model object.

1. <? php
3. namespace Catalog ;
4. use Zend \ Controller ;
5. use Core \ Model \ Entity ;
6. use Catalog \ Model ;
9. class IndexController extends Controller \ Action
10. {
12. public function init ( )
13. {
14. / * Initialize action controller here * /
15. }
17. public function indexAction ( ) {
20. $ product = new Model \ Product ( ) ;
21. $ product -> setName ( 'test' ) ;
22. $ product -> setSku ( 'test' . mktime ( ) ) ;
24. / * @var $ em Doctrine \ ORM \ EntityManager * /
25. $ em = $ this -> getInvokeArg ( 'bootstrap' ) -> getResource ( 'doctrine2' ) ;
27. $ em -> persist ( $ product ) ;
28. $ em -> flush ( ) ;
30. $ this -> _helper -> layout -> setLayout ( 'layout' ) ;
31. }
32. }

Everything should be simple and clear. It is worth paying attention only to the fact that it is necessary to use the namespace Catalog; - module name.

The class of the product model itself

1. <? php
3. namespace Catalog \ Model ;
5. use Core \ Model \ Entity ;
6. / **
7. * @Entity
8. * @HasLifecycleCallbacks
9. * @Table (name = "catalog_product")
10. * /
11. class Product extends Model \ Entity {
12. / **
13. * @var integer
14. * @Id @Column (type = "integer")
15. * @GeneratedValue (strategy = "AUTO")
16. * /
17. private $ id ;
19. / **
20. * @var string
21. * @Column (type = "string", length = 255)
22. * /
23. private $ name ;
25. / **
26. * @var string
27. * @Column (type = "string", length = 255, unique = true, nullable = false)
28. * /
29. private $ sku ;
31. / **
32. * @var string
33. * @Column (type = "datetime", nullable = true)
34. * /
35. private $ created ;
37. / **
38. * @var string
39. * @Column (type = "datetime", nullable = true)
40. * /
41. private $ updated ;
43. / **
44. * @return integer the $ id
45. * /
46. public function getId ( ) {
47. return $ this -> id ;
48. }
50. / **
51. * @return string the $ name
52. * /
53. public function getName ( ) {
54. return $ this -> getProperty ( 'name' ) ;
55. }
57. / **
58. * @param string $ name the $ name to set
59. * /
60. public function setName ( $ name ) {
61. $ this -> name = $ name ;
62. return $ this ;
63. }
65. / **
66. * @return string the $ created
67. * /
68. / **
69. * @return the $ sku
70. * /
71. public function getSku ( ) {
72. return $ this -> getProperty ( 'sku' ) ;
73. }
75. / **
76. * @param $ sku the $ sku to set
77. * /
78. public function setSku ( $ sku ) {
79. $ this -> sku = $ sku ;
80. return $ this ;
81. }
83. public function getCreated ( ) {
84. return $ this -> getProperty ( 'created' ) ;
85. }
87. / **
88. * @param $ created the $ created to set
89. * /
90. public function setCreated ( $ created ) {
91. $ this -> created = $ created ;
92. return $ this ;
93. }
95. / **
96. * @return the $ updated
97. * /
98. public function getUpdated ( ) {
99. return $ this -> getProperty ( 'updated' ) ;
100. }
102. / **
103. * @param $ updated the $ updated to set
104. * /
105. public function setUpdated ( $ updated ) {
106. $ this -> updated = $ updated ;
107. return $ this ;
108. }
110. }

Again, it is worth noting - namespace Catalog \ Model; Mandatory instruction for model class.

My thoughts - I like it all. PHP has risen one step higher as a language for the corporate sector.