SpringBoot集成monogoDB

1.MonogoDB VS MySql

MongoDB默认是B树，MySQL默认是B+树。

为什么这样选择，是因为两者的使用场景不同。一般MongoDB查单条数据的情景比较多，使用B树作为索引底层数据结构，因为索引节点可以存储数据，所以就不需要去叶子节点获取数据了。

所以查询一条数据所需要的平均随机 IO 次数会比 B+ 树少，因为IO的次数和我们的层高有关系，使用B树的MongoDB 在类似场景中的查询速度就会比 MySQL快，致命的缺陷是由于卫星数据在哪儿都是，所以很不适合范围查询。

1.1 两者速度比较

1.针对写入操作

MongoDB的写入速度更快。写操作MongoDB比传统数据库快的根本原因是Mongo使用的内存映射技术
写入数据时候只要在内存里完成就可以返回给应用程序，这样并发量自然就很高。而保存到硬体的操作则在后台异步完成。注意MongoDB在2.4就已经是默认安全写了（具体实现在驱动程序里）

2.针对读取操作

先说结论：如果是针对等值查询（如=1），MongoDB会更快一些。但针对范围查询，则MySQL更快一些。

读操作MongoDB快的原因是：

1）MongoDB的设计要求你常用的数据（working set)可以在内存里装下。这样大部分操作只需要读内存，自然很快。

2）文档性模式设计一般会是的你所需要的数据都相对集中在一起（内存或硬盘），大家知道硬盘读写耗时最多是随机读写所产生的磁头定位时间也就是我们常说的寻道和寻址时间，数据集中在一起则减少了关系性数据库需要从各个地方去把数据找过来（然后Join）所耗费的随机读时间

1.2 从索引上看两者区别

（1）mysql的索引有唯一索引、主键索引、联合索引、普通索引。MongoDB的索引支持地理位置索引、全文索引、哈希索引。

（2）msyql的主键索引可以指定1到N列作为主键索引，而MongoDB的主键索引指定为_id字段

2.monogoDB简介

传统的关系数据库一般由数据库（database）、表（table）、记录（record）三个层次概念组成，MongoDB是由数据库（database）、集合（collection）、文档对象（document）三个层次组成。MongoDB对于关系型数据库里的表，但是集合中没有列、行和关系概念，这体现了模式自由的特点。

MonogoDB存储数据的格式为BJSON格式，BSON是一种类json的一种二进制形式的存储格式，简称Binary JSON，它和JSON一样，支持内嵌的文档对象和数组对象，但是BSON有JSON没有的一些数据类型，如Date和Binary Data类型。

BSON可以做为网络数据交换的一种存储形式,是一种schema-less的存储形式。

它的优点是灵活性高，但它的缺点是空间利用率不是很理想。

{key:value,key2:value2} 这是一个BSON的例子，其中key是字符串类型,后面的value值，它的类型一般是字符串,double,Array,ISODate等类型。

BSON有三个特点：轻量性、可遍历性、高效性

3.SpringBoot集成monogoDB实战

3.1 安装MonogoDB数据库

我是通过docker安装的，其他需要安装至本地的可以自行百度一下
《docker安装monogoDB》

3.2 添加maven依赖

        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-data-mongodbartifactId>
        dependency>
        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
        dependency>

3.3 添加配置信息

spring:
  data:
    mongodb:
      host: 192.168.1.2
      port: 27017
      password: root
      username: admin
      database: admin #指定操作的数据库

注意：我的用户：admin只对admin库有操作权限，自己在创建角色时要注意

3.4 添加实体类

在添加实体类之前，我们先确定一个应用场景，我们以考试模块为例，我们可以将题库信息存储进去，也就是存我们的题目信息

import lombok.Data;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;
import org.springframework.data.mongodb.core.mapping.Field;

@Data
@Document("problem")
public class TbProblem {
    @Id
    private Integer problemId;
    //pid=0说明是题目，否则是选项
    @Field
    private Integer pid;
    //题目所属的课程Id
    @Field
    private Integer courseId;
    //内容
    @Field
    private String content;
    //答案
    @Field
    private String answer;
    //类型1-单选；2-多选
    @Field
    private Integer type;

}

添加monogodb的操作

import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Update;

import java.util.List;

public interface MonogoService {
    //创建集合
    public void createCollection(String collectionName);

    //插入文档
    public <T> T insert(T t);

    //删除集合
    public void deleteCollection(String collectionName);

    //删除所有文档
    public DeleteResult deleteAllDocument(Class T);

    //条件删除文档
    public DeleteResult deleteDocumentByQueriter(Criteria criteria, Class T);

    //更新符合条件的第一条数据
    UpdateResult updateFirst(Update update, Criteria criteria, Class T);

    //更新符合条件的所有数据
    UpdateResult update(Update update, Criteria criteria, Class T);

    //获取所有
    <T> List<T> getAll(Class<T> t);

    //根据id查询
    public <T> T findById(int id, Class<T> t);

    //通过条件查询
    public <T> List<T> findByQuery(Criteria criteria, Class<T> t);

    //获取数量
    public Long getCount(Class t);

}

实现类：

import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;
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 javax.annotation.Resource;
import java.util.List;

@Service
public class MonogoServiceImpl implements MonogoService {
    @Resource
    MongoTemplate mongoTemplate;

    @Override
    public void createCollection(String collectionName) {
        mongoTemplate.createCollection(collectionName);
    }

    @Override
    public void deleteCollection(String collectionName) {
        mongoTemplate.dropCollection(collectionName);
    }

