As vezes eu acho graça na TI: julho 2012

25 de julho de 2012

Implementando Herança no Doctrine

Nesse artigo vamos falar um pouco sobre a implementação de Herança no Doctrine. Como exemplo didático de herança, temos a épica relação entre DarthVader, Luke Skywalker e Leia Organa no filme Star Wars (Figura 1). Em vista disto, vamos utilizar esta relação entre os personagens para ilustrar a implementação da herança no Doctrine.

Figura: "I am your father".

A herança no Doctrine é especificada através dos atributos:

@DiscriminatorColumn: utilizado para indicar qual o elemento da hierarquia (classe) a linha da tabela representa.
@DiscriminatorMap: utilizado para identificar quais os valores que existirão na coluna do discriminador e qual classe da hierarquia está mapeado para cada valor.
@InheritanceType: representa a estrutura no Banco de Dados que irá armazenar a herança. SINGLE_TABLE indicada que tanto o objeto pai quanto os objetos filhos estarão representados na mesma tabela. JOINED indica que cada classe da hierarquia terá uma tabela própria.

Por exemplo, tendo o mapa:

@DiscriminatorMap({"father" = "DarthVader", "son" = "Luke", "daughter" = "Leia"})

temos que father representa um objeto da classe DarthVader, já son representa um elemento da classe Luke.

A seguir um exemplo de implementação da herança. São especificadas três classes: DarthVader (classe pai), Luke (classe filho) e Leia (classe filho).

Classe DarthVader (pai)

<?php

/**
 * @Entity
 * @InheritanceType("SINGLE_TABLE")
 * @Table(name="father")
 * @DiscriminatorColumn(name="discr", type="string")
 * @DiscriminatorMap({"father" = "DarthVader", "son" = "Luke", "daughter" = "Leia"})
 */
class DarthVader{
    
    /**
     * @var integer $id
     * @Column(type="integer")
     * @Id
     * @GeneratedValue(strategy="IDENTITY")
     */
    private $id;
    
    public function setId($id){$this->id = $id;}
    public function getId(){return $this->id;}
    
    /**
     * 
     * @Column(type="integer")
     * 
     */
    private $atributo_anakin;    
    
    public function setAtributoAnakin($atributo){$this->atributo_anakin=$atributo;}
    public function getAtributoAnakin(){return $this->atributo_anakin;}
}

Classe Luke (filho)

<?php

/**
 * 
 * @Entity
 * @Table(name="son") 
 */
class Luke extends DarthVader {
    
    /**
     * 
     * @Column(type="integer")
     * 
     */
    private $atributo_luke;    
    
    public function setAtributoLuke($atributo){$this->atributo_luke=$atributo;}
    public function getAtributoLuke(){return $this->atributo_luke;}
    
}

Classe Leia (filho)

<?php

/**
 * 
 * @Entity
 * @Table(name="daughter") 
 */
class Leia extends DarthVader {
    
    /**
     * 
     * @Column(type="integer")
     * 
     */
    private $atributo_leia;    
    
    public function setAtributoLeia($atributo){$this->atributo_leia=$atributo;}
    public function getAtributoLeia(){return $this->atributo_leia;}
    
    
}

A seguir a estrutura gerada no Banco de Dados para cada tipo de herança (InheritanceType).

JOINED

Figura: Tipo de Herança JOINED

SINGLE_TABLE

Figura: Tipo de Herança SINGLE_TABLE

Num próximo artigo vamos falar como ocorre o processo de persistência dos objetos Doctrine no Banco de Dados.

18 de julho de 2012

Adicionando Javascript nas views do Zend Framework

A inserção de código Javascript nas view do Zend Framework pode ser realizada através da utilização de dois helpers (classes) existentes: HeadScript Helper e InlineScriptHelper. Essas entidades podem ser utilizadas para adicionar diretamente o código javascript ou anexar um arquivo contendo o código javascript.

HeadScript é utilizado quando se deseja referenciar o código javascript na marcação (tag) header da página. Para utilização(*) do HeadScript deve-se:

1) No Controller adicionar o endereço do arquivo no HeadScript da view.

Exemplo: <?php $this->view->headScript()->appendFile('/js/funcoes.js'); ?>

2) Na view imprimir o conteúdo do HeadScript:

Exemplo: <?php echo $this->headScript(); ?>

InlineScript é utilizado quando se deseja referenciar o código javascript na marcação (tag) body da página, ou seja, deseja-se anexar o javascript em uma determinada "posição" da página. Para utilização(*) do InlineScript deve-se:

