mongodb基本使用

最新推荐文章于 2024-06-27 23:08:09 发布

沙滩上的漫步者

最新推荐文章于 2024-06-27 23:08:09 发布

阅读量999

点赞数

分类专栏： mongodb 文章标签： mongodb01

本文链接：https://blog.csdn.net/Alano1994/article/details/88902823

版权

mongodb 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

mongoDB

一、NoSql简介

NoSQL(NoSQL = Not Only SQL )，意即“不仅仅是SQL”, 泛指非关系型的数据库

Nosql这个技术门类,早期就有人提出,发展至2009年趋势越发高涨。

二、NoSQL数据库的四大分类

l 键值(Key-Value)存储数据库

这一类数据库主要会使用到一个哈希表，这个表中有一个特定的键和一个指针指向特定的数据。

Key/value模型对于IT系统来说的优势在于简单、易部署。

但是如果DBA只对部分值进行查询或更新的时候，Key/value就显得效率低下了。

举例如：Tokyo Cabinet/Tyrant, **Redis**, Voldemort, Oracle BDB.

l 列存储数据库

这部分数据库通常是用来应对分布式存储的海量数据。

键仍然存在，但是它们的特点是指向了多个列。这些列是由列家族来安排的。

如：Cassandra, **HBase**, Riak.

l 文档型数据库

文档型数据库的灵感是来自于Lotus Notes办公软件的，而且它同第一种键值存储相类似。

该类型的数据模型是版本化的文档，半结构化的文档以特定的格式存储，比如JSON。文档型数据库可 以看作是键值数据库的升级版，允许之间嵌套键值。而且文档型数据库比键值数据库的查询效率更高。

如：CouchDB, **MongoDb**. 国内也有文档型数据库SequoiaDB，已经开源。

l 图形(Graph)数据库

图形结构的数据库同其他行列以及刚性结构的SQL数据库不同，它是使用灵活的图形模型，并且能够扩展到多个服务器上。

NoSQL数据库没有标准的查询语言(SQL)，因此进行数据库查询需要制定数据模型。许多NoSQL数据库都有REST式的数据接口或者查询API。

如：Neo4J, **InfoGrid**, Infinite Graph.

三、MongoDB的引言

MongoDB是一个基于分布式文件存储的数据库。由C++语言编写。旨在为WEB应用提供可扩展的高性能数据存储解决方案。

MongoDB是一个介于关系数据库和非关系数据库之间的产品，是非关系数据库当中功能最丰富，最像关系数据库的。他支持的数据结构非常松散，是类似json的bson格式，因此可以存储比较复杂的数据类型。Mongo最大的特点是他支持的查询语言非常强大，其语法有点类似于面向对象的查询语言，几乎可以实现类似关系数据库单表查询的绝大部分功能，而且还支持对数据建立索引。

四、MongoDB的特点

⾯向集合存储，易存储对象类型的数据
模式⾃由-schemaless，Ol 支持RUBY，PYTHON，JAVA，C++，PHP，C#等多种语言
⽀持复制和故障恢复-集群⽀持性。
使⽤⾼效的⼆进制数据存储，包括⼤型对象（如视频等）-GridFS
⽂件存储格式为BSON（⼀种JSON的扩展）。
不⽀持事务（单个Document/记录事务）
单⾏记录｜document最⼤⽀持16MB存储

基本概念

（1）⽂档

⽂档是 MongoDB 中数据的基本单位，类似于关系数据库中的⾏（但是⽐⾏复杂）。多个
键及其关联的值有序地放在⼀起就构成了⽂档。不同的编程语⾔对⽂档的表示⽅法不同，在
JavaScript 中⽂档表示为：{“greeting”:“hello,world”}
这个⽂档只有⼀个键“greeting”，对应的值为“hello,world”。多数情况下，⽂档⽐这个更复
杂，它包含多个键/值对。例如：{“greeting”:“hello,world”,“foo”: 3}
⽂档中的键/值对是有序的，下⾯的⽂档与上⾯的⽂档是完全不同的两个⽂档。
{“foo”: 3 ,“greeting”:“hello,world”}
⽂档中的值不仅可以是双引号中的字符串，也可以是其他的数据类型，例如，整型、布尔
型等，也可以是另外⼀个⽂档，即⽂档可以嵌套。⽂档中的键类型只能是字符串。

