SpringBoot 整合 MongoDB

已于 2023-08-16 15:04:32 修改
阅读量929 收藏 2
点赞数 1
分类专栏： SpringBoot 文章标签： mongodb spring boot 数据库
于 2023-06-29 08:53:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baihaibo1024/article/details/131402602
版权

1. pom.xml

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.12</version>
</dependency>

2. 分页工具类

import lombok.Data;

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

/**
 * 分页工具类
 */
@Data
public class PageHelper<T> implements Serializable {
    
    // 当前页数
    private long currentPage;
    // 总记录数
    private long total;
    // 页大小
    private long pageSize;
    // 总页数
    private int totalPage;
    // 数据列表
    private List<T> list;
    
    public PageHelper(long pageNum, long pageSize, long total, List<T> list) {
        this.currentPage = pageNum;
        this.pageSize = pageSize;
        this.total = total;
        this.list = list;
        this.totalPage = (int) Math.ceil((double) total / pageSize);
    }
    
    public PageHelper(long pageNum, long pageSize, List<T> list) {
        this.currentPage = pageNum;
        this.pageSize = pageSize;
        this.list = list;
    }
}

3. MongoDB 分页工具类

import org.springframework.data.mongodb.core.query.Query;
import org.springframework.stereotype.Component;

import java.util.List;

/**
 * MongoDB 分页工具类
 */
@Component
public class MongoPage<T> {

    private Integer pageSize;
    private Integer currentPage;

    public void initPage(Integer currentPage, Integer pageSize, Query query) {
        pageSize = pageSize == 0 ? 20 : pageSize;
        query.limit(pageSize);
        query.skip((currentPage - 1) * pageSize);
        this.pageSize = pageSize;
        this.currentPage = currentPage;
    }

    public PageHelper<T> pageHelper(long total, List<T> list) {
        return new PageHelper<>(this.currentPage, total, this.pageSize, list);
    }

    public PageHelper<T> pageHelper(List<T> list) {
        return new PageHelper<>(this.currentPage, this.pageSize, list);
    }

    public PageHelper<T> pageHelper(long currentPage, long total, long pageSize, List<T> list) {
        return new PageHelper<>(currentPage, total, pageSize, list);
    }

    public PageHelper<T> pageHelper(long currentPage, long pageSize, List<T> list) {
        return new PageHelper<>(currentPage, pageSize, list);
    }
}

4. MongoDB API

import org.springframework.data.domain.Sort;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Update;

import java.util.List;
import java.util.Map;

/**
 * MongoDB API
 */
public interface MongoDBDao {

    /**
     * 创建集合
     *
     * @param collectionName 集合名
     */
    boolean createCollection(String collectionName);

    /**
     * 删除集合
     *
     * @param collectionName 集合名
     */
    boolean dropCollection(String collectionName);

    /**
     * 插入一条记录，如已存在则抛出异常
     *
     * @param o 记录
     * @param collectionName 集合名
     */
    boolean insert(Object o, String collectionName);

    /**
     * 插入一条记录，如已存在则抛出异常
     *
     * @param o 记录
     */
    boolean insert(Object o);

    /**
     * 插入多条记录，如已存在则抛出异常
     *
     * @param o 记录
     * @param c 插入的类型
     */
    boolean insertAll(List o, Class c);

    /**
     * 插入一条记录，如已存在则更新
     *
     * @param o 记录
     * @param collectionName 集合名
     */
    void save(Object o, String collectionName);

    /**
     * 查询集合中全部记录
     *
     * @param c 返回的类型
     * @param collectionName 集合名
     */
    Object findAll(Class c, String collectionName);

    /**
     * 根据 id 查询
     *
     * @param id 记录 id
     * @param c 返回的类型
     */
    Object findById(String id, Class c);

    /**
     * 根据 ids 查询
     *
     * @param idName 主键字段名
     * @param ids id 集合
     * @param c 返回的类型
     */
    Object findByIds(String idName, List<String> ids, Class c);

    /**
     * 根据条件查询一条记录
     *
     * @param criteria 条件拼接，如：Criteria.where("name").is("bai")
     * @param c 返回的类型
     * @param collectionName 集合名
     */
    Object findOne(Criteria criteria, Class c, String collectionName);

