学步园

优点：简单的和基础的CRUD功能可以很快实现，可以说是比较的“标准化”。维护起来也很容易。

缺点：性能没有保障。不支持特别复杂的CRUD。

可以适用的场景：小型Web项目

1.CrudDao完成最基本的增删改查

  包括增加一个对象create、根据主键获得对象get、更新一个持久化的对象update、逻辑删除一个对象remove、逻辑恢复一个对象recover、物理删除一个持久化的对象delete、更新属性（TODO，需要增加where限制）、更新属性update。

package cn.fansunion.hibernate;

import java.lang.reflect.ParameterizedType;
import java.util.Map;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;

import cn.fansunion.hibernate.constants.CommonConstants;
import cn.fansunion.hibernate.constants.StatusConstants;
import cn.fansunion.hibernate.sql.update.HqlUpdateBuilder;
import cn.fansunion.hibernate.util.Pair;

/**
 * Dao基类，完成最基本的增删改查操作。
 *
 * @author LeiWen@FansUnion.cn
 */
public class CrudDao<T> {

    /**
     * 表的实体类型
     */
    protected Class<T> modelClazz;

    @Autowired
    protected SessionFactory sessionFactory;

    public CrudDao() {
        this.modelClazz = (Class<T>) ((ParameterizedType) getClass()
                .getGenericSuperclass()).getActualTypeArguments()[0];
    }

    // //////////////////////////////////////////////////////
    // ///////////泛型方法-CRUD/////////////////////////
    // /////////////////////////////////////////////////////

    /**
     * 根据主键（唯一标志）查询一条记录
     *
     * @param id
     *            主键
     * @return 一条记录对应的实体对象
     */
    public T get(Integer id) {
        T entity = (T) getCurrentSession().get(modelClazz, id);
        return entity;
    }

    /**
     * 向数据库插入一条记录
     *
     * @param entity
     *            与数据库表对应的实体对象
     */
    public void create(T entity) {
        getCurrentSession().save(entity);
    }

    /**
     * 更新一条记录
     *
     * @param entity
     *            持久态的实体对象
     */
    public void update(T entity) {
        getCurrentSession().update(entity);
    }

    /**
     * 根据主键（唯一标志），逻辑删除一条记录
     *
     * @param id
     *            主键
     */
    public void remove(Integer id) {
        updateProperties(new Pair(CommonConstants.ID, id), new Pair(
                CommonConstants.IS_DELETED, StatusConstants.DELETED));
    }

    /**
     * 根据主键（唯一标志），恢复一条记录
     *
     * @param id
     *            主键
     */
    public void recover(Integer id) {
        updateProperties(new Pair(CommonConstants.ID, id), new Pair(
                CommonConstants.IS_DELETED, StatusConstants.NORMAL));
    }

    /**
     * 物理删除一条记录
     *
     * @param entity
     *            持久态的实体对象
     */
    public void delete(T entity) {
        getCurrentSession().delete(entity);

    }

    /**
     * 获取主数源
     */
    protected Session getCurrentSession() {
        return sessionFactory.getCurrentSession();

    }

    // ///////////////////////////////////////////////
    // /////根据属性更新(TODO 增加where限制)//////////
    // ///////////////////////////////////////////////
    /**
     * 根据1个属性更新(谨慎使用)
     *
     * @param key
     *            属性名称
     * @param value
     *            属性的值
     * @return 更新的记录数
     */
    public Integer updateProperty(String key, Object value) {
        HqlUpdateBuilder builder = new HqlUpdateBuilder();
        String hql = builder.param(key, value).toHql();
        return update(hql, key, value);
    }

    /**
     * 根据0个、1个或多个属性更新（强烈建议，至少使用2个键值对）
     */
    public Integer updateProperties(Pair... pair) {
        HqlUpdateBuilder builder = new HqlUpdateBuilder();
        String hql = builder.param(pair).toHql();
        return update(hql, pair);
    }

    /**
     * 根据多个键值对，更新记录
     */
    public Integer updateProperties(Map<String, Object> params) {
        HqlUpdateBuilder builder = new HqlUpdateBuilder();
        String hql = builder.param(params).toHql();
        return update(hql, params);
    }

    /**
     * 根据hql语句和键值对，更新记录
     *
     * @param hql
     *            hql语句
     * @param key
     *            属性名称
     * @param value
     *            属性的值
     * @return
     */
    public Integer update(String hql, String key, Object value) {
        Map<String, Object> params = createMap(key, value);
        return update(hql, params);
    }


    public Integer update(String hql, Pair... pair) {
        Map<String, Object> params = createMap(pair);
        return update(hql, params);
    }

    public Integer update(String hql, Map<String, Object> params) {
        Query query = createQuery(hql, params);
        return query.executeUpdate();
    }

    // ///////////////////////////////////////////////
    // ////////////创建Query对象/////////////////////////
    // ///////////////////////////////////////////////
    protected Query createQuery(String hql, Map<String, Object> params) {
        return DaoUtils.createQuery(getCurrentSession(), hql, params);
    }

    protected Query createQuery(String hql, String key, Object value) {
        return DaoUtils.createQuery(getCurrentSession(), hql, key, value);
    }

    protected Query createQuery(String hql) {
        return DaoUtils.createQuery(getCurrentSession(), hql);
    }

    protected Map<String, Object> createMap() {
        return DaoUtils.createMap();
    }

