厄索斯

mongodb作为非关系型数据库的主流之一，还是有学习的必要，redis也是非关系数据库的一种

# 1、简介

MongoDB是一个基于分布式文件存储的数据库。由C++语言编写，旨在为WEB应用提供可扩展的高性能数据存储解决方案。MongoDB是一个介于关系型数据库和非关系型数据库之间的产品，是非关系型数据库当中功能最丰富，最像关系型数据库的。

# 2、安装

# window下的安装

1、下载地址 https://www.mongodb.com/download-center/community，选择版本4.2.5

2、配置MongoDB，让MongoDB作为服务运行，并配置好数据目录和日志目录

3、取消MongoDB Compass的安装选项（不取消安装极慢），需要可自行安装

4、双击mongo.exe可以运行MongoDB自带客户端，操作MongoDB

5、启动成功

移除MongoDB服务

# 只需使用管理员权限运行`cmd`工具，并输入如下命令
sc.exe delete MongoDB

配置文件为根目录下的mongod.cfg

安装为服务

# 运行命令需要用管理员权限
D:\developer\env\MongoDB\bin\mongod.exe --config "D:\developer\env\MongoDB\mongod.cfg" --install

# 启动服务：
net start MongoDB
# 关闭服务：
net stop MongoDB
# 移除服务：
D:\developer\env\MongoDB\bin\mongod.exe --remove

# linux下的安装

我们使用docker安装，mysql也可以使用docker安装，直接运行它的镜像就可以了，按实际需要修改它的运行端口

1、从docker hub拉取镜像

docker pull mongo:4.2.5

2、启动mongo并创建用户

# 1.启动
docker run -p 27017:27017 --name mongo \
-v /mydata/mongo/db:/data/db \
-d mongo:4.2.5 --auth

# 2.进入运行mongodb的容器
docker exec -it mongo mongo

# 3.创建基于root角色的超级管理员帐号
use admin
db.createUser({ 
    user: 'mongoadmin', 
    pwd: 'secret', 
    roles: [ { role: "root", db: "admin" } ] });

# 4.验证是否可以登录
db.auth("mongoadmin","secret")

整个过程如下图：

# 客户端工具

MongoDB的客户端工具有很多，navicat也可以，这里我们选择robo 3T

1、选择对应的系统版本(windows/mac/linux)下载https://robomongo.org/download (opens new window)

Windows

下载完成后解压，双击robo3t.exe即可使用；

创建mongodb的连接

# 3、类比关系型数据库概念

MongoDB是非关系型数据库当中最像关系型数据库的，我们可以对比关系型数据库的概念

SQL概念	MongoDB概念	说明
Database	Database	数据库
table	collection	数据库表/集合
row	document	数据记录行/文档
column	field	数据字段/域
index	index	索引
primary key	primary key	主键,MongoDB自动将_id字段设置为主键

# 4、数据库操作

MongoDB里也有数据库的概念，我们来创建一个test数据库

# 创建数据库

# 1、使用use命令去创建数据库
> use test
switched to db test
# 当插入第一条数据时会创建数据库，并创建集合article,插入一个文档
> db.article.insert({name:"MongoDB 教程"})
WriteResult({ "nInserted" : 1 })
# 列出所有数据库
> show dbs
admin   0.000GB
config  0.000GB
local   0.000GB
test    0.000GB

# 删除数据库

# 2、使用db对象中的dropDatabase()方法来删除；
> db.dropDatabase()
{ "dropped" : "test", "ok" : 1 }
> show dbs
admin   0.000GB
config  0.000GB
local   0.000GB

# 5、集合操作

# 创建集合

# 切换数据库
> use test
switched to db test
# 使用db对象中的createCollection()方法来创建集合
> db.createCollection("article")
{ "ok" : 1 }
# 列出当前数据库下的所有集合
> show collections
article

# 删除集合

# 使用collection对象的drop()方法来删除集合
> db.article.drop()
true
> show collections

# 6、文档操作

跟elasticsearch的文档概念是一样的

# 插入文档 insert()

通过collection对象的insert()方法向集合中插入文档，语法如下；

db.collection.insert(document)

向集合article插入一个文档

db.article.insert({title: 'MongoDB 教程', 
    description: 'MongoDB 是一个 Nosql 数据库',
    by: 'Andy',
    url: 'https://www.mongodb.com/',
    tags: ['mongodb', 'database', 'NoSQL'],
    likes: 100
})

# 更新文档 update()/save()

通过collection对象的update()来更新集合中的文档，语法如下:

db.collection.update(
   <query>,
   <update>,
   {
     multi: <boolean>
   }
)
# query：修改的查询条件，类似于SQL中的WHERE部分
# update：更新属性的操作符，类似与SQL中的SET部分
# multi：设置为true时会更新所有符合条件的文档，默认为false只更新找到的第一条

# 例子：将title为MongoDB 教程的所有文档的title修改为MongoDB
db.article.update({'title':'MongoDB 教程'},{$set:{'title':'MongoDB'}},{multi:true})

save()方法可以用来替换已有文档，语法如下:

db.collection.save(document)

将ObjectId为5e9943661379a112845e4056的文档的title改为MongoDB 教程

db.article.save({
  "_id" : ObjectId("5e9943661379a112845e4056"),
    "title" : "MongoDB 教程",
    "description" : "MongoDB 是一个 Nosql 数据库",
    "by" : "Andy",
    "url" : "https://www.mongodb.com/",
    "tags" : [ 
        "mongodb", 
        "database", 
        "NoSQL"
    ],
    "likes" : 100.0
})

# 删除文档remove()

通过collection对象的remove()方法来删除集合中的文档，语法如下

db.collection.remove(
   <query>,
   {
     justOne: <boolean>
   }
)
# query：删除的查询条件，类似于SQL中的WHERE部分
# justOne：设置为true只删除一条记录，默认为false删除所有记录

删除title为MongoDB 教程的所有文档

db.article.remove({'title':'MongoDB 教程'})

# 查询文档find()

通过collection对象的find()方法来查询文档，语法如下

db.collection.find(query, projection)
# query：查询条件，类似于SQL中的WHERE部分
# projection：可选，使用投影操作符指定返回的键

# 查询article集合中的所有文档； 
db.article.find()
# 返回
/* 1 */
{
    "_id" : ObjectId("5e994dcb1379a112845e4057"),
    "title" : "MongoDB 教程",
    "description" : "MongoDB 是一个 Nosql 数据库",
    "by" : "Andy",
    "url" : "https://www.mongodb.com/",
    "tags" : [ 
        "mongodb", 
        "database", 
        "NoSQL"
    ],
    "likes" : 50.0
}

/* 2 */
{
    "_id" : ObjectId("5e994df51379a112845e4058"),
    "title" : "Elasticsearch 教程",
    "description" : "Elasticsearch 是一个搜索引擎",
    "by" : "Ruby",
    "url" : "https://www.elastic.co/cn/",
    "tags" : [ 
        "elasticearch", 
        "database", 
        "NoSQL"
    ],
    "likes" : 100.0
}

/* 3 */
{
    "_id" : ObjectId("5e994e111379a112845e4059"),
    "title" : "Redis 教程",
    "description" : "Redis 是一个key-value数据库",
    "by" : "Andy",
    "url" : "https://redis.io/",
    "tags" : [ 
        "redis", 
        "database", 
        "NoSQL"
    ],
    "likes" : 150.0
}

条件查询，操作符号

操作	格式	SQL的类似语句
等于	{<key>:<value>}	where title = 'MongoDB 教程'
小于	{<key>:{$lt:<value>}}	where likes < 50
小于或等于	{<key>:{$lte:<value>}}	where likes <= 50
大于	{<key>:{$gt:<value>}}	where likes > 50
大于或等于	{<key>:{$gte:<value>}}	where likes >= 50
不等于	{<key>:{$ne:<value>}}	where likes != 50

# 1.查询title为MongoDB 教程的所有文档；
db.article.find({'title':'MongoDB 教程'})

# 2.查询likes大于50的所有文档；
db.article.find({'likes':{$gt:50}})

# 3.AND条件可以通过在find()方法传入多个键，以逗号隔开来实现，例如查询title为MongoDB 教程并且by为Andy的所有文档；
db.article.find({'title':'MongoDB 教程','by':'Andy'})

# 4.OR条件可以通过使用$or操作符实现，例如查询title为Redis 教程或MongoDB 教程的所有文档；
db.article.find({$or:[{"title":"Redis 教程"},{"title": "MongoDB 教程"}]})

# 5.AND和OR条件的联合使用，例如查询likes大于50，并且title为Redis 教程或者"MongoDB 教程的所有文档
db.article.find({"likes": {$gt:50}, $or: [{"title": "Redis 教程"},{"title": "MongoDB 教程"}]})

# 7、其他操作

# limit与skip操作

读取指定数量的文档，可以使用limit()方法，语法如下；

db.collection.find().limit(NUMBER)

只查询article集合中的2条数据

db.article.find().limit(2)

跳过指定数量的文档来读取，可以使用skip()方法，语法如下；

db.collection.find().limit(NUMBER).skip(NUMBER)

