DAO Genérico com JPA e Hibernate

Olá pessoal,

Criei uma estrutura inicial de um DAO Genérico que gostaria de compartilhar com vcs. Ainda não existe todos os métodos que vou precisar, mas vou atualizando aqui a cada mudança no código. Para esta implementação utilizei JPA + Hibernate e para meu caso vem me atendendo bem por enquanto. Segue abaixo a implementação:

-----------------------------------------------


/**
* Esta classe é responsável por conter as operações genéricas para realização
* do acesso aos dados do sistema.
*
* @author Samuel
*
* @param 
*/
@SuppressWarnings("unchecked")
public abstract class GenericDAOImpl {
 
 private EntityManager entityManager;

 private Class classePersistente;

 /**
  * Contrutor que guarda o tipo atual da classe T.
  */
 public GenericDAOImpl() {
  this.classePersistente = (Class) ((ParameterizedType) getClass()
    .getGenericSuperclass()).getActualTypeArguments()[0];
 }
 
 /**
  * Atualiza o objeto que se encontra em memória.
  *
  * @param object
  *            objeto a ser atualizado
  */
 public final void refresh(T object) {
  getEntityManager().refresh(object);
 }

 /**
  * Executa o flush no entity manager.
  *
  */
 public final void flush() {
  getEntityManager().flush();
 }
 
 /**
  * Executa o flush no entity manager.
  *
  */
 public final void clear() {
  flush();
  getEntityManager().clear();
 }


 /**
  * Executa o merge do objeto que se encontra em memória.
  *
  * @param objeto
  *            a ser realizado o merge
  * @return objeto que foi executado o merge
  */
 public final T merge(T objeto) {
  objeto = getEntityManager().merge(objeto);
  return objeto;
 }
 
 /**
  * Salva o objeto atual na base de dados.
  *
  * @param objeto
  *            a ser salvo
  */
 public final void salvar(T objeto) {
  getEntityManager().persist(objeto);
 }

 /**
  * Remove o objeto da base de dados.
  *
  * @param objeto
  *            a ser removido
  */
 public final void remover(T objeto) {
  getEntityManager().remove(objeto);
 }

 /**
  * Remove o objeto uma vez passado sua chave como parâmetro.
  *
  * @param chave
  *            identificadora do objeto
  */
 public final void removerPorChave(Integer chave) {
  getEntityManager().createQuery(
    "delete from " + getClassePersistente().getName()
      + " where id = " + chave).executeUpdate();
 }

 /**
  * Busca o objeto uma vez passado sua chave como parâmetro.
  *
  * @param chave
  *            identificador
  * @return Objeto do tipo T
  */
 public final T buscarPorChave(Integer chave) {
  T instance = null;
  try {
   instance = getEntityManager().find(getClassePersistente(), chave);
  } catch (RuntimeException re) {
   re.printStackTrace();
  }
  return instance;
 }

 /**
  * Busca o objeto de acordo com o objeto preenchido com os valores passado
  * como exemplo.
  *
  * @param objeto
  *            utilizado para realizar a busca
  * @param ordenacoes
  *            lista de critérios de ordenação
  * @return Lista de objetos retornada
  */
 public final List buscarPorExemplo(T objeto, Order... ordenacoes) {
  Session session = (Session) getEntityManager().getDelegate();
  Example example = criaExemplo(objeto);
  Criteria criteria = session.createCriteria(objeto.getClass()).add(
    example);
  for (int i = 0; i < ordenacoes.length; i++) {
   criteria.addOrder(ordenacoes[i]);
  }
  return (List) criteria.list();
 }

 /**
  * Busca o objeto de acordo com o objeto preenchido com os valores passado
  * como exemplo.
  *
  * @param objeto
  * @param indiceInicial
  * @param indiceFinal
  * @param ordenacoes
  *            lista de critérios de ordenação.
  * @return Lista de orden
  */
 public final List buscarPorExemplo(T objeto, Integer indiceInicial,
   Integer indiceFinal, Order... ordenacoes) {
  Example example = criaExemplo(objeto);
  Criteria criteria = criaCriteria().add(example);
  criteria.setFirstResult(indiceInicial);
  criteria.setMaxResults(indiceFinal);

  for (int i = 0; i < ordenacoes.length; i++) {
   criteria.addOrder(ordenacoes[i]);
  }

  return (List) criteria.list();
 }

 /**
  * Retorna a quantidade total de objetos para aquela entidade específica.
  *
  * @return quantidade total de objetos
  */
 public final int buscaQuantidadeTotal() {
  Criteria criteria = criaCriteria();
  criteria.setProjection(Projections.rowCount());
  return (Integer) criteria.uniqueResult();
 }

 /**
  * Busca todos os objetos para aquela entidade específica.
  *
  * @param ordenacoes
  *            lista de ordenações para pesquisa
  * @return lista de todos os objetos da entidade
  */
 public List buscarTodos(Order... ordenacoes) {
  List results = null;
  try {
   Query query = getEntityManager().createQuery(
     "from " + getClassePersistente().getName()
       + adicionaOrderByHql(ordenacoes));
   results = query.getResultList();
  } catch (RuntimeException re) {
   re.printStackTrace();
  }
  return results;
 }

