JPA封装baseDao

/**
 * 
 */
package pw.lizi.base;

import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import javax.annotation.Resource;
import javax.persistence.EntityManager;
import javax.persistence.Query;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import pw.lizi.util.AssertUtil;
import pw.lizi.util.CollectionUtil;
import pw.lizi.util.StringUtil;

/**
 * 说明:
 *  34  * 2018年9月29日 下午2:03:17
 */
@SuppressWarnings("unchecked")
@Transactional
public abstract class BaseServiceImpl<T, ID> implements BaseService<T, ID> {  

    static Logger log = LoggerFactory.getLogger(BaseServiceImpl.class);
    
    //实体类class
    private Class<T> entityClass = null;
    
    //ID字段的class
    private Class<ID> idClass = null;

    {
        
        //getSuperclass   返回直接继承的父类（由于编译擦除，没有显示泛型参数）
        //getGenericSuperclass  返回直接继承的父类（包含泛型参数）
        Type type = getClass().getGenericSuperclass();

        //解决多层继承拿泛型类型   //BaseServiceImpl<User> <- UserService <- PassportService 
        while(!(type instanceof ParameterizedType)){ 
            type = ((Class<?>)type).getGenericSuperclass();
            //为了避免写错代码出现死循环，加上这个保险。
            if(type == null || "java.lang.Object".equals(type.getClass())){
                break;
            }
        }

        if(type instanceof ParameterizedType){
            ParameterizedType parameterizedType = (ParameterizedType)type;
            Type[] genericTypies = parameterizedType.getActualTypeArguments();
            entityClass = (Class<T>)genericTypies[0];
            idClass     = (Class<ID>)genericTypies[1];
        }
    }

    /**
     * 从strter-jpa里面取出entityManager
     */
    @Resource
    protected EntityManager entityManager;

    /* (non-Javadoc)
     * @see pw.lizi.base.BaseService#save(T)
     */
    @Override
    public void save(T entity){
        entityManager.persist(entity);
    }

    /* (non-Javadoc)
     * @see pw.lizi.base.BaseService#delete(T)
     */
    @Override
    public void delete(T entity){
        entityManager.remove(entity);
    }

    /* (non-Javadoc)
     * @see pw.lizi.base.BaseService#delete(java.io.Serializable)
     */
    @Override
    public int delete(Serializable id){
        Query query = entityManager.createQuery("DELETE FROM " + entityClass.getName() + " WHERE " + getIdField() + "=?");
        query.setParameter(0, id);
        return query.executeUpdate();
    }
    
    
    /* (non-Javadoc)
     * @see pw.lizi.base.BaseService#update(java.io.Serializable, java.util.LinkedHashMap)
     */
    @Override
    public int update(Serializable id, LinkedHashMap<String, Object> values){
        LinkedHashMap<String, Object> conditions = new LinkedHashMap<>();
        conditions.put(getIdField(), id); //where uid=?
        return updates(conditions, values);
    }
    
    
    /* (non-Javadoc)
     * @see pw.lizi.base.BaseService#updates(java.util.LinkedHashMap, java.util.LinkedHashMap)
     */
    @Override
    public int updates(LinkedHashMap<String, Object> conditions, LinkedHashMap<String, Object> values){
        AssertUtil.notEmpty(values, "要更新的值不能空");
        //update entityClass set field1=?,field2=?, where field1=? AND field2=? AND
        StringBuilder jpql = new StringBuilder("UPDATE ").append(entityClass.getName()).append(" SET ");
        for(Map.Entry<String, Object> v : values.entrySet()){
            jpql.append(v.getKey()).append("=?,");
        }
        jpql.deleteCharAt(jpql.length() - 1);
        
        Collection<Object> params = new ArrayList<Object>();
        params.addAll(values.values());
        
        if(conditions != null && conditions.size() > 0){
            jpql.append(" WHERE ");
            for(Map.Entry<String, Object> condition : conditions.entrySet()){
                jpql.append(condition.getKey()).append("=? AND ");
            }
            jpql.delete(jpql.length() - 5, jpql.length());
            
            params.addAll(conditions.values());
        }
        
        log.debug("更新语句：" + jpql.toString());
        
        Query query = entityManager.createQuery(jpql.toString());
        
        int i = 0;
        for (Object value : params) {
            query.setParameter(++i, value);
        }
        
        return query.executeUpdate();
    }