（2）集合

集合就是⼀组⽂档，类似于关系数据库中的表。集合是⽆模式的，集合中的⽂档可以是各
式各样的。例如，{“hello,word”:“Mike”}和{“foo”: 3}，它们的键不同，值的类型也不同，但
是它们可以存放在同⼀个集合中，也就是不同模式的⽂档都可以放在同⼀个集合中。既然集合
中可以存放任何类型的⽂档，那么为什么还需要使⽤多个集合？这是因为所有⽂档都放在同⼀
个集合中，⽆论对于开发者还是管理员，都很难对集合进⾏管理，⽽且这种情形下，对集合的
查询等操作效率都不⾼。所以在实际使⽤中，往往将⽂档分类存放在不同的集合中，例如，
对于⽹站的⽇志记录，可以根据⽇志的级别进⾏存储，Info级别⽇志存放在Info 集合中，
Debug 级别⽇志存放在Debug 集合中，这样既⽅便了管理，也提供了查询性能。但是需要注
意的是，这种对⽂档进⾏划分来分别存储并不是MongoDB 的强制要求，⽤户可以灵活选择。
可以使⽤“.”按照命名空间将集合划分为⼦集合。例如，对于⼀个博客系统，可能包括
blog.user 和blog.article 两个⼦集合，这样划分只是让组织结构更好⼀些，blog 集合和
blog.user、blog.article 没有任何关系。虽然⼦集合没有任何特殊的地⽅，但是使⽤⼦集合组
织数据结构清晰，这也是MongoDB 推荐的⽅法。

（3）数据库
MongoDB 中多个⽂档组成集合，多个集合组成数据库。⼀个MongoDB 实例可以承载多个
数据库。它们之间可以看作相互独⽴，每个数据库都有独⽴的权限控制。在磁盘上，不同的数
据库存放在不同的⽂件中。

五、MongoDB 安装

1. 下载mongoDB的安装包(最新版本3.6,只能在64位系统安装)这里使用的3.0.6版本

在这里插入图片描述

上传至linux系统中解压当前的linux系统

[root@localhost usr]# tar -zxvf mongodb-linux-i686-3.0.6.gz

1. 将解压的文件为了方便目录进行重命名(这步可以跳过)
1. 进入mongodb的文件夹中查看目录
1. 在bin目录中存在大量mongodb使用的命令

在这里插入图片描述

1. 启动mongoDB数据库服务

# 先创建mongodb的数据存放目录
[root@localhost ~]# makir -p /root/data
# 启动服务
[root@localhost bin]# ./mongod --port 27017 --bind_ip_all --dbpath /root/data

注意:

启动时要求存放数据的目录必须存在

默认的端口号是27017 可以通过--port 指定端口启动

--bind_ip_all 可以支持navcat连接mongodb

1. 出现如下结果代表启动成功

在这里插入图片描述

六、MongoDB的shell(客户端)操作

1. 进入mongo的bin目录中找到如下指令，使用如下命令连接到mongodb的服务中

在这里插入图片描述
注意:

a) 连接到mongodb后,mongo和mysql数据库有点像,先是一个一个库的概念,操作之前需要先选中库

查看系统中默认的所有库

在这里插入图片描述

选中一个库