从第二条开始，查询article集合中的2条数据

db.article.find().limit(2).skip(1)

# 排序

在MongoDB中使用sort()方法对数据进行排序，通过参数来指定排序的字段，并使用1和-1来指定排序方式，1为升序，-1为降序；

db.collection.find().sort({KEY:1})

按article集合中文档的likes字段降序排列；

db.article.find().sort({likes:-1})

# 索引

MongoDB的索引概念与关系型数据库如mysql的索引是一样，用来提高查询效率，

createIndex()方法来创建索引，语法如下

db.collection.createIndex(keys, options)
# background：建索引过程会阻塞其它数据库操作，设置为true表示后台创建，默认为false
# unique：设置为true表示创建唯一索引
# name：指定索引名称，如果没有指定会自动生成

给title和description字段创建索引，1表示升序索引，-1表示降序索引，指定以后台方式创建

db.article.createIndex({"title":1,"description":-1}, {background: true})

查看article集合中已经创建的索引

db.article.getIndexes()

# 返回
[
    {
        "v" : 2,
        "key" : {
            "_id" : 1
        },
        "name" : "_id_",
        "ns" : "test.article"
    },
    {
        "v" : 2,
        "key" : {
            "title" : 1.0,
            "description" : -1.0
        },
        "name" : "title_1_description_-1",
        "ns" : "test.article",
        "background" : true
    }
]

# 聚合

类比ElasticSearch的聚合查询，MongoDB中的聚合使用aggregate()方法，类似于SQL中的group by语句，语法如下

db.collection.aggregate(AGGREGATE_OPERATION)

聚合中常用操作符如下

$sum 总和
$avg 平均值
$min 最小值
$max 最大值

根据by字段聚合文档并计算文档数量，类似与SQL中的count()函数

db.article.aggregate([{$group : {_id : "$by", sum_count : {$sum : 1}}}])

# 返回
/* 1 */
{
    "_id" : "Andy",
    "sum_count" : 2.0
}

/* 2 */
{
    "_id" : "Ruby",
    "sum_count" : 1.0
}

根据by字段聚合文档并计算likes字段的平局值，类似与SQL中的avg()语句

db.article.aggregate([{$group : {_id : "$by", avg_likes : {$avg : "$likes"}}}])

# 返回
/* 1 */
{
    "_id" : "Andy",
    "avg_likes" : 100.0
}

/* 2 */
{
    "_id" : "Ruby",
    "avg_likes" : 100.0
}

# 正则表达式

MongoDB使用$regex操作符来设置匹配字符串的正则表达式，可以用来模糊查询，类似于SQL中的like操作；

查询title中包含“教程”的文档

db.article.find({title:{$regex:"教程"}})

不区分大小写的模糊查询，使用$options操作符

db.article.find({title:{$regex:"elasticsearch",$options:"$i"}})

# 8、SpringBoot集成MongoDB

使用SpringData操作MongoDB，在coding老师的课程里有讲到，无论是SQL、NoSQL(非关系型数据库)，在数据库操作底层都是使用SpringData封装的。

官网地址：https://spring.io/projects/spring-data (opens new window)

SpringData 封装大量的xxTemplate供我们直接操作数据库，十分方便，简化了企业开发。这里我们使用Spring Data MongoDB 这个依赖包。

1、pom.xml导入依赖

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>

2、application.yml 配置文件

mongodb:
 host:localhost # mongodb的连接地址
 port: 27017 # mongodb的连接端口号
 database: mall-port # mongodb的连接的数据库

3、声明文档

package com.macro.mall.tiny.nosql.mongodb.document;

import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.index.Indexed;
import org.springframework.data.mongodb.core.mapping.Document;
import java.util.Date;

/**
     * 用户商品浏览历史记录
     * Created by macro on 2018/8/3.
     */
@Document // 映射到Mongodb文档上的领域对象
public class MemberReadHistory {
  @Id // 文档的ID字段
  private String id;
  @Indexed // 映射到Mongodb文档的索引字段
  private Long memberId;
  private String memberNickname;
  private String memberIcon;
  @Indexed
  private Long productId;
  private String productName;
  private String productPic;
  private String productSubTitle;
  private String productPrice;
  private Date createTime;
  
  //省略了所有getter和setter方法
}

4、继承MongoRepository接口，这样就拥有了一些基本的Mongodb数据操作方法，

public interface MemberReadHistoryRepository extends MongoRepository<MemberReadHistory,String> {
    /**
     * 自定义的文档查询方法
     * 根据会员id按时间倒序获取浏览记录
     * @param memberId 会员id
     */
    List<MemberReadHistory> findByMemberIdOrderByCreateTimeDesc(Long memberId);
}

