Integração do Doctrine 2 com Zend Framework

Olá pessoal, vou demonstrar como configurei o Doctrine 2 (ótimo de framework ORM) com o Zend Framework.

O meu ambiente de desenvolvimento está com o PHP 5.3, pois é requisito necessário para o ZF e para o Doctrine 2.

Para este tutorial, irei partir do ponto quando já se tem conhecimento da estrutura dos frameworks, mas irei ilustrar como deverá ficar a estrutura do projeto, e deve ser a seguinte:

Depois de ver a estrutura do projeto, você verificou que a pasta com o framework Doctrine está contida dentro de library, certo?!

Ok, vamos a configuração....

Como demonstrado na estrutura acima, crie a pasta Resouce em: zend_doctrine/library/ , e dentro dela crie o arquivo Doctrine.php, com o seguinte conteúdo:


Arquivo: zend_doctrine/library/Resource/Doctrine.php

1. class Resource_Doctrine extends Zend_Application_Resource_ResourceAbstract
2. {

1. protected $_options = array(

2.                 'connection' => array(
3.                         'driver' => 'pdo_mysql',
4.                         'host' => 'localhost',
5.                         'dbname' => 'banco',
6.                         'user' => 'seuusuario',
7.                         'password' => 'suasenha'),
8.                 'modelDir' => '/models/Entities',
9.                 'proxyDir' => '/proxies',
10.                 'proxyNamespace' => 'Proxies',
11.                 'autoGenerateProxyClasses' => true
12.         );

     
         public function init()

1.         {
2.                 $options = $this->getOptions();
3.                
4.                 $config = new \Doctrine\ORM\Configuration;
5.                 $cache = new \Doctrine\Common\Cache\ArrayCache;
6.                 $driverImpl = $config->newDefaultAnnotationDriver($options['modelDir']);

1.                 $config->setMetadataCacheImpl($cache);
2.                 $config->setQueryCacheImpl($cache);
3.                 $config->setProxyDir($options['proxyDir']);
4.                 $config->setProxyNamespace($options['proxyNamespace']);
5.                 $config->setAutoGenerateProxyClasses($options['autoGenerateProxyClasses']);
6.                 $config->setMetadataDriverImpl($driverImpl);
8.                 $em = \Doctrine\ORM\EntityManager::create($options['connection'], $config);
9.                 Zend_Registry::set('doctrine', $em);
10.                
11.                 return $em;
12.         }
13. }

Vamos entender o que este arquivo irá fazer....

Primeiramente, ele defini as credenciais de acesso para o banco de dados, depois, o diretório onde estarão as classes de entidades, e também o namespace para as classes Proxy que serão geradas automaticamente. Com esses dados o doctrine poderá ser inicializado, e é exatamente isso que é feito no método init().
No final deste método é realizada a chamada a classe de registro do Zend, que é a Zend_Registry, para que a variável gerenciadora de entidade seja registrada na aplicação, ficando assim disponível para usos futuros.


Agora teremos que adicionar algumas linhas ao arquivo de configuração da aplicação, que é o: zend_doctrine/application/config/aplication.ini.


No final do item: [production], adicione as seguintes linhas

pluginPaths.Resource = "Resource"
resources.doctrine.modelDir = APPLICATION_PATH "/Models"
resources.doctrine.proxyDir = APPLICATION_PATH "/Proxies"
autoloaderNamespaces[] = "Doctrine"
autoloaderNamespaces[] = "Resource"


Com essas configurações o ZF irá encontrar o Doctrine e nossa pasta de inicialização Resource.


Para finalizar, teremos que chamar a inicialização do Doctrine no arquivo zend_doctrine/application/Bootstrap.php

Dentro da classe Bootstrap, crie o seguinte método:

1. protected  function _initDoctrine(){
3.         $doctrine = new Resource_Doctrine();
4.         $doctrine->init();
6. }
   
   

Este método irá chamar a inicialização que criamos para o Doctrine, que está contida dentro do método init() desta classe Resource_Doctrine.


Após estas configurações, o Doctrine estará disponível na aplicação da seguinte maneira:

1. $registry = Zend_Registry::getInstance();
2. $entityManager = $registry->get('doctrine');