    /**
     * 根据条件查询记录列表
     *
     * @param criteria 条件拼接
     * @param c 返回的类型
     * @param sorts 需要排序的字段集合
     */
    Object findByCondition(Criteria criteria, Class c, List<Sort> sorts);

    /**
     * 根据条件查询记录列表
     *
     * @param criteria 条件拼接
     * @param c 返回的类型
     * @param collectionName 集合名
     */
    Object findByCondition(Criteria criteria, Class c, String collectionName);

    /**
     * 根据条件查询记录列表
     *
     * @param criteria 条件拼接
     * @param c 返回的类型
     * @param collectionName 集合名
     * @param limit 数量
     */
    Object findByCondition(Criteria criteria, Class c, int limit, String collectionName);

    /**
     * 根据条件查询记录列表
     *
     * @param criteria 条件拼接
     * @param c 返回的类型
     * @param collectionName 集合名
     * @param limit 数量
     * @param sort 排序
     */
    Object findByCondition(Criteria criteria, Class c, int limit, Sort sort, String collectionName);

    /**
     * 根据条件查询记录列表
     *
     * @param criteria 条件拼接
     * @param c 返回的类型
     * @param pageNum 当前页
     * @param pageSize 页大小
     * @param sorts 需要排序的字段集合
     */
    Object findByCondition(Criteria criteria, Class c, Integer pageNum, Integer pageSize, List<Sort> sorts);

    /**
     * 根据条件查询记录列表
     *
     * @param criteria 条件拼接
     * @param c 返回的类型
     * @param collectionName 集合名
     * @param pageNum 当前页
     * @param pageSize 页大小
     * @param sorts 需要排序的字段集合
     */
    Object findByCondition(Criteria criteria, Class c, String collectionName, Integer pageNum, Integer pageSize, List<Sort> sorts);

    /**
     * 分组查询
     *
     * @param criteria 条件拼接
     * @param c 返回的类型
     * @param fields 需要分组的字段
     * @param collectionName 集合名
     * @param pageNum 当前页数
     * @param pageSize 页大小
     */
    Object group(Criteria criteria, Class c, String[] fields, String collectionName, long pageNum, long pageSize);

    /**
     * 分组查询
     *
     * @param criteria 条件拼接
     * @param c 返回的类型
     * @param fields 需要分组的字段
     * @param collectionName 集合名
     */
    Object group(Criteria criteria, Class c, String[] fields, String collectionName);

    /**
     * 返回指定字段
     *
     * @param criteria 条件拼接
     * @param c 返回的类型
     * @param collectionName 集合名
     */
    Object findPropertyByCondition(Criteria criteria, Class c, String collectionName, String[] includes);

    /**
     * 返回满足条件的文档数量
     *
     * @param criteria 条件拼接
     * @param collectionName 集合名
     */
    long count(Criteria criteria, String collectionName);

    /**
     * 返回满足条件的文档数量
     *
     * @param criteria 条件拼接
     * @param c 返回的类型
     */
    long count(Criteria criteria, Class c);

    /**
     * 更新满足条件的第一条文档
     *
     * @param criteria 条件拼接
     * @param update new Update().set("age",20).set("name","bai");
     * @param collectionName 集合名
     */
    Object updateOne(Criteria criteria, Update update, String collectionName);

    /**
     * 更新满足条件的第一条文档
     *
     * @param criteria 条件拼接
     * @param update new Update().set("age",20).set("name","bai");
     * @param c 修改的类型
     */
    Object updateOne(Criteria criteria, Update update, Class c);

    /**
     * 更新所有满足条件的文档
     *
     * @param criteria 条件拼接
     * @param update new Update().set("age",20).set("name","bai");
     * @param collectionName 集合名
     */
    Object updateMany(Criteria criteria, Update update, String collectionName);

    /**
     * 更新所有满足条件的文档
     *
     * @param criteria 条件拼接
     * @param update new Update().set("age",20).set("name","bai");
     * @param c 修改的类型
     */
    Object updateMany(Criteria criteria, Update update, Class c);

    /**
     * 删除满足条件的信息
     *
     * @param criteria 条件拼接
     * @param collectionName 集合名
     */
    Object delete(Criteria criteria, String collectionName);

    /**
     * 删除满足条件的信息
     *
     * @param criteria 条件拼接
     * @param c 删除的类型
     */
    Object delete(Criteria criteria, Class c);

