springboot整合mongodb

最新推荐文章于 2020-10-18 09:26:53 发布
最新推荐文章于 2020-10-18 09:26:53 发布
阅读量4.2k 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 数据库 文章标签： mongodb 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_41205148/article/details/103615194

springboot整合mongodb

实现方式1

添加maven依赖

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

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
</dependency>

配置文件

server.port=8091

#数据库连接
spring.datasource.url=jdbc:mysql://localhost:3306/test?useUnicode=true
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.username=root
spring.datasource.password=root

#mybatis配置
mybatis.type-aliases-package=com.congge.entity
mybatis.mapper-locations=classpath:mybatis/*.xml

#mongodb配置
spring.data.mongodb.uri=mongodb://192.168.111.132:27017/congge

添加对应实体类

package com.congge.entity;

import java.util.Date;

import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;
@Data
@Document(collection="book")
public class Book {
	
	@Id
	private String id;
	
	private Integer price;
	
	private String name;
	
	private String info;
	
	private String publish;
	
	private Date createTime;
	
	private Date updateTime;

}

service层代码实现

package com.congge.service;

import java.util.Date;
import java.util.List;
import java.util.regex.Pattern;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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.stereotype.Service;

import com.congge.entity.Book;

@Service
public class MongoDbService {

	private static final Logger logger = LoggerFactory.getLogger(MongoDbService.class);

	@Autowired
	private MongoTemplate mongoTemplate;

	/**
	 * 保存对象
	 * @param book
	 * @return
	 */
	public String saveObj(Book book) {
		book.setCreateTime(new Date());
		book.setUpdateTime(new Date());
		mongoTemplate.save(book);
		return "添加成功";
	}

	/**
	 * 查询所有
	 * @return
	 */
	public List<Book> findAll() {
		return mongoTemplate.findAll(Book.class);
	}

	/***
	 * 根据id查询
	 * @param id
	 * @return
	 */
	public Book getBookById(String id) {
		Query query = new Query(Criteria.where("_id").is(id));
		return mongoTemplate.findOne(query, Book.class);
	}

	/**
	 * 根据名称查询
	 *
	 * @param name
	 * @return
	 */
	public Book getBookByName(String name) {
		Query query = new Query(Criteria.where("name").is(name));
		return mongoTemplate.findOne(query, Book.class);
	}

	/**
	 * 更新对象
	 *
	 * @param book
	 * @return
	 */
	public String updateBook(Book book) {
		Query query = new Query(Criteria.where("_id").is(book.getId()));
		Update update = new Update().set("publish", book.getPublish()).set("info", book.getInfo()).set("updateTime",
				new Date());
		// updateFirst 更新查询返回结果集的第一条
		mongoTemplate.updateFirst(query, update, Book.class);
		// updateMulti 更新查询返回结果集的全部
		// mongoTemplate.updateMulti(query,update,Book.class);
		// upsert 更新对象不存在则去添加
		// mongoTemplate.upsert(query,update,Book.class);
		return "success";
	}

	/***
	 * 删除对象
	 * @param book
	 * @return
	 */
	public String deleteBook(Book book) {
		mongoTemplate.remove(book);
		return "success";
	}

	/**
	 * 根据id删除
	 *
	 * @param id
	 * @return
	 */
	public String deleteBookById(String id) {
		// findOne
		Book book = getBookById(id);
		// delete
		deleteBook(book);
		return "success";
	}
	
	/**
	 * 模糊查询
	 * @param search
	 * @return
	 */
	public List<Book> findByLikes(String search){
		Query query = new Query();
		Criteria criteria = new Criteria();
		//criteria.where("name").regex(search);
		Pattern pattern = Pattern.compile("^.*" + search + ".*$" , Pattern.CASE_INSENSITIVE);
		criteria.where("name").regex(pattern);
		List<Book> lists = mongoTemplate.findAllAndRemove(query, Book.class);
		return lists;
	}

}

controller层代码实现

package com.congge.controller;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import com.congge.entity.Book;
import com.congge.service.MongoDbService;

@RestController
public class MongoDbController {
	
	@Autowired
	private MongoDbService mongoDbService;