    protected Map<String, Object> createMap(String key, Object value) {
        return DaoUtils.createMap(key, value);
    }

    protected Map<String, Object> createMap(Pair... pair) {
        return DaoUtils.createMap(pair);

    }
}

2.BasicQueryUpdateDao完成几个较为通用的几个功能

  包括获取记录总数count、获取一个列表list、获得唯一结果unique。

package cn.fansunion.hibernate;

import java.util.List;
import java.util.Map;

import org.hibernate.Query;

import cn.fansunion.hibernate.util.EmptyUtils;
import cn.fansunion.hibernate.util.PageConstants;
import cn.fansunion.hibernate.util.PageUtils;
import cn.fansunion.hibernate.util.Pair;

/**
 * 完成基本的查询操作。
 *
 * @author LeiWen@FansUnion.cn
 */
public class BasicQueryUpdateDao<T> extends CrudDao<T> {

    public static final boolean NOT_PAGE = false;

    public static final boolean NEED_PAGE = true;
    
    // ///////////////////////////////////////////////
    // ////////////获取记录总数/////////////////////////
    // ///////////////////////////////////////////////
    public Integer count(String hql) {
        Query query = createQuery(hql);
        Integer count = doCount(query);
        return count;
    }

    public Integer count(String hql, String key, Object value) {
        Query query = createQuery(hql, key, value);
        Integer count = doCount(query);
        return count;
    }

    public Integer count(String hql, Pair... pair) {
        Map<String, Object> params = createMap(pair);
        return count(hql, params);

    }

    public Integer count(String hql, Map<String, Object> params) {
        Query query = createQuery(hql, params);
        Integer count = doCount(query);
        return count;
    }

    protected Integer doCount(Query query) {
        Integer count = 0;
        Object uniqueResult = query.uniqueResult();
        if (uniqueResult != null) {
            count = Integer.parseInt(uniqueResult.toString());
        }
        return count;
    }

    // ///////////////////////////////////////////////
    // ///////获取一个列表(不使用泛型 List<T>)/////////////////
    // ///////////////////////////////////////////////
    // 执行不带参数的hql查询，返回一个结果集List
    public List list(String hql, boolean needPage) {
        return list(hql, needPage);
    }

    public List list(String hql, String key, Object value, boolean needPage) {
        Map<String, Object> params = createMap(key, value);
        return list(hql, params, needPage);
    }

    public List list(String hql, Map<String, Object> params, boolean needPage) {
        if (needPage) {
            PageUtils.fillDefaultPageParams(params);
        }
        List list = list(hql, params, needPage);
        return list;
    }

    // 执行带参数并且含有分页的hql查询
    private List doList(String hql, Map<String, Object> params) {
        Query query = createQuery(hql, params);
        fillPageParams(query, params);
        List list = doQuery(query);
        return list;
    }

    /**
     * 向查询对象Query中设置分页参数
     *
     * @param query
     *            查询对象
     * @param params
     *            查询参数
     */
    private void fillPageParams(Query query, Map<String, Object> params) {
        Integer firstResult = (Integer) params.get(PageConstants.FIRST_RESULT);
        Integer maxResults = (Integer) params.get(PageConstants.MAX_RESULTS);
        if (firstResult > 0) {
            query.setFirstResult(firstResult);
        }

        if (maxResults > 0) {
            query.setMaxResults(maxResults);
        }
    }

    /**
     * 执行查询语句
     *
     * @param query
     *            查询对象
     * @return 查询结果
     */
    protected List doQuery(Query query) {
        return query.list();
    }

    public T unique(String hql) {
        List<T> list = list(hql,NOT_PAGE);
        T result = doGetFirst(list);
        return result;
    }

    public T unique(String hql, String key, Object value) {
        Map<String, Object> params = createMap(key, value);
        return unique(hql, params);
    }

    public T unique(String hql, Pair... pair) {
        Map<String, Object> params = createMap(pair);
        return unique(hql, params);
    }

    public T unique(String hql, Map<String, Object> params) {
        List<T> list = list(hql, params,NOT_PAGE);
        T result = doGetFirst(list);
        return result;
    }

    protected T doGetFirst(List<T> list) {
        T result = null;
        if (EmptyUtils.notEmpty(list)) {
            result = list.get(0);
        }
        return result;
    }
}

3.BasicSqlQueryUpdateDao

  使用原生的SQL，而不是HQL，实现一些较为通用的功能，与BasicQueryUpdateDao类似。

  更多功能，与上面的几个都差不多。只是封装程度不同而已。

4.BaseDao

  更多类似的功能，还有

  searchListByProperty： 根据一个或多个键值对模糊搜索符合条件的结果集

  findListByProperty：根据一个键值对精确查找对象

  findByPropertyUnique：根据1个键值对精确查找一个对象

  countFindByPropertyListAnd：计算查询记录的个数count

5.More API

  更多功能需要结合实际需求，整理了...

小结

网站开发最基础最常用的功能就是增删改查CRUD。

无论是用Hibernate还是Mybatis，都会有自己的优势和不足。

如果只是站在开发和技术的角度想问题，永远有做不完的问题，数不清的重复代码。

不去思考和总结，高富帅级的程序员也会被弄成码农，被折磨。

原文链接：http://blog.fansunion.cn/articles/3624(小雷博客-blog.fansunion.cn)