Entendendo o Lazy e o Eager Load da JPA
3 minutos de leitura
Autor(a)
Felipe Oliveira
Inscreva-se em nossa Newsletter
Fique por dentro de conteúdos, insights e oportunidades do universo tech. Receba novidades e lançamentos direto no seu e-mail.
3 minutos de leitura
Autor(a)
Fique por dentro de conteúdos, insights e oportunidades do universo tech. Receba novidades e lançamentos direto no seu e-mail.
Um dos pontos mais importantes para se analisar em um software é a performance e otimizar as queries SQL ao maximo, pode resultar em um ganho considerável de performance. Levando isso em consideração vamos ver como funciona o Lazy e o Eager Load da JPA (Java Persistence API), pois o uso deles de maneira incorreta ocasiona uma perda enorme na performance de uma aplicação, forçando o banco de dados a querys desnecessárias.
Quando modelamos um sistema usando orientação à objetos criamos vários relacionamentos que podem ser @OneToOne, @ManyToOne, @OneToMany ou @ManyToMany e para o banco de dados cada relacionamento é uma nova tabela para consultar.
Suponha que temos duas entidades, Aluno e Matricula: ```java
@Entity public class Aluno { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; private String nome; @OneToOne private Matricula matricula;
// getters e setters omitidos }
```java
@Entity public class Matricula { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; @Column(unique = true, nullable = false) private String codigo;
// getters e setters omitidos }
Por padrão, quando o relacionamento está anotado com @OneToOne ou @ManyToOne ele é carregado de modo Eager ou seja, quando fizemos qualquer tipo de busca na entidade como por exemplo um find(Aluno.class, 1) ele será carregado junto com a entidade e nesse caso a JPA executará uma query só.
No exemplo acima colocamos anotação @OneToOne no atributo Matricula, faz sentido? Não, pois geralmente um aluno tem varias matriculas, então vamos alterar a anotação do relacionamento da classe Aluno para @OneToMany e o tipo para List:
@Entity public class Aluno { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; private String nome; @OneToMany private List<Matricula> matriculas;
// getters e setters omitidos }
@Entity public class Matricula { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; @Column(unique = true, nullable = false) private String codigo;
// getters e setters omitidos }
Por padrão quando o relacionamento está anotado com @OneToMany ou @ManyToMany ele é carregado de modo Lazy ou seja, quando fizemos qualquer tipo de busca na entidade como por exemplo um find(Aluno.class, 1) ele não será carregado junto com a entidade, somente quando executarmos o comando getMatriculas() o relacionamento será carregado.
Por o modo Lazy só carregar as informações quando executamos um getter fazer um aluno.getMatriculas().getCodigo() dentro de um for para pegar o código de todas as matriculas do aluno pode trazer problema de performance à aplicação, pois a JPA executará várias queries.
for(Aluno aluno : alunos) { for(Matricula matricula : aluno.getMatriculas(){ System.out.println(matricula.getCodigo()); } }
O código de dentro do for será executado o tamanho da lista vezes, por exemplo se o tamanho da lista for N, o código será executado N vezes então a JPA executará N queries no banco de dados, podemos contar também a query para carregar a entidade. Esse problema é conhecido como ```N+1
queries, um dos problemas a serem evitados no uso da JPA e do Hibernate.
Além do problema citado acima temos que tomar cuidado com a LazyInitializationException. No post Enfrentando a LazyInitializationException no Hibernate o Paulo Silveira explica como lidar com esse problema.
Como vimos neste post o carregamento das entidades de modo incorreto pode ocasionar perda de performance, portanto lembre-se de considerar a melhor estratégia para o carregamento dos seus relacionamentos.
Avalie este artigo