	@PostMapping("/mongo/save")
	public String saveObj(@RequestBody Book book) {
		return mongoDbService.saveObj(book);
	}

	@GetMapping("/mongo/findAll")
	public List<Book> findAll() {
		return mongoDbService.findAll();
	}

	@GetMapping("/mongo/findOne")
	public Book findOne(@RequestParam String id) {
		return mongoDbService.getBookById(id);
	}

	@GetMapping("/mongo/findOneByName")
	public Book findOneByName(@RequestParam String name) {
		return mongoDbService.getBookByName(name);
	}

	@PostMapping("/mongo/update")
	public String update(@RequestBody Book book) {
		return mongoDbService.updateBook(book);
	}

	@PostMapping("/mongo/delOne")
	public String delOne(@RequestBody Book book) {
		return mongoDbService.deleteBook(book);
	}

	@GetMapping("/mongo/delById")
	public String delById(@RequestParam String id) {
		return mongoDbService.deleteBookById(id);
	}
	
	@GetMapping("/mongo/findlikes")
	public List<Book> findByLikes(@RequestParam String search) {
		return mongoDbService.findByLikes(search);
	}
}

最后调用接口即可

实现方式2

maven依赖同上

配置文件

mongodb.host=192.168.110.171
mongodb.port=27017
mongodb.database=test
mongodb.username=user_01
mongodb.password=bsw23!@#xsddS

添加配置配置类

package com.pica.sso.report.config;

import com.pica.sso.report.utils.MongoUtil;
import lombok.Data;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @Description mongo配置类
 * @Author Chongwen.jiang
 * @Date 2019/12/19 15:07
 * @ModifyDate 2019/12/19 15:18
 * @Params
 * @Return
 */
@Data
@Configuration
public class MongoBean {
    @Value("${mongodb.host}")
    private String mongdbHost;

    @Value("${mongodb.port}")
    private String mongdbPort;

    @Value("${mongodb.database}")
    private String mongodbDatabase;

    @Value("${mongodb.username}")
    private String mongodbUsername;

    @Value("${mongodb.password}")
    private String mongodbPassword;

    @Bean({"mongoUtil"})
    public MongoUtil mongoUtil() {
        MongoUtil util = MongoUtil.getInstance(this.getMongdbHost(), this.getMongdbPort(),
                this.getMongodbDatabase(), this.getMongodbUsername(), this.getMongodbPassword());
        return util;
    }
}

添加操作工具类

package com.pica.sso.report.utils;

import com.mongodb.BasicDBObject;
import com.mongodb.MongoClient;
import com.mongodb.MongoCredential;
import com.mongodb.ServerAddress;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import org.apache.commons.lang.StringUtils;
import org.bson.Document;
import org.bson.conversions.Bson;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.regex.Pattern;

/**
 * @Description mongo操作工具类
 * @Author Chongwen.jiang
 * @Date 2019/12/19 15:18
 * @ModifyDate 2019/12/19 15:18
 * @Params
 * @Return
 */
public class MongoUtil {
    private static Logger logger = LoggerFactory.getLogger(MongoUtil.class);
    private static final String IDKEY = "_id";
    public static final String RESULT = "result";

    private static MongoClient mongoClient = null;
    private static MongoDatabase database = null;

    private MongoUtil() {

    }

    private static class MongoUtilSingle {
        private static MongoUtil mongoUtil = new MongoUtil();
    }

    /**
     * @Description 获取MongoUtil单例
     * @Author Chongwen.jiang
     * @Date 2019/12/19 15:16
     * @ModifyDate 2019/12/19 15:16
     * @Params [host, ports, databases, userName, password]
     * @Return com.pica.sso.report.utils.MongoUtil
     */
    public static MongoUtil getInstance(String host, String ports, String databases, String userName, String password) {
        try {
            Thread.sleep(1000);
        } catch (Exception e) {
            logger.error("MongoUtil.getInstance() error:" + e.getMessage(), e);
        }

        if (StringUtils.isBlank(userName)) {
            mongoClient = new MongoClient(new ServerAddress(host, Integer.parseInt(ports)));
        } else {
            List<ServerAddress> addresses = new ArrayList<>();
            MongoCredential credential = MongoCredential.createCredential(userName, databases, password.toCharArray());
            List<MongoCredential> creList = new ArrayList<>();
            addresses.add(new ServerAddress(host, Integer.parseInt(ports)));
            creList.add(credential);
            mongoClient = new MongoClient(addresses, creList);
        }
        database = mongoClient.getDatabase(databases);

        return MongoUtilSingle.mongoUtil;
    }

