public class UserDAO extends AbstractDataAccessObject<User> {

  public UserDAO() {
    super(User.class);
  }

  public User getByName(String name) {
    User example = new User(name, null);
    Collection<User> users = getByExample(example);
    if (users.size() == 0) {
      return null;
    }
    if (users.size() > 1) {
      throw new IllegalStateException("More than one user with name \""
          + name + "\" found in database.");
    }
    return users.iterator().next();
  }

}

import java.util.Collection;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.LockMode;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.criterion.Example;

/**
* An abstract and generic DAO using Hibernate.
* <p>
* Extend this class to make use of it.
* </p>
* @author Christian Stein
*/
public abstract class AbstractDataAccessObject<E> {

  protected final Class<E> entityClass;

  protected AbstractDataAccessObject(Class<E> entityClass) {
    this.entityClass = entityClass;
  }

  public Collection<E> getAll() throws HibernateException {
    Session session = HibernateUtil.getSession();
    return session.createCriteria(entityClass).list();
  }

  public int getAllSize() throws HibernateException {
    return getCount();
  }

  public Collection<E> getByExample(E entity) throws HibernateException {
    Session session = HibernateUtil.getSession();
    Criteria criteria = session.createCriteria(entityClass);
    criteria.add(Example.create(entity));
    return (Collection<E>) criteria.list();
  }

  public E getById(Long id) throws HibernateException {
    Session session = HibernateUtil.getSession();
    return (E) session.get(entityClass, id, LockMode.NONE);
  }

  public E getById(Long id, LockMode lockMode) throws HibernateException {
    Session session = HibernateUtil.getSession();
    return (E) session.get(entityClass, id, lockMode);
  }

  public int getCount() throws HibernateException {
    Session session = HibernateUtil.getSession();
    String tableName = entityClass.getSimpleName();
    Query query = session.createQuery("select count(*) from " + tableName); // not very generic... needs fix!
    int count = ((Integer) query.uniqueResult()).intValue();
    return count;
  }

  public E loadById(Long id) throws HibernateException {
    Session session = HibernateUtil.getSession();
    return (E) session.load(entityClass, id, LockMode.NONE);
  }

  public E loadById(Long id, LockMode lockMode) throws HibernateException {
    Session session = HibernateUtil.getSession();
    return (E) session.load(entityClass, id, lockMode);
  }

  public void makePersistent(boolean flush, Collection<E> es)
      throws HibernateException {
    Session session = HibernateUtil.getSession();
    for (E e : es) {
      session.persist(e);
    }
    if (flush) {
      session.flush();
    }
  }

  public void makePersistent(boolean flush, E... es)
      throws HibernateException {
    Session session = HibernateUtil.getSession();
    for (E e : es) {
      session.persist(e);
    }
    if (flush) {
      session.flush();
    }
  }

  public void makePersistent(Collection<E> es) throws HibernateException {
    makePersistent(false, es);
  }

  public void makePersistent(E... es) throws HibernateException {
    makePersistent(false, es);
  }

  public void makeTransient(boolean flush, Collection<E> es)
      throws HibernateException {
    Session session = HibernateUtil.getSession();
    for (E e : es) {
      session.delete(e);
    }
    if (flush) {
      session.flush();
    }
  }

  public void makeTransient(boolean flush, E... es)
      throws HibernateException {
    Session session = HibernateUtil.getSession();
    for (E e : es) {
      session.delete(e);
    }
    if (flush) {
      session.flush();
    }
  }

  public void makeTransient(Collection<E> es) throws HibernateException {
    makeTransient(false, es);
  }

  public void makeTransient(E... es) throws HibernateException {
    makeTransient(false, es);
  }

}

public class CategoryDAO extends GenericDAO<Category, Long> {
  public CategoryDAO() {
    super(Category.class, Long.class);
  }

public List<Category> getRootCategories() {
    return get(Expression.isNull("parentCategory"));
  }
}

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.LockMode;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.criterion.Criterion;

public abstract class GenericDAO<T extends Serializable, K extends Serializable> {

   private Class persistentClass;
   private Class idClass;

   private static Log log = LogFactory.getLog(GenericDAO.class);

   protected Session currentSession() {
      return HibernateUtil.currentSession();
   }

