一个对JPA查询的封装服务类

import org.apache.commons.lang3.StringUtils;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author: 李浩泉
 *
 * @Description: 本类是采用JPA的EntityManager进行数据查询 
 * 核心方法,请见 : getBy()
 *
 */
@Service("JpaQueryService")
@Transactional
public class JpaQueryService  {

    @PersistenceContext
    private EntityManager em;

    /**
     *
     * @Description: 取服务单例
     * @return
     */
    public static JpaQueryService getInstance() {
        ApplicationContext context = ApplicationContextManagement.getApplicationContext();
        return (JpaQueryService)context.getBean("JpaQueryService");
    }

    /**
     * 创建Select部分
     * @param entityClazz
     * @return
     */
    public <T>String createSelect(Class<T> entityClazz) {
        return "select o from "+entityClazz.getName()+" o";
    }

    /**
     * 通过JPA获取所有的对象 :P
     * @param entityClazz
     * @param <T>
     * @return
     */
    public <T>List<T> queryForAll(final Class<T> entityClazz) {
        return em.createQuery(createSelect(entityClazz)).getResultList();
    }

    /**
     * 通过JPA获取第一个对象
     * @param entityClazz
     * @param <T>
     * @return
     */
    public <T>Object queryForSigleResult(final Class<T> entityClazz) {
        return em.createQuery(createSelect(entityClazz)).getSingleResult();
    }

    /**
     * 通过查询语句来获取结果数据
     * @param entityClazz
     * @param sql
     * @param <T>
     * @return
     */
    public <T>List<T> queryBySQL(final Class<T> entityClazz,String sql) {
        return em.createQuery(createSelect(entityClazz)+" where "+sql).getResultList();
    }


    /**
     * 获取总行数
     * @param cls
     * @param <T>
     * @return
     */
    public <T> long getRowSize(Class<T> cls) {
        return new Long(getBy(true, true, cls,null, null, 0, 0).get(0).toString());
    }


    /**
     * 获取条件查询的行数(等值)
     * @param cls
     * @param paramsMap
     * @param <T>
     * @return
     */
    public <T> long getRowSizeByEqual(Class<T> cls, Map<String, Object> paramsMap) {
        return new Long(getBy(true, false, cls,null, paramsMap, 0, 0).get(0).toString());
    }

    /**
     * 获取条件查询的行数(模糊)
     * @param cls
     * @param paramsMap
     * @param <T>
     * @return
     */
    public <T> long getRowSizeByLike(Class<T> cls, Map<String, String> paramsMap) {
        Map<String, Object> map = toStringObjectMap(paramsMap);
        return new Long(getBy(true, true, cls,null, map, 0, 0).get(0).toString());
    }


    /**
     * 获取子结果集
     * @param cls
     * @param from
     * @param size
     * @param <T>
     * @return
     */
    public <T> List<T> getSub(Class<T> cls, int from, int size) {
        return getBy(false, false, cls, null,null, from, size);
    }

    /**
     * 获取等值的子结果集
     * @param cls
     * @param paramsMap
     * @param from
     * @param size
     * @param <T>
     * @return
     */
    public <T> List<T> getSubByEqual(Class<T> cls, Map<String, Object> paramsMap, int from, int size) {
        return getBy(false, false, cls,null, paramsMap, from, size);
    }

    /**
     * 获取等值结果集
     * @param cls
     * @param paramsMap
     * @param <T>
     * @return
     */
    public <T> List<T> getByEqual(Class<T> cls, Map<String, Object> paramsMap) {
        return getBy(false, false, cls,null, paramsMap, 0, 0);
    }

    public <T> List<T> getByEqualWithOrder(Class<T> cls, Map<String, Object> paramsMap,String oderby) {
        return getBy(false, false, cls,oderby, paramsMap, 0, 0);
    }


