mongoDB使用工具类

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
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 org.springframework.data.domain.Sort;
import org.springframework.data.domain.Sort.Direction;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Component
public class MongodbUtils {

    public static MongodbUtils mongodbUtils;

    @PostConstruct
    public void init() {
        mongodbUtils = this;
        mongodbUtils.mongoTemplate = this.mongoTemplate;
    }

    @Resource
    private MongoTemplate mongoTemplate;

    /**
         * 保存数据对象，集合为数据对象中@Document 注解所配置的collection
         *
         * @param obj
         *            数据对象
         */
    public static void save(Object obj) {
        mongodbUtils.mongoTemplate.save(obj);
    }

    /**
         * 指定集合保存数据对象
         *
         * @param obj
         *            数据对象
         * @param collectionName
         *            集合名
         */
    public static Object save(Object obj, String collectionName) {
        return mongodbUtils.mongoTemplate.save(obj, collectionName);
    }

    public static Object saveImport(List<Map<String,Object>> list, String collectionName) {
        return mongodbUtils.mongoTemplate.insert(list, collectionName);
    }

    /**
         * 根据数据对象中的id删除数据，集合为数据对象中@Document 注解所配置的collection
         *
         * @param obj
         *            数据对象
         */
    public static void remove(Object obj) {

        mongodbUtils.mongoTemplate.remove(obj);
    }

    /**
         * 指定集合 根据数据对象中的id删除数据
         *
         * @param obj
         *            数据对象
         * @param collectionName
         *            集合名
         */
    public static void remove(Object obj, String collectionName) {

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

    /**
         * 根据key，value到指定集合删除数据
         *
         * @param key
         *            键
         * @param ids
         *            值
         * @param collectionName
         *            集合名
         */
    public static void removeById(String key, String[] ids, String collectionName) {
        Criteria criteria = Criteria.where(key).in(ids);
//        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
         *            集合名
         */
    public static 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
         *            集合名
         */
    public static 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++) {
            if (updateKeys[i].equals("_id")){
                continue;
            }
            update.set(updateKeys[i], updateValues[i]);
        }
        mongodbUtils.mongoTemplate.updateMulti(query, update, collectionName);
    }

    /**
     * 根据条件查询出所有结果集 集合为数据对象中@Document 注解所配置的collection
     *
     * @param obj
     *            数据对象
     * @param findKeys
     *            查询条件 key
     * @param findValues
     *            查询条件 value
     * @return
     */
    public static List<? extends Object> find(Object 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<? extends Object> resultList = mongodbUtils.mongoTemplate.find(query, obj.getClass());
        return resultList;
    }

    /**
     * 指定集合 根据条件查询出所有结果集
     *
     * @param obj
     *            数据对象
     * @param findKeys
     *            查询条件 key
     * @param findValues
     *            查询条件 value
     * @param collectionName
     *            集合名
     * @return
     */
    public static List<? extends Object> find(Object 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<? extends Object> resultList = mongodbUtils.mongoTemplate.find(query, obj.getClass(), collectionName);
        return resultList;
    }

    /**
     * 指定集合 根据条件查询出所有结果集 并排倒序
     *
     * @param obj
     *            数据对象
     * @param findKeys
     *            查询条件 key
     * @param findValues
     *            查询条件 value
     * @param collectionName
     *            集合名
     * @param sort
     *            排序字段
     * @return
     */
    public static List<? extends Object> find(Object 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(Sort.by(Direction.DESC, sort));
        List<? extends Object> resultList = mongodbUtils.mongoTemplate.find(query, obj.getClass(), collectionName);
        return resultList;
    }
    /**
     * 指定集合 根据条件查询出所有结果集 并排倒序
     *
     * @param findKeys
     *            查询条件 key
     * @param findValues
     *            查询条件 value
     * @param collectionName
     *            集合名
     * @param sort
     *            排序字段
     * @return
     */
    public static Map<String,Object> findModel(int page,int size,String[] findKeys, Object[] findValues,String collectionName,String sort){
        Map<String,Object> map = new HashMap<>();
//        Criteria criteria = Criteria.where(generalName).ne("").ne("-1");
        Criteria criteria = null;
        for (int i = 0; i < findKeys.length; i++) {
            if (i == 0) {
                if (findValues[i].equals("")||findValues[i] == null){
                    continue;
                }
                // 改为模糊查询
//                //完全匹配
//        //Pattern pattern = Pattern.compile("^name$", Pattern.CASE_INSENSITIVE);
//        //右匹配
//        //Pattern pattern = Pattern.compile("^.*name$", Pattern.CASE_INSENSITIVE);
//        //左匹配
//        //Pattern pattern = Pattern.compile("^name.*$", Pattern.CASE_INSENSITIVE);
//        //模糊匹配
//        Pattern pattern = Pattern.compile("^.*name8.*$", Pattern.CASE_INSENSITIVE);
//                criteria = Criteria.where(findKeys[i]).is(findValues[i]);
                if (findKeys[i].equals("resTypeCode")){
                    criteria = Criteria.where(findKeys[i]).regex("^"+findValues[i]+ ".*$");
                }else {
                    criteria = Criteria.where(findKeys[i]).regex("^.*" +findValues[i]+ ".*$");
                }
            } else {
                if (findValues[i].equals("")||findValues[i] == null){
                    continue;
                }
                if (findKeys[i].equals("resTypeCode")){
                    criteria.and(findKeys[i]).regex("^"+findValues[i]+ ".*$");
                }else {
                    criteria.and(findKeys[i]).regex("^.*" +findValues[i]+ ".*$");

                }
            }
        }
        Query query;
        Query countQuert;
        if (criteria == null){
            query =  new Query();
            countQuert = new Query();
        }else {
            query =  Query.query(criteria);
            countQuert = Query.query(criteria);
        }
        if (!sort.equals("")){
            sort="_id";
        }
        query.with(Sort.by(Direction.DESC,sort));
        countQuert.with(Sort.by(Direction.DESC,sort));
        int nub = (page-1) * size;
        query.skip(nub);
        query.limit(size);
        List<Map> maps = mongodbUtils.mongoTemplate.find(query, Map.class, collectionName);
        long count = mongodbUtils.mongoTemplate.count(countQuert,collectionName);
        map.put("data", maps);
        map.put("count",count);
        return map;
    }