    /**
     * @Description 获取mongodb的collection
     * @Author Chongwen.jiang
     * @Date 2019/12/19 15:18
     * @ModifyDate 2019/12/19 15:18
     * @Params [collName]
     * @Return com.mongodb.client.MongoCollection<org.bson.Document>
     */
    public MongoCollection<Document> getCollection(String collName) {
        if (database != null) {
            return database.getCollection(collName);
        }
        return null;
    }

    public static String fieldWithDoublePrefix(String field) {
        return new StringBuilder("$$").append(field).toString();
    }

    public static String fieldWithPrefix(String field) {
        return new StringBuilder("$").append(field).toString();
    }

    public static String resultFieldWithPrefix(String field) {
        return new StringBuilder("$").append(RESULT).append(".").append(field).toString();
    }

    public static String fieldWithPrefix(String field1, String field2) {
        return new StringBuilder("$").append(field1).append(".").append(field2).toString();
    }

    public static BasicDBObject firstRecord(String... fields) {
        if (fields.length == 0) {
            return new BasicDBObject("$first", "$$ROOT");
        }
        BasicDBObject resFields = new BasicDBObject();
        for (String field : fields) {
            resFields.append(field, fieldWithPrefix(field));
        }
        return new BasicDBObject("$first", resFields);
    }

    public static BasicDBObject allRecord(String... fields) {
        if (fields.length == 0) {
            return new BasicDBObject("$push", "$$ROOT");
        }
        BasicDBObject resFields = new BasicDBObject();
        for (String field : fields) {
            resFields.append(field, fieldWithPrefix(field));
        }
        return new BasicDBObject("$push", resFields);
    }

    public static BasicDBObject sortBy(BasicDBObject basicDBObject) {
        return new BasicDBObject("$sort", basicDBObject);
    }

    public static BasicDBObject sortBy(List<String> ascFields, List<String> descFields) {
        BasicDBObject orderFields = new BasicDBObject();
        if (ascFields != null) {
            for (String field : ascFields) {
                orderFields.append(field, 1);
            }
        }
        if (descFields != null) {
            for (String field : descFields) {
                orderFields.append(field, -1);
            }
        }
        if (orderFields.isEmpty()) {
            orderFields.append(IDKEY, 1);
        }
        return sortBy(orderFields);
    }

    private static BasicDBObject sortBy(int direct, String... fields) {
        if (fields.length == 0) {
            return null;
        }
        BasicDBObject sort = new BasicDBObject();
        for (String field : fields) {
            sort = sort.append(field, direct);
        }
        return sortBy(sort);
    }

    public static BasicDBObject sortAscBy(String... fields) {
        return sortBy(1, fields);
    }

    public static BasicDBObject sortDescBy(String... fields) {
        return sortBy(-1, fields);
    }

    public static BasicDBObject base() {
        return new BasicDBObject();
    }

    public static BasicDBObject blank() {
        return null;
    }

    public static BasicDBObject sumBy() {
        return new BasicDBObject("$sum", 1);
    }

    public static BasicDBObject sumBy(String field) {
        return new BasicDBObject("$sum", fieldWithPrefix(field));
    }

    public static BasicDBObject sumResultBy(String field) {
        return new BasicDBObject("$sum", resultFieldWithPrefix(field));
    }

    public static BasicDBObject sumBy(BasicDBObject basicDBObject) {
        return new BasicDBObject("$sum", basicDBObject);
    }

    public static BasicDBObject cond(BasicDBObject match) {
        return new BasicDBObject("$cond", Arrays.asList(match, 1, 0).toArray());
    }

