Resolvendo LazyInitializationException em 5 minutos

Olá Pessoal,

No post de hoje vamos ver como podemos resolver o LazyInitializationException em 5 minutos. Dificilmente um desenvolvedor não passou por essa exceção. Não vou entrar em detalhes sobre o motivo  da exceção LazyInitializationException, até por que já falei em um post aqui no blog, usando a solução com filter.

Lets go…

Na prática

Para mostrar a solução na prática, vou pegar um exemplo simples. Vamos considerar o relacionamento de que um Type  tem muitos Users, veja

@Entity

@Table(name = “type”)

public class Type implements java.io.Serializable { 

private static final long serialVersionUID = 2644022136811709451L; 

private Long id;

private String description;

private Set<User> users = new HashSet<User>(); 

public Type() {

}

@Id

@GeneratedValue

@Column(name = “ID”, unique = true, nullable = false)

public Long getId() {

return this.id;

}

@OneToMany(fetch = FetchType.LAZY, mappedBy = “type”,  targetEntity=User.class)

public Set<User> getUsers() {

return this.users;

}

//getters/setters omitidos

}

User.java

@Entity

@Table(name = “user”, uniqueConstraints = @UniqueConstraint(columnNames = “EMAIL”))

public class User implements java.io.Serializable,Comparable<User> { 

private static final long serialVersionUID = 9108778602728711429L; 

//declaração de variaveis omitidas 

@ManyToOne(fetch = FetchType.LAZY)

@JoinColumn(name = “TYPE_ID”,nullable=false)

public Type getType() {

return this.type;

}

//getters/setters omitidos

} 

Nada de especial até aqui, apenas o relacionamento que já conhecemos.

O problema

Agora que temos o problema, quando o User.java tentar acessar o Type e a conexão já foi fechada, já sabemos que vamos resolver LazyInitializationException. Uma forma para resolver é usando  join fetch, que evitará o problema pelo seguinte motivo:

– Apenas uma consulta será feita e evitamos o problema N + 1;

– A realização da consulta vai deixar de ser Lazy para Eager. Isso é diferente de você mudar de Lazy para Eager.

No DAO

Devemos ter a consulta assim:

public class UserDAO{

public List<User> readAll() {

                //avoiding LazyInitializationException join fetch

                String hql = “select u from User u join fetch u.type”;

                Query query = getCurrentSession().createQuery(hql);

                return query.list();

        }

}

Pronto. Resolvido seu problema com LazyInitializationException. Mas um detalhe importante é que para cada coleção que temos, é uma consulta que devemos ter. Se Type tem uma coleção de acesso, é uma consulta.

Bom é isso. Vou ficando por aqui e espero que tenham gostado do post.

Abraços, see ya!! 

Os melhores posts de 2010 LpJava

ae! Pessoal,

Em preparativo dos posts para 2011 e das novidades para o próximo ano, resolvi listar os 12 posts mais visitados neste ano. Caso tenha perdido algum, confira quem são eles:

Os posts mais visitados 2010:

  1. Uma simples aplicação Hibernate + JSF + poolConexao

  2. Série NZ: Minha Experiência Intercâmbio – Auckland

  3. SimSCJP Premium

  4. Java Básico + Hibernate JPA + Mysql

  5. Quando ser contratado como PJ?

  6. selectOneMenu JSF com BD

  7. Como ser um Programador Senior Java

  8. JPA com Java Básico MySql

  9. Como melhorar seu estudo? English

  10. Praticando JSF Facelets no Eclipse

  11. Projetos com RedMine

  12. Open Session View – Hibernate Solução

Atingimos o número de 184 posts, desde os técnicos e não técnicos, nesses dois anos de trabalho, iniciado desde março/2008. Este ano foram 55 novos posts( técnicos, carreira, inglês). Espero escrever mais em 2011 😉

Vou ficando por aqui e semana que vem retorno com o ultimo post do ano, sobre metas/plano de carreira e retrospectiva.

Abracos, see ya!

Uma simples aplicação Hibernate + JSF + poolConexao

olá Pessoal,

Bem, hoje resolvi fazer um post, do qual eu já tive problemas e acredito que alguém já passou ou passa por isso. Vc nunca ficou perdido nos passos de como desenvolver uma nova aplicação usando um conjunto de frameworks? Tipo, por onde começar? Quando você faz isso com frequência não tem como esquecer, mas não é a realidade, nem todo dia estamos criando novas aplicações e alguns processos base, “dão branco”. Eu sofria com isso, quando precisava iniciar uma nova app do zero. Claro que hoje temos ferramentas que nos ajuda. Mas, vamos esquecer essas ferramentas de auxilio e pensar em um ambiente que não temos ela disponível.

O objetivo deste post, é documentar tópicos  para que você possa montar uma pequena estrutura para o ambiente de produção e ao mesmo tempo ir reelembrando aquilo que seu cerebro deixou no “pool” dele. Usarei o Hibernate + JSF tendo o pool de conexão implementado.

note: Claro em projetos reais e grandes não fazemos isso, para não perder tempo e tb não é nada legal. Porém, se você está começando agora a fazer aplicações sem muita experiência, procure sempre lembrar a funcionalidade de cada framework dentro do projeto e quando eles aparecem no desenvolvimento isto é tão importante qto saber usar cada um deles.

Lets go…

note: vou considerar os passos abaixo para um ambiente de produção, pois em testes raramente temos problemas. Um deles é o open session view que só descobrir ele quando subir minha app.

Steps

  1. Ter o BD e tabelas criadas

  2. criar a estrutura do projeto JSF Project

  3. Adicionar as bibliotecas dos frameworks

  4. criar o bean e fazer os annotations (não queira usar xml )

  5. criar o JNDI META-INF/context.xml

  6. criar o pool de conexao com o JNDI em web.xml (Resources)

  7. atualizar o hibernate.cfg.xml com o JNDI/Pool de conexão.

    current_session_context_class: thread

    connection.datasource: java:com/env/jdbc/nomejndi

    transaction.factory_class:org.hibernate.transaction.JDBCTransactionFactory

    jdbc.batch_size:0

  8. criar o DAO Generico com Hibernate no package dao

  9. Criar a classeDAO para fazer a persistencia no BD

  10. criar o managebean e controlador para JSF

  11. iniciar a construção do front end com JSF.

  12. Implementar o SpringSecurity (optional)

  13. Implementar o Filter para evitar o open session view

Claro que nesses passos há temos apenas  os pontos chaves que acabam reativando o conhecimento que está la no “pool de string” do seu cerebro.

Visite a nossa as categorias abaixo no blog que boa parte dos assuntos listados nos passos estão nas respectivas categorias:

https://blog.camilolopes.com.br/category/hibernate/

https://blog.camilolopes.com.br/category/java/

https://blog.camilolopes.com.br/category/javaee/

https://blog.camilolopes.com.br/category/jpa/

https://blog.camilolopes.com.br/category/jsf/

Abracos, see you next post. 🙂