    @Override
    public DeleteResult deleteAllDocument(Class T) {
        //条件删除
        DeleteResult deleteResult = mongoTemplate.remove(new Query(), T);
        return deleteResult;
    }

    @Override
    public DeleteResult deleteDocumentByQueriter(Criteria criteria, Class T) {
        return null;
    }

    @Override
    public UpdateResult updateFirst(Update update, Criteria criteria, Class T) {
        return mongoTemplate.updateFirst(Query.query(criteria), update, T);
    }

    @Override
    public UpdateResult update(Update update, Criteria criteria, Class T) {
        return mongoTemplate.updateMulti(Query.query(criteria), update, T);
    }

    @Override
    public <T> List<T> getAll(Class<T> t) {
        return mongoTemplate.findAll(t);
    }

    @Override
    public <T> T findById(int id, Class<T> t) {
        T re = mongoTemplate.findById(id, t);
        return re;
    }

    @Override
    public <T> List<T> findByQuery(Criteria criteria, Class<T> t) {
        Query query = Query.query(criteria);
        List<T> res = mongoTemplate.find(query, t);
        return res;
    }

    @Override
    public Long getCount(Class t) {
        long count = mongoTemplate.count(new Query(), t);
        return count;
    }



    @Override
    public <T> T insert(T t) {
        T re = mongoTemplate.save(t);
        return re;
    }


}

Controller：

import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;
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.Update;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
public class TestController {
    @Autowired
    MonogoService monogoService;

    /**
     * 创建集合
     */
    @GetMapping("createCollection")
    public void createCollection(@RequestParam("collectionName") String collectionName) {
        monogoService.createCollection(collectionName);
    }

    /**
     * 插入文档
     */
    @GetMapping("insert")
    public TbProblem insert() {
        TbProblem tbProblem = new TbProblem();
        Double val = Math.random() * 10 + 1;
        tbProblem.setProblemId((val).intValue());
        tbProblem.setContent("monogoDB有哪些注意事项");
        tbProblem.setAnswer("12");
        tbProblem.setPid(0);
        tbProblem.setType(1);
        tbProblem.setCourseId(1);
        return monogoService.insert(tbProblem);

    }

    /**
     * 删除集合
     */
    @GetMapping("deleteCollection")
    public void deleteCollection() {
        monogoService.deleteCollection("problemBank");
    }

    /**
     * 删除所有文档
     */
    @GetMapping("deleteAllDocument")
    public DeleteResult deleteAllDocument() {
        return monogoService.deleteAllDocument(TbProblem.class);
    }

    /**
     * 条件删除文档
     */
    @GetMapping("deleteDocumentByQueriter")
    public DeleteResult deleteDocumentByQueriter() {
        Criteria criteria = new Criteria();
        criteria.where("problemId").is(1);
        return monogoService.deleteDocumentByQueriter(criteria, TbProblem.class);
    }

    /**
     * 更新符合条件的第一条数据
     */
    @GetMapping("updateFirst")
    public UpdateResult updateFirst() {
        Update update = new Update();
        update.set("pid", 1);
        Criteria criteria = new Criteria();
        criteria.where("pid").is(0);
        return monogoService.updateFirst(update, criteria, TbProblem.class);
    }

    /**
     * 更新符合条件的所有数据
     */
    @GetMapping("update")
    public UpdateResult update() {
        Update update = new Update();
        update.set("pid", 2);
        Criteria criteria = new Criteria();
        criteria.where("pid").is(0);
        return monogoService.update(update, criteria, TbProblem.class);
    }

    /**
     * 获取所有
     */
    @GetMapping("getAll")
    public List<TbProblem> getAll() {

        return monogoService.getAll(TbProblem.class);
    }

    /**
     * 根据id查询
     */
    @GetMapping("findById")
    public TbProblem findById() {

        return monogoService.findById(1, TbProblem.class);
    }

    /**
     * 通过条件查询
     */
    @GetMapping("findByQuery")
    public List<TbProblem> findByQuery() {
        Criteria criteria = new Criteria();
        criteria.where("pid").is(0);
        return monogoService.findByQuery(criteria, TbProblem.class);
    }

    /**
     * 通过条件查询
     * and or
     */
    @GetMapping("findByQuery1")
    public List<TbProblem> findByQuery1() {
        Criteria criteria = new Criteria();
        criteria.where("pid").is(0).and("id").is(1);
        return monogoService.findByQuery(criteria, TbProblem.class);
    }
    /**
     * 通过条件查询
     * and or
     */
    @GetMapping("findByQuery2")
    public List<TbProblem> findByQuery2() {
        Criteria criteriaAndOr = new Criteria();
        criteriaAndOr.and("pid").is(0)
                .orOperator(
                        Criteria.where("pid").is(1),
                        Criteria.where("courseId").is(2)
                );
        return monogoService.findByQuery(criteriaAndOr, TbProblem.class);
    }

}

测试：

• 访问：http://localhost:8080/createCollection?collectionName=problemBank
  

• 访问：http://localhost:8080/insert
  

• 访问：http://localhost:8080/deleteCollection
  可以到数据库中查看，会发现problemBank已经没了

• 访问：http://localhost:8080/deleteAllDocument
  可以发现tbProblem中数据已经清空了

• 访问：http://localhost:8080/deleteDocumentByQueriter
  可以发现tbProblem中主键为1的已经清空了

• 访问：http://localhost:8080/updateFirst

下面的自己自行测试即可。
至此，monogoDB的基本操作，我们就完成了。