Doctrine ORM

Uma breve apresentação do Doctrine ORM, projeto open-source pioneiro em implementar o padrão ORM no PHP.

1. Doctrine ORM
Rafael Mello ([email protected])

2. Índice
●O que é Doctrine ORM
●Como funciona o ORM
●Principais annotations
●Manipulação de dados
●Repositórios
●Precauções
●Vantagens
●Desvantagens

3. O que é Doctrine ORM
O Doctrine ORM, inspirado nos padrões do JPA e no
Hibernate do Java, é das principais libraries PHP de
implementação do padrão ORM.

4. Como funciona o ORM
No ORM, entidades representam tabelas e atributos
representam seus campos.

5. Como funciona o ORM
Relacionamento entre tabelas
podem ser representados em
seus atributos.

6. Principais annotations
@Entity
Define que a classe representa uma entidade.
Exemplo:
/**
* @ORM\Entity
*/
class Product
{
}

7. Principais annotations
@Table
Define que a classe de entidade representa uma tabela.
Exemplo:
/**
* @ORM\Entity
* @ORM\Table(name="product")
*/
class Product
{
}

8. Principais annotations
@Column
Define que o atributo da entidade corresponde a um campo.
Exemplo:
/**
* @ORM\Column(type="string")
*/
private $name;

9. Principais annotations
@Id
Define que o atributo da entidade corresponde a uma chave primaria.
Exemplo:
/**
* @ORM\Column(type="integer")
* @ORM\Id
*/
private $id;

10. Principais annotations
@GeneratedValue
Especifica estratégia de como o valor da chave primária será gerado.
Exemplo:
/**
* @ORM\Column(type="integer")
* @ORM\Id
* @ORM\GeneratedValue(strategy="AUTO")
*/
private $id;

11. Principais annotations
@OneToMany
Define que o campo é uma relação de um para muitos.
Exemplo:
/**
* @ORM\OneToMany(targetEntity="Product", mappedBy="category")
*/
private $products;
public function __construct()
{
$this->products = new ArrayCollection();
}

12. Principais annotations
@ManyToOne
Define que o campo é uma relação de muitos para um.
Exemplo:
/**
* @ORM\ManyToOne(targetEntity="Category", inversedBy="products")
*/
private $category;

13. Principais annotations
@OneToOne
Define que o campo é uma relação de um para um.
Exemplo:
/**
* @ORM\OneToOne(targetEntity="Category", inversedBy="products")
*/
private $category;

14. Manipulação de dados
As buscas poderão ser feitas utilizando a
linguagem DQL(Doctrine Query Language),
inspira no HQL do Hibernate.

15. Manipulação de dados
Exemplo:
// Busca por DQL
$result = $em
->createQuery(“SELECT p FROM Product p ”)
->getResult();
// Busca por repositório
$result = $em->getRepository(“Product”)->findAll();
A consulta retornará objetos da entidade “Product”.

16. Manipulação de dados
Exemplo:
$result = $em->createQuery(“ SELECT p.name, p.price, c.name as
category_name FROM Product p JOIN p.category c ”)
->setParameter(‘nome_categoria’, ‘bebida’)
->getResult();
A consulta retornará um array com nome do produto, preço do produto e
nome da categoria.

17. Manipulação de dados
Para inserir um dado ou atualizá-lo, deverá ser
utilizado o objeto de entidade.
Exemplo de inserção:
$category = new Category();
$category->setName(‘bebida’);
$em->persist($category);
$em->flush();
Exemplo de atualização:
$category = $em->getRepository(“Category”)->find(1);
$category->setName(‘bebida’);
$em->flush();

18. Manipulação de dados
Para excluir um dado, deverá ser utilizado o
objeto de entidade.
Exemplo:
$category = $em->getRepository(“Category”)->find(1);
$em->remove($category);
$em->flush();

19. Repositórios
Um repositório é uma classe onde é vinculada a
uma entidade e possui métodos para realizar
buscas.
Por padrão, todas as entidades possuem
repositórios, mesmo que você não os crie.

20. Repositórios
Boas práticas:
●Sempre crie os repositórios de todas as
entidades, independente se possuirá métodos
ou não;
●Por definição da equipe do Doctrine, repositórios
deverão possuir apenas métodos que realizem
buscas.

21. Repositórios
Exemplo de repositório
class ProductRepository extends EntityRepository
{
public function buscaProdutosPorCategoria($nomeCategoria)
{
return $em->createQuery(“SELECT p FROM Products p JOIN
p.category c WHERE c.name = :nome_categoria”)
->setParameter(‘nome_categoria’, $nomeCategoria)
->getResult();
}
}

22. Repositórios
Exemplo de entidade vinculada a um repositório
/**
* @ORM\Entity(repositoryClass=”ProductRepository”)
* @ORM\Table(name="product")
*/
class Product
{
}

23. Precauções
●Consulta de dados onde retornam entidades
poderá buscar campos nos quais muitas vezes
não serão utilizados.

24. Precauções
●Consultar relacionamentos por LAZY pode
causar perda de desempenho, principalmente se
a mesma estiver dentro de um foreach.
Exemplo de consulta por LAZY:
$categoryName = $product->getCategory()->getName();

25. Precauções

26. Precauções
●A cada consulta ou inserção, o Doctrine
armazena a entidade em memória. Sempre que
realizar procedimentos onde trabalhe com
muitas entidades, tire da memória as quais não
serão mais utilizadas.
Exemplo
//Remove da memória somente a entidade armazenada na variável
$em->detach($product);
//Remove todas as entidades da memória
$em->clear();

27. Vantagens
●Maior independência ao banco de dados;
●Fácil estruturação sem se preocupar com
sintaxes de SQL nativas do SGBD;
●A camada de modelo representa a estrutura de
seu banco de dados.

28. Desvantagens
●Por se tratar de uma camada intermediaria entre
o sistema e o banco de dados, uma má
implementação poderá causar queda de
performance.