Zend Framework and the Doctrine2 MongoDB ODM (ZF1)

ZF & Doctrine 2 ODM

Doctrine

WHO IS RYAN MAUGER?
• Zend Framework Contributor

• Zend Framework CR Team Member

• Co-Author of Zend Framework 2 in Action (With Rob Allen)

• Technical Editor for Zend Framework: A Beginners Guide

• Community Supporter

• Zend Certiﬁed PHP5 Engineer

• Lead Developer at Lupimedia and trainer at Lupijuice

What is the ODM?
Object Document Mapper

What is the ODM?

Similar to an ORM

What is the ODM?

Similar to an ORM
But works with a Document Database

Whats the advantage?

• Schema-less design (no complicated ALTER
TABLE statements, just save your data!

• Works with JSON objects, familiar with what
your already doing

• Simple!


• Schema-less design (no complicated ALTER
TABLE statements, just save your data!

• Works with JSON objects, familiar with what
your already doing

• Simple! (at least to get started)

Doctrine 2

• Uses the Data Mapper pattern
• Simpliﬁes your domain, removes the
persistence logic

• Entities are free to do their job
• Deﬁnes a framework by which your domain
model will work, improving consistency

Getting started with the
ODM

Persistence operations revolve around the Document Manager

Mapping of properties is carried out through annotations in
your entities, or through xml/yaml mappings

<?php
namespace ApplicationBlog;

/**
* @Document(db="blog", collection="posts")
*/
class Post
{
/**
* @Id
*/
private $id;
An example entity
/**
* @Field(type="string")
*/
private $title;

/**
* @String
*/
Properties
private $content;

/** /**
* @EmbedMany(targetDocument="ApplicationBlogComment")
*/ * @Id
private $comments = array();
*/
public function getId() private $id;
{
return $this->id;
} /**
public function setId($id) * @Field(type="string")
{
$this->id = (string) $id; */
return $this; private $title;
}

public function getTitle()
{
/**
return $this->title; * @String
}
*/
public function setTitle($title) private $content;
{
$this->title = (string) $title;

}
return $this; /**
public function getContent()
{ */
return $this->content; private $comments = array();
}

public function setContent($content)
{
$this->content = (string) $content;
return $this;
}

public function getComments()
{
return $this->comments;
}

public function addComment(ApplicationBlogComment $comment)
{
$this->comments[] = $comment;
return $this;
}
}

<?php

/**
*/
class Post
{
/**
* @Id
*/
private $id;
An example entity
/**
*/
private $title;

/**
* @String
*/
Methods
private $content;

/**
*/ {
private $comments = array();
return $this->content;
public function getId() }
{
return $this->id;
} public function setContent($content)
public function setId($id) {
{
$this->id = (string) $id; $this->content = (string) $content;
return $this; return $this;
}
}
public function getTitle()
{
return $this->title; public function getComments()
}
{
public function setTitle($title) return $this->comments;
{
$this->title = (string) $title; }
return $this;
}
{ {
return $this->content; $this->comments[] = $comment;
}
return $this;
public function setContent($content)
{
}
$this->content = (string) $content;
return $this;
}

public function getComments()
{
return $this->comments;
}

{
$this->comments[] = $comment;
return $this;
}
}

Using your entity
Create
<?php

class IndexController extends Zend_Controller_Action
{

public function init()
{
/* Initialize action controller here */
}

public function indexAction()
{
$documentManager = $this->getInvokeArg('bootstrap')->getResource('odm');
$post = new ApplicationBlogPost();
$post->setTitle('My Interesting Post')
->setContent('I have somethnng very interesting to say');
$documentManager->persist($post);
$documentManager->flush();
}

}

> use blog
switched to db blog
> db.posts.find();
{ "_id" : ObjectId("4dde4067fbd2237df1000000"), "title" : "My Interesting Post", "content" : "I have somethnng very
interesting to say" }

Using your entity
Update
<?php

{

{
}

{
$post = $documentManager->getRepository('ApplicationBlogPost')
->find('4dde4067fbd2237df1000000');
$post->setTitle('My Interesting Post')
->setContent('I have something very interesting to say');
}

}

> db.posts.find();
{ "_id" : ObjectId("4dde4067fbd2237df1000000"), "title" : "My Interesting Post", "content" : "I have something very
interesting to say" }

Using your entity
Add an comment
<?php

{

{
}

{
->find('4dde4067fbd2237df1000000');
$comment = new ApplicationBlogComment();
$comment->setEmail('foo@example.com')
->setComment('Nice post!');
$post->addComment($comment);
}

}
> db.posts.find();
{ "_id" : ObjectId("4dde4067fbd2237df1000000"), "comments" : [
{
"_id" : ObjectId("4dde439afbd22380f1000000"),
"email" : "foo@example.com",
"comment" : "Nice post!"
}
], "content" : "I have something very interesting to say", "title" : "My Interesting Post" }

Using your entity
Delete
<?php

{

{
}

{
->find('4dde4067fbd2237df1000000');
$documentManager->remove($post);
}

}

> db.posts.find();
>

Available Annotations
http://www.doctrine-project.org/docs/mongodb_odm/1.0/en/
reference/annotations-reference.html

Available Annotations
http://www.doctrine-project.org/docs/mongodb_odm/1.0/en/
reference/annotations-reference.html
@Field(type="string" name="origin")

Field Mappings. Many aliases are available: @String, @Date, @Int, @Float etc.

@EmbedOne / @EmbedMany

Embedded Documents, stores the document inside the current document

@ReferenceOne / @ReferenceMany

Referenced Documents, stores a reference to one or more documents outside the current document

@Document / @EmbeddedDocument

Marks entities which are allowed to be managed by the document manager. additionally
EmbeddedDocuments may not be saved independently, and must be a child of an @Document

@HasLifecycleCallbacks & @PrePersist, @PostPersist etc.

Marks an entity as having callbacks such as PrePersist which will be called automatically by the
DocumentManager during the entities lifetime. (see reference for list)

Integrating with ZF
Example Sandbox: http://github.com/bittarman/zf-d2-odm
Includes all (PHP) dependencies
Requires the mongo pecl extension
$ sudo pecl install mongo

Install Doctrine from PEAR
$ sudo pear channel-discover pear.doctrine-project.org
$ sudo pear install pear.doctrine-project.org/DoctrineMongoDBODM-1.0.0BETA3

Checkout from Github
$ git clone git://github.com/doctrine/mongodb-odm.git mongodb_odm
$ cd mongodb_odm
$ git checkout 1.0.0BETA3

The Plugin Resource
<?php

/* Import namespaces */
use DoctrineCommonClassLoader,
DoctrineCommonAnnotationsAnnotationReader,
DoctrineODMMongoDB,
DoctrineODMMongoDBDocumentManager,
DoctrineODMMongoDBMongo,
DoctrineODMMongoDBMappingDriverAnnotationDriver;

/**
* Doctrine 2 ODM Resource Plugin
*
* @author Ryan Mauger
* @copyright Ryan Mauger 2012
*/
class Lupi_Resource_Odm extends Zend_Application_Resource_ResourceAbstract
{
{
$options = $this->getOptions();
$this->registerAutoloaders($options);

// Config
$config = new DoctrineODMMongoDBConfiguration();
foreach ($options['config'] as $option => $value) {
$method = "set" . ucfirst($option);
$config->{$method}($value);
}

// Annotation reader
$reader = new AnnotationReader();
$reader->setDefaultAnnotationNamespace('DoctrineODMMongoDBMapping');
$config->setMetadataDriverImpl(new AnnotationDriver($reader, $options['documents']['dir']));

$dm = DocumentManager::create(new DoctrineMongoDBConnection(new Mongo), $config);
return $dm;
}

public function registerAutoloaders($options)
{
$autoloader = Zend_Loader_Autoloader::getInstance();

// Document classes
$classLoader = new ClassLoader($options['documents']['namespace'],
$options['documents']['dir']);
$autoloader->pushAutoloader(array($classLoader, 'loadClass'), $options['documents']['namespace']);

}
}

The Plugin Resource
<?php

DoctrineODMMongoDB,

/**
*
*/
{
{
$this->registerAutoloaders($options); Set up class loaders.
// Config
Use the Doctrine
}

loaders for ease

return $dm;
}

{

// Document classes

}
}

The Plugin Resource
<?php

DoctrineODMMongoDB,

/**
*
*/
{
{

// Config
Set up the conﬁg object
}


return $dm;
}

{

// Document classes

}
}

The Plugin Resource
<?php

DoctrineODMMongoDB,

/**
*
*/
{
{
Set up the Annotation

// Config
Reader, or mapping driver
should you prefer YAML /
}

XML

return $dm;
}

{

// Document classes

}
}

