JPA DAO: DAO Generico com JPA e Spring

Como em todos os projetos, ou pelo menos a maioria deles, � necess�rio realizar uma conex�o e diversos procedimento da aplica��o com o banco de dados: consultas, inser��es, dele��es, altera��es e entre outros. Queremos com esse artigo criar uma classe gen�rica o suficiente para que esses procedimentos possam ser reutilizados em qualquer tipo de projeto, sem a necessidade de ter que recriar tudo de novo, com isso aplicamos aqui o principio da �Reusabilidade�.

Antes de iniciarmos � importante entender o que � um DAO, conceito importante para entender o porque desta classe existir em nosso projeto.

Nota: Vale a pena dar uma conferida nos cursos de java da DevMedia. Se voc� deseja se tornar um Java Developer de sucesso, voc� precisa ver esses cursos.

Entendendo o DAO

Conhecido tamb�m por Data Access Object ou Objeto de Acesso a Dados, � um padr�o para persist�ncia de dados onde seu principal objetivo � separar regras de neg�cio de regras de acesso a banco de dados. Este � muito utilizado com a arquitetura MVC (Model-View-Controller), onde toda separa��o de conex�es, SQL's e fun��es diretas ao banco, s�o tratadas no DAO.

Como iremos tratar de um DAO gen�rico, este deve ser poderoso o suficiente para realizar quaisquer procedimentos e/ou conex�es com nosso banco de dados, deixando que a aplica��o nem precise se preocupar com esse tipo de tarefa.

Exemplo: Como estamos trabalhando com Hibernate, podemos fazer uso do HQL (Hibernate Query Language). Sabendo disso, podemos criar um m�todo em nosso DAO chamado findAllByBean(AbstractBean bean), onde passamos qualquer bean e o m�todo nos retorna todos os beans do banco. Veja que neste ponto, n�o nos importa saber como � feita a conex�o ou mesmo o SQL, apenas queremos todos os Beans (Registros) do banco.

O exemplo acima foi apenas para demonstrar que o nosso DAO � quem conversar� com o banco de dados (independente de qual for ele), e nossa aplica��o conversar� com o DAO quando precisar de algum registro do Banco.

Implementando um DAO Gen�rico

A primeira etapa para come�armos a implementa��o de nosso DAO Gen�rico � a cria��o de uma Interface, pois mesmo que nosso DAO seja super completo com v�rios recursos �timos, pode ainda existir algum ponto da aplica��o que precise criar seu pr�prio DAO, um Custom DAO. Nesse caso precisamos garantir que este novo DAO tenha pelo menos os mesmos m�todos do nosso DAO Gen�rico com mais os m�todos customizados. Assim, garantimos a organiza��o adequada de nossa aplica��o, pois saberemos, por exemplo, que em todos os nossos DAO a opera��o de salvar um Bean chama-se �save()�, mesmo que com procedimentos internos distintos. Observe a Listagem 1.


package br.com.mygenericdao.dao;
import java.util.List;
import java.util.Map;
import br.com.mygenericdao.bean.AbstractBean;
 
public interface BasicDAO {
 
       public abstract List findByNamedQuery(String s,
                    Map<String, Object> map);
 
       public abstract List findByNamedQuery(String s);
 
       public abstract List findByQuery(String s);
 
       public abstract List findByQuery(String s,
                    Map<String, Object> map);
       
       public abstract AbstractBean findById(Class clazz, Integer id);
 
       public abstract AbstractBean save( AbstractBean bean);
 
       public abstract void delete( AbstractBean bean);
 
       public abstract void clear();
 
       public abstract void flush();
       
       public abstract void evict( AbstractBean bean);
}

Listagem 1. Interface BasicDAO

Agora que j� temos nossa Interface criada, podemos come�ar a definir nosso DAO Gen�rico, chamado de BasicDAOImpl, por ser uma implementa��o da nossa Interface acima. Mostraremos primeiro a estrutura do nosso DAO, sem nenhum m�todo, conforme a Listagem 2.