    public static BasicDBObject cond(BasicDBObject match, String field) {
        return new BasicDBObject("$cond", Arrays.asList(match, fieldWithPrefix(field), 0).toArray());
    }

    public static BasicDBObject avgBy(String field) {
        return new BasicDBObject("$avg", fieldWithPrefix(field));
    }

    public static BasicDBObject avgResultBy(String field) {
        return new BasicDBObject("$avg", resultFieldWithPrefix(field));
    }

    public static BasicDBObject groupBy(List<String> fieldList) {
        return groupBy(fieldList.toArray(new String[0]));
    }

    public static BasicDBObject groupBy(String... fields) {
        if (fields.length == 0) {
            return new BasicDBObject(IDKEY, 0);
        }
        BasicDBObject groupFields = new BasicDBObject();
        for (String field : fields) {
            groupFields.append(field, fieldWithPrefix(field));
        }
        return new BasicDBObject(IDKEY, groupFields);
    }

    public static BasicDBObject groupResultBy(List<String> fieldList) {
        return groupResultBy(fieldList.toArray(new String[0]));
    }

    public static BasicDBObject groupResultBy(String... fields) {
        if (fields.length == 0) {
            return new BasicDBObject(IDKEY, 0);
        }
        BasicDBObject groupFields = new BasicDBObject();
        for (String field : fields) {
            groupFields.append(field, resultFieldWithPrefix(field));
        }
        return new BasicDBObject(IDKEY, groupFields);
    }

    public static List<BasicDBObject> group(BasicDBObject basicDBObject) {
        BasicDBObject param = new BasicDBObject("$group", basicDBObject);
        return Arrays.asList(param, project(param));
    }

    public static BasicDBObject project(List<String> fieldList) {
        return project(fieldList.toArray(new String[0]));
    }

    public static BasicDBObject project(String... fields) {
        BasicDBObject basicDBObject = new BasicDBObject(IDKEY, 0);
        for (String field : fields) {
            basicDBObject.append(field, fieldWithPrefix(field));
        }
        return new BasicDBObject("$project", basicDBObject);
    }

    public static BasicDBObject project(BasicDBObject group) {
        //{"$group":{"_id":{"course_id":"$course_id"},"totalCount":{"$sum":1}}}
        //{"$project":{"_id":0,"course_id":"$_id.course_id","totalCount":"$totalCount"}}
        String groupKey = "$group";
        if (!group.containsField(groupKey)) {
            return null;
        }

        BasicDBObject groupValue = (BasicDBObject) group.get(groupKey);
        BasicDBObject basicDBObject = new BasicDBObject(IDKEY, false);
        for (String keyInGroup : groupValue.keySet()) {
            if (IDKEY.equals(keyInGroup)) {
                Object obj = groupValue.get(keyInGroup);
                if (Boolean.class.equals(obj.getClass())) {
                    basicDBObject.append(keyInGroup, obj);
                } else if (!BasicDBObject.class.equals(obj.getClass())) {
                    basicDBObject.append(keyInGroup, fieldWithPrefix(keyInGroup));
                } else {
                    BasicDBObject childValue = (BasicDBObject) obj;
                    for (String childKey : childValue.keySet()) {
                        basicDBObject.append(childKey, fieldWithPrefix(keyInGroup, childKey));
                    }
                }
            } else {
                basicDBObject.append(keyInGroup, fieldWithPrefix(keyInGroup));
            }
        }
        return new BasicDBObject("$project", basicDBObject);
    }

    public static BasicDBObject match(BasicDBObject basicDBObject) {
        return new BasicDBObject("$match", basicDBObject);
    }

    public static BasicDBObject andBy(List<BasicDBObject> basicDBObjects) {
        return andBy(basicDBObjects.toArray(new BasicDBObject[0]));
    }

    public static BasicDBObject andBy(BasicDBObject... basicDBObjects) {
        //andBy need at least two object.
        List<BasicDBObject> params = new ArrayList<>();
        for (BasicDBObject basicDBObject : basicDBObjects) {
            if (basicDBObject != null && basicDBObject.size() > 0) {
                params.add(basicDBObject);
            }
        }
        return new BasicDBObject("$and", params);
    }