The Plugin Resource
<?php

DoctrineODMMongoDB,

/**
*
*/
{
{

// Config
Create and return the
Document manager
}


return $dm;
}

{

// Document classes

}
}

[production]
; PHP settings
phpSettings.display_startup_errors = 0
phpSettings.display_errors = 0

; Set Plugin path for lupi mongoodm resource
Conﬁguration
pluginPaths.Lupi_Resource = APPLICATION_PATH "/../library/Lupi/Resource"

; Library include paths & namespaces
includePaths.library = APPLICATION_PATH "/../library"
autoloaderNamespaces[] = "Lupi"
autoloaderNamespaces[] = "Doctrine"

; Bootstrap options
bootstrap.path = APPLICATION_PATH "/Bootstrap.php"
bootstrap.class = "Bootstrap"

; Applicaiton Setup
appnamespace = "Application"
resources.frontController.controllerDirectory = APPLICATION_PATH "/controllers"
resources.frontController.params.displayExceptions = 0

; ODM settings
resources.odm.documents.dir = APPLICATION_PATH "/entities"
resources.odm.documents.namespace = "Application"
resources.odm.config.proxyDir = APPLICATION_PATH "/cache/proxies"
resources.odm.config.proxyNamespace = "proxies"
resources.odm.config.hydratorDir = APPLICATION_PATH "/cache/hydrators"
resources.odm.config.hydratorNamespace = "hydrators"