package br.com.mygenericdao.dao;
import java.io.Serializable;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
 
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;
 
import org.apache.log4j.Logger;
import org.hibernate.Session;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
 
import br.com.mygenericdao.bean.AbstractBean;
import br.com.mygenericdao.exception.DAOException;
@Repository(value = "basicDAO")
public class BasicDAOImpl implements BasicDAO, Serializable {
 
    /**
        *
        */
    private static final long serialVersionUID = 1L;
        
    @PersistenceContext
    protected EntityManager entityManager;
 
    private static Logger logger = Logger.getLogger(BasicDAOImpl.class);
�
�
}

Listagem 2. Estrutura do BasicDAOImpl

Perceba que anotamos nosso DAO com Spring, utilizando o @Repository. Assim, deixamos o Spring gerenciar a inst�ncia da nossa classe. Al�m disso, temos dois atributos importantes na nossa classe: O entityManager e o logger.

O atributo entityManager � respons�vel por realizar as conex�es e opera��es com o banco atrav�s do JPA. Deixamos o padr�o do PersistenceContext como TRANSIENT. Est� impl�cito, mas poder�amos adicionar o atributo.

O atributo logger � apenas para logarmos as opera��es que est�o ocorrendo durante a aplica��o. Neste caso, estamos utilizando o Log4j.

Na Listagem 3 voc� ver� nossos m�todos findByNamedQuery com diversos tipos de par�metros, um para cada tipo de situa��o.


/**
  * OP��O 001: findByNamedQuery com par�metros
  * */
 @Transactional(readOnly = true, propagation = Propagation.SUPPORTS)
 public List findByNamedQuery(String namedQuery,
              Map<String, Object> namedParams) {
       try {
              logger.info("Procurando pela namedQuery " + namedQuery + " com "
                            + namedParams.size() + " parametros");

              Query query = entityManager.createNamedQuery(namedQuery);

              if (namedParams != null) {
                     Entry<String, Object> mapEntry;

                     for (Iterator it = namedParams.entrySet().iterator(); it
                                  .hasNext(); query.setParameter(
                                  (String) mapEntry.getKey(), mapEntry.getValue())) {

                            mapEntry = (Entry<String, Object>) it.next();
                            logger.info("Param: " + mapEntry.getKey() + ", Value: "
                                         + mapEntry.getValue());
                     }

              }

              List returnList = query.getResultList();
              logger.info("Objetos Encontrados: " + returnList.size());

     return returnList;
 } catch (Exception e) {
     e.printStackTrace();
     logger.error("Ocorreu um erro ao executar o findByNamedQuery com par�metros. MSG ORIGINAL: "
           + e.getMessage());
     throw new DAOException(
           "Ocorreu um erro ao executar o findByNamedQuery com par�metros");
 }
}


 
 /**
  * OP��O 002: findByNamedQuery sem par�metros
  * */
 @Transactional(readOnly = true, propagation = Propagation.SUPPORTS)
public List findByNamedQuery(String namedQuery) {
 try {
     logger.info((new StringBuilder("Procurando pela namedQuery "))
           .append(namedQuery).append(" sem nenhum parametro")
           .toString());
     Query query = entityManager.createNamedQuery(namedQuery);
     List returnList = query.getResultList();

     logger.info("Objetos Encontrados: " + returnList.size());

     return returnList;
 } catch (Exception e) {
     e.printStackTrace();
     logger.error("Ocorreu um erro ao executar o findByNamedQuery sem par�metros. 
     MSG ORIGINAL: "
           + e.getMessage());
     throw new DAOException(
           "Ocorreu um erro ao executar o findByNamedQuery sem par�metros");
 }
}

/**
  * OP��O 003: find sem namedQuery e sem parametros
  * */
 @Transactional(readOnly = true, propagation = Propagation.SUPPORTS)