    public static BasicDBObject orBy(List<BasicDBObject> basicDBObjects) {
        return orBy(basicDBObjects.toArray(new BasicDBObject[0]));
    }

    public static BasicDBObject orBy(BasicDBObject... basicDBObjects) {
        //orBy need at least two object.
        List<BasicDBObject> params = new ArrayList<>();
        for (BasicDBObject basicDBObject : basicDBObjects) {
            if (basicDBObject != null && basicDBObject.size() > 0) {
                params.add(basicDBObject);
            }
        }
        return new BasicDBObject("$or", params);
    }

    public static BasicDBObject inBy(String field, Object[] values) {
        return new BasicDBObject(field, new BasicDBObject("$in", values));
    }

    public static<T> BasicDBObject inBy(String field, List<T> values) {
        return new BasicDBObject(field, new BasicDBObject("$in", values));
    }

    public static BasicDBObject ninBy(String field, Object[] values) {
        return new BasicDBObject(field, new BasicDBObject("$nin", values));
    }

    public static<T> BasicDBObject ninBy(String field, List<T> values) {
        return new BasicDBObject(field, new BasicDBObject("$nin", values));
    }

    public static BasicDBObject ltBy(String field, Object value) {
        return new BasicDBObject(field, new BasicDBObject("$lt", value));
    }

    public static BasicDBObject lteBy(String field, Object value) {
        return new BasicDBObject(field, new BasicDBObject("$lte", value));
    }

    public static BasicDBObject gtBy(String field, Object value) {
        return new BasicDBObject(field, new BasicDBObject("$gt", value));
    }

    public static BasicDBObject gteBy(String field, Object value) {
        return new BasicDBObject(field, new BasicDBObject("$gte", value));
    }

    public static BasicDBObject neBy(String field, Object value) {
        return new BasicDBObject(field, new BasicDBObject("$ne", value));
    }

    public static BasicDBObject eqBy(String field, Object value) {
        return new BasicDBObject(field, value);
    }

    public static BasicDBObject condInBy(String field, Object[] values) {
        return new BasicDBObject("$in", Arrays.asList(fieldWithPrefix(field), values).toArray());
    }

    public static BasicDBObject condLtBy(String field, Object value) {
        return new BasicDBObject("$lt", Arrays.asList(fieldWithPrefix(field), value).toArray());
    }

    public static BasicDBObject condLteBy(String field, Object value) {
        return new BasicDBObject("$lte", Arrays.asList(fieldWithPrefix(field), value).toArray());
    }

    public static BasicDBObject condGtBy(String field, Object value) {
        return new BasicDBObject("$gt", Arrays.asList(fieldWithPrefix(field), value).toArray());
    }

    public static BasicDBObject condGteBy(String field, Object value) {
        return new BasicDBObject("$gte", Arrays.asList(fieldWithPrefix(field), value).toArray());
    }

    public static BasicDBObject condNeBy(String field, Object value) {
        return new BasicDBObject("$ne", Arrays.asList(fieldWithPrefix(field), value).toArray());
    }

    public static BasicDBObject condEqBy(String field, Object value) {
        return new BasicDBObject("$eq", Arrays.asList(fieldWithPrefix(field), value).toArray());
    }

    public static BasicDBObject condLtResultBy(String field, Object value) {
        return new BasicDBObject("$lt", Arrays.asList(resultFieldWithPrefix(field), value).toArray());
    }

    public static BasicDBObject condLteResultBy(String field, Object value) {
        return new BasicDBObject("$lte", Arrays.asList(resultFieldWithPrefix(field), value).toArray());
    }

    public static BasicDBObject condGtResultBy(String field, Object value) {
        return new BasicDBObject("$gt", Arrays.asList(resultFieldWithPrefix(field), value).toArray());
    }

    public static BasicDBObject condGteResultBy(String field, Object value) {
        return new BasicDBObject("$gte", Arrays.asList(resultFieldWithPrefix(field), value).toArray());
    }

