Hibernate的CRUD重用性

1、在研究了hibernate框架之后，准备完成一套Hibernate的CRUD操作，并且让其具有高度的重用性。在复杂查询方面，hibernate可谓是各种不方便，因此查询方面，利用java反射做出一套根据对象属性来动态查询数据的小框架。

2、先做出可行的设计图

3、具体的实现过程

package com.framework.common.dao;

import test.framework.common.PageEntity;

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

/**
 * @AUTHOR fuguangli
 * @DESCRIPTION hibernate的查询类，利用反射检测对象的不为空条件
 * @DATE 2017/4/8 0008
 */
public interface HibernateQueryReflect<T> {
    /**
     * 按条件分页查询所有
     * @param t
     * @param pageEntity
     * @return
     */
    List<T> listAllWithPage(T t, PageEntity pageEntity);

    /**
     * 按条件查询所有
     * @param t
     * @return
     */
    List<T> listAll(T t);

    /**
     * 按hql语句查询所有,针对复杂查询
     * @param hql
     * @return
     */
    List<T> listByHql(String hql);
}

package com.framework.common.dao;

import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import org.springframework.util.CollectionUtils;
import test.framework.common.PageEntity;
import test.framework.common.dao.*;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @AUTHOR fuguangli
 * @DESCRIPTION 类
 * @DATE 2017/4/8 0008
 * @warning 并没有获取实体的父类属性当作条件
 * @extend 应该使条件可自定义，应该使父类的属性也能参与条件
 * @explain 原理就是利用java的反射调用属性相应的get方法，如果值不为null，则添加条件
 */
public abstract class HibernateQueryReflectImpl<T> extends HibernateDaoSupport implements test.framework.common.dao.HibernateQueryReflect<T> {