public List findByQuery(String s) {
 try {
     logger.info((new StringBuilder("Procurando pela query: "))
           .append(s).toString());
     Query query = entityManager.createQuery(s);
     List returnList = query.getResultList();

     logger.info("Objetos Encontrados: " + returnList.size());

     return returnList;
 } catch (Exception e) {
     e.printStackTrace();
     logger.error("Ocorreu um erro ao executar o findByQuery. MSG ORIGINAL: "
           + e.getMessage());
     throw new DAOException("Ocorreu um erro ao executar o findByQuery");
 }
}

/**
  * OP��O 004: find sem namedQuery e co parametros
  * */
@Transactional(readOnly = true, propagation = Propagation.SUPPORTS)
public List findByQuery(String hql, Map<String, Object> namedParams) {
 try {
     logger.info((new StringBuilder("Procurando pela query: ")).append(
           hql).toString());
     Query query = entityManager.createQuery(hql);
     if (namedParams != null) {
       Entry mapEntry;
       for (Iterator it = namedParams.entrySet().iterator(); it
               .hasNext(); query.setParameter(
               (String) mapEntry.getKey(), mapEntry.getValue())) {
           mapEntry = (Entry) it.next();
           logger.info("Param: " + mapEntry.getKey() + ", Value: "
                  + mapEntry.getValue());
       }

     }
     List returnList = query.getResultList();

     logger.info("Objetos Encontrados: " + returnList.size());

     return returnList;
 } catch (Exception e) {
     e.printStackTrace();
     logger.error("Ocorreu um erro ao executar o findByQuery. MSG ORIGINAL: "
           + e.getMessage());
     throw new DAOException("Ocorreu um erro ao executar o findByQuery");
 }

}

/**
  * OP��O 005: find objeto pela classe
  * */

@Transactional(readOnly = true, propagation = Propagation.SUPPORTS)
public AbstractBean findById(Class clazz, Integer id) {
 try {
     logger.info("Procurando pelo Bean " + clazz.getName() + " com ID "
           + id);
     Query query = entityManager.createQuery("SELECT c FROM " + clazz.getName() 
     + " c WHERE c.id = :id");
     query.setParameter("id", id);
     AbstractBean resultBean = (AbstractBean) query.getSingleResult();

     if (resultBean != null)
       logger.info("Objetos Encontrados: 1");
     else
       logger.info("Objetos Encontrados: 0");

     return resultBean;
 } catch (Exception e) {
     e.printStackTrace();
     logger.error("Ocorreu um erro ao executar o findById. MSG ORIGINAL: "
           + e.getMessage());
     throw new DAOException(
           "Ocorreu um erro ao executar o findById");
 }
}

Listagem 3. M�todos findByNamedQuery

N�o entraremos no m�rito de explicar como utilizar o JPA passo-a-passo. Perceba que temos quatro tipos distintos de m�todos, com o mesmo nome, mas parametriza��es distintas. Al�m disso, todos os nossos m�todos acima tem a anota��o @Transactional(readOnly = true, propagation = Propagation.SUPPORTS), assim, estamos dizendo ao Spring que se houver alguma transa��o quando esta consulta for realizada, ela dever� fazer parte da transa��o, caso contr�rio, ela ser� executada sem nenhuma transa��o, diferente do Propagation.REQUIRED, que for�a a cria��o de uma transa��o caso n�o exista.

Outro ponto importante � o uso da classe AbstractBean, que nada mais � do que do que uma classe Gen�rica para todos os nossos Beans, tendo apenas a propriedade ID que � comum a todos. Veja como � nossa classe AbstractBean na Listagem 4.


@MappedSuperclass
public abstract class AbstractBean implements Serializable {

   @Id
   @GeneratedValue(strategy = javax.persistence.GenerationType.IDENTITY)
   private Integer id;

   public Integer getId() {
         return id;
   }