    public static BasicDBObject condNeResultBy(String field, Object value) {
        return new BasicDBObject("$ne", Arrays.asList(resultFieldWithPrefix(field), value).toArray());
    }

    public static BasicDBObject condEqResultBy(String field, Object value) {
        return new BasicDBObject("$eq", Arrays.asList(resultFieldWithPrefix(field), value).toArray());
    }

    public static BasicDBObject regexBy(String field, String regex) {
        return new BasicDBObject(field, Pattern.compile(
                new StringBuilder("^.*").append(regex).append(".*$").toString(),
                Pattern.CASE_INSENSITIVE));
    }

    public static List<BasicDBObject> join(String collectionName, BasicDBObject fieldMap) {
        if (fieldMap == null || fieldMap.size() == 0) {
            return Collections.emptyList();
        }
        /** BasicDBObject fieldMap eg:
         * "project_id":null,
         * "doctor_id":null,
         * "course_id":5210
         */
        BasicDBObject lookup = new BasicDBObject("from", collectionName);
        BasicDBObject lets = new BasicDBObject();
        List<BasicDBObject> andBy = new ArrayList<>();
        for (String field : fieldMap.keySet()) {
            if (fieldMap.get(field) == null) {
                lets = lets.append(field, fieldWithPrefix(field));
            } else {
                lets = lets.append(field, fieldMap.get(field));
            }
            andBy.add(condEqBy(field, fieldWithDoublePrefix(field)));
        }
        lookup.append("let", lets);
        lookup.append("pipeline", Arrays.asList(
                new BasicDBObject("$match", new BasicDBObject("$expr", andBy(andBy))),
                new BasicDBObject("$limit", 1)
        ));
        lookup.append("as", "result");

        List<BasicDBObject> list = new ArrayList<>();
        list.add(new BasicDBObject("$lookup", lookup));
        list.add(match(andBy(eqBy("result", Collections.emptyList()))));
        list.add(new BasicDBObject("$project", new BasicDBObject("result", 0)));
        return list;
    }

    public static List<BasicDBObject> page(int pageNo, int pageSize) {
        return page(pageNo, pageSize, 0);
    }

    public static List<BasicDBObject> page(int pageNo, int pageSize, int skipCount) {
        List<BasicDBObject> list = new ArrayList<>();
        if (pageNo > 1 && pageSize > 0) {
            list.add(new BasicDBObject("$skip", (pageNo - 1) * pageSize + skipCount));
        }
        if (pageSize > 0) {
            list.add(new BasicDBObject("$limit", pageSize));
        }
        return list;
    }

    public static BasicDBObject page(int pageNo, int pageSize, BasicDBObject basicDBObject) {
        if (pageNo > 1 && pageSize > 0) {
            basicDBObject.put("$skip", (pageNo - 1) * pageSize);
        }
        if (pageSize > 0) {
            basicDBObject.put("$limit", pageSize);
        }
        return basicDBObject;
    }

    public static BasicDBObject skip(int pageNo, int pageSize) {
        if (pageNo <= 1 || pageSize <= 0) {
            return null;
        }
        return new BasicDBObject("$skip", (pageNo - 1) * pageSize);
    }

    public static BasicDBObject limit(int pageSize) {
        if (pageSize <= 0) {
            return null;
        }
        return new BasicDBObject("$limit", pageSize);
    }

    public static BasicDBObject let(String key1, String v1,
                                    String key2, String v2) {
        return new BasicDBObject(key1, v1).append(key2, v2);
    }

    public static Bson lookup(BasicDBObject let, String from,
                                       List<BasicDBObject> pipeline, String as) {
        BasicDBObject lookupBase = new BasicDBObject();
        lookupBase.put("from", "lr_project_progress");
        lookupBase.put("let", let);
        lookupBase.put("pipeline", pipeline);
        lookupBase.put("as", as);
        return new BasicDBObject("$lookup", lookupBase);
    }


}

