mongodb(三) spring中mongodb的简化操作

介绍?

spring 操作mongodb 数据，我目前接触的方式有两种，一种是mongoTemplate、一种是springData jpa那种东西。本人在项目中使用的是 ：?两种都用了。

mongoTemplate ：
		优势：写法简单、直接封装好的，用就OK
		缺点：1）用它你不用写mql ,长期使用会让你忘记怎么去操作数据库的（只用这个api,会出问题的，不利于长期发张），
					2）写法太臃肿了。基本的查询方法，如根据id 查对象，都需要自己写、`费劲`

springData JPA : 
		优势：具备一些基本的增删改查操作、可以大幅度提成开发效率
		缺点：查询的时候，`关键字为空`会报错（因为它是接口、so,没法判断啊，当然也可以解决，
	啰嗦啊，?，说多了都是泪，mongodb 坑太多）

mongoTemplate ☂️

给大家贡献一个由我封装的mongoTemplate 类，直接注入到spring中就行了，个人平时就比较懒，喜欢写各种工具类，还好?领导比较支持，由此也耽误了一些时间，不过最终的成果还是不错的，程序员如果不能让自己变懒，怎么能写出高质量的代码呢？?，卓见，别喷我，哈哈

下面给源码:

源码

/**
 * 描述：
 * User liupenghao
 * Date 2018/11/06 11:15
 **/
@Component
public class MongoQueryService<T> {

    @Resource
    private MongoTemplate mongoTemplate;

    /**
     * 单个等值查询
     *
     * @param query query
     * @param key   key
     * @param value value
     * @return query
     */
    public Query getEqualQuery(Query query, String key, Object value) {
        if (query == null) {
            query = new Query();
        }
        if (value == null) {
            return query;
        }

        query.addCriteria(Criteria.where(key).is(value));

        return query;
    }

    /**
     * 获取等值的查询对象
     *
     * @param query query
     * @param keys keys
     * @param values values
     * @return query query
     */
    public Query getEqualQuery(Query query, String[] keys, Object[] values) {
        if (keys.length == 0 || values.length == 0 || keys.length != values.length) {
            throw new ServiceException(ResultEnum.QUERY_PARAMS_ERROR);
        }
        if (query == null) {
            query = new Query();
        }
        // 移除 查询字段为空的情况
        for (int i = 0; i < keys.length; i++) {
            String key = keys[i];
            Object value = values[i];

            if (StringUtils.isEmpty(key)) {
                throw new ServiceException(ResultEnum.QUERY_PARAMS_ERROR);
            }

            if (value == null) {
                continue;
            }

            if (value instanceof String) {
                if (StringUtils.isEmpty(value.toString())) {
                    continue;
                }
            }
            query.addCriteria(new Criteria(key).is(value));
        }
        return query;
    }

    /**
     * 日期区间查询
     *
     * @param fieldName field name
     * @param start     start
     * @param end       end
     * @return query
     */
    public Query getDateQuery(String fieldName, Date start, Date end) {
        return getRangeQuery(null, fieldName, start, end, true, false);
    }

    /**
     * 返回范围查询的Query
     *
     * @param start        开始
     * @param end          结束
     * @param startInclude 是否包括开始
     * @param endInclude   是否包括结束
     * @return query
     */
    public Query getRangeQuery(Query query, String fieldName, Object start, Object end, boolean startInclude, boolean endInclude) {
        if (query == null) {
            query = new Query();
        }
        if (start == null || end == null) {
            return query;
        }
        if (startInclude) {
            if (endInclude) {
                query.addCriteria(Criteria.where(fieldName).gte(start).lte(end));
            } else {
                query.addCriteria(Criteria.where(fieldName).gte(start).lt(end));
            }
        } else {
            if (endInclude) {
                query.addCriteria(Criteria.where(fieldName).gt(start).lte(end));
            } else {
                query.addCriteria(Criteria.where(fieldName).gt(start).lt(end));
            }
        }
        return query;
    }


    /**
     * <pre>
     * 适用于多个字段有一个值来匹配，
     * 获取正则 模糊匹配的Query
     * </pre>
     *
     * @param query      query
     * @param fieldNames names
     * @param value      value
     * @return query
     */
    public Query getRegexQuery(Query query, String[] fieldNames, String value) {
        if (query == null) {
            query = new Query();
        }
        Criteria criteria = getRegexCriteria(fieldNames, value);
        if (criteria == null) {
            return query;
        }
        query.addCriteria(criteria);
        return query;
    }

    /**
     * <pre>
     * 适用于多个字段有一个值来匹配，
     * 获取正则 模糊匹配的Query
     * </pre>
     *
     * @param fieldNames names
     * @param value      value
     * @return query
     */
    public Criteria getRegexCriteria(String[] fieldNames, String value) {
        if (fieldNames == null || fieldNames.length <= 0) {
            throw new ServiceException(ResultEnum.QUERY_PARAMS_ERROR);
        }
        if (StringUtils.isEmpty(value)) {
            return null;
        }
        List<Criteria> items = new ArrayList<>();
        for (String entity : fieldNames) {
            if (!StringUtils.isEmpty(entity)) {
                items.add(Criteria.where(entity).regex(value, "i"));
            }
        }
        return new Criteria().orOperator(items.toArray(new Criteria[0]));
    }

    /**
     * 分页查询查询的封装
     *
     * @param sort sort
     * @param query query
     * @param page page
     * @param size size
     * @param clazz clazz
     * @return page page
     */
    public PageImpl<T> getPageQueryResultSort(Sort sort, Query query, Integer page, Integer size, Class<T> clazz) {
        if (page == null) {
            page = 0;
        }
        if (size == null) {
            size = 10;
        }
        Pageable pageable = PageRequest.of(page, size, sort);
        long count = mongoTemplate.count(query, clazz);
        if (count <= 0) {
            return new PageImpl<>(new ArrayList<>(0), pageable, 0);
        }
        query.with(pageable);
        List<T> data = mongoTemplate.find(query, clazz);
        return new PageImpl<>(data, pageable, count);
    }

    /**
     * <pre>
     * 分页查询查询的封装：
     *      默认通过createTime 倒叙排列,
     *          可以通过getPageQueryResultSort,自定义排序逻辑
     * </pre>
     *
     * @param clazz clazz
     * @param query query
     * @param page  page
     * @param size  size
     * @return page
     */
    public PageImpl<T> getPageQueryResult(Query query, Integer page, Integer size, Class<T> clazz) {
        Sort sort = new Sort(Sort.Direction.DESC, "createTime");
        return getPageQueryResultSort(sort, query, page, size, clazz);
    }
}

用法 ?

• 1）将上面给出的类，加入到@CompmentSan ，即spring 的扫描路径中
• 2）直接在service实现类中注入就行，示例如下：

@Resource
private MongoQueryService<ExamMember> mongoQueryService;

springData JPA ☂️

源码地址