 /**
  *
  * Busca todos os objetos de uma entidade específica de um índice inicial
  * até um índice final.
  *
  * @param indiceInicial
  *            indice inicial da busca
  * @param indiceFinal
  *            indice final da pesquisa.
  * @param ordenacoes
  *            lista de ordenação a ser criado
  * @return uma lista de objetos do tipo T
  */
 public List buscarTodos(Integer indiceInicial,
   Integer indiceFinal, Order... ordenacoes) {
  List results = null;
  try {
   Query query = getEntityManager().createQuery(
     "from " + getClassePersistente().getName()
       + adicionaOrderByHql(ordenacoes));
   query.setFirstResult(indiceInicial);
   query.setMaxResults(indiceFinal);

   results = (List) query.getResultList();
  } catch (RuntimeException re) {
   re.printStackTrace();
  }
  return results;
 }

 /**
  * Utilizado para se injetar o Entity manager no DAO.
  *
  * @param entityManager
  *            entity manager
  */
 public void setEntityManager(EntityManager entityManager) {
  this.entityManager = entityManager;
 }

 /**
  * Utilizado para se utilizar o entity manager nos DAOS que herdam do DAO
  * genérico.
  *
  * @return Entity manager.
  */
 protected EntityManager getEntityManager() {
  return entityManager;
 }

 /**
  * Adiciona o orderBy no final da query a ser utilizada.
  *
  * @param ordenacoes
  *            a serem utilizadas para a busca
  * @return string com o orderBy
  */
 protected final static String adicionaOrderByHql(Order... ordenacoes) {
  String result = "";
  if (ordenacoes.length > 0) {
   StringBuilder builder = new StringBuilder(" order by ");
   for (int i = 0; i < ordenacoes.length - 1; i++) {
    builder.append(ordenacoes[i].toString());
    builder.append(", ");
   }
   builder.append(ordenacoes[ordenacoes.length - 1]);
   result = builder.toString();
  }

  return result;
 }

 /**
  * Busca a classe persistente do objeto utilizado na classe.
  *
  * @return classe persistente
  */
 protected final Class getClassePersistente() {
  return classePersistente;
 }

 /**
  * Retorna o objeto da clases Criteria.
  *
  * @return um objeto do tipo Criteria do Hibernate
  */
 protected final Criteria criaCriteria() {
  Session session = (Session) getEntityManager().getDelegate();
  return session.createCriteria(getClassePersistente());
 }

 /**
  * Método utilizado para criar o objeto Example. Este objeto é utilizado
  * para realizar a busca por exemplo.
  *
  * @param objeto
  *            sobre o qual o Example será criado
  * @return em objeto do tipo Example
  */
 protected final Example criaExemplo(T objeto) {

  Example example = Example.create(objeto);
  example.enableLike(MatchMode.ANYWHERE);
  example.excludeZeroes();
  example.ignoreCase();

  return example;
 }

}

-----------------------------------------------

Para ilustrar como esta classe é utilizada mostrarei abaixo como extender este DAO genérico:

-----------------------------------------------

public class PessoaDAO extends GenericDAOImpl {

    public List buscarTodosTelefoneEndereco(Integer indiceInicial, Integer indiceFinal,
            Order... ordenacoes) {
        List pessoas = super.buscarTodos(indiceInicial, indiceFinal,
                ordenacoes);

        for (Pessoa pessoa : pessoas) {
            // Carrega os relazionamentos que são LAZY. Este método chama o
            // método initialize do Hibernate.
            pessoa.getTelefones().size();
            pessoa.getEnderecos().size();
        }

        return pessoas;
    }
   
    @SuppressWarnings("unchecked")
    public List buscarTodosHQL() {
        Query query = getEntityManager().createNamedQuery("selectAllHQL");
        List pessoas = query.getResultList();

        return pessoas;
    }

    @SuppressWarnings("unchecked")
    public List buscarTodosSQL() {
       
        Query query = getEntityManager().createNamedQuery("selectAllNativo");
        List pessoas = query.getResultList();

        return pessoas;
    }
   
    @SuppressWarnings("unchecked")
    public List buscarTodosComTelefone() {
       
        List resultado = new ArrayList();
        Query query = getEntityManager().createNamedQuery("selectAllNativoTelefone");

        List resultados = query.getResultList();
        for (Object object : resultados) {
            Object[] arranjo = (Object[]) object;
            Pessoa pessoa = (Pessoa) arranjo[0];
            Telefone telefone = (Telefone) arranjo[1];
            Collection telefones = new ArrayList();
            telefones.add(telefone);
            pessoa.setTelefones(telefones);
           
            resultado.add(pessoa);
        }

        return resultado;
    }

-----------------------------------------------

Em breve postarei como realizo a injeção do Entity Manager utilizando a classe DAOFactory. Qualquer dúvida ou coisa que precisarem me mandem mensagem.