DAO Genérico Hibernate

2 respostas
R

Procurei pelo google sobre esse assunto, mas não consegui entender muito bem o conceito, bem olhei documentação oficial do hibernate, blog do urubatan, blog da caelum,...
Enfim, criei uma interface com os métodos que eu uso normalmente:

public interface GenericDAO<T, ID extends Serializable> {

    String salvar();

    String editar();

    String excluir();

    T getObjeto(); //pega objeto para editar ou excluir

    List<T> listaPorNome();

    List<T> listaTodos();
}

Agora no dao, tenho bastante dúvida de como implementar esses métodos, por exemplo, o método save que tem no exemplo do blog do urubatan:

public T save(final T object) {
        try {
            final Session s = getSession(false);
            s.save(object);
            s.flush();
            return object;
        } catch (final HibernateException ex) {
            TOBaseHibernateDao.logger.error(ex);
            throw convertHibernateAccessException(ex);
        }
    }

1)Por que essa linha? final Session s = getSession(false); //pq false?
E por que eu retorno o objeto, se ele já foi salvo?Eu vou retornar ele null?

E esse método que tem na documentação do hibernate:

@SuppressWarnings("unchecked")
    protected List<T> findByCriteria(Criterion... criterion) {
        Criteria crit = getSession().createCriteria(getPersistentClass());
        for (Criterion c : criterion) {
            crit.add(c);
        }
        return crit.list();
   }

2)O que ele faz?Ele busca todos resultados de um objeto?

3)Por exemplo, no meu CargoBean tenho um método que pega o cargo para editar ou excluir(uso jsf):

public Cargo getCargoParaEditarExcluir() {
        Cargo cargo = (Cargo) model.getRowData();
        return cargo;
    }

3)No dao eu troco onde tem Cargo por Generic(T)? Ou tenho que fazer mais alguma coisa?

Creio que sejam dicas básicas, quem puder me ajudar agradeço :wink:

2 Respostas

R

Ainda nem foram respondidas as duvidas do post acima, mas ja me surgiram outras ;D

Achei um outro site, e fiz desse jeito:

Interface GenericDAO (acima)
Classe Abstrata que implementa a interface

public class AbstractDAO implements GenericDAO {

    private Session session;
    private Transaction tx;

    public AbstractDAO() {
        HibernateFactory.buildIfNeeded();
    }

    public String salvar(Object obj) {
        try {
            startOperation();
            session.merge(obj);
            tx.commit();
            FacesUtils.mensInfo("Salvo com sucesso");

            return "sucesso";
        } catch (HibernateException e) {
            handleException(e);
        } finally {
            HibernateFactory.close(session);
        }

        return null;
    }

...

E dai vou criar um DAO para cada modelo, que vai extender essa classe abstrata:

public class CargoDAO extends AbstractDAO{

    public CargoDAO() {
        super();
    }

    public void salvar(Cargo cargo) throws DataAccessLayerException{
        super.salvar(cargo);  
    } 
...

E dai no MB chamo o dao:

/** 
     * Adiciona cargo
     */
    public String salvar() {
        dao.salvar(cargo);
        novoCargo();
        return "sucesso";
    }

Achei que são muitos arquivos, para fazer algo.Isso me traz algum beneficio ou estou fazendo errado?

WashingtonBotelho

Eu vou aprender Hibernate ainda, mas a linha:

Ele cria uma sessão, e caso ela já não exista ela também não será criada, que no caso é o false.
true a gente usa quando declaramos o objeto Session e em outra parte do código o declaramos, ai como ficamos ‘sem saber’ se já foi istânciado ou não a gente coloca true, caso não tenha sido istânciado ainda eu istâncio.
Mas como no caso ele já declara e já istância ela coloca falso, deve ser questão de performance, já que true é o padrão no qual teria de verificar se foi istânciado ou não, e tabém já deixa final, pois não irá mudar mesmo.

Espero ter ajudado ao menos um pouco… :wink:
Abraço…

Criado 15 de novembro de 2008
Ultima resposta 15 de nov. de 2008
Respostas 2
Participantes 2