Hibernate (Generico)

Gente estou a desenvolver um projeto e gostaria da colaboração de vocês…
desenvolvi um hibernate Generico com ajuda de alguns tutoriais…e adicionei outras funcionalidades…
ele ta rodando e faz exatamente o que eu quero, porem gostaria de saber se esta dentro dos padroes…
ainda falta agregar outras funcionalidades… mas analisem por enquanto o que eu ja tenho

Segue o codigo :

DaoGeneric : interface

[code]package uai.base;
import java.io.Serializable;
import java.util.List;

public interface DaoGeneric<T,ID extends Serializable> {
//retorna a classe na qual esta trabalhando
public Class getObjectClass();
//adiciona o objeto no BD
public boolean add(T object);
//atualiza o objeto no BD
public boolean update(T obj);
//deleta o objeto no BD
public boolean delete(T obj);
//adiciona ou atualiza o objeto no BD caso ja exista
public boolean addOrUpdate(T obj);
//executa uma instrucao hql e retorna lista
public List query(String sql);
//lista todos de uma determinada classe
public List listAll();
//lista todos (paginacao)
public List listAll(int first,int max );
//listagem passando um arary de fields {“nome;alexandre”,“email;teste”}e um array de ordens{“email;desc;”,“telefone;asc”}
//isto sera util para quando eu quiser pesquisar por mais de um campo…
public List listByField(String[] fields,String[] orders) ;
//a mesma do metodo com paginacao
public List listByField(String[] fields,String[] orders,int first,int max);
//objeto corrente
public T get(ID id);
//retorna uma lista de acordo com parametros da url
public List listByRequest(String field,String fieldValue,String fieldOrd,String ord);

}[/code]

//aqui meu generico implementado

[code]/*

  • DaoGenericImpl.java
  • Created on 18 de Abril de 2008, 10:16
  • To change this template, choose Tools | Template Manager
  • and open the template in the editor.
    */

package uai.base;

import java.io.Serializable;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.Session;

import org.hibernate.Transaction;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import uai.factory.HibernateUtil;