    /**
     * 获取模糊查询子结果集
     * @param cls
     * @param paramsMap
     * @param from
     * @param size
     * @param <T>
     * @return
     */
    public <T> List<T> getSubByLike(Class<T> cls, Map<String, String> paramsMap, int from, int size) {
        Map<String, Object> map = toStringObjectMap(paramsMap);
        return getBy(false, true, cls,null, map, from, size);
    }


    /**
     * 模糊查询
     * @param cls
     * @param paramsMap
     * @param <T>
     * @return
     */
    public <T> List<T> getByLike(Class<T> cls, Map<String, String> paramsMap) {
        Map<String, Object> map = toStringObjectMap(paramsMap);
        return getBy(false, true, cls,null, map, 0, 0);
    }


    /**
     * 可构造性的原始查询
     * @param getRowCount 是否计算记录条数的查询（即，select count(*)）
     * @param isVagou  是否模糊查询like（相对于精确查询equal）
     * @param cls  对应的实体类名
     * @param paramsMap   查询字段映射数据
     * @param from  起始记录序号
     * @param size 本次查询的记录数
     * @return
     */
    private <T> List<T> getBy(boolean getRowCount, boolean isVagou, Class<T> cls,String orderby,
                              Map<String, Object> paramsMap, int from, int size) {

        String paramTag;     // sql语句中的占位参数标记名
        String paramValue;   // sql语句中的参数值
        String entityValue;  // sql语句中的实体参数名
        String className = cls.getSimpleName(); // 对应的类名
        String preSql = getRowCount ? "select count(e) from " : "select e from ";
        StringBuffer sql = new StringBuffer(preSql);
        sql.append(className).append(" e where 1=1 ");
        Query query;

        if (null != paramsMap) {
            //真帅
            for (String key : paramsMap.keySet()) {
                paramTag = ":".concat(key.replace(".", "_"));
                entityValue = "lower(e.".concat(key).concat(")");
                if (!isVagou) {
                    sql.append(" and ").append(entityValue).append("=").append(paramTag).append(" ");
                } else if(paramTag.endsWith("_id")){
                    // 如果对应的是主键，则将like改为equal
                    sql.append(" and ").append(entityValue).append("=").append(paramTag).append(" ");
                } else {
                    sql.append(" and ").append(entityValue).append(" like ").append(paramTag).append(" ");
                }

                if(QueryUtil.isNotEmpty(orderby)) {
                    if(StringUtils.contains(orderby,"_")) {
                        String[] orderbys = orderby.split("_");
                        sql.append(" order by e."+orderbys[0]+" "+orderbys[1]);
                    }else {
                        sql.append(" order by e."+orderby);
                    }
                }

                System.out.println("JPA 查询语句== "+sql.toString()+"---"+paramsMap.get(key));
            }
        }

        query = em.createQuery(sql.toString());

        if (null != paramsMap) {
            // 填值
            for (String key : paramsMap.keySet()) {
                paramTag = key.replace(".", "_");
                paramValue = paramsMap.get(key).toString().toLowerCase();
                if (!isVagou) {
                    try {
                        query.setParameter(paramTag, new Long(paramValue));
                    } catch (Exception ex) {
                        query.setParameter(paramTag, paramValue);
                    }
                } else {
                    // 如果对应的是主键，则将like改为equal
                    if(paramTag.endsWith("_id")){
                        query.setParameter(paramTag, new Long(paramValue));
                    } else{
                        query.setParameter(paramTag, "%" + paramValue + "%");
                    }
                }
            }
        }

        if (from == 0 && size == 0) {
            return query.getResultList();
        }
        return query.setFirstResult(from).setMaxResults(size).getResultList();
    }


    /**
     * 将<String, String>类型的映射转换为<String, Object>类型
     *
     * @param paramsMap
     * @return
     */
    private Map<String, Object> toStringObjectMap(Map<String, String> paramsMap) {
        Map<String, Object> map = new HashMap<String, Object>();
        for (String key : paramsMap.keySet()) {
            map.put(key, paramsMap.get(key));
        }
        return map;
    }

}