[staging : production]

[testing : production]

[development : production]

[production]
; PHP settings

Conﬁguration


; Bootstrap options
Tell it where to load the plugin resource

; Applicaiton Setup

; ODM settings




[production]
; PHP settings

Conﬁguration


; Bootstrap options
Minimal conﬁg to get started

; Applicaiton Setup

; ODM settings




Base Controller

• Provide an easy method to access the
DocumentManager, and perhaps a service
layer / repository

• Not using an action helper because we will be
likely to be using this tightly everywhere, so it
avoids writing _helper a few hundred times!

• You could use an action helper and use IOC or
similar to replace this, this is for simplicity

<?php
namespace LupiController;
Base Controller
abstract class Action extends Zend_Controller_Action
{
/**
* @var Zend_Application
*/ Override the constructor at this point!
protected $bootstrap;

/**
* @var DoctrineODMMongoDBDocumentManager
*/
protected $dm;
It’s useful to leave
public function __construct(Zend_Controller_Request_Abstract $request,
Zend_Controller_Response_Abstract $response,
array $invokeArgs = array())
init() for the ﬁnal
{
$this->setRequest($request)
->setResponse($response)
implementation so
->_setInvokeArgs($invokeArgs);
$this->_helper = new Zend_Controller_Action_HelperBroker($this);
$this->dm = $this->getBootstrap()->getResource('odm');
you don’t need to
$this->init();
} remember to always
public function getBootstrap()
{
if (null === $this->bootstrap) {
call parent::init()
$this->bootstrap = $this->getInvokeArg('bootstrap');
}
return $this->bootstrap;
}
}

Simpliﬁed controller code
<?php
use LupiController as controller;

class IndexController extends controllerAction
{
Common repository for
/**
* @var DoctrineODMMongoDBDocumentRepository
*/
the controller, set it in
protected $repository;

the init
{
$this->repository = $this->dm->getRepository('ApplicationBlogPost');
}

{
$post = $this->repository->find('4dde4067fbd2237df1000000');
$comment->setEmail('foo@test.com')
->setComment('nice post!');
$this->dm->persist($post);
$this->dm->flush();
}

}