剩下的在service业务层通过工具类去调用方法即可
【微服务】springboot整合mongodb使用详解
congge_study的博客
07-30 5437
springboot整合mongodb使用详解
SpringBoot整合MongoDB
空夜's Blog
11-07 1067
本节使用SpringBoot 2.1.9.RELEASE，示例源码在https://github.com/laolunsi/spring-boot-examples/tree/master/06-spring-boot-mongo-demo SpringBoot可以非常方便地引入和操作MongoDB。本节分两部分，记录个人学习SpringBoot使用MongoDB数据库的一些知识。 第一部分是一...
SpringBoot 集成mongodb（1）单数据源配置
weixin_30794851的博客
06-30 180
新项目要用到mongodb，于是在个人电脑上的虚拟环境linux上安装了下mongodb，练习熟悉下。 1、虚拟机上启动mongodb。 首先查看虚拟机ip地址，忘了哈~~ 命令行>ifconfig mongodb安装目录bin>sudo ./mongod -f mongodb.conf 检查是否已经启动：>netstat -lanp|grep "27017" ...
SpringBoot整合MongoDB（附MongoDB做缓存demo源码）
Nicer_feng's blog
10-18 949
SpringBoot整合MongoDB 之前我们讲解了MongoDB在不同环境的安装和MongoDB的CRUD以及Robo3T可视化工具操作MongoDB，今天我们来看看实际业务中整合MongoDB的场景。 本文我们主要是通过两种方法实现SpringBoot整合MongoDB，最后写一个小demo来理解MongoDB在实际业务中的应用。
Spring Boot 实战 ：集成 MongoDB
平凡的人类的博客
05-07 397
什么是 MongoDB ?? MongoDB 是由C++语言编写的，是一个基于分布式文件存储的开源数据库系统，在高负载的情况下，添加更多的节点，可以保证服务器性能，MongoDB 旨在为WEB应用提供可扩展的高性能数据存储解决方案，MongoDB 将数据存储为一个文档，数据结构由键值(key=>value)对组成，MongoDB 文档类似于 JSON 对象，字段值可以包含其他文档...
springboot整合mongodb changestream代码
02-23
在本文中，我们将深入探讨如何在Spring Boot应用中整合MongoDB的Change Stream功能。Change Stream是MongoDB提供的一种强大特性，允许我们实时监控数据库中的变化，例如文档的插入、更新和删除操作。这对于构建实时...
SpringBoot整合MongoDB快速上手文档.zip
09-30
总结，SpringBoot整合MongoDB涉及的主要步骤包括：添加依赖，配置数据库连接，定义Repository接口，使用MongoTemplate进行复杂操作，以及创建实体类。通过这些步骤，开发者可以快速地在SpringBoot项目中搭建起与...
springboot+mybatis+mongoDB
wenlt的博客
06-26 2万+
上篇文章介绍了springboot+dubbo,本章结合mongoDB，myBatis，数据库，写个test1：首先引入mybatis，mongoDB的包，用druid数据源&lt;dependency&gt; &lt;groupId&gt;mysql&lt;/groupId&gt; &lt;artifactId&gt;mysql-connector-java&lt;/artifact...
springboot 连接池wait_timeout超时设置
weixin_34072637的博客
11-02 3362
使用springboot 线程池连接MySQL时，mysql数据库wait_timeout 为8个小时，所以程序第二天发现报错，在url配置了 autoReconnect=true 也不行，查询配置以下 #验证连接的有效性 spring.datasource.test-while-idle=true #获取连接时候验证，会影响性能spring.datasource.test-on-borrow=t...
Spring Boot中整合MongoDB
zhouym_的博客
08-28 588
MongoDB介绍 MongoDB 是由C++语言编写的，是一个基于分布式文件存储的开源数据库系统。 在高负载的情况下，添加更多的节点，可以保证服务器性能。 MongoDB 旨在为WEB应用提供可扩展的高性能数据存储解决方案。 MongoDB 将数据存储为一个文档，数据结构由键值(key=>value)对组成。MongoDB 文档类似于 JSON 对象。字段值可以包含其他文档，数组及文档数组...
Springboot 整合MySQL 和 MongoDB 同时支持两种数据库事务
u010169334的博客
10-12 8298
一、配置spirngboot数据源 # mybatis数据源 spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver spring.datasource.url= spring.datasource.username= spring.datasource.password= #mongodb数据源，主副使用逗号分隔 spring.data.mongodb.uri=mongodb://192.168.10.150:27018,192.1
@Value面试题
qq_34823218的博客
06-28 362
一 @Value的用法 系统中需要连接db，连接db有很多配置信息。 系统中需要发送邮件，发送邮件需要配置邮件服务器的信息。 还有其他的一些配置信息。 我们可以将这些配置信息统一放在一个配置文件中，上线的时候由运维统一修改。 那么系统中如何使用这些配置信息呢，spring中提供了@Value注解来解决这个问题。 通常我们会将配置信息以key=value的形式存储在properties配置文件中。 通过@Value("${配置文件中的key}")来引用指定的key对应的value。 二 .
SpringBoot整合MongoDB，使用mongoTemplate实现高级查询
热门推荐
我的博客
08-30 5万+
一、前言 最近项目使用MongoDB作为数据主要存取的地方 又是第一次接触MongoDB，也是踩了不少坑... 维护数据无非就是增删改查，而里面最复杂的就是查询了 所以来总结一下有关MongoDB的查询方法 当然如果你在此之前你对MongoDB一点都不了解的话 个人建议点击这里，花三十分钟初步了解一下MongoDB ok，正文开始 二、正文 1.使用mongoTemplate对象...
Springboot系列之二十三：Spring Boot和Mongodb整合（完整版）
qq_32534441的博客
05-19 5194
转自：https://blog.csdn.net/stronglyh/article/details/81024588 今天主要讲的是Spring Boot和Mongodb整合我们先来回顾一下前面章节的相关内容前面我们讲了SpringBoot和mysql整合，并且讲了操作数据库的几种方式SpringBoot+JPA自动生成表数据库操作SpringBoot+JDBC操作篇SpringBoot+Myb...
spring data mongodb 配置遇到的几个问题
weixin_30745553的博客
09-18 989
一. mongodb 2.2版本以上的配置 spring.data.mongodb.uri = mongodb://newlook:newlook@192.168.0.109:27017/admin 2.2及以下版本的配置 #spring.data.mongodb.host = 192.168.0.109 #spring.data.mongodb.username = newloo...
springboot整合MongoDB
最新发布
02-25
### Spring Boot 整合 MongoDB 示例教程 #### 配置 `application.yml` 文件中的 MongoDB 连接信息 为了使Spring Boot应用能够连接到MongoDB，在项目的资源目录下的`application.yml`文件中指定MongoDB的相关参数： ```yaml spring: data: mongodb: host: localhost port: 27017 database: test ``` 当MongoDB实例未设置认证机制时，也可以采用URI形式简化配置[^3]。 #### 创建实体类映射文档结构 定义一个Java类来表示存储于MongoDB集合内的文档模型。例如，创建名为`Comment.java`的POJO（Plain Old Java Object），它代表评论表单的数据对象并标注适当注解以便ORM框架识别其为持久化实体。 ```java package com.example.demo_mongodb.po; import org.springframework.data.annotation.Id; import org.springframework.data.mongodb.core.mapping.Document; @Document(collection = "comments") public class Comment { @Id private String id; private String content; private Long timestamp; // Getters and Setters... } ``` #### 定义数据访问接口继承自 `MongoRepository` 通过扩展`MongoRepository<T, ID>`接口的方式快速获得CRUD功能支持，无需编写具体实现逻辑即可完成对特定类型的增删改查操作。这里展示了一个简单的仓库接口声明——`CommentRepository.java`: ```java package com.example.demo_mongodb.dao; import com.example.demo_mongodb.po.Comment; import org.springframework.data.mongodb.repository.MongoRepository; public interface CommentRepository extends MongoRepository<Comment, String> { } ``` 上述代码片段展示了如何利用Spring Data JPA提供的特性轻松地与MongoDB交互，从而专注于业务逻辑而非底层细节处理[^5]。 #### 测试服务层方法验证整合效果 最后一步是在控制器或者其他组件里注入之前建立好的仓储接口，并调用相应的方法来进行测试。这有助于确认整个系统的连通性和预期行为的一致性。 ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值