BaseMongoDaoImpl實現類抽取

BaseMongoDaoImpl實現類

import com.zh.cloud.common.data.entity.GridRequest;
import com.zh.cloud.common.data.entity.OrderCondition;
import com.zh.cloud.common.data.entity.WhereCondition;
import com.zh.cloud.common.data.entity.entityMenu.OrderConditionMethod;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Sort;
import org.springframework.data.domain.Sort.Direction;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.mapreduce.GroupBy;
import org.springframework.data.mongodb.core.mapreduce.GroupByResults;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;
import com.zh.cloud.common.data.entity.entityMenu.WhereConditionMethod;


import javax.annotation.PostConstruct;
import java.lang.reflect.ParameterizedType;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Pattern;

/**
 * 抽取出來的BaseMongoDaoImpl
 * @author tianxiaobin
 *
 */
public class BaseMongoDaoImpl<T> implements  BaseMongoDaoI<T>{

    public static BaseMongoDaoImpl mongodbUtils;
    public Class c;
    @PostConstruct
    public void init() {
        mongodbUtils = this;
        mongodbUtils.mongoTemplate = this.mongoTemplate;
        c= (Class) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];
    }

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
     * 保存數據對象，集合爲數據對象中@Document 註解所配置的collection
     *
     * @param obj
     *            數據對象
     */
    @Override
    public void save(T obj) {
        mongodbUtils.mongoTemplate.save(obj);
    }

    /**
     * 指定集合保存數據對象
     *
     * @param obj
     *            數據對象
     * @param collectionName
     *            集合名
     */
    @Override
    public void save(T obj, String collectionName) {
        mongodbUtils.mongoTemplate.save(obj, collectionName);
    }

    /**
     * 根據數據對象中的id刪除數據，集合爲數據對象中@Document 註解所配置的collection
     *
     * @param obj
     *            數據對象
     */
    @Override
    public void remove(T obj) {

        mongodbUtils.mongoTemplate.remove(obj);
    }

    /**
     * 指定集合 根據數據對象中的id刪除數據
     *
     * @param obj
     *            數據對象
     * @param collectionName
     *            集合名
     */
    @Override
    public void remove(T obj, String collectionName) {

        mongodbUtils.mongoTemplate.remove(obj, collectionName);
    }

    /**
     * 根據key，value到指定集合刪除數據
     *
     * @param key
     *            鍵
     * @param value
     *            值
     * @param collectionName
     *            集合名
     */
    @Override
    public void removeById(String key, Object value, String collectionName) {
        Criteria criteria = Criteria.where(key).is(value);
        criteria.and(key).is(value);
        Query query = Query.query(criteria);
        mongodbUtils.mongoTemplate.remove(query, collectionName);
    }

    /**
     * 指定集合 修改數據，且僅修改找到的第一條數據
     *
     * @param accordingKey
     *            修改條件 key
     * @param accordingValue
     *            修改條件 value
     * @param updateKeys
     *            修改內容 key數組
     * @param updateValues
     *            修改內容 value數組
     * @param collectionName
     *            集合名
     */
    @Override
    public void updateFirst(String accordingKey, Object accordingValue, String[] updateKeys, Object[] updateValues,
                                   String collectionName) {

        Criteria criteria = Criteria.where(accordingKey).is(accordingValue);
        Query query = Query.query(criteria);
        Update update = new Update();
        for (int i = 0; i < updateKeys.length; i++) {
            update.set(updateKeys[i], updateValues[i]);
        }
        mongodbUtils.mongoTemplate.updateFirst(query, update, collectionName);
    }

    /**
     * 指定集合 修改數據，且修改所找到的所有數據
     *
     * @param accordingKey
     *            修改條件 key
     * @param accordingValue
     *            修改條件 value
     * @param updateKeys
     *            修改內容 key數組
     * @param updateValues
     *            修改內容 value數組
     * @param collectionName
     *            集合名
     */
    @Override
    public void updateMulti(String accordingKey, Object accordingValue, String[] updateKeys, Object[] updateValues,
                                   String collectionName) {

        Criteria criteria = Criteria.where(accordingKey).is(accordingValue);
        Query query = Query.query(criteria);
        Update update = new Update();
        for (int i = 0; i < updateKeys.length; i++) {
            update.set(updateKeys[i], updateValues[i]);
        }
        mongodbUtils.mongoTemplate.updateMulti(query, update, collectionName);
    }

    /**
     * 根據條件查詢出所有結果集 集合爲數據對象中@Document 註解所配置的collection
     *
     * @param obj
     *            數據對象
     * @param findKeys
     *            查詢條件 key
     * @param findValues
     *            查詢條件 value
     * @return
     */
    @Override
    public List<T> find(T obj, String[] findKeys, Object[] findValues) {
        Criteria criteria = null;
        for (int i = 0; i < findKeys.length; i++) {
            if (i == 0) {
                criteria = Criteria.where(findKeys[i]).is(findValues[i]);
            } else {
                criteria.and(findKeys[i]).is(findValues[i]);
            }
        }
        Query query = Query.query(criteria);
        List<T> resultList = mongodbUtils.mongoTemplate.find(query, c);
        return resultList;
    }

    /**
     * 指定集合 根據條件查詢出所有結果集
     *
     * @param obj
     *            數據對象
     * @param findKeys
     *            查詢條件 key
     * @param findValues
     *            查詢條件 value
     * @param collectionName
     *            集合名
     * @return
     */
    @Override
    public List<T> find(T obj, String[] findKeys, Object[] findValues, String collectionName) {

        Criteria criteria = null;
        for (int i = 0; i < findKeys.length; i++) {
            if (i == 0) {
                criteria = Criteria.where(findKeys[i]).is(findValues[i]);
            } else {
                criteria.and(findKeys[i]).is(findValues[i]);
            }
        }
        Query query = Query.query(criteria);
        List<T> resultList = mongodbUtils.mongoTemplate.find(query, c, collectionName);
        return resultList;
    }

    /**
     * 指定集合 分組查詢結果
     *
     * @param obj
     *            數據對象
     * @param groupBy
     *            排序對象
     * @param collectionName
     *            集合名
     * @return
     *
     */
    @Override
    public List<T> group(String collectionName, GroupBy groupBy, T obj){
        //TODO groupBy的例子:根據carId和CarLicenseNO分組 , 求出分組數量
        // GroupBy groupBy = GroupBy.key("carId","CarLicenseNO").initialDocument("{carCount:0}")
        // .reduceFunction("function(key, values){values.carCount+=1;}");
        GroupByResults<T> group = mongodbUtils.mongoTemplate.group(collectionName, groupBy, c);
        List<T> tList = (List)group.getRawResults().get("retval");
        return tList;
    }

    /**
     * 指定集合 根據條件查詢出所有結果集 並排倒序
     *
     * @param obj
     *            數據對象
     * @param findKeys
     *            查詢條件 key
     * @param findValues
     *            查詢條件 value
     * @param collectionName
     *            集合名
     * @param sort
     *            排序字段
     * @return
     */
    @Override
    public List<T> find(T obj, String[] findKeys, Object[] findValues, String collectionName ,String sort) {
        Criteria criteria = null;
        for (int i = 0; i < findKeys.length; i++) {
            if (i == 0) {
                criteria = Criteria.where(findKeys[i]).is(findValues[i]);
            } else {
                criteria.and(findKeys[i]).is(findValues[i]);
            }
        }
        Query query = Query.query(criteria);
        query.with(new Sort(Direction.DESC, sort));
        List<T> resultList = mongodbUtils.mongoTemplate.find(query, c, collectionName);
        return resultList;
    }

    /**
     * 根據條件查詢出符合的第一條數據 集合爲數據對象中 @Document 註解所配置的collection
     *
     * @param obj
     *            數據對象
     * @param findKeys
     *            查詢條件 key
     * @param findValues
     *            查詢條件 value
     * @return
     */
    @Override
    public T findOne(T obj, String[] findKeys, Object[] findValues) {
        Criteria criteria = null;
        for (int i = 0; i < findKeys.length; i++) {
            if (i == 0) {
                criteria = Criteria.where(findKeys[i]).is(findValues[i]);
            } else {
                criteria.and(findKeys[i]).is(findValues[i]);
            }
        }
        Query query = Query.query(criteria);
        T resultObj = (T)mongodbUtils.mongoTemplate.findOne(query, c);
        return resultObj;
    }

    /**
     * 指定集合 根據條件查詢出符合的第一條數據
     *
     * @param obj
     *            數據對象
     * @param findKeys
     *            查詢條件 key
     * @param findValues
     *            查詢條件 value
     * @param collectionName
     *            集合名
     * @return
     */
    @Override
    public T findOne(T obj, String[] findKeys, Object[] findValues, String collectionName) {
        Criteria criteria = null;
        for (int i = 0; i < findKeys.length; i++) {
            if (i == 0) {
                criteria = Criteria.where(findKeys[i]).is(findValues[i]);
            } else {
                criteria.and(findKeys[i]).is(findValues[i]);
            }
        }
        Query query = Query.query(criteria);
        T resultObj = (T)mongodbUtils.mongoTemplate.findOne(query, c, collectionName);
        return resultObj;
    }

    /**
     * 查詢出所有結果集 集合爲數據對象中 @Document 註解所配置的collection
     *            數據對象
     * @return
     */
    @Override
    public List<T> findAll(T obj) {
        List<T> resultList = mongodbUtils.mongoTemplate.findAll(c);
        return resultList;
    }

    /**
     * 指定集合 查詢出所有結果集
     *
     * @param obj
     *            數據對象
     * @param collectionName
     *            集合名
     * @return
     */
    @Override
    public List<T> findAll(T obj, String collectionName) {
        List<T> resultList = mongodbUtils.mongoTemplate.findAll(c, collectionName);
        return resultList;
    }

    /**
     * 分頁查詢所有數據
     * @param obj
     * @param sort
     * @param pageIndex
     * @param pageCount
     * @return
     */
    @Override
    public List<T> findAllByPage(T obj,String sort, int pageIndex, int pageCount) {
        Query query = new Query().skip(pageIndex * pageCount).limit(pageCount).with(new Sort(Direction.DESC, sort));
        List<T> resultList = mongodbUtils.mongoTemplate.find(query, c);
        return resultList;
    }

    @Override
    public long getCount(T obj) {
        Query query = new Query();
        return mongodbUtils.mongoTemplate.count(query, c);
    }

    @Override
    public long getCount(T obj, String sort, GridRequest gridRequest) {
        int pageIndex = 1;
        int pageCount = 10;
        List<WhereCondition> whereConditions = null;
        List<OrderCondition> orderConditions = null;
        if(gridRequest != null){
            //接收頁面頁碼
            pageIndex = gridRequest.getPageIndex();
            //接收頁面顯示數量
            pageCount = gridRequest.getPageItemCount();
            //接收篩選條件
            whereConditions = gridRequest.getWhereConditions();
            //接收排序條件
            orderConditions = gridRequest.getOrderConditions();
        }
        Query query = new Query();
        if(whereConditions!=null && !whereConditions.isEmpty()){
            for (WhereCondition whereCondition : whereConditions) {
                if(StringUtils.isNotBlank(whereCondition.getValue().toString())){
                    if (whereCondition.getMethod().equals(WhereConditionMethod.Like)){
                        Pattern pattern = Pattern.compile("^.*"+whereCondition.getValue()+".*$", Pattern.CASE_INSENSITIVE);
                        query.addCriteria(Criteria.where(whereCondition.getField()).regex(pattern));
                    }else if (whereCondition.getMethod().equals(WhereConditionMethod.LessThanEqual)){
                        System.out.println(whereCondition.getField()+whereCondition.getValue()+whereCondition.getMethod());
                        query.addCriteria(Criteria.where(whereCondition.getField()).lt(whereCondition.getValue()));
                    }else if(whereCondition.getMethod().equals(WhereConditionMethod.GreaterThanEqual)){
                        query.addCriteria(Criteria.where(whereCondition.getField()).gte(whereCondition.getValue()));
                    }
                }
            }
        }
        ArrayList<Sort.Order> orders = new ArrayList<>();
        Sort.Order field = null;
        if(orderConditions!=null && !orderConditions.isEmpty()){
            for (OrderCondition orderCondition : orderConditions) {
                if(orderCondition.getMethod().equals(OrderConditionMethod.DESC) && StringUtils.isNotBlank(orderCondition.getField())){
                    field = Sort.Order.desc(orderCondition.getField());
                }else if(orderCondition.getMethod().equals(OrderConditionMethod.ASC) && StringUtils.isNotBlank(orderCondition.getField())){
                    field = Sort.Order.asc(orderCondition.getField());
                }
                orders.add(field);
            }
        }
        query.skip(pageIndex-1 * pageCount).limit(pageCount);
        query.with(Sort.by(orders
        ));
        return mongodbUtils.mongoTemplate.count(query, c);
    }

    @Override
    public List<T> find(T obj, String sort, GridRequest gridRequest){
        int pageIndex = 1;
        int pageCount = 10;
        List<WhereCondition> whereConditions = null;
        List<OrderCondition> orderConditions = null;
        if(gridRequest != null){
            //接收頁面頁碼
            pageIndex = gridRequest.getPageIndex();
            //接收頁面顯示數量
            pageCount = gridRequest.getPageItemCount();
            //接收篩選條件
            whereConditions = gridRequest.getWhereConditions();
            //接收排序條件
            orderConditions = gridRequest.getOrderConditions();
        }
        Query query = new Query();
        if(whereConditions!=null && !whereConditions.isEmpty()){
            for (WhereCondition whereCondition : whereConditions) {
                if(StringUtils.isNotBlank(whereCondition.getValue().toString())){
                    if (whereCondition.getMethod().equals(WhereConditionMethod.Like)){
                        Pattern pattern = Pattern.compile("^.*"+whereCondition.getValue()+".*$", Pattern.CASE_INSENSITIVE);
                        query.addCriteria(Criteria.where(whereCondition.getField()).regex(pattern));
                    }else if(whereCondition.getMethod().equals(WhereConditionMethod.Equal)){
                        query.addCriteria(Criteria.where(whereCondition.getField()).is(whereCondition.getValue()));
                    }
                    else if (whereCondition.getMethod().equals(WhereConditionMethod.LessThanEqual)){
                        System.out.println(whereCondition.getField()+whereCondition.getValue()+whereCondition.getMethod());
                        query.addCriteria(Criteria.where(whereCondition.getField()).lt(whereCondition.getValue()));
                    }else if(whereCondition.getMethod().equals(WhereConditionMethod.GreaterThanEqual)){
                        query.addCriteria(Criteria.where(whereCondition.getField()).gte(whereCondition.getValue()));
                    }
                }
            }
        }
        ArrayList<Sort.Order> orders = new ArrayList<>();
        Sort.Order field = null;
        if(orderConditions!=null && !orderConditions.isEmpty()){
            for (OrderCondition orderCondition : orderConditions) {
                if(orderCondition.getMethod().equals(OrderConditionMethod.DESC) && StringUtils.isNotBlank(orderCondition.getField())){
                    field = Sort.Order.desc(orderCondition.getField());
                }else if(orderCondition.getMethod().equals(OrderConditionMethod.ASC) && StringUtils.isNotBlank(orderCondition.getField())){
                    field = Sort.Order.asc(orderCondition.getField());
                }
                orders.add(field);
            }
        }
        query.skip(pageIndex * pageCount).limit(pageCount);
        query.with(Sort.by(orders
        ));
//                Sort.Order.desc("carLicenseNO"),
//                Sort.Order.desc("startTime")
        List<T> resultList = mongodbUtils.mongoTemplate.find(query, c);
        //long count = mongodbUtils.mongoTemplate.count(query, c);
        return resultList;
    }

    @Override
    public List<T> findLike(T obj, String[] findKeys, Object[] findValues) {
        Criteria criteria = null;
        for (int i = 0; i < findKeys.length; i++) {
            if (i == 0) {
                criteria = Criteria.where(findKeys[i]).regex(".*?\\" +findValues[i]+ ".*");
            } else {
                criteria.and(findKeys[i]).regex(".*?\\" +findValues[i]+ ".*");
            }
        }
        Query query = Query.query(criteria);
        List<T> resultList = mongodbUtils.mongoTemplate.find(query, c);
        return resultList;
    }
}