   /**
    * Constructor
    *
    * @param persistentClass
    * @param idClass
    */
   public GenericDAO(Class persistentClass, Class idClass) {
      this.persistentClass = persistentClass;
      this.idClass = idClass;
      currentSession().beginTransaction();
   }

   /**
    * @return Returns the idClass.
    */
   public Class getIdClass() {
      return idClass;
   }

   /**
    * @return Returns the persistentClass.
    */
   public Class getPersistentClass() {
      return persistentClass;
   }

   /**
    * Persist entity in database
    *
    * @param entity
    */
   public void persist(T entity) {
      Session session = null;

      try {
         session = currentSession();
         session.persist(entity);
      } catch (HibernateException ex) {
         log.error(ex.getMessages());
         throw new DaoException(ex);
      }
   }

   /**
    * Save entity in database
    *
    * @param entity
    */
   public void save(T entity) {
      Session session = null;

      try {
         session = currentSession();
         session.save(entity);
      } catch (HibernateException ex) {
         log.error(ex.getMessages());
         throw new DaoException(ex);
      }
   }

   /**
    * Save or update entity in database
    *
    * @param entity
    */
   public void saveOrUpdate(T entity) {
      Session session = null;

      try {
         session = currentSession();
         session.saveOrUpdate(entity);
      } catch (HibernateException ex) {
         log.error(ex.getMessages());
         throw new DaoException(ex);
      }
   }

   /**
    * Delete entity in database
    *
    * @param entity
    */
   public void delete(T entity) {
      Session session = null;

      try {
         session = currentSession();
         session.delete(entity);
      } catch (HibernateException ex) {
         log.error(ex.getMessages());
         throw new DaoException(ex);
      }
   }

   /**
    * Delete all entities
    */
   public void deleteAll() {
      Session session = null;

      try {
         session = currentSession();
         session.delete("from " + getPersistentClass().getName() + " x");

      } catch (HibernateException ex) {
         log.error(ex.getMessages());
         throw new DaoException(ex);
      }
   }

   /**
    * Find entity by ID
    *
    * @param id
    * @param lock
    * @return entity
    */
   @SuppressWarnings("unchecked")
   public T getById(K id, boolean lock) {
      T entity = null;

      try {
         if (lock) {
            entity = (T) currentSession().get(getPersistentClass(), id,
                  LockMode.UPGRADE);
         } else {
            entity = (T) currentSession().get(getPersistentClass(), id);
         }
      } catch (HibernateException ex) {
         log.error(ex.getMessages());
         throw new DaoException(ex);
      }

      return entity;
   }

   /**
    * Get all
    *
    * @return list of entities
    */
   @SuppressWarnings("unchecked")
   public List<T> getAll() {
      List<T> list = null;
      Session session = null;
      Query query = null;

      try {
         session = currentSession();
         query = session.createQuery("from "
               + getPersistentClass().getName() + " x");
         list = query.list();
      } catch (HibernateException ex) {
         throw new DaoException(ex);
      }

      return list;
   }

   /**
    * This is the cool finder method
    *
    * @param criterion
    * @return list of entities
    */
   @SuppressWarnings("unchecked")
   public List<T> get(Criterion... criterion) {
      List<T> list = null;

      Criteria criteria = currentSession().createCriteria(
            getPersistentClass());

      try {
         for (Criterion c : criterion) {
            criteria.add(c);
         }

         list = new ArrayList<T>(criteria.list());
      } catch (HibernateException ex) {
         throw new DaoException(ex);
      }

      return list;
   }
}

public class ItemDAO extends GenericDAO<Item, Long> {
   public ItemDAO() {
      super(Item.class, Long.class);
   }
   
   public Bid getMaxBid(Long itemId) {
      //TODO ...
      return null;
   }

   public Bid getMinBid(Long itemId) {
      //TODO ...
      return null;
   }
}


public class UserDAO extends GenericDAO<User, Long> {
   public UserDAO() {
      super(User.class, Long.class);
   }
}

...

public List<T> get(Criterion... criterion)
method in GenericHibernateDAO.

    public List<Category> getRootCategories() {
        return get(Expression.isNull("parentCategory"));
    }

public Class getPersistentClass()

public Class<T> getPersistentClass()