Intégrer Doctrine 2 à Zend Framework 1.1x

Doctrine ORM 2 offre de meilleures performances que sa première version en tirant partie des nouveautés apportées par PHP 5.3. Nous allons voir, ici, comment l'intégrer à Zend Framework 1.11.11.

Installation / mise en place

Tout d'abord, il faut commencer par télécharger la dernière version de Doctrine 2. Vous pourrez la trouver sur le site de Doctrine 2.

Vous devrez extraire le répertoire Doctrinede l'archive dans le répertoire libraryde votre projet.

Initialisation

Il faut ensuite placer le code suivant dans le fichier Bootstrap.phpde votre projet :

protected function _initDoctrine()
{
	$options = $this->getOptions();
	$doctrinePath = $options['includePaths']['library'];
	require_once $doctrinePath . '/Doctrine/Common/ClassLoader.php';
	$autoloader = Zend_Loader_Autoloader::getInstance();

	$doctrineAutoloader = array(new \Doctrine\Common\ClassLoader(), 'loadClass');
	$autoloader->pushAutoloader($doctrineAutoloader, 'Doctrine');

	$classLoader = new \Doctrine\Common\ClassLoader('Entities', realpath(__DIR__ . '/models/'), 'loadClass');
	$autoloader->pushAutoloader(array($classLoader, 'loadClass'), 'Entities');
	$classLoader = new \Doctrine\Common\ClassLoader('Symfony', realpath(__DIR__ . '/../library/Doctrine/'), 'loadClass');
	$autoloader->pushAutoloader(array($classLoader, 'loadClass'), 'Symfony');

	if (APPLICATION_ENV == "development") {
		$cache = new \Doctrine\Common\Cache\ArrayCache();
	} else {
		$cacheOptions = $options['cache']['backendOptions'];
		$cache = new \Doctrine\Common\Cache\MemcacheCache();
		$memcache = new Memcache;
		$memcache->connect($cacheOptions['servers']['host'], $cacheOptions['servers']['port']);
		$cache->setMemcache($memcache);
	}

	$config = new \Doctrine\ORM\Configuration()
	$config->setMetadataCacheImpl($cache);
	$driverImpl = $config->newDefaultAnnotationDriver(APPLICATION_PATH . '/models/Entities');
	$config->setMetadataDriverImpl($driverImpl);
	$config->setQueryCacheImpl($cache);
	$config->setProxyDir(APPLICATION_PATH . '/models/Proxies');
	$config->setProxyNamespace('Proxies');

	if (APPLICATION_ENV == "development") {
		$config->setAutoGenerateProxyClasses(true);
	} else {
		$config->setAutoGenerateProxyClasses(false);
	}

	$em =  \Doctrine\ORM\EntityManager::create($options['db'], $config);

	Zend_Registry::set('em', $em);
	return $em;
}

Ce code permet d'initialiser la connexion avec la base de données et d'instancier un EntityManager : la classe la plus importante dans Doctrine 2. Vous remarquerez plusieurs antislashs (\) qui représentent le nouveau modèle dit de namespace (espace de nommage, en français). C'est un procédé permettant de simplifier le nommage, chargement de classes depuis PHP 5.3.

Configuration

À présent, voyons les options de configuration que l'on passera à Doctrine dans le fichier de configuration du projet :

[production]

includePaths.library = APPLICATION_PATH "/../library"
; Chargement de l'aide d'action
resources.frontController.actionHelperPaths.My_Controller_Action_Helper = "My/Controller/Action/Helper"

;; DB
db.driver = "pdo_mysql"
db.host = "localhost"
db.dbname = "dbname"
db.user = "dbuser"
db.password = "somePassword"

;; Cache
cache.frontendOptions.lifetime = 86400
cache.frontendOptions.automatic_serialization = true
cache.frontendOptions.cache_id_prefix = prfx
cache.backend = Memcached
cache.backendOptions.servers.host = 127.0.0.1
cache.backendOptions.servers.port = 11211
cache.backendOptions.servers.persistent = true
cache.backendOptions.compression = false

[development : production]

;; DB
db.user = "root"
db.password = ""

Modèle de base

A présent, voyons la construction d'un modèle de classe d'abstraction de la base de données :

namespace Entities;
/**
 * @Entity
 * @Table(name="users")
 */
class User
{

    /** @Id @Column(type="integer") @GeneratedValue */
    public $id;
    
    /** @Column(length=50,nullable=true) */
    public $name;
    
    /** @Column(length=50) */
    public $login;
    
    /** @Column(length=32) */
    public $password;

    /** @Column(type="integer") */
    public $role;

}

Aide d'action

Maintenant, nous avons besoin d'un moyen pratique d'accéder à notre EntityManager depuis un contrôleur. Nous créons donc une aide d'action que l'on nommera Em.

class My_Controller_Action_Helper_Em extends Zend_Controller_Action_Helper_Abstract
{

	/**
	* Entity manager
	* @var \Doctrine\ORM\EntityManager
	*/
	private $_em = null;

	/**
	* Return entity manager
	* Could be overriden to support custom entity manager
	*
	* @return \Doctrine\ORM\EntityManager
	*/
	public function getEntityManager() 
	{
	    if ( $this->_em == null) {
    		$this->_em = Zend_Registry::get('em');
	    }
    	    return $this->_em;
	}

	/**
	* @return \Doctrine\ORM\EntityManager
	*/
	public function direct() 
	{
	    return $this->getEntityManager();
	}

}

Utilisation de l'aide d'action

Voyons comment utiliser cette aide d'action depuis un contrôleur à travers un exemple rapide :

class Default_IndexController extends Zend_Controller_Action
{


    public function indexAction()
    {
        $user = new \Entities\User();
        $user->name = 'test';
        $user->login = 'test';
        $user->password = md5('123456');

        $em = $this->_helper->Em();
        $em->persist($user);
        $em->flush();
    }

}

Sources

Voici quelques ressources citées par l'article ayant inspiré celui-ci :

• http://stackoverflow.com/questions/3246515/using-doctrine-2-with-zend-framework-1-10-x
• http://jeboy25.blogspot.com/2010/08/doctrine-2-and-zend-framework-110.html
• http://www.doctrine-project.org/docs/orm/2.0/en/tutorials/getting-started-xml-edition.html
• http://stackoverflow.com/questions/4582203/unable-to-load-doctrine-orm-configuration-class-with-doctrine-2-classloader-in
• http://bostjan.muha.cc/2010/08/doctrine-2-zend-framework/

Cette page est fortement inspirée de l'article Integrating Doctrine2 ORM in Zend Framework project du site Victim of Babylon.