   public void setId(Integer id) {
         this.id = id;
   }

   @Override
   public int hashCode() {
         final int prime = 31;
         int result = 1;
         result = prime * result + ((id == null) ? 0 : id.hashCode());
         return result;
   }

   @Override
   public boolean equals(Object obj) {
         if (this == obj)
                return true;
         if (obj == null)
                return false;
         if (getClass() != obj.getClass())
                return false;
         
         return (obj instanceof AbstractBean) ? (this.getId() == null ? this == obj : 
         this.getId().equals(((AbstractBean)obj).getId())):false;
         
   }

   
}

Listagem 4. AbstractBean

Outro ponto importante em nossos m�todos findNamedQuery() � o uso de NamedQueries, que s�o recursos muito �teis do JPA. Estas s�o anotadas diretamente no nosso bean. Veja um exemplo na Listagem 5 de um NamedQuery mapeada em um bean Pessoa.


@Entity
@NamedQueries(value = { @NamedQuery(name = "Pessoa.findAllCompleto", query 
= "SELECT c FROM Pessoa c "
             + "JOIN FETCH c.situacao") })
@Table(name = "pessoa")
@Inheritance(strategy = javax.persistence.InheritanceType.JOINED)
public class Pessoa extends AbstractBean {
�
�
...
}

Listagem 5. NamedQuery no Bean Pessoa

Ent�o quando passarmos uma namedQuery para nosso DAO, apenas passaremos Pessoa.findAllCompleto e o DAO saber� qual query desejamos executar. Simples e funcional. Toda nossa aplica��o trabalhar� com o conceito de NamedQuery, assim centralizamos nossas Querys e saberemos exatamente onde os erros poder�o ocorrer.

Mas, para deixar nosso DAO ainda mais completo, criaremos um �punhado� de m�todos para executar outras Querys que n�o sejam NamedQueries. Por algum motivo poderemos executar querys diretas sem o uso desse recurso do JPA. Vejamos como na Listagem 6.


@Transactional(readOnly = true, propagation = Propagation.SUPPORTS)
public List findByQuery(String s) {
   try {
       logger.info((new StringBuilder("Procurando pela query: "))
             .append(s).toString());
       Query query = entityManager.createQuery(s);
       List returnList = query.getResultList();

       logger.info("Objetos Encontrados: " + returnList.size());

       return returnList;
   } catch (Exception e) {
       e.printStackTrace();
       logger.error("Ocorreu um erro ao executar o findByQuery. MSG ORIGINAL: "
             + e.getMessage());
       throw new DAOException("Ocorreu um erro ao executar o findByQuery");
   }
}

@Transactional(readOnly = true, propagation = Propagation.SUPPORTS)
public List findByQuery(String hql, Map<String, Object> namedParams) {
   try {
       logger.info((new StringBuilder("Procurando pela query: ")).append(
             hql).toString());
       Query query = entityManager.createQuery(hql);
       if (namedParams != null) {
         Entry mapEntry;
         for (Iterator it = namedParams.entrySet().iterator(); it
                 .hasNext(); query.setParameter(
                 (String) mapEntry.getKey(), mapEntry.getValue())) {
             mapEntry = (Entry) it.next();
             logger.info("Param: " + mapEntry.getKey() + ", Value: "
                    + mapEntry.getValue());
         }

       }
       List returnList = query.getResultList();

       logger.info("Objetos Encontrados: " + returnList.size());

       return returnList;
   } catch (Exception e) {
       e.printStackTrace();
       logger.error("Ocorreu um erro ao executar o findByQuery. MSG ORIGINAL: "
             + e.getMessage());
       throw new DAOException("Ocorreu um erro ao executar o findByQuery");
   }

}

Listagem 6. M�todos sem uso de NamedQueries

Em suma, a execu��o e retorno dos m�todo findByNamedQuery() e findByQuery() s�o iguais, o que os diferencia � apenas que no primeiro caso temos como par�metro uma NamedQuery mapeada em nosso Bean e no segundo caso temos um HQL �puro� passado como par�metro.

