Doctrine ORM

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

Transcript

1. Doctrine ORM Rafael Mello (merorafael@gmail.com)
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.