JPA e Spring framework: criando um DAO Genérico

Neste artigo iremos mostrar como criar um DAO (Data Access Object) gen�rico para ser utilizado em qualquer parte do seu sistema, garantindo alta reusabilidade e produtividade. Trabalharemos neste artigo com Spring Framework e Hibernate/JPA para manipula��o da nossa classe DAO, por�m n�o iremos mostrar como configurar ou utilizar o Spring ou JPA, pois n�o � foco deste artigo.

Antes de iniciarmos � importante entender o que vem a ser um DAO, conceito importante para entender o porqu� desta classe deve existir em nosso projeto.

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.myapp.dao;
 
import br.com.sender.bean.AbstractBean;
import java.util.List;
import java.util.Map;
 
public interface BasicDAO {
 
         public abstract List<? extends AbstractBean> 
           findByNamedQuery (String s, Map<String, Object> map);
 
         public abstract List<? extends AbstractBean> 
           findByNamedQuery(String s);
 
         public abstract List<? extends AbstractBean> 
           findByQuery(String s,
           Map<String, Object> map);
 
         public abstract List<? extends AbstractBean> 
           findByNamedQuery(String s,
            Map<String, Object> map, int maxResults);
 
         public abstract List<? extends AbstractBean> 
           findByNamedQuery(String s,
            int maxResults);
 
         public abstract List<? extends AbstractBean> 
           findByQuery(String s, Map<String, Object> 
            map, int maxResults);
 
         public abstract AbstractBean save(AbstractBean abstractbean);
         public abstract AbstractBean saveFlushAndClear
          (AbstractBean abstractbean);
 
         public abstract void update(AbstractBean abstractbean);
 
         public abstract void delete(AbstractBean abstractbean);
         
         public abstract void clear();
         public abstract void flushAndClear();
         public abstract void flush();
}

Listagem 1. Interface BasicDAO

Agora que j� temos nossa Interface criada, podemos come�ar a definir nosso DAO Gen�rico, chamaremos ele 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.


@Repository(value = "basicDAO")
public class BasicDAOImpl implements BasicDAO, Serializable {
 
@PersistenceContext(type = 
 javax.persistence.PersistenceContextType.EXTENDED)
  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, colocamos o �PersistenceContextType.EXTENDED� para que nosso entityManager n�o se torne �detach, assim precisar�amos ficar criando novos a cada momento.

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<? extends AbstractBean> 
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<? extends AbstractBean> returnList = 
   (List<? extends AbstractBean>) 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 com par�metros e 
* limitando a quantidade m�xima
* de resultados que deve ser retornado
* */
@Transactional(readOnly = true, propagation =
Propagation.SUPPORTS)
public List<? extends AbstractBean> findByNamedQuery
(String namedQuery,
Map<String, Object> namedParams, int maxResults) {
try {
    logger.info("Procurando pela namedQuery " 
     + namedQuery + " com "
    + namedParams.size() + " parametros");
    Query query = entityManager.createNamedQuery(namedQuery);
    query.setMaxResults(maxResults);
    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<? extends AbstractBean> returnList = 
   (List<? extends AbstractBean>) 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 003: findByNamedQuery sem par�metros e nem limita��o 
* de quantidade, o mais simples de todos
* */
@Transactional(readOnly = true, propagation = 
Propagation.SUPPORTS)
public List<? extends AbstractBean> findByNamedQuery
(String namedQuery) {
try {
    logger.info((new StringBuilder("Procurando pela namedQuery "))
    .append(namedQuery).append(" sem nenhum parametro")
    .toString());
    Query query = entityManager.createNamedQuery(namedQuery);
    List<? extends AbstractBean> returnList =
    (List<? extends AbstractBean>) 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 004: findByNamedQuery sem par�metros, mas 
* com limita��o de quantidade de resultados
* */
@Transactional(readOnly = true, propagation = 
Propagation.SUPPORTS)
public List<? extends AbstractBean> 
findByNamedQuery(String namedQuery,
int maxResults) {
try {
    logger.info((new StringBuilder("Procurando pela namedQuery "))
    .append(namedQuery).append(" sem nenhum parametro")
    .toString());
    Query query = entityManager.createNamedQuery(namedQuery);
    query.setMaxResults(maxResults);
    List<? extends AbstractBean> returnList = 
    (List<? extends AbstractBean>) 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");
   }
}

Listagem 3. M�todos findByNamedQuery

Como dissemos logo no in�cio do artigo, 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. Esta classe 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 uteis 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 alguns 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<? extends AbstractBean> findByQuery
   (String hql, Map 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<? extends AbstractBean> returnList = 
             (List<? extends AbstractBean>) 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<? extends AbstractBean> findByQuery(String hql,
            Map namedParams, int maxResults) {
     try {
            logger.info((new StringBuilder("Procurando 
             pela query: ")).append(
            hql).toString());
            Query query = entityManager.createQuery(hql);
            query.setMaxResults(maxResults);
            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<? extends AbstractBean> returnList = 
             (List<? extends AbstractBean>) 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 do 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 realiza��o a atualiza��o, inser��o e dele��o dos registros no banco. Veja na Listagem 7.


@Transactional(readOnly = true, propagation = Propagation.REQUIRED)
public AbstractBean save(AbstractBean bean) {
     try {
            logger.info("Salvando Bean " + bean.getClass().getName());
            entityManager.persist(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 = true, propagation = 
 Propagation.REQUIRED)
public AbstractBean saveFlushAndClear(AbstractBean bean) {
     try {
            logger.info("Salvando Bean " + bean.getClass().getName());
            entityManager.persist(bean);
            entityManager.flush();
            entityManager.clear();
            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 = true, propagation = 
  Propagation.REQUIRED)
public void update(AbstractBean bean) {
     try {
            logger.info("Alterando Bean " + bean.getClass().getName());
            entityManager.merge(bean);
     } catch (Exception e) {
            e.printStackTrace();
            logger.error("Ocorreu um erro ao tentar
               atualizar. MSG ORIGINAL: "
                          + e.getMessage());
            throw new DAOException("Ocorreu um erro ao 
                tentar atualizar");
     }
}

@Transactional(readOnly = true, propagation = 
  Propagation.REQUIRED)
public void delete(AbstractBean bean) {
     try {
            logger.info("Deletando Bean " + 
             bean.getClass().getName());
            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");
     }
}

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.

Temos dois m�todos para inserir registros, s�o eles: save() e saveFlushAndClear(). Para quem j� tem mais habilidade com o Hibernate, vai perceber que a diferen�a entre os dois m�todos � que o segundo m�todo, �for�a� o sincronismo com o banco de dados e a limpeza de altera��es na mesma hora que o registro � inserido. 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 o m�todo saveFlushAndClear() faz-se necess�rio para processar a trigger no mesmo instante e gerar este novo valor.

Concluindo, este artigo teve como principal foco mostrar a estrutura de uma classe DAO gen�rica, n�o se atendo a detalhes de utiliza��o do Hibernate ou Spring, caso contr�rio perderia o foco. 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.

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

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

JPA e Spring framework: criando um DAO Gen�rico

Veja neste artigo como criar um DAO Gen�rico utilizando JPA e Spring Framework