一个强大的父类：BaseDao

import static com.xxx.travel.common.utils.ClassUtils.getActualTypeArguments;
import static com.xxx.travel.common.utils.ClassUtils.getUUField;

import java.lang.reflect.Field;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.transform.Transformers;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.support.DaoSupport;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.HibernateTemplate;

import com.xxx.travel.common.base.bo.Page;
import com.xxx.travel.common.base.dao.interfaces.BaseDaoInterface;

/**
 * 数据层的基类
 * 
 * @author IXR
 * @param <M>
 *          模型对象
 */
public class BaseDao<M> extends DaoSupport implements BaseDaoInterface<M> {
  @Autowired
  private SessionFactory sessionFactory;
  private HibernateTemplate hibernateTemplate;

  /**
   * 获取数据库操作模版
   */
  public final HibernateTemplate getHibernateTemplate() {
    return this.hibernateTemplate;
  }

  /** 初始化hibernateTemplate对象 */
  protected void checkDaoConfig() throws IllegalArgumentException {
    hibernateTemplate = new HibernateTemplate(sessionFactory);
  }

  /** 获取SessionFactory工厂 */
  protected SessionFactory getSessionFactory() {
    return sessionFactory;
  }

  /**
   * 保存数据
   * 
   * @param m
   *          模型对象
   * @author IXR
   */
  public void save(M m) {
    getHibernateTemplate().save(m);
  }

  /**
   * 加载数据
   * 
   * @param m
   *          模型对象
   * @author IXR
   */
  public void load(M m) {
    try {
      Field field = getUUField(getModelClass());
      field.setAccessible(true);
      getHibernateTemplate().load(m, field.get(m).toString());
    } catch (Exception e) {
      // TODO : ERROR
      logger.error(e);
    }
  }

  /**
   * 删除对象
   * 
   * @param m
   *          模型对象
   * @author IXR
   */
  public void delete(M m) {
    getHibernateTemplate().delete(m);
  }

  /**
   * 更新数据
   * 
   * @param m
   *          模型对象
   * @author IXR
   */
  public void update(M m) {
    getHibernateTemplate().update(m);
  }

  /**
   * 根据条件查询数量
   * 
   * @return Long
   * @author IXR
   */
  public Long findExampleCount(M m) {
    ModuleExample example = new ModuleExample(m);
    return (Long) getObject("select count(*) " + example.getHql(), example.getParameters());
  }

  /**
   * 保存集合
   * 
   * @param mList
   *          对象集合
   */
  public void saveAll(List<M> mList) {
    Session session = sessionFactory.openSession();
    for (M m : mList) {
      session.save(m);
    }
    session.flush();
    session.close();
  }

  /**
   * 执行无返回结果语句
   * 
   * @param hql
   *          执行语句
   * @param parameters
   *          参数列表
   */
  public void execute(final String hql, final Map<String, Object> parameters) {
    getHibernateTemplate().execute(new HibernateCallback() {
      public Object doInHibernate(Session session) throws HibernateException, SQLException {
        Query query = session.createQuery(hql);
        if (parameters != null && parameters.size() > 0) {
          for (String key : parameters.keySet()) {
            query.setParameter(key, parameters.get(key));
          }
        }
        return query.executeUpdate();
      }
    });
  }

  /**
   * 根据条件分页查询数据
   * 
   * @param page
   *          分页信息
   * @return List<M>
   * @author IXR
   */
  @SuppressWarnings("unchecked")
  public List<M> findExampleByPage(Page<M> page) {
    ModuleExample example = new ModuleExample(page.getModel());
    return (List<M>) findExampleByPage(example.getHql(), example.getParameters(), page.getStartRow(), page.getPageSize());
  }

  /**
   * 根据条件查询数据
   * 
   * @param M
   *          模型信息
   * @return List<M>
   * @author IXR
   */
  public List<M> findExample(M m) {
    ModuleExample example = new ModuleExample(m);
    return findByParameters(example.getHql(), example.getParameters());
  }

  /**
   * 分页查询数据
   * 
   * @param hql
   *          查询语句
   * @param parameters
   *          查询条件
   * @param firstResult
   *          开始条数
   * @param maxResults
   *          查询条数
   * @return
   */
  public List<?> findExampleByPage(final String hql, final Map<String, Object> parameters, final int firstResult, final int maxResults) {
    return getHibernateTemplate().executeFind(new HibernateCallback() {
      public Object doInHibernate(Session session) throws HibernateException, SQLException {
        Query query = session.createQuery(hql);
        if (parameters != null && parameters.size() > 0) {
          for (String key : parameters.keySet()) {
            query.setParameter(key, parameters.get(key));
          }
        }
        query.setFirstResult(firstResult);
        query.setMaxResults(maxResults);
        return query.list();
      }
    });
  }