No meu caso utilizei uma estrutura para reutilizar esta chamada nos meus DAOs, mas isso pode ser feito de diversas maneiras e também vária de acordo com a utilização, mas isso fica para um próximo post.


Valeu pessoal, por enquanto é só e até a próxima.

Polimorfismo utilizando PHP

Olá a todos, hoje vou fazer algumas demostrações da utilização do Polimorfismo, que é ums dos 3 pilares da Orientação a Objetos(OO), mas mostrando como a linguagem PHP se comporta.

Já ecrevi outros 2 posts relacionados, o primeiro você pode ver aqui e o segundo aqui.

Let's go....

O Polimorfismo, é um dos conceitos mais complexos da OO. Com o uso da Herança podemos ter várias hierarquias de classes, mas e se por acaso, uma única classe lá no meio/final da hierarquia resolver mudar seu comportamento dos demais....vamos ter que construir uma hierarquia somente pra ela???? Não, e graças ao Polimorfismo que não!!!!!!

O Polimorfismo, nos permite mudar o comportamento já especificado pela superclasse. 

Vamos a um exemplo prático: 

1. <?php
3. class Brasileiro{
5.         public function falar(){
6.                 //falando em portugues
7.         }
8. }
11. class Paulista extends Brasileiro{
13.         public function trabalhar(){
14.                 //trabalhando o tempo todo
15.         }
16.        
17. }
19. class Carioca extends Brasileiro{
20.        
21.         public function irParaBaileFunk(){
22.                 // tchu tcha tchu tcha
23.         }
24. }
26. ?>

No exemplo acima, temos 3 classes: Brasileiro, Paulista e Carioca, sendo que as classes Paulista e Carioca estedem da classe Brasileiro. Com isso os objetos paulistas e cariocas podem invocar o método falar(). 

Agora uma curiosidade, o Paulista e o Carioca, falam o idioma Português da mesma forma? Não!!!!! Cada um deles tem um dialeto próprio, isso quer dizer, que cada um deles fala um português próprio, mas na estrutura hierarquica acima não está implementado isso.........

Usando um conceito contido no Polimorfismo, a sobrescrita de método, podemos mudar o comportamento. Veja como seria esta implementação:

1. <?php
3. class Brasileiro{
5.         public function falar(){
6.                 //falando em portugues
7.         }
8. }
11. class Paulista extends Brasileiro{
13.         public function trabalhar(){
14.                 //trabalhando o tempo todo
15.         }
17.         public function falar(){
18.                 //falando em portugues dos manos
19.         }
20.        
21. }
23. class Carioca extends Brasileiro{
24.        
26.         public function falar(){
27.                 //falando em portugues da favela
28.         }
30.         public function irParaBaileFunk(){
31.                 // tchu tcha tchu tcha
32.         }
33. }
36. ?>

Com esta modificação, cada uma das subclasses já fala no seu próprio dialeto.....AÍ SIM HEIN?!

Quando instanciarmos um objeto tanto da classe Paulista, com da Carioca, e chamarmos o método falar(), será chamado os métodos implementados pelas subclasses, e o método da superclasse não será chamado.

BONUS ROUND!!!!!!!

Caso sejam feitas estas alterações e ainda haja necessidade da utilização do método da superclasse, é necessário invocá-lo dentro dos métodos das subclasses(Paulista e Carioca), veja exemplo:

1. <?php
3. class Brasileiro{
5.         public function falar(){
6.                 //falando em portugues
7.         }
8. }
11. class Paulista extends Brasileiro{
13.         public function trabalhar(){
14.                 //trabalhando o tempo todo
15.         }
17.         public function falar(){
19.                 //chamando método da super classe             
20.                 parent::falar();
22.                 //falando em portugues dos manos
23.         }
24.        
25. }
27. class Carioca extends Brasileiro{
28.        
30.         public function falar(){
32.                 //chamando método da super classe
33.                 parent::falar();
36.                 //falando em portugues da favela
37.         }
39.         public function irParaBaileFunk(){
40.                 // tchu tcha tchu tcha
41.         }
42. }
45. ?>

Muito bom hein?!!

Isso ajuda muito no desenvolvimento de aplicações orientadas a objeto.

Bom pessoal por enquanto é só, abraço e até a próxima!