Generic DAO with Hibernate

import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.util.Collection;
import java.util.List;

import org.apache.log4j.Logger;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.classic.Session;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

/**
* Dao generico que contiene las operasiones basicas y que regula el
* comportamiento de los metodos.
*
* @author Juan Antonio Ramirez Orduna
* @version 1.0
* @T Es la clase que mapea ORM.
* @ID Es el ID de la tabla mapeada.
*
*/
@SuppressWarnings("unchecked")
public class GenericDAO extends
HibernateDaoSupport {
private static final Logger log = Logger
.getLogger(SevenBaseHibernateDao.class);
private Class persistentClass = getDomainClass();

public void setSessionFactoryHibernate(SessionFactory sessionFactory) {
super.setSessionFactory(sessionFactory);
}

/**
* Constructor de la clase
*/
public GenericDAO() {
/*
* ParameterizedType thisType = (ParameterizedType) getClass()
* .getGenericSuperclass(); setPersistentClass((Class)
* thisType.getActualTypeArguments()[0]);
*/

}

/**
* Realiza una busqueda en la base de datos por ID.
*
* @param id
* ID de la tabla en la que se va a realizar la busqueda.
* @return Regresa un objeto encontrado del tipo T.
*/
public T findById(ID id) {
if (log.isDebugEnabled()) {
log.debug("getting " + getClassName() + " instance with id: " + id);
}
T entity;
entity = (T) getHibernateTemplate().get(getPersistentClass(), id);
return entity;
}

/**
* Busqueda que regresa todos los registros de la T.
*
* @return Regresa una lista con todos los tegistros de la tabla T.
*/
public List findAll() {
if (log.isDebugEnabled()) {
log.debug("finding " + getClassName() + " instance by example");
}
return getHibernateTemplate().find("from " + getClassName());
}


public List getByListId(String lista) {
if (log.isDebugEnabled()) {
log.debug("finding " + getClassName() + " instance by example");
}





if(lista==""||lista==null){
//return getHibernateTemplate().find("from " + getClassName());
return null;
}else{
return getHibernateTemplate().find("from " + getClassName() + " where id in ("+lista+"))");
}

}



public List getByListIdNotIn(String lista) {
if (log.isDebugEnabled()) {
log.debug("finding " + getClassName() + " instance by example");
}

if(lista==""||lista==null){
//return getHibernateTemplate().find("from " + getClassName());
return null;
}else{
return getHibernateTemplate().find("from " + getClassName() + " where id not in ("+lista+"))");
}

}



/**
* Obtiene el valor de la variable referencia persistenClass.
*
* @return Regresa la referencia a la que apunta persistenClass.
*/
public Class getPersistentClass() {
return persistentClass;
}

protected Class getDomainClass() {
if (persistentClass == null) {
ParameterizedType thisType = (ParameterizedType) getClass()
.getGenericSuperclass();
persistentClass = (Class) thisType.getActualTypeArguments()[0];
}
return persistentClass;
}

/**
* Aigna la referencia a la variable referencia persistenClass.
*
* @param persistentClass
* Referencia que se le va a asignar a la variable
* persistenClass.
*/
public void setPersistentClass(Class persistentClass) {
this.persistentClass = persistentClass;
}

/**
* Obtiene el nombre del tipo de la variable persistentClass.
*
* @return Regresa una cadena con el nombre del tipo de la variable
* persistentClass.
*/
private String getClassName() {
return persistentClass.getName();
}

/**
* Guarda el objeto pasado como parametro en la tabla que coincide con T.
*
* @param transientInstance
* Objeto que contiene los valores.
*/
public void save(T transientInstance) {
if (log.isDebugEnabled()) {
log.debug("saving " + getClassName() + " instance");
}
getHibernateTemplate().save(transientInstance);

if (log.isDebugEnabled()) {
log.debug("save successful");
}
}

/**
* Guarda o actualiza el objeto pasado como parametro en la tabla que
* coincide con T.
*
* @param transientInstance
* Objeto que contiene los valores.
*/
public void saveOrUpdate(T transientInstance) {
if (log.isDebugEnabled()) {
log.debug("saving " + getClassName() + " instance");
}

getHibernateTemplate().saveOrUpdate(transientInstance);
if (log.isDebugEnabled()) {
log.debug("save successful");
}
}

/**
* Elimina el objeto pasado como parametro de la tabla que coincide con T.
*
* @param persistentInstance
* Objeto que contiene el registro a ser eliminado.
*/
public void delete(T persistentInstance) {
if (log.isDebugEnabled()) {
log.debug("deleting " + getClassName() + " instance");
}
getHibernateTemplate().delete(persistentInstance);
if (log.isDebugEnabled()) {
log.debug("delete successful");
}
}

/**
* Actualiza el objeto pasado como parametro en la tabla que coincide con T.
*
* @param transientInstance
* Objeto que contiene los valores.
*/
public void update(T transientInstance) {
if (log.isDebugEnabled()) {
log.debug("updating " + getClassName() + " instance");
}
getHibernateTemplate().update(transientInstance);

if (log.isDebugEnabled()) {
log.debug("update successful");
}
}

/**
* Perzonalizado Guarda o actualiza las entidades pasado como parametro en
* la tabla que coincide con T. Todas las entidades son persistidas dentro
* de una misma transaccion.
*
* @param transientInstances
* Objetos que contienen los valores.
*/
public boolean insertBachTransac(Collection transientInstances) {
Session session = getSessionFactory().openSession();
Transaction tx = session.beginTransaction();
System.out.println("Size bach >>" + transientInstances.size());
boolean transac = Boolean.TRUE;
int i = 0;
for (T persistEntity: transientInstances) {
try {
session.saveOrUpdate(persistEntity);

} catch (Exception e) {
e.printStackTrace();
transac = Boolean.FALSE;
tx.rollback();
}
i++;

}
if (transac) {
tx.commit();
}
return transac;

}
public void merge(T transientEntity) {
getHibernateTemplate().merge(transientEntity);
}




}