    /* (non-Javadoc)
     * @see pw.lizi.base.BaseService#findOne(java.io.Serializable)
     */
    @Override
    @Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)
    public T findOne(Serializable id){
        return entityManager.find(entityClass, id);
    }
    
    
    /* (non-Javadoc)
     * @see pw.lizi.base.BaseService#finds()
     */
    @Override
    @Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)
    public List<T> finds(){
        return entityManager.createQuery("from " + entityClass.getName()).getResultList();
    }
    
    /* (non-Javadoc)
     * @see pw.lizi.base.BaseService#finds(java.util.LinkedHashMap)
     */
    @Override
    @Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)
    public List<T> finds(Sort sort){
        return finds(null, null, null, sort);
    }
    
    /* (non-Javadoc)
     * @see pw.lizi.base.BaseService#finds(pw.lizi.base.Page)
     */
    @Override
    @Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)
    public List<T> finds(Page page){
        return finds(null, null, page, null);
    }
    
    /* (non-Javadoc)
     * @see pw.lizi.base.BaseService#finds(pw.lizi.base.Page, java.util.LinkedHashMap)
     */
    @Override
    @Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)
    public List<T> finds(Page page, Sort sort){
        return finds(null, null, page, sort);
    }
    
    /* (non-Javadoc)
     * @see pw.lizi.base.BaseService#finds(java.util.LinkedHashMap, pw.lizi.base.Page, java.util.LinkedHashMap)
     */
    @Override
    @Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)
    public List<T> finds(LinkedHashMap<String, Object> conditions, Page page, Sort sort){
        return finds(null, conditions, page, sort);
    }
    
    /* (non-Javadoc)
     * @see pw.lizi.base.BaseService#finds(java.lang.String, java.util.LinkedHashMap, pw.lizi.base.Page, java.util.LinkedHashMap)
     */
    @Override
    @Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)
    public List<T> finds(String fields, LinkedHashMap<String, Object> conditions, Page page, Sort sort){
        
        //准备返回字段，如果没自定义就返回*
        fields = StringUtil.hasLength(fields) ? "new " + entityClass.getName() + "(" + fields + ") " : "o ";
        
        //拼查询语句：select o.* from entityClass as o where f=v order by xxx
        StringBuilder JPQL = new StringBuilder("SELECT ").append(fields).append(" FROM ").append(entityClass.getName()).append(" as o");
        
        //拼统计语句：select count(getIdField()) from entityClass where f=v 
        StringBuilder countJPQL = new StringBuilder("SELECT count(o.").append(getIdField()).append(')')
                .append(" FROM ").append(entityClass.getName()).append(" as o");
        
        //拼条件
        if(CollectionUtil.notEmpty(conditions)){
            JPQL.append(" WHERE ");
            countJPQL.append(" WHERE ");
            
            for(Map.Entry<String, Object> condition : conditions.entrySet()){
                JPQL.append("o.").append(condition.getKey()).append("=? AND ");
                countJPQL.append("o.").append(condition.getKey()).append("=? AND ");
            }
            JPQL.delete(JPQL.length() - 5, JPQL.length());
            countJPQL.delete(JPQL.length() - 5, JPQL.length());
        }
        
        /* 分页：只分第1页，后面的记录总页数就可以算出总记录数，从而不需要再统计
         * (98条|100条)=总页面相等
         * http://localhsot/news/list?pageIndex=2&pageCount=10
         */
        if(page != null && page.getTotalCount() == 0){
            log.debug("统计语句：" + countJPQL.toString());
            Query query = entityManager.createQuery(countJPQL.toString());
            if(conditions != null){
                setParameter(query, conditions.values());
            }
            long count = (Long) query.getSingleResult();
            page.setTotalCount((int)count);
        }
        
        //排序
        if(CollectionUtil.notEmpty(sort)){
            JPQL.append(" ORDER BY ");
            for(Map.Entry<String, Boolean> order : sort.entrySet()){
                JPQL.append("o.").append(order.getKey()).append(' ').append(order.getValue() ? "ASC" : "DESC").append(',');
            }
            JPQL.deleteCharAt(JPQL.length() - 1);
        }
        
        log.debug("查询语句：" + JPQL.toString());
        
        //生成查询对象，绑定参数
        Query query = entityManager.createQuery(JPQL.toString());
        if(conditions != null){
            setParameter(query, conditions.values());
        }
        
        //设置分页 limit 50,10
        query.setFirstResult(page.getOffset()).setMaxResults(page.getPageSize());
        
        //返回查询结果
        List<T> result = query.getResultList();
        
        return result;
    }
    
    //--------------------------------------------private-----------------------------------------

    private void setParameter(Query query, Collection<Object> params){
        int i = 0;
        for (Object object : params) {
            query.setParameter(++i, object);//JPA是从1开始
        }
    }
    
    private String getIdField(){
        
        /*
        //第1个bug：拿不到父类的field，除非父类的属性设为public
        //第2个bug：如果注解是放在get方法上的，那还得要遍历方法
        //第3个问题：性能较关
        Field[] fields = entityClass.getDeclaredFields();
        for (Field field : fields) {
            Id id = field.getAnnotation(Id.class);
            if(id != null){
                return field.getName();
            }
        }
        */
        
        String idField = entityManager.getMetamodel().entity(entityClass).getId(idClass).getName();
        
        return idField;
    }
}