Simpliﬁed controller code
<?php
use LupiController as controller;

class IndexController extends controllerAction
{
Common repository for
/**
* @var DoctrineODMMongoDBDocumentRepository
*/
the controller, set it in
protected $repository;

the init
{
$this->repository = $this->dm->getRepository('ApplicationBlogPost');
}

{
$post = $this->repository->find('4dde4067fbd2237df1000000');
$comment->setEmail('foo@test.com')
->setComment('nice post!');
$this->dm->persist($post);
$this->dm->flush();
}

}

Nice verbose code!

Managing change

• For adding a new property, mostly, you don’t
need to do much

Managing change

• The db is schema-less

Managing change

• You can add properties, without needing to
update the old objects until your ready

Managing change


• Simply add the property, and update old
objects through your usual admin interface

Managing change


• Simply add the property, and update old
objects through your usual admin interface

• Objects without the new property will simply
have a null value until you change them

Managing change

Make use of the annotations!

Changing a property name
From To
<?php <?php
namespace ApplicationBlog; namespace ApplicationBlog;

/** /**
* @Document(db="blog", collection="posts") * @Document(db="blog", collection="posts")
*/ */
class Post class Post
{ {
/** /**
* @Id * @Id
*/ */
private $id; private $id;

/** /**
* @Field(type="string") * @Field(type="string")
*/ */
private $name; private $title;

/** /**
* @String * @String
*/ */
private $content; private $content;
} }

Changing a property name
From To
<?php
<?php

/**
/**
*/
*/
class Post
class Post
{
{
/**
* @Id
Add @AlsoLoad

/**
* @Id
*/
*/
private $id;
private $id;

/**
/**
* @AlsoLoad({“name”})
*/
*/
private $name;
private $title;

/**
/**
* @String
* @String
*/
*/
private $content;
private $content;
}
}

Transforming a property
From To
<?php

<?php
/**
*/
/**
class User
{
*/
/**
class User
* @Id
{
*/
/**
private $id;
* @Id

*/
/**
private $id;

*/
/**
private $firstname;
*/
/**
private $fullname;
*/
/**
private $lastname;
* @ReferenceMany(targetDocument=”ApplicationBlogPost”)
*/
/**
private $posts;
}
*/
private $posts;
}

Transforming a property
From <?php
To

/**
<?php */
namespace ApplicationBlog; class User
{
/** /**
* @Id
* @Document(db="blog", collection="posts") */
*/ private $id;
class User
{ /**
/** */
* @Id private $firstname;
*/
private $id; /**
*/
/** private $lastname;
*/ /**
private $fulllname; */
private $posts;
/**
* @ReferenceMany(targetDocument=”ApplicationBlogPost”) /**
* @AlsoLoad({“fullname”})
*/ */
private $posts; public function populateNameProperties($fullname)
} {
$name = explode(‘ ‘, $fullname);
$this->firstname = $name[0];
$this->lastname = $name[1];
Use a method to migrate using }
}

@AlsoLoad

NOTE!

• When searching, your queries will not know
about the old name!

• Include old and new ﬁelds in your searches if
possible until all data has been migrated

NOTE!

• The ODM is still in BETA3, there are still
some glitches, but its well worth having a good
look now.

• http://www.doctrine-project.org/ and follow
progress

Useful information

• Oﬃcial docs: http://www.doctrine-project.org/
docs/mongodb_odm/1.0/en/

• Mongodb: http://www.mongodb.org/ excellent
intro to mongodb

• The example sandbox: http://github.com/
bittarman/zf-d2-odm

Thanks for listening
Catch me on twitter: @Bittarman
Slides will be available on slideshare
http://slideshare.com/rmauger

ZF & Doctrine 2 ODM

Doctrine

Zend Framework and the Doctrine2 MongoDB ODM (ZF1)

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Zend Framework and the Doctrine2 MongoDB ODM (ZF1)

Similar to Zend Framework and the Doctrine2 MongoDB ODM (ZF1) (20)

Recently uploaded

Recently uploaded (20)

Zend Framework and the Doctrine2 MongoDB ODM (ZF1)

Editor's Notes