Por fim, temos os m�todos que realizar�o a atualiza��o, inser��o e dele��o dos registros no banco. Veja na Listagem 7.


@Transactional(readOnly = false, propagation = Propagation.REQUIRED)
public AbstractBean save(AbstractBean bean, boolean flushAndRefresh) {
   try {
       logger.info("Salvando Bean " + bean.getClass().getName());
       bean = entityManager.merge(bean);

       if (flushAndRefresh) {
         entityManager.flush();
         entityManager.refresh(bean);
       }
       
       return bean;

   } catch (Exception e) {
       e.printStackTrace();
       logger.error("Ocorreu um erro ao tentar salvar. MSG ORIGINAL: "
             + e.getMessage());
       throw new DAOException("Ocorreu um erro ao tentar salvar");
   }
}

@Transactional(readOnly = false, propagation = Propagation.REQUIRED)
public AbstractBean save(AbstractBean bean) {
   return save(bean, false);
}


@Transactional(readOnly = false, propagation = Propagation.REQUIRED)
public void delete(AbstractBean bean) {
   try {
       logger.info("Deletando Bean " + bean.getClass().getName());
       bean = entityManager.merge(bean);
       entityManager.remove(bean);
   } catch (Exception e) {
       e.printStackTrace();
       logger.error("Ocorreu um erro ao tentar deletar. MSG ORIGINAL: "
             + e.getMessage());
       throw new DAOException("Ocorreu um erro ao tentar deletar");
   }
}

public void evict(AbstractBean bean){
   Session session = (Session) entityManager.getDelegate();
   session.evict(bean);
}

public void flush() {
   entityManager.flush();
}

public void clear() {
   entityManager.clear();
}

Listagem 7. M�todos de altera��o, inser��o e remo��o de registros

Perceba primeiramente que todos os nossos m�todos da Listagem 7 tem o Propagation.REQUIRED, ou seja, eles obrigatoriamente sempre estar�o em uma transi��o para serem executados.

Adicionamos ainda mais tr�s m�todos importantes: evict, flush e clear.

O evict limpa um determinado objeto (de acordo com o passado pelo par�metro do m�todo) do persistenceContext atual.
O flush sincroniza todas as altera��es com o banco de dados, ou seja, ele efetiva as altera��es que atualmente est�o salvas no persistenceContext no banco de dados.
O clear faz a mesma fun��o do evict com a �nica diferen�a que o clear limpa todos os objetos do persistenceContext e n�o apenas um como o evict faz.

O nosso save na verdade realiza uma 'merge', ou seja, ele pode tanto inserir ou atualizar. Isso vai depender se o objeto est� ou n�o no banco de dados.

Para quem j� tem mais habilidade com o Hibernate ou mesmo JPA, vai perceber que a diferen�a entre executar o m�todo passando a vari�vel flushAndRefresh como true. � que este �for�a� o sincronismo com o banco de dados e depois repopula o objeto no persistenceContext, atrav�s do refresh. Imagine, por exemplo, se voc� possuir uma trigger que � executada a cada vez que um registro � inserido, atualizando o valor de uma coluna qualquer, aqui a vari�vel flushAndRefresh como true faz-se necess�ria para processar a trigger no mesmo instante e gerar este novo valor.

A utiliza��o do JPA contribui ainda mais para abstrair tecnologias, sendo assim, voc� pode optar por utilizar outro Container que n�o seja o Hibernate, sem influenciar na aplica��o. Adotamos ainda o princ�pio e boa pr�tica de utilizar interfaces para manter nossa aplica��o mais organizada, leg�vel e bem estruturada.

Tecnologias:

Confira outros conte�dos:

Introdu��o ao JDBC

Novidades do Java

Teste unit�rio com JUnit

Assista grátis a nossa aula inaugural

