springboot实现操作mongodb,储存file文件以及基本数据的增删改查

前言

能找到这篇文章说明mg的基本介绍以及优缺点我就不介绍了，本文主要介绍java中如何对的mg的操作。

一、配置mongodb

1、依赖:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>

2、yml配置：

springboot对于mongo很友好,在引入包依赖后,直接在yam文件配置mongo的文件信息直接就可以用,请注意数据的格式。

二、对mg进行操作

2.1、对文件的存储

       可以直接注入，本人做过demo层级的测试,证明GridFsTemplate是确实可行。

 

2.2、基本的数据的增删改查

@Component
public class MongodbUtils {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
     * 根据ID查询
     *
     * @param id        ID
     * @param tableName 表名
     * @return
     */
    public JSONObject findById(String id, String tableName) {
        Query query = new Query();
        query.addCriteria(Criteria.where("ID").is(id));
        return findOne(query, tableName);
    }

    /**
     * 查询单条数据
     *
     * @param query     查询条件
     * @param tableName 表名
     */
    public JSONObject findOne(Query query, String tableName) {
        return mongoTemplate.findOne(query, JSONObject.class, tableName);
    }

    /**
     * 查询表中所有数据
     *
     * @param tableName 表名
     * @return
     */
    public List<JSONObject> findAll(String tableName) {
        return mongoTemplate.findAll(JSONObject.class, tableName);
    }

    /**
     * 条件查询 只支持and的关系
     *
     * @param map       条件 key=id value=1 查询id为1的数据
     * @param tableName 表名
     * @return
     */
    public List<JSONObject> find(Map<String, Object> map, String tableName) {
        Query quey = new Query();
        for (Map.Entry<String, Object> m : map.entrySet()) {
            String key = m.getKey();
            Object value = m.getValue();
            quey.addCriteria(Criteria.where(key).is(value));
        }
        return find(quey, tableName);
    }

    /**
     * 查询表是否存在
     *
     * @param tableName
     * @return
     */
    public boolean findTable(String tableName) {
        return mongoTemplate.exists(new Query(), tableName);
    }


    /**
     * 条件排序查询
     *
     * @param map       参数
     * @param tableName 表名
     * @param sort      排序字段
     * @return
     */
    public List<JSONObject> findSortList(Map<String, Object> map, String tableName, String sort) {
        Query quey = new Query();
        for (Map.Entry<String, Object> m : map.entrySet()) {
            String key = m.getKey();
            Object value = m.getValue();
            quey.addCriteria(Criteria.where(key).is(value));
        }
        quey.with(new Sort(Sort.Direction.ASC, sort));
        return find(quey, tableName);
    }


    /**
     * 新增一条数据
     *
     * @param json      数据
     * @param tableName 表名字
     */
    public void save(String tableName, Object json) {
        mongoTemplate.insert(json, tableName);
    }

    /**
     * 批量插入
     *
     * @param list      数据集合
     * @param tableName 表名
     */
    public void batchSave(List<Object> list, String tableName) {
        if (list != null && list.size() > 0) {
            // BulkMode.UNORDERED:表示并行处理，遇到错误时能继续执行不影响其他操作；BulkMode.ORDERED：表示顺序执行，遇到错误时会停止所有执行
            BulkOperations ops = mongoTemplate.bulkOps(BulkOperations.BulkMode.UNORDERED, tableName);
            ops.insert(list);
            ops.execute();
        }
    }


    /**
     * 更新符合条件的所有数据
     *
     * @param query     条件
     * @param update    更新的属性和值
     * @param tableName 表名
     * @return 更新状态
     */
    public void updateMulti(Query query, Update update, String tableName) {
        mongoTemplate.updateMulti(query, update, tableName);
    }

    /**
     * 条件查询
     *
     * @param query     条件
     * @param tableName 表名
     */
    public List<JSONObject> find(Query query, String tableName) {
        return mongoTemplate.find(query, JSONObject.class, tableName);
    }

    /**
     * 删除指定的数据
     *
     * @param json
     * @param tableName 表名
     * @return
     */
    public DeleteResult delete(Query json, String tableName) {
        return mongoTemplate.remove(json, tableName);
    }


    /**
     * 数量
     */
    public long count(Query query, String tableName) {
        return mongoTemplate.count(query, tableName);
    }

    /**
     * group by
     */
    public GroupByResults<JSONObject> group(Criteria criteria, String inputCollectionName, GroupBy groupBy,
                                            Class<JSONObject> entityClass) {
        return mongoTemplate.group(criteria, inputCollectionName, groupBy, entityClass);
    }


    /**
     * 通过ID删除
     *
     * @param ID
     * @param tableName
     */
    public void deleteByID(String ID, String tableName) {
        Query query = new Query();
        query.addCriteria(Criteria.where("_id").is(ID));
        delete(query, tableName);
    }


    /**
     * 删除表
     *
     * @param tableName
     * @return
     */
    public void deleteTable(String tableName) {
        mongoTemplate.dropCollection(tableName);
    }


    /**
     * 查询key
     *
     * @param deptName
     * @return
     */
    public JSONObject getKeyObjectOne(String deptName, Criteria criteria) {
        String deptTableName = CollectionNameUtil.getDeptTableName(deptName);
        Aggregation agg =
                Aggregation.newAggregation(
                        Aggregation.match(criteria),
                        Aggregation.unwind("head"),
                        Aggregation.replaceRoot("head"),
                        Aggregation.skip(0),
                        Aggregation.limit(1)
                );
        return mongoTemplate.aggregate(agg, deptTableName, JSONObject.class).getMappedResults().get(0);
    }

    /**
     * 查询data
     *
     * @param deptName
     * @return
     */
    public List<JSONObject> getDataObjectList(String deptName, Criteria criteria,long skip,long limit) {
        String deptTableName = CollectionNameUtil.getDeptDataName(deptName);
        Aggregation agg =
                Aggregation.newAggregation(
                        Aggregation.match(criteria),
                        Aggregation.unwind("body"),
                        Aggregation.replaceRoot("body"),
                        Aggregation.skip(skip),
                        Aggregation.limit(limit)
                );
        return mongoTemplate.aggregate(agg, deptTableName, JSONObject.class).getMappedResults();
    }


}

直接上代码吧,不多说了,可用。关注一下,互相交流学习。

mongoTemplate不介绍了,自行百度吧。

---

总结

没有最好的技术,只有对业务最友好的技术。