springboot-mongodb应用

学习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();
    }

springboot-mongodb应用

猜你喜欢