    public static Map<String,Object> findModelExport(String[] findKeys, Object[] findValues,String collectionName,String sort ,List<String> hostFieldDesc){
        Map<String,Object> map = new HashMap<>();
//        Criteria criteria = Criteria.where(generalName).ne("").ne("-1");
        Criteria criteria = null;
        for (int i = 0; i < findKeys.length; i++) {
            if (i == 0) {
                if (findValues[i].equals("")||findValues[i] == null){
                    continue;
                }
                // 改为模糊查询
//                criteria = Criteria.where(findKeys[i]).is(findValues[i]);
                if (findKeys[i].equals("resTypeCode")){
                    criteria = Criteria.where(findKeys[i]).regex("^"+findValues[i]+ ".*$");
                }else {
                    criteria = Criteria.where(findKeys[i]).regex("^.*" +findValues[i]+ ".*$");
                }
            } else {
                if (findValues[i].equals("")||findValues[i] == null){
                    continue;
                }
                if (findKeys[i].equals("resTypeCode")){
                    criteria.and(findKeys[i]).regex("^"+findValues[i]+ ".*$");
                }else {
                    criteria.and(findKeys[i]).regex("^.*" +findValues[i]+ ".*$");

                }
            }
        }
        Query query;
        Query countQuert;
        if (criteria == null){
            query =  new Query();
            countQuert = new Query();
        }else {
            query =  Query.query(criteria);
            countQuert = Query.query(criteria);
        }
        if (!sort.equals("")){
            sort="_id";
        }
        query.with(Sort.by(Direction.DESC,sort));
        countQuert.with(Sort.by(Direction.DESC,sort));
//        int nub = (page-1) * size;
        // 添加包含的字段
        for (String s :hostFieldDesc){
            query.fields().include(s); //包含该字段
        }
//        query.skip(nub);
//        query.limit(size);
        List<Map> maps = mongodbUtils.mongoTemplate.find(query, Map.class, collectionName);
        long count = mongodbUtils.mongoTemplate.count(countQuert,collectionName);
        map.put("data", maps);
        map.put("count",count);
        return map;
    }
    /**
     * 根据条件查询出符合的第一条数据 集合为数据对象中 @Document 注解所配置的collection
     *
     * @param obj
     *            数据对象
     * @param findKeys
     *            查询条件 key
     * @param findValues
     *            查询条件 value
     * @return
     */
    public static Object findOne(Object 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);
        Object resultObj = mongodbUtils.mongoTemplate.findOne(query, obj.getClass());
        return resultObj;
    }

    /**
     * 指定集合 根据条件查询出符合的第一条数据
     *
     * @param obj
     *            数据对象
     * @param findKeys
     *            查询条件 key
     * @param findValues
     *            查询条件 value
     * @param collectionName
     *            集合名
     * @return
     */
    public static Object findOne(Object 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);
        Object resultObj = mongodbUtils.mongoTemplate.findOne(query, obj.getClass(), collectionName);
        return resultObj;
    }

    /**
     * 查询出所有结果集 集合为数据对象中 @Document 注解所配置的collection
     *
     * @param obj
     *            数据对象
     * @return
     */
    public static List<? extends Object> findAll(Object obj) {

        List<? extends Object> resultList = mongodbUtils.mongoTemplate.findAll(obj.getClass());
        return resultList;
    }

    /**
     * 查询出所有结果集 集合为数据对象中 @Document 注解所配置的collection
     * @param clazz
     * @param <T>
     * @return
     */
    public static <T>  List<T> findAll(Class<T> clazz){
        List<T> resultList = mongodbUtils.mongoTemplate.findAll(clazz);
        return resultList;
    }

    /**
     * 指定集合 查询出所有结果集
     *
     * @param obj
     *            数据对象
     * @param collectionName
     *            集合名
     * @return
     */
    public static List<? extends Object> findAll(Object obj, String collectionName) {

        List<? extends Object> resultList = mongodbUtils.mongoTemplate.findAll(obj.getClass(), collectionName);
        return resultList;
    }

    /**
     * 指定集合 查询出所有结果集
     * @param clazz
     * @param collectionName
     * @param <T>
     * @return
     */
    public static <T> List<T> findAll(Class<T> clazz, String collectionName) {
        List<T> resultList = mongodbUtils.mongoTemplate.findAll(clazz, collectionName);
        return resultList;
    }


}