findByMemberIdOrderByCreateTimeDesc()是自定义的衍生查询，在接口中直接指定查询方法名称便可查询，无需进行实现，它是根据会员id按时间倒序获取浏览记录的意思，在idea中它会直接提示对应字段帮助你定义查询方法名称。

当然有些带条件的查询我们可以使用@Query注解，更简洁一些

@Query("{ 'memberId' : ?0 }")
List<MemberReadHistory> findByMemberId(Long memberId);

5、使用

业务层接口MemberReadHistoryService.java

import com.macro.mall.tiny.nosql.mongodb.document.MemberReadHistory;
import java.util.List;

/**
 * 会员浏览记录管理Service
 * Created by macro on 2018/8/3.
 */
public interface MemberReadHistoryService {
    /**
     * 生成浏览记录
     */
    int create(MemberReadHistory memberReadHistory);

    /**
     * 批量删除浏览记录
     */
    int delete(List<String> ids);

    /**
     * 获取用户浏览历史记录
     */
    List<MemberReadHistory> list(Long memberId);
}

业务层接口实现类MemberReadHistoryServiceImpl.java

import com.macro.mall.tiny.nosql.mongodb.document.MemberReadHistory;

import com.macro.mall.tiny.nosql.mongodb.repository.MemberReadHistoryRepository;
import com.macro.mall.tiny.service.MemberReadHistoryService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * 会员浏览记录管理Service实现类
 * Created by macro on 2018/8/3.
 */
@Service
public class MemberReadHistoryServiceImpl implements MemberReadHistoryService {

    @Autowired
    private MemberReadHistoryRepository memberReadHistoryRepository;

    @Override
    public int create(MemberReadHistory memberReadHistory) {
        memberReadHistory.setId(null);
        memberReadHistory.setCreateTime(new Date());
        memberReadHistoryRepository.save(memberReadHistory);
        return 1;

    }

    @Override
    public int delete(List<String> ids) {
        List<MemberReadHistory> deleteList = new ArrayList<>();
        for(String id:ids){
            MemberReadHistory memberReadHistory = new MemberReadHistory();
            memberReadHistory.setId(id);
            deleteList.add(memberReadHistory);
        }
        memberReadHistoryRepository.deleteAll(deleteList);
        return ids.size();
    }

    @Override
    public List<MemberReadHistory> list(Long memberId) {
        return memberReadHistoryRepository.findByMemberIdOrderByCreateTimeDesc(memberId);
    }
}

web层控制类MemberReadHistoryController.java

import com.macro.mall.tiny.common.api.CommonResult;
import com.macro.mall.tiny.nosql.mongodb.document.MemberReadHistory;
import com.macro.mall.tiny.service.MemberReadHistoryService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import java.util.List;


/**
 * 会员商品浏览记录管理Controller
 * Created by macro on 2018/8/3.
 */
@Controller
@Api(tags = "MemberReadHistoryController", description = "会员商品浏览记录管理")
@RequestMapping("/member/readHistory")
public class MemberReadHistoryController {
    @Autowired
    private MemberReadHistoryService memberReadHistoryService;

    @ApiOperation("创建浏览记录")
    @RequestMapping(value = "/create", method = RequestMethod.POST)
    @ResponseBody
    public CommonResult create(@RequestBody MemberReadHistory memberReadHistory) {
        int count = memberReadHistoryService.create(memberReadHistory);
        if (count > 0) {
            return CommonResult.success(count);
        } else {
            return CommonResult.failed();
        }
    }

    @ApiOperation("删除浏览记录")
    @RequestMapping(value = "/delete", method = RequestMethod.POST)
    @ResponseBody
    public CommonResult delete(@RequestParam("ids") List<String> ids) {
        int count = memberReadHistoryService.delete(ids);
        if (count > 0) {
            return CommonResult.success(count);
        } else {
            return CommonResult.failed();
        }
    }

    @ApiOperation("展示浏览记录")
    @RequestMapping(value = "/list", method = RequestMethod.GET)
    @ResponseBody
    public CommonResult<List<MemberReadHistory>> list(Long memberId) {
        List<MemberReadHistory> memberReadHistoryList = memberReadHistoryService.list(memberId);
        return CommonResult.success(memberReadHistoryList);
    }
}

6、启动项目，使用swagger进行接口测试

添加商品浏览记录到Mongodb

查询Mongodb中的商品浏览记录

测试项目源码地址

https://github.com/macrozheng/mall-learning/tree/master/mall-tiny-07 (opens new window)