    /**
     * 获取拼接条件
     *
     * @param map 查询参数
     */
    Criteria getCriteria(Map<String, Object> map);

    /**
     * 获取拼接条件
     *
     * @param map 查询参数
     * @param skipFields 过滤掉的字段
     */
    Criteria getCriteria(Map<String, Object> map, List<String> skipFields);

    /**
     * 获取拼接条件
     *
     * @param map 查询参数
     * @param skipFields 过滤掉的字段
     * @param likeFields 模糊查询的字段
     */
    Criteria getCriteria(Map<String, Object> map, List<String> skipFields, List<String> likeFields);

    /**
     * 获取拼接条件
     *
     * @param map 查询字段
     * @param skipFields 过滤掉的字段
     * @param likeFields 模糊查询的字段
     * @param inFields 使用 in 的查询字段
     */
    Criteria getCriteria(Map<String, Object> map, List<String> skipFields, List<String> likeFields, List<String> inFields);
}

5. MongoDB API 实现类

import org.springframework.data.domain.Sort;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.aggregation.Aggregation;
import org.springframework.data.mongodb.core.aggregation.AggregationResults;
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.stereotype.Repository;
import org.springframework.util.StringUtils;

import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;

/**
 * MongoDB 处理类
 */
@Repository
public class MongoDBDaoImpl implements MongoDBDao {

    @Resource
    private MongoTemplate mongoTemplate;

    @Resource
    private MongoPage mongoPage;

    @Override
    public boolean createCollection(String collectionName) {
        if (mongoTemplate.collectionExists(collectionName)) {
            return true;
        }
        mongoTemplate.createCollection(collectionName);
        return mongoTemplate.collectionExists(collectionName);
    }

    @Override
    public boolean dropCollection(String collectionName) {
        if (!mongoTemplate.collectionExists(collectionName)) {
            return true;
        }
        mongoTemplate.getCollection(collectionName).drop();
        return !mongoTemplate.collectionExists(collectionName);
    }