a) use 数据库名称

  ![在这里插入图片描述](https://img-blog.csdnimg.cn/20190329215624119.jpg)

注意:

use命名存在库使用当前库不存在则创建当前库

七、连接navcat

打开navicat建立连接

在这里插入图片描述

测试连接

在这里插入图片描述

八、测试

MongoDB操作

CRUD操作

db.users.insert({"name":"aa","sex":"男","age":18})
db.users.insert({"name":"bb","age":25})
db.users.insert({"name":"赵日天","comment:":"很好吃","append_comment":[{"1楼":"好吃个毛线"},{"2楼":"1楼是傻逼"}]})
db.users.insertOne({"name":"ww"})
db.users.insertMany([{"name":"zl"},{"name":"tq"},{"name":"wb"}]}
# 等价于 delete from users where name = 'wb'
# deleteone只会删除第一个条符合条件的结果
db.users.deleteOne({"name":"wb"})
# deletemany会删除所有符合条件的结果
db.users.deleteMany({"name":"wb"})
# 删除名字叫做zs并且性别是男性的用户信息
db.users.deleteMany({"name":"zs","sex":"男"})
# 删除名字叫做ls或者ww的用户信息信息 $or操作符
db.users.deleteMany({"$or":[{"name":"ls"},{"name":"ww"}]})
# 查所有
db.users.find()
db.users.find({})
# 等值查询 where 条件查询 投影查询（指定返回的结果字段）
# select id,name from t_user
db.users.find({"name":"赵日天"},{"_id":1,"name":1})
# or查询
db.users.find({"$or":[{"name":"zs"},{"name":"ls"}]})
# 范围查询 查询年龄在15岁到30岁之间的用户 $lt $gt $lte $gte $ne $eq操作符
db.users.find({"age":{"$gte":18,"$lt":30}})
db.users.find({"age":{"$ne":18}})
db.users.find({"age":18})
# 模糊查询
# 名字中包含s的相关用户
db.users.find({"name":/s/})
# 使用正则查询名字以z开头的相关用户
db.users.find({"name":{"$regex":/^z.*/}})
# 枚举查询 in
# 查询名字是zs或者ls的相关用户 select * from t_user where name in['zs','ls']
db.users.find({"name":{"$in":["zs","ls"]}})
# 排序 order by 排序规则：升序 1 降序 -1
db.users.find().sort({"_id":-1})
# 分页 skip: 行下标 (nowPage-1)*pageSize limit: 每页显示的结果条数
db.users.find().skip(4).limit(2)
# 根据append_comment中1楼是傻逼查询
db.users.find({"append_comment.1":"1楼是傻逼"})
# 将名字aa用户年龄修改为28岁 $set 修改
db.users.update({"name":"aa"},{"$set":{"age":28}})
db.users.updateMany({"name":"aa"},{"$inc":{"age":3}})

地理位置查询

# 地理位置查询 实现附近的景点
db.places.insert( {
  name: "圆明园",
 location: { type: "Point", coordinates: [ 116.310701,40.01547 ] },
 category: "Parks"
} );
db.places.insert( {
  name: "清华大学",
 location: { type: "Point", coordinates: [ 116.318966,40.015581] },
 category: "Parks"
} );
db.places.insert( {
  name: "后海望海楼 ",
 location: { type: "Point", coordinates: [ 116.392842,39.949265] },
 category: "Parks"
} );
db.places.insert( {
  name: "天安门 ",
 location: { type: "Point", coordinates: [ 116.403874,39.916734] },
 category: "Parks"
} );
# 创建球面索引
db.places.createIndex( { location: "2dsphere" } )
# 根据提供的坐标点 查询符合条件的数据
db.places.find(
 {
  location:
   { $near:
    {
      $geometry: { type: "Point",  coordinates: [116.344549,39.998573 ] },
      $minDistance: 0,
      $maxDistance: 5000
    }
   }
 }
)

聚合管道

# 聚合管道
db.orders.insert([{"name":"zs","sex":"男","total_money":2000.0},{"name":"ls","sex":"男","total_money":4000.0},{"name":"xh","sex":"女","total_money":6000.0}])
# select sex as _id,avg(total_money) from orders group by sex
db.orders.aggregate([{"$match":{}},{"$group":{_id:"$sex",avg:{$avg:"$total_money"}}}])
# MapReduce
# 通过MR程序计算男性或者女性的平均消费能力
db.orders.mapReduce(function(){emit(this.sex,this.total_money)},function(key,values){return
Array.avg(values)},{query:{},out:"order_result"})

GridFS

Note：
GridFS特别适合流媒体存储，如视频、音频文件等

# GridFS
# 上传
[root@hadoop mongodb-linux-x86_64-3.6.2]# bin/mongofiles --host 127.0.0.1 --port 27017 put ~/1.mkv
2019-03-28T15:33:51.431+0800   connected to: 127.0.0.1:27017
added file: /root/1.mkv
# 下载
[root@hadoop mongodb-linux-x86_64-3.6.2]# bin/mongofiles --host localhost --port 27017 get_id
'ObjectId("5c9c78df0238775a0660084d")'
2019-03-28T15:41:09.191+0800   connected to: localhost:27017
finished writing to: /root/1.mkv

九、JavaApi—Spring Data MongoDB

集成maven

Maven标签

<dependency>
    <!--mongodb-spring依赖-->
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-mongodb</artifactId>
    <version>2.0.13.RELEASE</version>
</dependency>

准备Spring配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:mongo="http://www.springframework.org/schema/data/mongo"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/data/mongo http://www.springframework.org/schema/data/mongo/spring-mongo.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 通过mongodb 标签扫描自定义的DAO接口-->
    <mongo:repositories base-package="com.baizhi.mongodb.dao"></mongo:repositories>

    <!-- mongo 客户端对象 -->
    <mongo:mongo-client host="192.168.21.159" port="27017" id="mongoClient">
    </mongo:mongo-client>

    <!-- 操作mongodb的数据库信息 -->
    <mongo:db-factory dbname="baizhi" mongo-ref="mongoClient"/>

    <!-- mongoTemplate 完成自定义的操作 -->
    <bean id="mongoTemplate" class="org.springframework.data.mongodb.core.MongoTemplate">
        <constructor-arg name="mongoDbFactory" ref="mongoDbFactory"/>
    </bean>
</beans>

创建实体类配置映射关系

package com.baizhi.mongodb.entity;

import org.springframework.data.annotation.Id;
import org.springframework.data.annotation.PersistenceConstructor;
import org.springframework.data.mongodb.core.mapping.Document;

import java.io.Serializable;
import java.util.Date;
// 实体对象映射的集合信息
@Document(collection = "persons")
public class Persons implements Serializable {
    @Id
    private String id;
    private String name;
    private Double salary;
    private Date date;

    public Persons() {
    }
    // 从mongodb中恢复数据时调用的构造方法
    @PersistenceConstructor
    public Persons(String id, String name, Double salary, Date date) {
        this.id = id;
        this.name = name;
        this.salary = salary;
        this.date = date;
    }

    @Override
    public String toString() {
        return "Persons{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", salary=" + salary +
                ", date=" + date +
                '}';
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Double getSalary() {
        return salary;
    }

    public void setSalary(Double salary) {
        this.salary = salary;
    }

    public Date getDate() {
        return date;
    }

    public void setDate(Date date) {
        this.date = date;
    }
}

创建自定义的Repository

package com.baizhi.mongodb.dao;
import com.baizhi.mongodb.entity.Persons;
import org.springframework.data.mongodb.repository.MongoRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface CustomRepository extends MongoRepository<Persons ,String> {
}

或者创建自定义方法

package com.baizhi.mongodb.dao;
import com.baizhi.mongodb.entity.Persons;
import org.springframework.data.mongodb.repository.MongoRepository;
import org.springframework.stereotype.Repository;

import java.util.List;

/**
 * 自定义方法 实现对mongodb的操作
 *      符合mongodb规范 无需写方法的实现
 */
@Repository
public interface CustomRepository2 extends MongoRepository<Persons ,String> {
    /**
     * db.persons.find({"name":值})
     * @param name
     * @return
     */
    public List<Persons> findByName(String name);

    /**
     * 根据关键字模糊查询
     * @param keyword
     * @return
     */
    public List<Persons> findByNameLike(String keyword);

}

测试

package com.baizhi.mongodb;

import com.baizhi.mongodb.dao.CustomRepository;
import com.baizhi.mongodb.dao.CustomRepository2;
import com.baizhi.mongodb.entity.Persons;
import com.mongodb.client.result.UpdateResult;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
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 java.util.Arrays;
import java.util.Date;
import java.util.List;

public class MongodcTest {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        CustomRepository repository = applicationContext.getBean(CustomRepository.class);
        CustomRepository2 repository2 = applicationContext.getBean(CustomRepository2.class);
        MongoTemplate template = applicationContext.getBean(MongoTemplate.class);
        /**
         *  内嵌方法
         */
        // 新增一条记录
       // repository.save(new Persons(null,"ws",4000D,new Date()));
        //repository.saveAll(Arrays.asList(new Persons(null,"ls",2000D,new Date()),new Persons(null,"ww",3000D,new Date())));
        //查询
        //List<Persons> persons = repository.findAll();
        // 排序
        //List<Persons> persons = repository.findAll(Sort.by(Sort.Direction.DESC, "salary"));
        //persons.forEach(p->System.out.println(p));
        // 分页
        //Page<Persons> page = repository.findAll(new PageRequest(0, 3));
       // System.out.println(page.getTotalPages());
       // System.out.println(page.getSize());
       // page.forEach(p->System.out.println(p));
        // 修改
        //repository.save(new Person("5c9c854c08e9eb1b946c8064","zs",2500d,new Date()));
        /**
         *  自定义方法只声明即可
         */
        // 自定义方法测试
        // List<Persons> people = repository2.findByName("zs");
         //List<Persons> people = repository2.findByNameLike("s");
         //System.out.println(people);

        /**
         * 使用templete
         */
        // 查询工资在2000到3000元之间的相关用户
         //Query query = Query.query(Criteria.where("salary").gte(2000D).lte(3000D));
        // List<Persons> persons = template.find(query, Persons.class);
        // persons.forEach( p -> System.out.println(p));
        // 修改用户名字叫做zs或者ls的工资3500
        Query query = Query.query(Criteria.where("name").in("zs","ls"));
        Update update = Update.update("salary",100);
        UpdateResult updateResult = template.updateMulti(query, update, Persons.class);
        System.out.println(updateResult.getModifiedCount());
    }
}

Spring Boot 整合MongoDB

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-
instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.3.RELEASE</version>
    <relativePath/> <!-- lookup parent from repository -->
  </parent>
  <groupId>com.baizhi</groupId>
  <artifactId>springboot_mongodb</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <name>springboot_data</name>
  <description>Demo project for Spring Boot</description>
  <properties>
    <java.version>1.8</java.version>
  </properties>
  <dependencies>
      <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-mongodb</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
      <scope>test</scope>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
    </plugins>
  </build>
</project>

application.properties

spring.data.mongodb.database=baizhi
spring.data.mongodb.host=192.168.11.131
spring.data.mongodb.port=27017

其余操作方式同Spring Data MongoDB

.................

沙滩上的漫步者

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
mongodb基本使用

mongoDB一、NoSql简介NoSQL(NoSQL = Not Only SQL )，意即“不仅仅是SQL”, 泛指非关系型的数据库Nosql这个技术门类,早期就有人提出,发展至2009年趋势越发高涨。二、NoSQL数据库的四大分类l 键值(Key-Value)存储数据库这一类数据库主要会使用到一个哈希表，这个表中有一个特定的键和一个指针指向特定的数据。Key/value模型对...
复制链接

扫一扫

专栏目录