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业务层通过工具类去调用方法即可