1) No Controller adicionar o endereço do arquivo no InlineScript da view.

Exemplo: <?php $this->view->inlineScript()->appendFile('/js/funcoes.js'); ?>

2) Na view imprimir o conteúdo do InlineScript na posição desejada para o código javascript. Geralmente é recomendado imprimir o conteúdo no fim do código da view.

Exemplo: <?php echo $this->inlineScript(); ?>

(*) Apenas salientando que os exemplos englobam a inserção de uma referência a um arquivo .js na página. Para inserir diretamente um código javascript verificar a função appendScript().

2 de julho de 2012

Singletons

''Se o singleton fosse um meme ele seria o Forever Alone.''

Forever Alone é um meme que representa o nível extremo de solidão de uma pessoa. O Singleton é um Padrão de Projeto de Software (do inglês Design Pattern) que restringe a instanciação de uma classe a apenas um único objeto. Como podemos observar o comportamento do Singleton é semelhante ao de nosso amigo Forever Alone, ou seja, por mais que deseje, ele não vai encontrar ninguém de seu tipo (classe) para consolá-lo na solidão e terá que chorar as pitangas sozinho.

Deixando um pouco o blablablá envolvendo Singletons, Padrões de Projetos e memes a seguir estão 2 exemplos de implementação de uma classe Singleton em PHP, sendo que apenas a primeira implementação está correta. Para cada uma das implementações são realizados alguns testes básicos para validar (ou invalidar) a implementação.

Implementação correta: definindo um objeto estático para a classe e deixar o construtor e o método clone como privados.

1:  <?php   
2:  class ForeverAlone{  
3:       /**Instância única*/  
4:       private static $instancia = null;  
5:       /**Quantidade de chamadas ao construtor*/  
6:       private static $chamadas_construtor = 0;  
7:       /**Quantidade de chamadas ao método getInstance()*/  
8:       private static $chamadas_instancia = 0;  
9:       private function __construct(){  
10:            // construtor privado  
11:            self::$chamadas_construtor;  
12:       }  
13:       private function __clone(){  
14:            // clone privado   
15:       }  
16:       public static function getInstance(){  
17:            self::$chamadas_instancia++;  
18:            if(self::$instancia == null){  
19:                 self::$instancia = new self();  
20:            }  
21:            return self::$instancia;  
22:       }  
23:       public function getStats(){  
24:            return 'Chamadas ao Construtor: ' . self::$chamadas_construtor . "\n" .   
25:            'Chamadas ao getInstance(): ' . self::$chamadas_instancia . "\n";  
26:       }  
27:  }

Implementação errada: deixando o construtor e o método clone como public (ou esquecendo de implementar eles).

1:  <?php   
2:  class ForeverAlone{  
3:       /**Instância única*/  
4:       private static $instancia = null;  
5:       /**Quantidade de chamadas ao construtor*/  
6:       private static $chamadas_construtor = 0;  
7:       /**Quantidade de chamadas ao método getInstance()*/  
8:       private static $chamadas_instancia = 0;  
9:       public function __construct(){  
10:            // construtor privado  
11:            self::$chamadas_construtor;  
12:       }  
13:       public function __clone(){  
14:            // clone privado   
15:       }  
16:       public static function getInstance(){  
17:            self::$chamadas_instancia++;  
18:            if(self::$instancia == null){  
19:                 self::$instancia = new self();  
20:            }  
21:            return self::$instancia;  
22:       }  
23:       public function getStats(){  
24:            return 'Chamadas ao Construtor: ' . self::$chamadas_construtor . "\n" .   
25:            'Chamadas ao getInstance(): ' . self::$chamadas_instancia . "\n";  
26:       }  
27:  }

Testes

1:  <?php  
2:  include('ForeverAlone.php');  
3:  $objeto1 = ForeverAlone::getInstance();  
4:  // Imprimindo as estatísticas  
5:  echo $objeto1->getStats();  
6:  // Nova chamada ao getInstance  
7:  $objeto2 = ForeverAlone::getInstance();  
8:  echo $objeto2->getStats();  
9:  // Chamada ao construtor  
10:  $objeto3 = new ForeverAlone(); // Na implementação correta gera erro, pois o método é privado  
11:  echo $objeto3->getStats();  
12:  // Chamada ao clone  
13:  $objeto4 = clone $objeto1;  // Na implementação correta gera erro, pois o método é privado
14:  echo $objeto4->getStats();  
15:  ?>