springboot整合mongodb实现增删改查
引入jar包
org.mongodb
mongodb-driver
3.4.3
org.springframework.boot
spring-boot-starter-data-mongodb
1.2.5.RELEASE
com.spring4all
mongodb-plus-spring-boot-starter
1.0.0.RELEASE
使用了mongo连接池，mongodb-plus
配置文件
Mongodb
库名
spring.data.mongodb.database=atm-ep
spring.data.mongodb.host=192.168.1.49
spring.data.mongodb.port=27017
spring.http.encoding.force-request=true
spring.mandatory-file-encoding=UTF-8
#用户名和密码 有的话需要加上
#spring.data.mongodb.username=atm_ep
#spring.data.mongodb.password=atm_ep
spring.data.mongodb.option.min-connection-per-host=0
spring.data.mongodb.option.max-connection-per-host=100
spring.data.mongodb.option.threads-allowed-to-block-for-connection-multiplier=5
spring.data.mongodb.option.server-selection-timeout=30000
spring.data.mongodb.option.max-wait-time=120000
spring.data.mongodb.option.max-connection-idle-time=0
spring.data.mongodb.option.max-connection-life-time=0
spring.data.mongodb.option.connect-timeout=10000
spring.data.mongodb.option.socket-timeout=0
spring.data.mongodb.option.socket-keep-alive=false
spring.data.mongodb.option.ssl-enabled=false
spring.data.mongodb.option.ssl-invalid-host-name-allowed=false
spring.data.mongodb.option.always-use-m-beans=false
spring.data.mongodb.option.heartbeat-socket-timeout=20000
spring.data.mongodb.option.heartbeat-connect-timeout=20000
spring.data.mongodb.option.min-heartbeat-frequency=500
spring.data.mongodb.option.heartbeat-frequency=10000
spring.data.mongodb.option.local-threshold=15启动类使用注解@EnableMongoPlus
@EnableMongoPlus
public class App {
@RequestMapping("/ep/")
String home() {
return "redirect:index.html";
}
public static void main(String[] args) throws Exception {
SpringApplication.run(App.class, args);
}
}自己写了个简单的工具类，项目中为了灵活使用，数据结构存为json对象
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Sort;
import org.springframework.data.mongodb.core.BulkOperations;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.mapreduce.GroupBy;
import org.springframework.data.mongodb.core.mapreduce.GroupByResults;
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.Component;
import java.util.*;
@Component
public class Mongodb {
@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
* 表名
*/
public List findAll(String tableName) {
return mongoTemplate.findAll(JSONObject.class, tableName);
}
/**
* 条件查询 只支持and的关系
*
* @param map
* 条件 key=id value=1 查询id为1的数据
* @param tableName
* 表名
* @return
*/
public List find(Map map, String tableName) {
Query quey = new Query();
for (Map.Entry 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 findSortList(Map map, String tableName, String sort) {
Query quey = new Query();
for (Map.Entry 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(JSONObject json, String tableName) {
mongoTemplate.save(json, tableName);
}
/**
* 批量插入
*
* @param list
* 数据集合
* @param tableName
* 表名
*/
public void batchSave(List 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 boolean update(Query query, Update update, String tableName) {
return mongoTemplate.updateFirst(query, update, tableName).isUpdateOfExisting();
}
/**
* 更新符合条件的所有数据
*
* @param query
* 条件
* @param update
* 更新的属性和值
* @param tableName
* 表名
* @return 更新状态
*/
public boolean updateMulti(Query query, Update update, String tableName) {
return mongoTemplate.updateMulti(query, update, tableName).isUpdateOfExisting();
}
/**
* 条件查询
*
* @param query
* 条件
* @param tableName
* 表名
*/
public List find(Query query, String tableName) {
return mongoTemplate.find(query, JSONObject.class, tableName);
}
/**
* 删除指定的数据
*
* @param json
* @param tableName
* 表名
* @return
*/
public int delete(JSONObject json, String tableName) {
return mongoTemplate.remove(json, tableName).getN();
}
/**
* 根据条件删除
*
* @param query
* 条件
* @param tableName
* 表名
* @return 受影响的文档数
*/
public int delete(Query query, String tableName) {
return mongoTemplate.remove(query, tableName).getN();
}
/**
* 数量
*/
public long count(Query query, String tableName) {
return mongoTemplate.count(query, tableName);
}
/**
* group by
*/
public GroupByResults group(Criteria criteria, String inputCollectionName, GroupBy groupBy,
Class entityClass) {
return mongoTemplate.group(criteria, inputCollectionName, groupBy, entityClass);
}
/**
* 通过ID删除
*
* @param ID
* @param tableName
* @return
*/
public int deleteByID(String ID, String tableName) {
Query query = new Query();
query.addCriteria(Criteria.where("ID").is(ID));
return delete(query, tableName);
}
/**
* 删除表
* @param tableName
* @return
*/
public void deleteTable(String tableName){
mongoTemplate.dropCollection(tableName);
}
}
库中数据存储结构类似下面的（使用mongo客户端为Studio 3T ，挺好用的 需要破解一下）
使用mongodb最大的好处是可以很随意的扩充列，因为存的是json对象 ，所以数据结构很灵活，不过mongodb写复杂sql查询是挺麻烦的，最好把数据平铺进去，不要写复杂sql查询，而且mongo本身是文件存储数据库，上传文件速度还是挺快的。