/**
*

  • @author Alexandre
    */
    public abstract class DaoGenericImpl<T,ID extends Serializable> implements DaoGeneric<T,ID> {

    final int ADD =1;
    final int DELETE =2;
    final int UPDATE =3;
    final int ADD_UPDATE =4;
    private final Class objectClass;

//construtor … ja pega a qual Classe estaremos nos referindo
public DaoGenericImpl(final Class objectClass) {
this.objectClass = objectClass;
}
//manipulara os metodos add,insert,update,delete,salvar ou atualizar
private boolean manipular(T obj,int operacao) {
try {
Session session = HibernateUtil.getSession();
Transaction tx = session.beginTransaction();
switch (operacao) {
case ADD: session.save(obj); break;
case DELETE: session.delete(obj); break;
case UPDATE: session.update(obj);break;
case ADD_UPDATE: session.saveOrUpdate(obj);break;
}

        tx.commit();
        session.close();
        return true;
    } catch (Exception e) {
        System.out.println("ocorreu um erro na opcao  "+operacao+""+e.getMessage());
        return false;
    }
}
public boolean add(T obj) {
    return manipular(obj,ADD);
    
}
public boolean update(T obj) {
    return manipular(obj,UPDATE);
    
}
public boolean delete(T obj) {
    return  manipular(obj,DELETE);
    
}
public boolean addOrUpdate(T obj) {
    return manipular(obj,ADD_UPDATE);
    
}
public  List listAll() {
    try {
        return HibernateUtil.getSession().createCriteria(getObjectClass()).list();
    } catch (Exception e) {
        System.out.println("erro ao retornar lista completa"+e.getMessage());
        return null;
    }
    
}
public  List listAll(int first,int max ) {
    try {
        Criteria criteria=HibernateUtil.getSession().createCriteria(getObjectClass());
        if (first != 0) {
            criteria.setFirstResult(first);
        }
        if (max != 0) {
            criteria.setMaxResults(max);
        }
        return criteria.list();
    } catch (Exception e) {
        System.out.println("erro ao retornar lista completa"+e.getMessage());
        return null;
    }
    
}

//Por padrao quando quiser listar por campo e ordenar. terei os parametros padrao {field,fieldValue,fieldOrder,Order}
//recebe um array de campos com seus valores e ordens ex: {“nome;alexandre”,“email:alex.”} ordens {“email;asc”}
//ai monta uma sql mais ou menos assim “select * from usuario where nome like’alexandre%’ and email like alex% order by email asc”
public List listByField(String[] fields,String[] orders) {
int qtde;
String[] pos={""};
try {
String resp=“N”;
int p=0;
Criteria criteria = HibernateUtil.getSession().createCriteria(getObjectClass());

        for(int j=0;j<fields.length;j++) {
            pos =fields[j].split(";");
            qtde = pos.length;
            if(qtde==2) {
                try {
                    p  =  Integer.parseInt(pos[1]);
                    resp="S";
                } catch (Exception e) {
                    resp="N";
                    
                }
                 
                if(pos[0].toUpperCase().equals("TODOS")==false) {
                   System.out.println("entrou aqui ta doidio->"+pos[0].toUpperCase());
                    if(resp=="N")
                        criteria = addSearchByfield(criteria,pos[0],pos[1]);
                    else if(resp=="S")
                        criteria = addSearchByfield(criteria,pos[0],p);
                }
            }
            
        }
       
        for(int j=0;j<orders.length;j++) {
           String[] pos2 =orders[j].split(";");
           int qtde2 = pos2.length;
            if(qtde2==2) {
                if(pos2[0].length()>0 && pos2[1].length()>0) {
                    criteria= addOrder(criteria,pos2[0],pos2[1]);
                }
            }
        }
        
        return  criteria.list();
        
    } catch (Exception e) {
        System.out.println("erro ao retornar lista"+e.getMessage());
        return null;
    }
    
}
public  List listByField(String[] fields,String[] orders,int first,int max) {
    int qtde;
    String[] pos={""};
    try {
        String resp="N";
        int p=0;
        Criteria criteria = HibernateUtil.getSession().createCriteria(getObjectClass());
        for(int j=0;j<fields.length;j++) {
            pos =fields[j].split(";");
            qtde = pos.length;
            if(qtde==2) {
                try {
                    p  =  Integer.parseInt(pos[1]);
                    resp="S";
                } catch (Exception e) {
                    resp="N";
                    
                }
                if(resp=="N")
                    criteria = addSearchByfield(criteria,pos[0],pos[1]);
                else if(resp=="S")
                    criteria = addSearchByfield(criteria,pos[0],p);
                
            }
            
        }
        
        for(int j=0;j<orders.length;j++) {
            pos =orders[j].split(";");
            qtde = pos.length;
            if(qtde==2) {
                if(pos[0].length()>0 && pos[1].length()>0) {
                    criteria= addOrder(criteria,pos[0],pos[1]);
                }
            }
        }
        if (first != 0) {
            criteria.setFirstResult(first);
        }
        if (max != 0) {
            criteria.setMaxResults(max);
        }
        
        
        return  criteria.list();
        
    } catch (Exception e) {
        System.out.println("erro ao retornar lista"+e.getMessage());
        return null;
    }
    
}

//retorna um obejto
public T get(ID id) {
try {
Session session = HibernateUtil.getSession();
return (T)session.get(getObjectClass(), id);

    } catch (Exception ex) {
        //TOBaseHibernateDao.logger.error(ex);
        // throw convertHibernateAccessException(ex);
        System.out.println("erro ao recuperar objeto");
        return null;
    }
}

//efetua uma consulta hql
public List query(String sql) {
try {
Query select = HibernateUtil.getSession().createQuery(sql);
return select.list();
} catch (Exception e) {
System.out.println(“sql ta errada olha so o erro->”+e.getMessage());
return null;
}

}
public Class getObjectClass() {
    return objectClass;
}
//Criteria,Nome do campo,Valor do campo -> adiciona a query "and field like value"
private  Criteria addSearchByfield(Criteria criteria,String field,String value) {
    criteria.add(Restrictions.like(field,value));
    return criteria;
}
//Criteria,Nome do campo,Valor do campo -> adiciona a query "and field = value"
private  Criteria addSearchByfield(Criteria criteria,String field,int value) {
    criteria.add(Restrictions.eq(field,value));
    return criteria;
}
//Criteria, nome do campo, tipo da ordenacao{ASC,DESC}
private  Criteria addOrder(Criteria criteria,String field,String ord ) {
    if(ord.toUpperCase().equals("ASC"))
        criteria.addOrder(Order.asc(field));
    if(ord.toUpperCase().equals("DESC"))
        criteria.addOrder(Order.desc(field));
    
    return criteria;
}
public List listByRequest(String field,String fieldValue,String fieldOrd,String ord)  {
    //HttpServletRequest request = ServletActionContext.getRequest();
    System.out.println("o parametro passado: field:->"+field);
    String resp;
    String[] fields=null;
    System.out.println("o valor do campo eh"+fieldValue);
    // se o campo for inteiro
    
    try {
        Integer.parseInt(fieldValue);
        String[] fields2={field+";"+fieldValue};
        fields=fields2;
        // se o campo for string, "LIKE"
    } catch (Exception e) {
        
        String[] fields2={field+";"+fieldValue+"%"};
        fields=fields2;
        System.out.println("\neh string");
        
    }//finally {
    String[] orders={fieldOrd+";"+ord};
    
    return this.listByField(fields,orders);
    
    // return null;
    //  }
    
    
}

}
[/code]

Sinceramente (na minha opnião) esta totalmente fora de qualquer padrão. Por que:

1 - A classe tem muita responsabilidade.
2 - Esse excesso de responsabilidade acontece por preguiça de escrever DAOs específicos para seus modelos.
3 - A manutenção do código esta com nível muito complicado, além de afetar o sistema INTEIRO.
3.1 - Uma troca de método e pronto, lá se foi seu sistema.

Resumindo, se vc quer um DAO genérico crie uma classe com um CRUD


public Class Hibernate&lt;T&gt;{

//Atributo
private Session sessao;

public Hibernate(Session sessao){
//Injeção de Dependência
this.sessao = sessao;
}

public void save(Object o){}

public void update(Object o){}

public void remove(Object o){}

E quando vc precisar de alguma coisa além desses métodos vc cria um DAO novo extendendo a sua DAO implementada. Pra mim isso estaria dentro dos padrões…

É só uma opnião minha ok…

[]'s e Boa Sorte no Projeto

VAleu ! Obrigado pela resposta…

Eu nao concordo com vc , ao dizer “preguica de fazer daos”.
Nao e exatemente isto. Todos os metodos ali implementados
sao comuns a todas as classes.
Por isso eu coloquei elas…

a ideia e simplificar .
Ex: o metodo listAll();

me retorna uma lista de objetos da classe passada por parametros…
ai se eu fosse seguindo sua opiniao.
teria q fazer um listAll para cada Classe…Se posso fazer um que funciona para todos… para que fazer um para cada um?..
Os Daos especificos serao feitos quando eu necessitar para fins especificos

Porque nao usar Generic Data Access Objects?