mongodb梳理:

谁践踏了优雅 2023-10-02 14:34 14阅读 0赞

## 1 mongodb简介 ##

**概述**:MongoDB是一个介于关系数据库和非关系数据库之间的产品，是非关系数据库当中功能最丰富，最像 关系数据库的，它支持的数据结构非常松散，是类似json的bson格式，因此可以存储比较复杂的数据类 型。

**优点:**

Momgodb 不支持表关系,且存储比较的懒散,在关系型数据库中若一个数据的某个字段为空,

则 sql 会为该字段保存存储空间,但是 mongodb 不会,mongodb 允许一组数据的某个字段空

并且不为该字段做占位存储空间,从而极大的减少了空间的浪费

Redis ： 内存中， 速度快，空间少

Mongodb : 磁盘上，不支持表关系，

MySQL : 磁盘上， 速度慢，空间多

注意:Mongoddb 的存储方式为 bson,类似 jsion,mongodb 支持对数据库建立索引

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qWgfuaeqw_size_20_color_FFFFFF_t_70_g_se_x_16][]

## **2 安装mongodb:** ##

window:百度...

linux:百度

有docker为嘛还要使用上面两个,麻烦

docker安装:

(1) 拉取镜像: docker pull mongo:4.0.3

(2) 创建容器:

\# 方式一:

docker create --name mongodb -v /root/dockerdata/mongodb:/data/db -p 27017:27017

docker:4.0.3

\# 方式二

docker run -it --name mongodb -v /root/dockerdata/mongodb:/data/db -p 27017:27017

docker:4.0.3

(3) 启动容器 :docker start mongodb

(4) 进入容器:docker exec -it mongodb /bin/bsah

(5) 进入 mongo : mongo

(6) 添加管理员:

\# 切换数据库:use admin

db.createUser(\{ user: 'root', pwd: 'root', roles: \[ \{ role: "root", db: "admin" \} \] \})

(7) 登录认证: mongo -u "root" -p "root" --authenticationDatabase "admin

## 3 基本操作 ##

(1) 查看数据库:

show dbs

(2) 切换数据库

use 数据库名

user test

(3) 查看集合(表)

Show tables

Show conllections

(4) 添加数据

db.集合名.save(\{jision 数据类型(键值对形式)\})

db.user.save(\{name:”nanfeng”,age:”23”\})

db.集合名.insert(\{键值对\})

db.user.insert(\{name:nanfeng,age:22\})

(5) 删除数据

db.集合名.deleteOne(\{键值对的条件\}) //删除单个满足条件的

db.user.deleteOne(\{name:”nanfeng”\})

db.集合名.deleteMany(\{键值对条件\}) //删除满足条件所有的数据

db.user.deleteMany(\{name:”nanfeng”\})

db.user.remove(\{\}) //删除全部,可以填条件,然后后面还有 boolean 类型的数据,决定

删除的类型

(6) 修改数据

db.user.update(\{条件键值对\},\{$set:\{要修改的键值对,倘若原始的没有某个字段,会做 自动添加\}\})

db.user.update(\{name:"楠枫"\},\{$set:\{address:"北京",id: "root",age:18 \}\})

\# 注意:$set 一定要这样更改,否则,若是少了 set 会将所有的数据都赋值为设置的键值对

原始格式:

db.collection.update(

upsert: ,

multi: ,

writeConcern:

)

\# 参数说明:upsert 若是没有该字段,是否插入,默认 false,multi 默认为 false,意思为是否修改全部满足条件的,false 只修改一条数据,true 会修改全部满足条件的数据

(7) 查询数据

db.集合名字.find(\{键值对形式的查询条件\})

db.user.find(\{name:"楠枫"\})

\# 常见条件查询条件设置

\#  注意 : 在查询  find() 后面添加  pretty() 格式更加好读 , 格式 :find().pretty()

综合条件查询示例 :

db .user.find(\{name:" 楠枫 ",age:\{$lt:22\}\})

(8)  索引 ,mongo  也支持索引 , 能提高数据的查询效率 ,

查看集合索引 :

db. 集合名 .getindexes()

结果 :

"v" : 2,

"key" : \{

"\_id" : 1

\},

"name" : "\_id\_",

"ns" : "testdb.user"

解释 :1  表示升序 ,-1  表示降序

\#  删除索引主 \_id  以外的索引 : db.user.dropIndexes()

\#  创建索引 : db.user.createIndexes(\{age:1\})  创建年龄为升序排序的索引 ,-1  表示降序

## 4 SpringBoot中使用mongodb ##

配置文件:

> **spring.application.name**  =  **mongodbtest** 
> 
> *\#无认证信息的配置* 
> 
> **spring.data.mongodb.uri** = **mongodb://47.119.137.8:27017/test** 
> 
> *\#有认证的配置* 
> 
> *\#spring.data.mongodb.username=nanfeng*
> 
> *\#spring.data.mongodb.password=rootrootrooe*
> 
> *V* 
> 
> *\#spring.data.mongodb.authentication-database=admin* 
> 
> *\#spring.data.mongodb.database=root*
> 
> *\#spring.data.mongodb.port=27018* 
> 
> *\#spring.data.mongodb.host=47.119.137.8*

坐标:

>     
>         <dependency>
>             <groupId>org.springframework.boot</groupId>
>             <artifactId>spring-boot-starter-data-mongodb</artifactId>
>         </dependency>
>         
>         <dependency>
>             <groupId>org.projectlombok</groupId>
>             <artifactId>lombok</artifactId>
>             <optional>true</optional>
>             <version>1.18.4</version>
>         </dependency>

实体类:

package com.nanfeng.mongodbtest.domian;
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    import org.springframework.data.mongodb.core.mapping.Document;
    import java.io.Serializable;
    /**
    * @ClassName: Address
    * @Author: nanfeng
    * @Date: 2021/2/28 21:02
    */
    @Data
    //添加该注解表明使用mongodb管理数,查数据的时候会聪该表中(集合)查询数据,一般情况下默认就好
    //@Document(collation = "addressarea")
    @AllArgsConstructor
    public class Address implements Serializable {
    private String province;
    private String city;
    private String area;}

package com.nanfeng.mongodbtest.domian;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    import org.bson.types.ObjectId;
    
    import java.io.Serializable;
    
    /**
     * @ClassName: Persion
     * @Author: nanfeng
     * @Date: 2021/2/28 21:02
     * @Description: TODO
     */
    @Data
    @AllArgsConstructor
    //添加该注解表明使用mongodb管理数,查数据的时候会聪该表中(集合)查询数据,一般情况下默认就好
    //@Document(collation = "nanzi")
    @NoArgsConstructor
    public class Persion implements Serializable {
        // 是实际mongodb中的-id.这块采用自动生成,使用格式为:ObjectId id=ObjectId.get(),
        // 这块就是自动在数据库生成的具体的id
        //若是想通过构造方法为对象赋值,这块注销,让monggo自动生成-id(其实就是ObjectId的对象),
        // 若通过set方法赋值,这块打开,
        // 不对ObjectId赋值即可,mongo自动生成
        //在pojo中设置ObjectId是为了方便映射,根据_id主键完成操作(mongodb中主键为_id)
        private ObjectId Id;
        private String uid;
        private String name;
        private int age;
        private Address address;
    
    
    
    }

dao:

package com.nanfeng.mongodbtest.service;
    
    import com.mongodb.client.result.DeleteResult;
    import com.mongodb.client.result.UpdateResult;
    import com.nanfeng.mongodbtest.domian.Persion;
    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.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.ArrayList;
    import java.util.Comparator;
    import java.util.List;
    
    /**
     * @ClassName: Mapper
     * @Author: nanfeng
     * @Date: 2021/2/28 21:28
     */
    @Component
    public class Mapper {
        @Autowired
        private MongoTemplate mongoTemplate;
        public void add(Persion persion) {
            //不指定集合名字(表名字,默认会将数据存储到类名小写的集合)
            Persion save = mongoTemplate.save(persion);
            Persion pertest = mongoTemplate.insert(persion, "aaa");
        }
    
        public DeleteResult delete(String id, Persion persion) {
            mongoTemplate.remove(persion);
            //构造条件
            Query query = Query.query(Criteria.where("uid").is(id));
            DeleteResult pertest = mongoTemplate.remove(query, "aaaa");
            return pertest;
        }
    
        /*
         这块的主要操作要根据主键id进行相关操作
         而主键id为ObjectId,这就需要在pojo(映射类)添加ObjectId,但是不不能进行赋值,要采取mongodb自动生成得_id进行相关操作
         */
        public List<UpdateResult> updates(Persion persion, String id ) {
            /*
             * 说明
             *  mongoTemplate.updateFist()  只升级满足条件的第一个
             *  mongoTemplate.updateMulti()  升级满足条件的所有数据
             * */
    
            UpdateResult updateResult1 = mongoTemplate.updateFirst(Query.query(Criteria.where("_id").is(id)), Update.update("name", "楠紫"), Persion.class);
            Update update = new Update();
            update.set("name", "楠紫");
            UpdateResult updateResult2 = mongoTemplate.updateFirst(Query.query(Criteria.where("_id").is(id)), update, "pertest");
            ArrayList<UpdateResult> list = new ArrayList<>();
            list.add(updateResult1);
            list.add(updateResult2);
            return list;
        }
    
    
        /*查询全部*/
        public List<List> findAll() {
            List<Persion> all = mongoTemplate.findAll(Persion.class);
            List<Persion> pertest = mongoTemplate.findAll(Persion.class, "pertest");
            List<List> lists = new ArrayList<>();
            lists.add(all);
            lists.add(pertest);
            return lists;
        }
    
    
        /*查询满足条的所有*/
        public List<List> findByCondition(String id) {
            List<Persion> ids = mongoTemplate.find(Query.query(Criteria.where("uid").is(id)), Persion.class);
            List<Persion> persions = mongoTemplate.find(Query.query(Criteria.where("uid").is(id)), Persion.class, "pertest");
            List<List> lists = new ArrayList<>();
            lists.add(ids);
            lists.add(persions);
            return lists;
        }
    
        /*查询满足条件的的单个*/
        public List<Persion> findOneByCondition(Object id) {
            Persion id1 = mongoTemplate.findOne(Query.query(Criteria.where("-id").is(id)), Persion.class);
            Persion one = mongoTemplate.findOne(Query.query(Criteria.where("-id").is(id)), Persion.class, "pertest");
            List<Persion> per = new ArrayList<>();
            per.add(id1);
            per.add(one);
            return per;
        }
    
        /*查询全部并排序*/
        public List<Persion> findAndSort() {
            List<Persion> all = mongoTemplate.findAll(Persion.class);
            all.sort(new Comparator<Persion>() {
                @Override
                public int compare(Persion o1, Persion o2) {
                    return o1.getAge() - o2.getAge();
                }
            });
            mongoTemplate.findAll(Persion.class, "pertest");
            return all;
        }
    
        /*查询满足条件的并排序*/
        public List<Persion> findAllCondition(String name) {
    /*
    
     Query query = Query.query(Criteria.where("toUserId").is(userId))
                    .with(Sort.by(Sort.Order.desc("score"))).limit(1);
    
     */
    
            List<Persion> persions = mongoTemplate.find(Query.query(Criteria.where("name").is(name)).with(Sort.by(Sort.Order.desc("age"))), Persion.class);
    
            return persions;
        }
    
    
    public List<User> pageList(int pageNum ,int pageSize){
        List<User> userList = new ArrayList<>();
        Mongo mg = new Mongo();
        DB db = mg.getDB("data");
        DBCollection coll = db.getCollection("t_user");
        DBCursor limit = coll.find().skip((pageNum-1)*pageSize).sort(new BasicDBObject()).limit(pageSize);
        while (limit.hasNext()){
            userList.add(parse(new User(),limit.next()));
        }
        return userList;
      }
    }
    
                 /* *
                  *is相当于等于
                  * in相当于sql中的in
                  * ne相当于不等于
                  * orOperator接受多个条件，组成or逻辑  addOperator同理
                  * Criteria.where("author").is("mongodb")  author = mongodb的数据
                  * Criteria.where("serial").lte(500).and("st").is("1703230781").and("c").in("5.7")   多条件的查询
                  * Criteria.where("st").exists(true)   判断这个字段存在
                  * Criteria.where("serial").ne(1)    不等于1的数据
                  * Criteria.where("serial").nin(1)    nin 不在这个范围中
                  * Criteria.where("serial").is(3).orOperator().is().andOperator() 追加or条件或者and条件
                  * Criteria.where("a").regex("1")   模糊查询   可以用正则表达式
                  * query6.with(new Sort(Sort.Direction.DESC,"a"));  按照a字段把结果降序
                  * query6.skip(n);    跳过结果集的第n个   超过总条数就是啥都不输出   n<=0  时 查询到结束不跳过
                  * query6.skip(n).limit(m)   跳过n条并显示m条记录
                  *  query6.addCriteria(Criteria.where("b").is("11"));   再加条件  查询子段不能是上一个query查询过的子段
                  *  query6.maxScan(6).skip(-2);   先截取六条数据再跳过两条
                  * */

类名就是表明(集合名字),条件构造器在代码中做了示例,只提供参考,偷个懒,全是粘贴的以前练文档总结,又回顾了一遍!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

差不多就我这样吧!!!!11~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5qWgfuaeqw_size_20_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/dc9e945f9a114a039e850598a0066149.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5qWgfuaeqw==,size_20,color_FFFFFF,t_70,g_se,x_16