学习mongodb的网址:
http://www.runoob.com/mongodb/mongodb-tutorial.html
https://www.yiibai.com/mongodb/
http://www.mongoing.com/
一、mongodb的优缺点:
优点:
1、每一个json不是固定字段、固定字段类型,相比于oracle、mysql扩展性极强;
2、查询速度快,数据量越大,性能越优越,相比于mysql和oracle;
3、文档结构的存储方式,能够更便捷的获取数据;
4、分布式存储,支持大批量的数据存储。
5、支持弱一致性,但是最终的结果是一致的;
6、MongoDB使用预写日志记录到磁盘日志,以保证写入操作的持久性并提供崩溃恢复能力。
缺点:
1、字段扩展性强,类型不一致,处理数据有时候带来麻烦;
2、支持弱一致性,比如统计的结果相比mysql和oracle不精确;
3、单机模式,稳定性差;
4、大批量数据插入性能低;
5、支持单文档事物,不支持多文档事物。
二、使用:
1、创建springboot项目,在pom文件中引入mongo的jar包
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>
2、application.properties配置
spring.data.mongodb.uri=连接串
mongo.log.uri=连接串
3、创建MongodbController类
package com.example.demo;
import com.alibaba.fastjson.JSONObject;
import org.bson.Document;
import org.springframework.beans.factory.annotation.Autowired;
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.AggregationOperation;
import org.springframework.data.mongodb.core.aggregation.AggregationResults;
import org.springframework.data.mongodb.core.query.BasicQuery;
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.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import java.util.ArrayList;
import java.util.List;
/**
* Created by yangyd on 2018/7/31.
*/
@RestController //返回参数是json格式
@RequestMapping("mongo")
/**
* mogodb的优缺点:
* 优点:
* 1、每一个json不是固定字段、固定字段类型,相比于oracle、mysql扩展性极强;
* 2、查询速度快,数据量越大,性能越优越,相比于mysql和oracle;
* 3、文档结构的存储方式,能够更便捷的获取数据;
* 4、分布式存储,支持大批量的数据存储。
* 5、支持弱一致性,但是最终的结果是一致的;
* 6、MongoDB使用预写日志记录到磁盘日志,以保证写入操作的持久性并提供崩溃恢复能力。
* 缺点:
* 1、字段扩展性强,类型不一致,处理数据有时候带来麻烦;
* 2、支持弱一致性,比如统计的结果相比mysql和oracle不精确;
* 3、单机模式,稳定性差;
* 4、大批量数据插入性能低;
* 5、支持单文档事物,不支持多文档事物。
* */
public class MongodbController {
@Autowired
MongoTemplate mongoTemplate;
/**
* 保存数据
* */
@RequestMapping("save")
public void saveData(){
//简单插入
JSONObject json = new JSONObject();
json.put("_id",23);
json.put("name","Tiger1");
json.put("age",23);
json.put("sex","男");
mongoTemplate.save(json,"person_data");
}
/**
* 查询
* @param id
* @return
* */
@PostMapping("find_by_id")
public JSONObject findById(@RequestParam(value = "id") int id){
Query query = new Query();
query.addCriteria(Criteria.where("_id").is(id));
return mongoTemplate.findOne(query,JSONObject.class,"person_data");
}
/**
* 修改
* @param id
* @param name
* @return
* */
@PostMapping("update_by_id")
public JSONObject updateById(@RequestParam(value = "id") int id,
@RequestParam(value = "name") String name){
Query query = new Query();
query.addCriteria(Criteria.where("_id").is(id));
JSONObject json = mongoTemplate.findOne(query,JSONObject.class,"person_data");
if(json != null && ! json.isEmpty()){
Update update = new Update();
update.set("name",name);
json.put("name",name);
mongoTemplate.updateFirst(query,update,"person_data");
}
return json;
}
/**
* 查询返回指定字段
* @param id
* @return
* */
@PostMapping("find")
public JSONObject findPerson(@RequestParam(value = "id") int id){
Document queryDoc = new Document();
queryDoc.put("_id",id);
Document backDoc = new Document();
backDoc.put("name",true);
Query query = new BasicQuery(queryDoc,backDoc);
return mongoTemplate.findOne(query,JSONObject.class,"person_data");
}
/**
* 批量查询
* @param sex
* @return
* */
@PostMapping("finds")
public List<JSONObject> findPerson(@RequestParam(value = "sex") String sex){
Document queryDoc = new Document();
queryDoc.put("sex",sex);
Document backDoc = new Document();
backDoc.put("name",true);
backDoc.put("age",true);
backDoc.put("_id",false);
Query query = new BasicQuery(queryDoc,backDoc);
List<JSONObject> jsons = mongoTemplate.find(query,JSONObject.class,"person_data");
return jsons;
}
/**
* 分页查询
* @param pageNum 查询第几页
* @param pageSize 每页显示多少条
* @return
* */
@PostMapping("page")
public JSONObject pageFinds(@RequestParam("sex") String sex,
@RequestParam(value = "page_num",defaultValue = "1") int pageNum,
@RequestParam(value = "page_size",defaultValue = "10") int pageSize){
long count = mongoTemplate.count(new Query(),"person_data");
Query query = new Query();
query.addCriteria(Criteria.where("sex").is(sex)).
skip((pageNum-1)*pageSize).limit(pageSize);
List<JSONObject> jsons = mongoTemplate.find(query,JSONObject.class,"person_data");
JSONObject result = new JSONObject();
result.put("jsons",jsons);
result.put("page_num",pageNum);
result.put("page_size",pageSize);
//返回是否存在下一页
if(count > pageNum * pageSize){
result.put("next_page",true);
}else {
result.put("next_page",false);
}
System.out.println(page(pageNum,pageSize));
return result;
}
/**
* 先按照某个字段升序或者降序排序,然后返回分页之后的结果
* @param pageNum
* @param pageSize
* @return
* */
private List<JSONObject> page(long pageNum,long pageSize){
List<AggregationOperation> operations = new ArrayList<>();
//这里的顺序决定了对那些数据进行排序,然后将sort放在最后,是对分页之后的数据进行排序,而不是所有数据
operations.add(Aggregation.sort(Sort.Direction.DESC, "_id"));
operations.add(Aggregation.skip((long) (pageNum - 1) * pageSize));
operations.add(Aggregation.limit(pageSize));
Aggregation aggregation = Aggregation.newAggregation(operations);
AggregationResults<JSONObject> results = mongoTemplate.aggregate(aggregation, "person_data", JSONObject.class);
return results.getMappedResults();
}
}
4、测试结果:
还有先排序后分页的方法
/**
* 先按照某个字段升序或者降序排序,然后返回分页之后的结果
* @param pageNum
* @param pageSize
* @return
* */
private List<JSONObject> page(long pageNum,long pageSize){
List<AggregationOperation> operations = new ArrayList<>();
//这里的顺序决定了对那些数据进行排序,然后将sort放在最后,是对分页之后的数据进行排序,而不是所有数据
operations.add(Aggregation.sort(Sort.Direction.DESC, "_id"));
operations.add(Aggregation.skip((long) (pageNum - 1) * pageSize));
operations.add(Aggregation.limit(pageSize));
Aggregation aggregation = Aggregation.newAggregation(operations);
AggregationResults<JSONObject> results = mongoTemplate.aggregate(aggregation, "person_data", JSONObject.class);
return results.getMappedResults();
}