Perguntas frequentes

Quem somos?

Por que a programação se tornou a profissão mais promissora da atualidade?

Como faço para começar a estudar?

Em quanto tempo de estudo vou me tornar um programador?

Sim, você pode se tornar um programador e não precisa ter diploma de curso superior!

O que eu irei aprender estudando pela DevMedia?

Principais diferenciais da DevMedia

Qual o investimento financeiro que preciso fazer para me tornar um programador?

Como funciona a forma de pagamento da DevMedia?

Por Ronaldo Em 2014

Coment�rios nesta publica��o Escrever um coment�rio sobre conte�do

Flavio Silva

N�vel 0

bom dia. eu poderia usar as namedqueries para evitar as excecoes LazyInitializationException atraves de fetch joins com as classes compostas? caso sim, essa e uma tecnica "aceitavel" ou geralmente programadores mais experientes optam por outras estrategias? obrigado!

há +1 ano

Ver coment�rios anteriores (2)

Gabriel Cruz

N�vel 5

SHOW DE BOLA Flavio!

Obrigado pelo feedback!

Forte abra�o e bons estudos! =D

há +1 ano

Nossos casos de sucesso

Leonardo Carlos

Eu sabia pouqu�ssimas coisas de programa��o antes de come�ar a estudar com voc�s, fui me especializando em v�rias �reas e ferramentas que tinham na plataforma, e com essa bagagem consegui um est�gio logo no in�cio do meu primeiro per�odo na faculdade.

Lucas Rodrigues

Estudo aqui na Dev desde o meio do ano passado! Nesse per�odo a Dev me ajudou a crescer muito aqui no trampo.
Fui o primeiro desenvolvedor contratado pela minha empresa. Hoje eu lidero um time de desenvolvimento!
Minha meta � continuar estudando e praticando para ser um Full-Stack Dev!

Her�clito J�nior

Economizei 3 meses para assinar a plataforma e sendo sincero valeu muito a pena, pois a plataforma � bem intuitiva e muuuuito did�tica a metodologia de ensino. Sinto que estou EVOLUINDO a cada dia. Muito obrigado!

Julio Cablen

Nossa! Plataforma maravilhosa. To amando o curso de desenvolvimento front-end, tinha coisas que eu ainda n�o tinha visto. A did�tica � do jeito que qualquer pessoa consegue aprender. S�rio, to apaixonado, adorando demais.

Joelberth Sena

Adquiri o curso de voc�s e logo percebi que s�o os melhores do Brasil. � um passo a passo incr�vel. S� n�o aprende quem n�o quer. Foi o melhor investimento da minha vida!

Felipe Nunes

Foi um dos melhores investimentos que j� fiz na vida e tenho aprendido bastante com a plataforma. Voc�s est�o fazendo parte da minha jornada nesse mundo da programa��o, irei assinar meu contrato como programador gra�as a plataforma.

Wanderson Oliveira

Comprei a assinatura tem uma semana, aprendi mais do que 4 meses estudando outros cursos. Exerc�cios pr�ticos que n�o tem como n�o aprender, est�o de parab�ns!

Jos� Lucas

Obrigado DevMedia, nunca presenciei uma plataforma de ensino t�o presente na vida acad�mica de seus alunos, parab�ns!

Eduardo Dorneles

Aprendi React na plataforma da DevMedia h� cerca de 1 ano e meio... Hoje estou h� 1 ano empregado trabalhando 100% com React!

Adauto Junior

J� fiz alguns cursos na �rea e nenhum � t�o bom quanto o de voc�s. Estou aprendendo muito, muito obrigado por existirem. Est�o de parab�ns... Espero um dia conseguir um emprego na �rea.

Ver todos os casos de sucesso

DAO Generico com JPA e Spring

Veja neste artigo como desenvolver um DAO Gen�rico para utilizar em projetos em envolvam Java Persistence API (JPA) e Spring.