    /**
     * 根据条件查询所有的数据
     *
     * @param t
     * @return
     */
    public List<T> listAll(T t) {
        try {
            //创建查询对象，根据对象值添加条件
            Criteria criteria = this.getSession().createCriteria(t.getClass());

            //反射添加条件
            Class clazz = t.getClass();
            Field[] fields = clazz.getDeclaredFields();
            if (!CollectionUtils.isEmpty(Arrays.asList(fields))) {
                for (Field f : fields) {
                    f.setAccessible(true);
                    String fieldSimpleName = f.getName();
                    String getMethodName = "get" + fieldSimpleName.substring(0, 1).toUpperCase() + fieldSimpleName.substring(1);
                    Method method = clazz.getDeclaredMethod(getMethodName, null);
                    Object value = method.invoke(t, null);
                    if (value != null) {
                        criteria.add(Restrictions.eq(fieldSimpleName, value));
                    }
                }
            }

            //执行查询
            return criteria.list();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 根据条件f分页查询所有的数据
     *
     * @param t
     * @param pageEntity
     * @return
     */
    public List<T> listAllWithPage(T t, PageEntity pageEntity) {

        try {
            //创建查询对象，根据对象值添加条件
            Criteria criteria = this.getSession().createCriteria(t.getClass());

            //反射添加条件
            Class clazz = t.getClass();
            Field[] fields = clazz.getDeclaredFields();
            if (!CollectionUtils.isEmpty(Arrays.asList(fields))) {
                for (Field f : fields) {
                    f.setAccessible(true);
                    String fieldSimpleName = f.getName();
                    String getMethodName = "get" + fieldSimpleName.substring(0, 1).toUpperCase() + fieldSimpleName.substring(1);
                    Method method = clazz.getDeclaredMethod(getMethodName, null);
                    Object value = method.invoke(t, null);
                    if (value != null) {
                        criteria.add(Restrictions.eq(fieldSimpleName, value));
                    }
                }
            }
            //查询总记录数
            criteria.setProjection(Projections.rowCount());
            long allCount = (Long) criteria.uniqueResult();

            //分页条件
            if (pageEntity != null) {
                criteria.setFirstResult(pageEntity.getStartRow());
                criteria.setMaxResults(pageEntity.getPageSize());
            }

            //恢复查询
            criteria.setProjection(null);
            //执行查询
            List<T> resultData = criteria.list();

            //扩展分页实体
            pageEntity.setTotalResultSize((int)allCount);
            pageEntity.setTotalPageSize((int)allCount / pageEntity.getPageSize() + (allCount % pageEntity.getPageSize() > 0 ? 1 : 0));



            return resultData;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 按hql语句查询所有,针对复杂查询
     *
     * @param hql
     * @return
     */
    @Override
    public List<T> listByHql(String hql) {
        Query query = this.getSession().createQuery(hql);
        List<T> data = query.list();
        return data;
    }

    /*排序 分组 查询*/

    /*模糊查询*/
}

package com.framework.dao;

import org.springframework.transaction.annotation.Transactional;
import test.framework.common.dao.HibernateQueryReflect;

import java.io.Serializable;

/**
 * @AUTHOR fuguangli
 * @DESCRIPTION 基础CRUD类
 * @DATE 2017/4/7 0007
 */
@Transactional
public interface BaseDao<T> extends HibernateQueryReflect<T> {
    /**
     * 插入数据
     * @param t
     * @return
     */
    T insert(T t);

    /**
     * 删除数据
     * @param t
     */
    void delete(T t);

    /**
     * 更新数据
     * @param t
     * @return
     */
    T update(T t);

    /**
     * 按ID查询数据
     * @param t
     * @param id
     * @return
     */
    @Transactional(readOnly = true)
    T getById(T t, Serializable id);
}

package com.framework.daoImpl;

import org.apache.log4j.Logger;
import org.hibernate.HibernateException;
import org.springframework.dao.DataAccessResourceFailureException;
import org.springframework.stereotype.Repository;
import test.framework.common.dao.HibernateQueryReflectImpl;
import test.framework.dao.BaseDao;

import java.io.Serializable;

/**
 * @AUTHOR fuguangli
 * @DESCRIPTION 基础CRUD类
 * @DATE 2017/4/7 0007
 */
@Repository
public abstract class BaseDaoImpl<T> extends HibernateQueryReflectImpl<T> implements BaseDao<T> {

    @Override
    public T insert(T t) {
        this.getSession().save(t);
        return t;
    }

    @Override
    public void delete(T t) {
        this.getSession().delete(t);
    }

    @Override
    public T update(T t) {
        this.getSession().update(t);
        return t;
    }


    @Override
    public T getById(T t, Serializable id) {
        return (T) this.getSession().get(t.getClass(), id);
    }

    /**
     * 根据对象动态获取hql语句
     *
     * @param o
     * @return
     */
    private String packageQueryObject(Object o) {
        return null;
    }
}

package com.framework.service;

import org.springframework.transaction.annotation.Transactional;
import test.framework.common.PageEntity;
import test.framework.dao.BaseDao;

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

/**
 * @AUTHOR fuguangli
 * @DESCRIPTION 基础业务类
 * @DATE 2017/4/8 0008
 */
public interface BaseService<T> {
    /**
     * 插入数据
     * @param t
     * @return
     */
    T insert(T t);

    /**
     * 删除数据
     * @param t
     */
    void delete(T t);

    /**
     * 更新数据
     * @param t
     * @return
     */
    T update(T t);

    /**
     * 按ID查询数据
     * @param t
     * @param id
     * @return
     */
    T getById(T t, Serializable id);

    /**
     * 按条件分页查询所有
     * @param t
     * @param pageEntity
     * @return
     */
    List<T> listAllWithPage(T t, PageEntity pageEntity);

    /**
     * 按条件查询所有
     * @param t
     * @return
     */
    List<T> listAll(T t);

    /**
     * 按hql语句查询所有,针对复杂查询
     * @param hql
     * @return
     */
    List<T> listByHql(String hql);
}

package com.framework.serviceimpl;

import org.springframework.beans.factory.annotation.Autowired;
import test.framework.common.PageEntity;
import test.framework.dao.BaseDao;
import test.framework.service.BaseService;

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

/**
 * @AUTHOR fuguangli
 * @DESCRIPTION 基础业务类
 * @DATE 2017/4/8 0008
 */
public abstract class BaseServiceImpl<T> implements BaseService<T> {
    /**
     * 插入数据
     *
     * @param t
     * @return
     */
    @Autowired
    private BaseDao<T> baseDao;

    @Override
    public T insert(T t) {
        return baseDao.insert(t);
    }

    /**
     * 删除数据
     *
     * @param t
     */
    @Override
    public void delete(T t) {
        baseDao.delete(t);
    }

    /**
     * 更新数据
     *
     * @param t
     * @return
     */
    @Override
    public T update(T t) {
        return baseDao.update(t);
    }

    /**
     * 按ID查询数据
     *
     * @param t
     * @param id
     * @return
     */
    @Override
    public T getById(T t, Serializable id) {
        return baseDao.getById(t,id);
    }

    /**
     * 按条件分页查询所有
     *
     * @param t
     * @param pageEntity
     * @return
     */
    @Override
    public List<T> listAllWithPage(T t, PageEntity pageEntity) {
        return baseDao.listAllWithPage(t,pageEntity);
    }

    /**
     * 按条件查询所有
     *
     * @param t
     * @return
     */
    @Override
    public List<T> listAll(T t) {
        return baseDao.listAll(t);
    }

    /**
     * 按hql语句查询所有,针对复杂查询
     *
     * @param hql
     * @return
     */
    @Override
    public List<T> listByHql(String hql) {
        return baseDao.listByHql(hql);
    }
}

4、到此，新建dao直接继承BaseDao或者service直接继承BaseService,就可以进行增删改查操作了