    @Override
    public boolean insert(Object o, String collectionName) {
        try {
            mongoTemplate.insert(o, collectionName);
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    @Override
    public boolean insert(Object o) {
        try {
            mongoTemplate.insert(o);
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    @Override
    public boolean insertAll(List o, Class c) {
        try {
            mongoTemplate.insert(o, c);
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    @Override
    public void save(Object o, String collectionName) {
        mongoTemplate.save(o, collectionName);
    }

    @Override
    public Object findAll(Class c, String collectionName) {
        return mongoTemplate.findAll(c, collectionName);
    }

    @Override
    public Object findById(String id, Class c) {
        return mongoTemplate.findById(id, c);
    }

    @Override
    public Object findByIds(String idName, List<String> ids, Class c) {
        Criteria in = Criteria.where(idName).in(ids);
        Query query = new Query(in);
        return mongoTemplate.find(query, c);
    }

    @Override
    public Object findOne(Criteria criteria, Class c, String collectionName) {
        Query query = new Query(criteria);
        return mongoTemplate.findOne(query, c, collectionName);
    }

    @Override
    public Object findByCondition(Criteria criteria, Class c, List<Sort> sorts) {
        Query query = new Query(criteria);
        if (sorts != null && sorts.size() > 0) {
            for (Sort sort : sorts) {
                query = query.with(sort);
            }
        }
        return mongoTemplate.find(query, c);
    }

    @Override
    public Object findByCondition(Criteria criteria, Class c, String collectionName) {
        return findByCondition(criteria, c, 0, collectionName);
    }

    @Override
    public Object findByCondition(Criteria criteria, Class c, int limit, String collectionName) {
        return findByCondition(criteria, c, limit, null, collectionName);
    }

    @Override
    public Object findByCondition(Criteria criteria, Class c, int limit, Sort sort, String collectionName) {
        Query query = new Query(criteria);
        if (sort != null) {
            query = query.with(sort);
        }
        if (limit > 0) {
            query.limit(limit);
        }
        return mongoTemplate.find(query, c, collectionName);
    }

    @Override
    public Object findByCondition(Criteria criteria, Class c, Integer pageNum, Integer pageSize, List<Sort> sorts) {
        return findByCondition(criteria, c, null, pageNum, pageSize, sorts);
    }

    @Override
    public Object findByCondition(Criteria criteria, Class c, String collectionName, Integer pageNum, Integer pageSize, List<Sort> sorts) {
        Query query = new Query(criteria);
        if (sorts != null && sorts.size() > 0) {
            for (Sort sort : sorts) {
                query = query.with(sort);
            }
        }

        long count = 0;
        if (StringUtils.hasText(collectionName)) {
            count = mongoTemplate.count(query, c);
        } else {
            count = mongoTemplate.count(query, collectionName);
        }

        mongoPage.initPage(pageNum, pageSize, query);
        List list = new ArrayList<>();
        if (StringUtils.hasText(collectionName)) {
            list = mongoTemplate.find(query, c);
        } else {
            list = mongoTemplate.find(query, c, collectionName);
        }
        return mongoPage.pageHelper(count, list);
    }

    @Override
    public long count(Criteria criteria, String collectionName) {
        Query query = new Query(criteria);
        return mongoTemplate.count(query, collectionName);
    }

    @Override
    public Object updateOne(Criteria criteria, Update update, String collectionName) {
        Query query = new Query(criteria);
        return mongoTemplate.updateFirst(query, update, collectionName);
    }

    @Override
    public Object updateMany(Criteria criteria, Update update, String collectionName) {
        Query query = new Query(criteria);
        return mongoTemplate.updateMulti(query, update, collectionName);
    }

    @Override
    public Object delete(Criteria criteria, String collectionName) {
        Query query = new Query(criteria);
        return mongoTemplate.remove(query, collectionName);
    }

    @Override
    public long count(Criteria criteria, Class c) {
        Query query = new Query(criteria);
        return mongoTemplate.count(query, c);
    }

    @Override
    public Object updateOne(Criteria criteria, Update update, Class c) {
        Query query = new Query(criteria);
        return mongoTemplate.updateFirst(query, update, c);
    }

    @Override
    public Object updateMany(Criteria criteria, Update update, Class c) {
        Query query = new Query(criteria);
        return mongoTemplate.updateMulti(query, update, c);
    }

    @Override
    public Object delete(Criteria criteria, Class c) {
        Query query = new Query(criteria);
        return mongoTemplate.remove(query, c);
    }

    @Override
    public Object group(Criteria criteria, Class c, String[] fields, String collectionName, long currentPage, long pageSize) {
        pageSize = pageSize == 0 ? 20 : pageSize;
        currentPage = currentPage == 0 ? 1 : currentPage;

        Aggregation aggregation = Aggregation.newAggregation(Aggregation.match(criteria),
                Aggregation.group(fields).count().as("sum"),
                Aggregation.sort(Sort.by(Sort.Direction.DESC, "sum")),
                Aggregation.skip((currentPage - 1) * pageSize),
                Aggregation.limit(pageSize));

        AggregationResults aggregate = mongoTemplate.aggregate(aggregation, collectionName, c);
        return mongoPage.pageHelper(currentPage, pageSize, aggregate.getMappedResults());
    }

    @Override
    public Object group(Criteria criteria, Class c, String[] fields, String collectionName) {
        Aggregation aggregation = Aggregation.newAggregation(Aggregation.match(criteria),
                Aggregation.group(fields).count().as("sum"),
                Aggregation.sort(Sort.by(Sort.Direction.DESC, "sum")));

        AggregationResults aggregate = mongoTemplate.aggregate(aggregation, collectionName, c);
        return aggregate.getMappedResults();
    }

    @Override
    public Object findPropertyByCondition(Criteria criteria, Class c, String collectionName, String[] includes) {
        Query query = new Query(criteria);
        query.fields().exclude("_id");
        if (!StringUtils.hasText(Arrays.toString(includes))) {
            for (String result : includes) {
                query.fields().include(result);
            }
        }
        return mongoTemplate.find(query, c, collectionName);
    }

    @Override
    public Criteria getCriteria(Map<String, Object> map) {
        return getCriteria(map, null, null, null);
    }

    @Override
    public Criteria getCriteria(Map<String, Object> map, List<String> skipFields) {
        return getCriteria(map, skipFields, null, null);
    }

    @Override
    public Criteria getCriteria(Map<String, Object> map, List<String> skipFields, List<String> likeFields) {
        return getCriteria(map, skipFields, likeFields, null);
    }

    @Override
    public Criteria getCriteria(Map<String, Object> map, List<String> skipFields, List<String> likeFields, List<String> inFields) {
        Criteria criteria = Criteria.where("1").is(1);
        for (String key : map.keySet()) {

            // 过滤掉的字段
            if (skipFields != null && skipFields.contains(key)) {
                continue;
            }

            // 模糊查询的字段
            if (likeFields != null && likeFields.contains(key)) {
                criteria.and(key).regex(".*" + map.get(key) + ".*");
                continue;
            }

            // 使用 in 的查询字段
            if (inFields != null && inFields.contains(key)) {
                criteria.and(key).in(map.get(key));
                continue;
            }

            // TODO: 日期范围查询模板
            if ("startTime".equals(key)) {
                criteria.andOperator(Criteria.where("createTime").gte(formatTime((LocalDateTime) map.get("startTime"))),
                        Criteria.where("createTime").lte(formatTime((LocalDateTime) map.get("endTime"))));
                continue;
            }

            // 其他正常查询字段
            criteria.and(key).is(map.get(key));
        }
        return criteria;
    }

    /**
     * 格式化时间
     */
    private String formatTime(LocalDateTime time) {
        return time.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
    }
}

6. 测试类

import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;
import lombok.Data;
import org.springframework.data.domain.Sort;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Update;

import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * 测试类
 */
public class MongoService {

    @Resource
    private MongoDBDao mongoDBDao;

    /**
     * 查询列表
     */
    public PageHelper<User> queryList(Map<String, Object> map) {
        List<String> likeFields = new ArrayList<>();
        likeFields.add("name");
        Criteria criteria = mongoDBDao.getCriteria(map, likeFields);

        List<Sort> sortList = new ArrayList<>();
        sortList.add(Sort.by(Sort.Order.desc("createTime")));
        return (PageHelper<User>) mongoDBDao.findByCondition(criteria, User.class,
                Integer.parseInt((String) map.get("pageNum")),
                Integer.parseInt((String) map.get("pageSize")), sortList);
    }


    /**
     * 插入一条数据
     */
    public boolean insert(User user) {
        user.setName("bai");
        user.setCreateTime(LocalDateTime.now());
        return mongoDBDao.insert(user);
    }


    /**
     * 批量插入数据
     */
    public boolean patchInsert(List<User> list) {
        for (User user : list) {
            user.setName("bai");
            user.setCreateTime(LocalDateTime.now());
        }
        return mongoDBDao.insertAll(list, User.class);
    }


    /**
     * 更新数据
     */
    public UpdateResult update(Map<String, Object> map) {
        Criteria criteria = Criteria.where("id").is(map.get("id"));
        Update update = new Update();
        for (String key : map.keySet()) {
            if ("id".equals(key)) {
                continue;
            }
            update = update.set(key, map.get(key));
        }
        return (UpdateResult) mongoDBDao.updateOne(criteria, update, User.class);
    }


    /**
     * 根据 Id 查询数据
     */
    public User findById(String id) {
        return (User) mongoDBDao.findById(id, User.class);
    }


    /**
     * 批量删除
     */
    public Long patchDelete(List<String> ids, String field) {
        Criteria criteria = Criteria.where(field).in(ids);
        DeleteResult deleteCount = (DeleteResult) mongoDBDao.delete(criteria, User.class);
        return deleteCount.getDeletedCount();
    }


    /**
     * 查询数量
     */
    public long count(Map<String, Object> map) {
        Criteria criteria = mongoDBDao.getCriteria(map);
        return mongoDBDao.count(criteria, User.class);
    }


    @Data
    public static class User {
        private Integer id;
        private String name;
        private LocalDateTime createTime;
    }
}
baihb1024
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot整合mongoDB并配置连接池
2301_76267999的博客
03-31 801
如果你选择了IT行业并坚定的走下去，这个方向肯定是没有一丝问题的，这是个高薪行业，但是高薪是凭自己的努力学习获取来的，这次我把P8大佬用过的一些学习笔记（pdf）都整理在本文中了《Java中高级核心知识全面解析》小米商场项目实战，别再担心面试没有实战项目：《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》点击传送门即可获取！” />
Spring连接到MongoDB的几种方法
深圳市多克创新科技有限公司
03-21 1355
Spring连接到MongoDB的几种方法
MongoDB安装及接入springboot
最新发布
LB_bei的博客
05-11 1043
MongoDB是一个开源、高性能、无模式（模式自由）的文档（Bson）型数据库；其特点如下：模式自由 ---- 不需要提前创建表 直接放数据就可以支持高并发 2000以上搭建集群比较方便支持海量数据存储。
springboot 整合monggoDB
dumuzhouguohe的博客
02-20 1885
spring boot 整合monggodb
springboot整合MongoDB
qq_62408075的博客
07-26 405
【代码】springboot整合MongoDB。
SpringBoot操作MongoDB数据库
m0_65563175的博客
12-29 1610
MongoTemplate开发spring-data-mongodb提供了MongoTemplate和MongoRepository两种方式访问MongoDB，MongoRepository的方式访问较为简单，MongoTemplate方式较为灵活，这两种方式在Java对于MongoDB的运用中相辅相成。
SpringBoot整合MongoDB详解
weixin_43564627的博客
12-14 558
SpringBoot整合MongoDB详解
springboot整合mongodb
07-23
mongodb版本号3.2,需手动开启http服务，启动时使用命令 ./mongod --httpinterface 新增 修改 删除 查询 排序 分页 可查看： https://blog.csdn.net/m0_37132783/article/details/96992439
springboot整合mongodb changestream代码
02-23
1、java客户端使用mongodb changestream代码 2、springboot整合mongodb changestream代码
SpringBoot整合MongoDB测试demo
02-15
Springboot整合MongoDB，包含Mongo的工具类以及测试类，只需配置自己的mongodb地址，开箱即用
详解springboot整合mongodb
08-30
Spring Boot 整合 MongoDB 本篇文章主要介绍了 Spring Boot 如何整合 MongoDB，并提供了详细的示例代码和配置文件，帮助读者快速上手使用 Spring Boot 和 MongoDB 进行开发。 Spring Boot 整合 MongoDB 的必要条件...
使用spring连接及操作mongodb3.0实例
08-31
主要介绍了使用spring连接及操作mongodb3.0实例，详细的介绍了使用spring的情况下，在java中简单操作mongodb。有兴趣的可以了解一下。
springboot整合mongodb详解
08-03
springboot整合mongodb详解，涵盖了几乎所有的开发中与mongodb操作相关的日常API的使用
在springboot中添加mongodb实现分页查询
weixin_42250577的博客
03-09 1568
在springboot中添加mongodb实现分页查询 1、添加maven依赖 <!--使用mongodb--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-mongodb</artifactId> </dependency> 2、注入mongodbTeml
Spring Boot中MongoDB的使用和实战
showswoller的博客
10-26 2524
Spring Boot中MongoDB的使用和实战 附有源码 讲解详细
SpringBoot简单使用MongoDB
李长渊的博客
11-16 5446
SpringBoot简单使用MongoDB
SpringBoot2.x集成MongoDB
热门推荐
LarsCheng's Blog
08-09 2万+
1.开发环境 IDEA、Maven、SpringBoot2.0.4、Jdk1.8、MongoDB4.0、MongoDB Compass Community、PostMan 2.MongoDB MongoDB（来自于英文单词“Humongous”，中文含义为“庞大”）是可以应用于各种规模的企业、各个行业以及各类应用程序的开源数据库。基于分布式文件存储的数据库。由C++语言编写。旨在为W...
SpingBoot整合MongoDB中分页查询
weixin_44130081的博客
05-14 2770
SpingBoot整合MongoDB中分页查询 废话不多说直接上代码，简单易懂，开箱即用 package com.tk.portal.utils; import java.util.List; /** * mongoDb分页对象 */ public class PageResult<T> { //当前业 private Integer pageNum; //每页...
Spring boot连接和操作mongoDB的两种方式
繁星、晚风
10-16 1万+
第一种方式是使用properties进行mongoDB的连接配置 第二种方式是创建配置类进行mongoDB的连接配置 https://blog.csdn.net/newCheng/article/details/77747492
SpringBoot整合MongoDB
09-24
SpringBoot整合MongoDB是通过使用MongoTemplate来实现对MongoDB数据库的操作。首先，需要在pom.xml文件中添加MongoDB的依赖。然后，在应用程序的配置文件中配置MongoDB的连接信息。接下来，创建一个实体类，用于映射...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值