  /**
   * 返回单一对象方法<br>
   * 如count、sum等<br>
   * 多用于分页总数统计<br>
   * 
   * @param hql
   *          查询语句
   * @param parameters
   *          查询参数
   * @return Object
   * @author IXR
   */
  protected Object getObject(final String hql, final Map<String, Object> parameters) {
    return getHibernateTemplate().execute(new HibernateCallback() {
      public Object doInHibernate(Session session) throws HibernateException, SQLException {
        Query query = session.createQuery(hql);
        if (parameters != null && parameters.size() > 0) {
          for (String key : parameters.keySet()) {
            query.setParameter(key, parameters.get(key));
          }
        }
        List<?> result = query.list();
        return result.size() > 0 ? result.get(0) : null;
      }
    });
  }

  /**
   * 根据M类型来算出带命名空间
   * 
   * @return 返回类型为 Class<M>
   * @author IXR
   */
  @SuppressWarnings("unchecked")
  protected Class<M> getModelClass() {
    return (Class<M>) getActualTypeArguments(this.getClass())[0];
  }

  /**
   * 根据参数查询列表
   * 
   * @param hql
   *          查询语句
   * @param parameters
   *          查询参数
   * @return 集合信息
   */
  protected List<?> findByParametersEx(String hql, Map<String, Object> parameters) {
    String[] keys = new String[parameters.size()];
    Object[] values = new Object[parameters.size()];
    Iterator<String> keyIterator = parameters.keySet().iterator();
    for (int i = 0; i < parameters.size(); i++) {
      keys[i] = keyIterator.next();
      values[i] = parameters.get(keys[i]);
    }
    return getHibernateTemplate().findByNamedParam(hql, keys, values);
  }

  /**
   * 根据参数查询列表
   * 
   * @param hql
   *          查询语句
   * @param parameters
   *          查询参数
   * @param boClass
   *          返回对象的类型
   * @return
   * @return 集合信息
   */
  @SuppressWarnings("unchecked")
  protected <T> List<T> findByParametersEx(final String hql, final Map<String, Object> parameters, final Class<T> boClass) {
    return (List<T>) getHibernateTemplate().execute(new HibernateCallback() {
      public Object doInHibernate(Session session) throws HibernateException, SQLException {
        Query query = session.createQuery(hql);
        if (parameters != null && parameters.size() > 0) {
          for (String key : parameters.keySet()) {
            query.setParameter(key, parameters.get(key));
          }
        }
        return query.setResultTransformer(Transformers.aliasToBean(boClass)).list();
      }
    });
  }

  /**
   * 根据参数查询列表
   * 
   * @param hql
   *          查询语句
   * @param parameters
   *          查询参数
   * @return 集合信息
   */
  @SuppressWarnings("unchecked")
  protected List<M> findByParameters(String hql, Map<String, Object> parameters) {
    return (List<M>) findByParametersEx(hql, parameters);
  }
  protected ModuleExample newInstanceModuleExample(M m) {
    return new ModuleExample(m);
  }
  /**
   * 模糊查询
   */
  protected class ModuleExample{
      public ModuleExample(M m) {
      Map<String, Object> parameters = new HashMap<String, Object>();
      StringBuffer hql = new StringBuffer();
      hql.append("from ");
      hql.append(getModelClass().getName());
      if (m == null) {
        try {
          m = getModelClass().newInstance();
        } catch (Exception e) {
          // TODO : ERROR
          logger.error(e);
        }
      } else {
        hql.append(" where ");
        StringBuffer where = new StringBuffer();
        where.append("1=1");
        Field[] fields = getModelClass().getDeclaredFields();
        for (Field field : fields) {
          if(field.getName().equals("serialVersionUID")){
            continue;
          }
          field.setAccessible(true);
          Object obj = null;
          try {
            obj = field.get(m);
          } catch (Exception e) {
            // TODO : ERROR
            logger.error(e);
          }
          if (obj != null && (!field.getType().equals(String.class) || !"".equals(obj))) {
            where.append(" and ");
            where.append(field.getName());
            if(obj.toString().startsWith("=")) {
        	where.append(" = :");
            }else if(obj.toString().startsWith("!")) {
        	where.append(" != :");
        	obj = obj.toString().substring(1);
            }else {
        	where.append(" like :");
            }
            where.append(field.getName());
            parameters.put(field.getName(), obj);
          }
        }
        this.where = where.toString();
        hql.append(this.where);
      }
      this.hql = hql.toString();
      this.parameters = parameters;
    }
    private String where;
    public String getWhere(){
      return where;
    }
    public String getWhere(String prefix){
      return where.replaceAll("and ", "and " + prefix + ".");
    }
    private String hql;
    private Map<String, Object> parameters = new HashMap<String, Object>();
    public String getHql() {
      return hql;
    }
    public Map<String, Object> getParameters() {
      return parameters;
    }
  }
}