package pw.lizi.base;

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


/**
 * 说明:
 * 
 *
 * 2018年9月30日 上午9:07:42
 */
public interface BaseService<T, ID> {

    /**
     * 功能说明：保存<br>
     * @param entity
     * void
     */
    public abstract void save(T entity);

    /**
     * 功能说明：删除实体<br>
     * @param entity
     * void
     */
    public abstract void delete(T entity);

    /**
     * 功能说明：根据ID删除<br>
     * @param id
     * void
     */
    public abstract int delete(Serializable id);

    /**
     * 功能说明：根据ID更新单条记录<br>
     * @param id
     * @param values
     * void
     */
    public abstract int update(Serializable id,
            LinkedHashMap<String, Object> values);

    /**
     * 功能说明：批量更新<br>
     * @param conditions
     * @param values
     * @return
     * int
     */
    public abstract int updates(LinkedHashMap<String, Object> conditions,
            LinkedHashMap<String, Object> values);

    public abstract T findOne(Serializable id);

    public abstract List<T> finds();

    /**
     * 功能说明：排序查询<br>
     * @param orders
     * @return
     * List<T>
     */
    public abstract List<T> finds(Sort sort);

    /**
     * 功能说明：分页查询<br>
     * @param page
     * @return
     * List<T>
     */
    public abstract List<T> finds(Page page);

    /**
     * 功能说明：分页排序查询<br>
     * @param page
     * @param orders
     * @return
     * List<T>
     */
    public abstract List<T> finds(Page page, Sort sort);

    /**
     * 功能说明：分页排序多条件查询<br>
     * @param conditions
     * @param page
     * @param orders
     * @return
     * List<T>
     */
    public abstract List<T> finds(LinkedHashMap<String, Object> conditions,     Page page, Sort sort);

    /**
     * 功能说明：分页排序多条件，且可自定义字段查询<br>
     * @param fields
     * @param conditions
     * @param page
     * @param orders
     * @return
     * List<T>
     */
    public abstract List<T> finds(String fields, LinkedHashMap<String, Object> conditions, Page page, Sort sort);

}

/**
 * 
 */
package pw.lizi.base;

import java.io.Serializable;

/**
 * 说明:
 * 
 *
 * 2018年9月30日 上午8:15:31
 */
public class Page implements Serializable {

    private static final long serialVersionUID = 1L;

    private int pageIndex = 1;
    
    private int pageSize;
    
    private int totalCount;

    
    public Page(int pageIndex, int pageSize) {
        super();
        this.pageIndex = pageIndex;
        this.pageSize = pageSize;
    }

    public int getOffset(){
        return (this.getPageIndex() - 1 ) * this.getPageSize();
    }
    
    public int getPageIndex() {
        return pageIndex;
    }

    public void setPageIndex(int pageIndex) {
        this.pageIndex = pageIndex;
    }

    public int getPageSize() {
        return pageSize;
    }

    public void setPageSize(int pageSize) {
        this.pageSize = pageSize;
    }

    public int getTotalCount() {
        return totalCount;
    }

    public void setTotalCount(int totalCount) {
        this.totalCount = totalCount;
    }
    
    
}

/**
 * 
 */
package pw.lizi.base;

import java.util.LinkedHashMap;

/**
 * 说明:
 * 
 *
 * 2018年9月30日 上午9:38:02
 */
public class Sort extends LinkedHashMap<String, Boolean> {

    private static final long serialVersionUID = 1L;

    public Sort(String field, boolean asc){
        put(field, asc);
    }
    
    public Sort add(String field, boolean asc){
        put(field, asc);
        return this;
    }
    public static Sort newInstance(String field, boolean asc){
        Sort sort = new Sort(field, asc);
        return sort;
    }
}