Generic DAO Vraptor | VRaptor e JPA: Pratique Java com um sistema completo

Bom dia,

Estou em dúvida de como utilizar um Generic Dao no Vraptor, pois criei as seguintes classes;

Interface GenericDao

public interface GenericDao<E,K> {
    void add(E entity) ;
    void saveOrUpdate(E entity) ;
    void update(E entity) ;
    void remove(E entity);
    E find(K key);
    List<E> getAll() ;
}

Implementação do GenericDao

public abstract class GenericDaoImpl<E, K extends Serializable> implements GenericDao<E, K> {

    protected final Session session;
    protected final Class<E> clazz;
    protected Class<? extends E> daoType;
    private Transaction tx;

    @SuppressWarnings("unchecked")
    protected GenericDaoImpl(Session session) {
        this.session = session;
        this.clazz = (Class<E>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];

        Type t = getClass().getGenericSuperclass();
        ParameterizedType pt = (ParameterizedType) t;
        daoType = (Class) pt.getActualTypeArguments()[0];
    }

    @Override
    public void add(E entity) {
        this.tx = this.session.beginTransaction();
        this.session.persist(entity);
        this.session.flush();
        this.tx.commit();
    }

    @Override
    public void saveOrUpdate(E entity) {
        this.tx = this.session.beginTransaction();
        this.session.merge(entity);
        this.session.flush();
        this.tx.commit();
    }

    @Override
    public void update(E entity) {
        this.tx = this.session.beginTransaction();
        this.session.merge(entity);
        this.session.flush();
        this.tx.commit();
    }

    @Override
    public void remove(E entity) {
        this.tx = this.session.beginTransaction();
        this.session.delete(entity);
        this.tx.commit();
    }

    @Override
    public E find(K key) {
        return null; 
    }

    @Override
    public List<E> getAll() {
        return null; 
    }
}

Para cada modelo vou criar uma interface como a seguinte;

Interface PacoteDao

public interface IPacoteDao extends GenericDao<Pacote, Integer>{
    void alterarSituacao(Long pacoteId, Pacote.PacoteSituacao situacao);
    void removerAgendamento(Agendamento agendamento, Boolean remover, HistoricoAcesso log);
    Long contarAgendamentosPendentes(Unidade unidade, LocalDate startDate, LocalDate endDate);
    Long contarPorSituacao(Unidade unidade, Pacote.PacoteSituacao situacao);
    Long contarFinalizamNoPeriodo(Unidade unidade, LocalDate startDate, LocalDate endDate);
    List<PacoteView> listar(Unidade unidade, Boolean novos, Boolean concluidos,
                            Boolean cancelados, LocalDate periodoInicio, LocalDate periodoFim);

}

Implementação PacoteDao

public class PacoteDaoImpl extends GenericDaoImpl<Pacote, Integer>
        implements IPacoteDao {

    protected PacoteDaoImpl(Session session) {
        super(session);
    }

    @Override
    public void alterarSituacao(Long pacoteId, Pacote.PacoteSituacao situacao) {}    
    @Override
    public void removerAgendamento(Agendamento agendamento, Boolean remover, HistoricoAcesso log) {}

    @Override
    public Long contarAgendamentosPendentes(Unidade unidade, LocalDate startDate, LocalDate endDate) {}

    @Override
    public Long contarPorSituacao(Unidade unidade, Pacote.PacoteSituacao situacao) {}

    @Override
    public Long contarFinalizamNoPeriodo(Unidade unidade, LocalDate startDate, LocalDate endDate) {}

    @Override
    public List<PacoteView> listar(Unidade unidade, Boolean novos, Boolean concluidos, Boolean cancelados, LocalDate periodoInicio, LocalDate periodoFim) {}

}

Quando eu incluo a anotação @Component na classe PacoteDaoImpl ocorre um erro ao rodar o projeto. Como é a primeira vez que implemento o uso de GenericDao no Vraptor, estou com dificuldades para implementá-lo.

A minha idéia é dividir os escopos; Controller --> Service --> Dao.

Conto com a ajuda!

Vamos la, quando você utilize Generic DAO a ideia é que ele sirva para todos, então você não precisa do seu PacoteDao.

O primeiro passo é criar a interface que servirá para definir todos os métodos contidos nele.

Feito isso, a implementação deve ser feita utilizando generics assim ele conseguira salvar qualquer objeto passado para ele.

Caso queira, vou listar o meu para você dar uma olhada:

@RequestScoped
public class Dao {

    private GenericDao dao;

    @Inject
    public Dao(GenericDao dao) {
        // TODO Auto-generated constructor stub
        this.dao = dao;
    }
    @Deprecated
    public Dao() {
        // TODO Auto-generated constructor stub
    }

    public GenericDao getDao() {
        return this.dao;
    }

}

public interface GenericDao<T> {

    void delete(T obj);
    T edit(T obj);
    List<T> executeNamedQuery(String namedQuery, Class clazz, Object[] parameters);
    void executeProcedure(String procedure, Object[] parameters, Class[] clazzs);
    T find(Class clazz, List<ParametrosWeb> parametrosWeb);
    List<T> findAll(Class clazz, List<ParametrosWeb> parametrosWeb);
    List<T> findLimit(Class clazz, List<ParametrosWeb> parametrosWeb, Integer limit);
    List<T> findPagination(Class clazz, List<ParametrosWeb> parametrosWeb, Paginator paginator);
    Connection getConnection();
    T getObj();
    T refresh(T obj);
    void save(T obj);

}

Ai tem a última classe que é responsável por implementar o JPA: JPAGenericDao

Espero ter ajudado