MongoDB数据库

安装

# 使用的centos7系统,可到官网下载相应版本
wget https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-rhel70-5.0.14.tgz
# 解压
tar -zxf mongodb-linux-x86_64-rhel70-5.0.14.tgz
# 进入mongodb目录,创建data目录存放数据
mkdir data
# 进入bin目录进行启动,--bind_ip_all开放所有ip地址访问,也可--bind_ip指定ip地址
./mongod --port=27017 --dbpath=../data --bind_ip_all

一.操作命令

1.数据库命令

展示所有库: show dbs; 或 show databases; 数据库中无数据库,则不显示.

查询当前所在库: db

创建/切换库: use 库名称 无库则创建,有库则切换.

删除库: db.dropDatabase()

2.集合命令

展示所有集合: show collections 或 show tables

创建集合: db.createCollection('集合名称', [options]) options有如下值:

capped 布尔类型, 默认false, 如果指定为true,则为固定集合,必须指定size(字节数).固定集合如果达到size或者文档数量max的值则会覆盖最初的文档.
size 数值, 表示集合字节数, 如果 capped 为true, 则size必填.
max 数值, 表示文档最大数量.

删除集合: db.集合名称.drop()

3.文档命令

插入文档: db.集合名称.insert({}) 插入多条: db.集合名称.insert([{},{}]) 或

db.集合名称.insertMany(
   [ <document 1> , <document 2>, ... ],
   {
      writeConcern: <document>, // Write concern描述了MongoDB对独立mongod,副本集或分片集群的写入操作请求的确认级别
      ordered: <boolean> // 是否按顺序插入,默认true
   }
);
// 插入一条
db.集合名称.insertOne({});

删除文档: db.集合名称.remove({query})

db.集合名称.remove(
   <query>, // 查询参数
   {
     justOne: <boolean>,// 是否只删除一个
     writeConcern: <document>,
     collation: <document>,
     let: <document> // Added in MongoDB 5.0
   }
);

// 删除一个
db.集合名称.deleteOne({});

// 删除多个
db.collection.deleteMany(
   <filter>,
   {
      writeConcern: <document>,
      collation: <document>
   }
)

更新文档: db.集合名称.update({query},{update},{})

db.集合名词.update(
   <query>,
   <update>, // update中如果不使用$set则会覆盖原有的数据,如果使用$set则如果有相应字段的数据则进行更新,否则进行插入;$inc给指定字段增加值
   {
     upsert: <boolean>, // 如果没有是否进行插入,默认false
     multi: <boolean>, // 是否修改多条,默认false
     writeConcern: <document>,
     collation: <document>,
     arrayFilters: [ <filterdocument1>, ... ],
     hint:  <document|string>, // Added in MongoDB 4.2
     let: <document> // Added in MongoDB 5.0
   }
)

查询文档

基本语法: db.集合名称.find(query, projection);

query条件可多个,表示交集(相当于sql中的and)

projection: 选择可返回的字段, 1是返回, 0是不返回, 0和1不能同时使用.

// age和name字段都返回
db.users.find({},{age:1,name:1});

$or: [{field1: value1},{field1: value1}]相当于sql中的or

db.users.find({age:1},$or:[{name:'lzlg'},{address:'China'}])

某个字段等于(默认), 不等于 $ne 大于 $gt 大于等于 $gte 小于 $lt 小于等于 $lte: db.users.find({age:{$ne:11}})

模糊查询直接使用正则表达式: db.users.find({name:/好/})

统计数量: 在find()后面添加count()函数: db.users.find().count()

排序: 在find()后面添加sort()函数, 1升序, -1降序: db.users.find().sort({age:1,name:-1})

分页: 在find()后面添加skip()函数,表示起始位置,limit()表示行数: db.users.find().skip(1).limit(5)

去重: db.users.distinct('字段')

数组/模糊查询直接支持.如果想指定数组长度使用$size: db.users.find({arrays:{$size:1}})

显式格式化: 在find()后面添加pretty()函数: db.users.find().pretty()

$type

使用 $type 可以查询指定类型的数据, 比如一个字段有可能是数字,数组或字符串,使用$type可查询只是数字的数据.常用的数据类型对应数字表:

类型	数字
Double(代表数字)	1
String	2
Object	3
Array	4
Object id	7
Boolean	8
Date	9

二.索引

创建索引: db.集合名称.createIndex({keys}, {optionals})

其中keys可以指定多个,值为1(升序)或-1(降序)

可选参数有以下:

参数名	参数值类型	说明
background	Boolean	是否后台创建索引,默认false
unique	Boolean	是否唯一索引,默认false
name	String	索引名称
sparse	Boolean	对文档中数据为null的不启用索引,如果为true,则不会包含有null值的数据,默认false
expireAfterSeconds	Integer	索引过期时间
v	index version	索引版本号
weights	document	索引权重值

查询索引: db.集合名称.getIndexes() 查看集合索引大小: db.集合名称.totalIndexSize()

删除索引: 删除所有-db.集合名称.dropIndexes(); 删除指定名称-db.集合名称.dropIndex('字段名')

三.聚合

MongoDB中聚合(aggregate)主要用于处理数据,比如统计平均值,求和,并返回计算后的结果,常用聚合表达式:

db.集合名称.aggregate([{$group: {_id:"$分组字段名", "输出字段名":{聚合表达式:"$字段名"}}}])

表达式	描述
$sum	求和
$avg	平均值
$min	最小值
$max	最大值
$push	将值添加到数组中,不判断是否重复
$addToSet	将值添加到数组中,判断重复
$first	获取第一个
$last	最后一个

例子: db.users.aggregate([{$group:{_id:"$age", "age_avg":{$first:"$age"}}}])

四.整合SpringBoot

依赖

<properties>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <spring-boot.version>2.3.7.RELEASE</spring-boot.version>
        <lombok.version>1.18.16</lombok.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</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-data-mongodb</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

配置

server:
  port: 8080
spring:
  data:
    mongodb:
    # 单机模式
      uri: mongodb://localhost:27017/myblog

使用

/
 * @author lzlg
 * 2022/12/1 12:04
 */
@Data
@ToString
@NoArgsConstructor
@AllArgsConstructor
@Document("users")
public class User {

    @Id
    private Integer id;

    @Field("username")
    private String name;

    @Field("hobbies")
    private List<String> hobbies;

    @Field("birthday")
    private LocalDate birthday;
}

@SpringBootTest
public class MongodbLearnApplicationTests {

    @Autowired
    private MongoTemplate mongoTemplate;

    @Test
    public void testCollection() {
        String tableName = "users";
        boolean exists = mongoTemplate.collectionExists(tableName);
        if (exists) {
            System.out.println(tableName + "集合已存在");
        } else {
            System.out.println(tableName + "集合不存在");
            MongoCollection<Document> products = mongoTemplate.createCollection(tableName);
            long count = products.countDocuments();
            System.out.println(tableName + "集合中文档数量:" + count);
        }
    }

    @Test
    public void testDocument() {
        List<User> users = Arrays.asList(
                new User(1, "李四", Arrays.asList("美女", "读书", "看视频"), LocalDate.now()),
                new User(2, "张三", Arrays.asList("帅哥", "读书", "看抖音"), LocalDate.now()));
        mongoTemplate.insert(users, User.class);
    }

    @Test
    public void testSelectDocument() {
        List<User> users = mongoTemplate.findAll(User.class);
        users.forEach(System.out::println);

        users = mongoTemplate.find(Query.query(Criteria.where("name").is("张三").and("username").regex("/张/").orOperator(
                Criteria.where("birthday").lte(LocalDate.now()),
                Criteria.where("hobbies").regex("/美女/")
        )).skip(1).limit(5), User.class);
        users.forEach(System.out::println);

        long count = mongoTemplate.count(Query.query(Criteria.where("username").regex("张.")), User.class);
        System.out.println(count);

        List<LocalDate> dateList = mongoTemplate.findDistinct(Query.query(Criteria.where("hobbies").regex("美女*")),
                "birthday", User.class, LocalDate.class);
        dateList.forEach(System.out::println);
    }

    @Test
    public void testUpdateOrDeleteDoc() {
        UpdateResult updateResult = mongoTemplate.updateFirst(Query.query(Criteria.where("username").regex("张.")),
                Update.update("username", "刘姥姥"), User.class);
        System.out.println(updateResult);

        DeleteResult deleteResult = mongoTemplate.remove(Query.query(Criteria.where("username").regex("张.")),
                User.class);
        System.out.println(deleteResult );
    }
}

五.集群

副本集群

# 启动第一个 ./mongod --port=27017 --dbpath=../replica/data1 --bind_ip_all --replSet=myReplica/[192.168.174.160:27018,192.168.174.160:27019] # 启动第二个 ./mongod --port=27018 --dbpath=../replica/data2 --bind_ip_all --replSet=myReplica/[192.168.174.160:27017,192.168.174.160:27019] # 启动第三个 ./mongod --port=27019 --dbpath=../replica/data3 --bind_ip_all --replSet=myReplica/[192.168.174.160:27017,192.168.174.160:27018] # 进入任意节点 ./mongo --port=27017 # 进入admin库中 use admin # 插入配置信息,注意_id要和replSet中的一致 var config = { _id:"myReplica", members: [ {_id:0,host:"192.168.174.160:27017"},{_id:1,host:"192.168.174.160:27018"}, {_id:2,host:"192.168.174.160:27019"} ] } # 启用配置信息 rs.initiate(config) # 设置客户端临时访问 rs.secondaryOk(); # 使用spring boot连接 mongodb://192.168.174.160:27017,192.168.174.160:27018,192.168.174.160:27018/test?replicaSet=myReplica

分片集群

# 集群规划, 三台虚拟机,每台机器一个分片+副本+配置,其中一个作为路由 # 三台虚拟机ip分别为: 192.168.174.133 192.168.174.134 192.168.174.135 # 占用端口 27017(分片) 27018(副本) 27020(作为配置服务器) 27030(路由) # 目录 cluster/data cluster/replica cluster/config mkdir cluster cd cluster mkdir data replica config # 启动分片副本并配置 ./mongod --port=27017 --dbpath=../cluster/data --bind_ip_all --shardsvr --replSet=s0/192.168.174.133:27018 ./mongod --port=27018 --dbpath=../cluster/replica --bind_ip_all --shardsvr --replSet=s0/192.168.174.133:27017 var config = { _id:"s0", members: [ {_id:0,host:"192.168.174.133:27017"},{_id:1,host:"192.168.174.133:27018"} ] } rs.initiate(config) ./mongod --port=27017 --dbpath=../cluster/data --bind_ip_all --shardsvr --replSet=s1/192.168.174.134:27018 ./mongod --port=27018 --dbpath=../cluster/replica --bind_ip_all --shardsvr --replSet=s1/192.168.174.134:27017 var config = { _id:"s1", members: [ {_id:0,host:"192.168.174.134:27017"},{_id:1,host:"192.168.174.134:27018"} ] } rs.initiate(config) ./mongod --port=27017 --dbpath=../cluster/data --bind_ip_all --shardsvr --replSet=s2/192.168.174.135:27018 ./mongod --port=27018 --dbpath=../cluster/replica --bind_ip_all --shardsvr --replSet=s2/192.168.174.135:27017 var config = { _id:"s2", members: [ {_id:0,host:"192.168.174.135:27017"},{_id:1,host:"192.168.174.135:27018"} ] } rs.initiate(config) # 启动配置服务器 ./mongod --port=27020 --dbpath=../cluster/config --bind_ip_all --replSet=config/[192.168.174.134:27020,192.168.174.135:27020] --configsvr ./mongod --port=27020 --dbpath=../cluster/config --bind_ip_all --replSet=config/[192.168.174.133:27020,192.168.174.135:27020] --configsvr ./mongod --port=27020 --dbpath=../cluster/config --bind_ip_all --replSet=config/[192.168.174.133:27020,192.168.174.134:27020] --configsvr # 登录任意节点 var config = { _id:"config", configsvr: true, members:[ {_id:0,host:"192.168.174.133:27020"},{_id:1,host:"192.168.174.134:27020"},{_id:2,host:"192.168.174.135:27020"} ] } rs.initiate(config) # 启动mongos路由服务,在133这台机器上 ./mongos --port=27030 --configdb=config/192.168.174.133:27020,192.168.174.134:27020,192.168.174.135:27020 --bind_ip_all ./mongo --port=27030 # 指定分片配置信息 db.runCommand({addshard:"s0/192.168.174.133:27017,192.168.174.133:27018",allowLocal:true}); db.runCommand({addshard:"s1/192.168.174.134:27017,192.168.174.134:27018",allowLocal:true}); db.runCommand({addshard:"s2/192.168.174.135:27017,192.168.174.135:27018",allowLocal:true}); # 指定分片的数据库 db.runCommand({enablesharding:"myblog"}) # 设定库的分片键信息 db.runCommand({shardcollection:"myblog.users",key:{_id:"hashed"}})

六.安全认证

直接使用分片副本集群进行操作

生成鉴权文件

# 生成鉴权文件 openssl rand -base64 90 -out ./mongo.keyfile # 修改mongo.keyfile文件权限,否则会报权限太开放的错误 chmod 400 ./mongo.keyfile

第一个分片副本集群

# 创建第一个分片副本集群 mkdir -p ./cluster/sharding_01/primary_27018/log \ ./cluster/sharding_01/primary_27018/data \ ./cluster/sharding_01/secondary_27118/log \ ./cluster/sharding_01/secondary_27118/data \ ./cluster/sharding_01/arbiter_27218/log \ ./cluster/sharding_01/arbiter_27218/data # primary_27018配置文件,路径./cluster/sharding_01/primary_27018/mongod.conf systemLog: # MongoDB发送所有日志输出的目标指定为文件 destination: file # 日志文件路径 path: /root/mongodb/cluster/sharding_01/primary_27018/log/mongod.log # 日志追加模式 logAppend: true storage: # 数据文件存储目录 dbPath: /root/mongodb/cluster/sharding_01/primary_27018/data journal: # 启用永久性日志确保数据文件保持有效和可恢复 enabled: true processManagement: # 在后台运行守护进程模式 fork: true # 进程id文件 pidFilePath: /root/mongodb/cluster/sharding_01/primary_27018/log/mongod.pid net: # 服务实例绑定的ip,绑定所有ip使用bindIpAll: true bindIp: localhost,192.168.174.133 port: 27018 replication: # 副本集名称 replSetName: sharding_01 sharding: # 分片角色 clusterRole: shardsvr #security: # keyFile鉴权文件存放路径 #keyFile: /root/mongodb/mongo.keyfile # 开启认证 #authorization: enabled # secondary_27118配置文件,路径./cluster/sharding_01/secondary_27118/mongod.conf systemLog: # MongoDB发送所有日志输出的目标指定为文件 destination: file # 日志文件路径 path: /root/mongodb/cluster/sharding_01/secondary_27118/log/mongod.log # 日志追加模式 logAppend: true storage: # 数据文件存储目录 dbPath: /root/mongodb/cluster/sharding_01/secondary_27118/data journal: # 启用永久性日志确保数据文件保持有效和可恢复 enabled: true processManagement: # 在后台运行守护进程模式 fork: true # 进程id文件 pidFilePath: /root/mongodb/cluster/sharding_01/secondary_27118/log/mongod.pid net: # 服务实例绑定的ip,绑定所有ip使用bindIpAll: true bindIp: localhost,192.168.174.133 port: 27118 replication: # 副本集名称 replSetName: sharding_01 sharding: # 分片角色 clusterRole: shardsvr #security: # keyFile鉴权文件存放路径 #keyFile: /root/mongodb/mongo.keyfile # 开启认证 #authorization: enabled # arbiter_27218配置文件,路径./cluster/sharding_01/arbiter_27218/mongod.conf systemLog: # MongoDB发送所有日志输出的目标指定为文件 destination: file # 日志文件路径 path: /root/mongodb/cluster/sharding_01/arbiter_27218/log/mongod.log # 日志追加模式 logAppend: true storage: # 数据文件存储目录 dbPath: /root/mongodb/cluster/sharding_01/arbiter_27218/data journal: # 启用永久性日志确保数据文件保持有效和可恢复 enabled: true processManagement: # 在后台运行守护进程模式 fork: true # 进程id文件 pidFilePath: /root/mongodb/cluster/sharding_01/arbiter_27218/log/mongod.pid net: # 服务实例绑定的ip,绑定所有ip使用bindIpAll: true bindIp: localhost,192.168.174.133 port: 27218 replication: # 副本集名称 replSetName: sharding_01 sharding: # 分片角色 clusterRole: shardsvr # 先不开启安全认证,等配置好副本后再进行 #security: # keyFile鉴权文件存放路径 #keyFile: /root/mongodb/mongo.keyfile # 开启认证 #authorization: enabled # 进入bin目录进行启动 ./mongod -f /root/mongodb/cluster/sharding_01/primary_27018/mongod.conf ./mongod -f /root/mongodb/cluster/sharding_01/secondary_27118/mongod.conf ./mongod -f /root/mongodb/cluster/sharding_01/arbiter_27218/mongod.conf # 进入27018节点 ./mongo --port 27018 # 执行初始化副本集命令 rs.initiate() # 查看副本集情况 rs.status() # 主节点配置查看 rs.conf() # 添加副本节点 rs.add("192.168.174.133:27118") # 添加仲裁节点 rs.addArb("192.168.174.133:27218")

第二个分片副本集群

# 同第一个,但是ip地址改为192.168.174.134 # 创建第一个分片副本集群 mkdir -p ./cluster/sharding_02/primary_27018/log \ ./cluster/sharding_02/primary_27018/data \ ./cluster/sharding_02/secondary_27118/log \ ./cluster/sharding_02/secondary_27118/data \ ./cluster/sharding_02/arbiter_27218/log \ ./cluster/sharding_02/arbiter_27218/data # primary_27018配置文件,路径./cluster/sharding_02/primary_27018/mongod.conf systemLog: # MongoDB发送所有日志输出的目标指定为文件 destination: file # 日志文件路径 path: /root/mongodb/cluster/sharding_02/primary_27018/log/mongod.log # 日志追加模式 logAppend: true storage: # 数据文件存储目录 dbPath: /root/mongodb/cluster/sharding_02/primary_27018/data journal: # 启用永久性日志确保数据文件保持有效和可恢复 enabled: true processManagement: # 在后台运行守护进程模式 fork: true # 进程id文件 pidFilePath: /root/mongodb/cluster/sharding_02/primary_27018/log/mongod.pid net: # 服务实例绑定的ip,绑定所有ip使用bindIpAll: true bindIp: localhost,192.168.174.134 port: 27018 replication: # 副本集名称 replSetName: sharding_02 sharding: # 分片角色 clusterRole: shardsvr #security: # keyFile鉴权文件存放路径 #keyFile: /root/mongodb/mongo.keyfile # 开启认证 #authorization: enabled # secondary_27118配置文件,路径./cluster/sharding_02/secondary_27118/mongod.conf systemLog: # MongoDB发送所有日志输出的目标指定为文件 destination: file # 日志文件路径 path: /root/mongodb/cluster/sharding_02/secondary_27118/log/mongod.log # 日志追加模式 logAppend: true storage: # 数据文件存储目录 dbPath: /root/mongodb/cluster/sharding_02/secondary_27118/data journal: # 启用永久性日志确保数据文件保持有效和可恢复 enabled: true processManagement: # 在后台运行守护进程模式 fork: true # 进程id文件 pidFilePath: /root/mongodb/cluster/sharding_02/secondary_27118/log/mongod.pid net: # 服务实例绑定的ip,绑定所有ip使用bindIpAll: true bindIp: localhost,192.168.174.134 port: 27118 replication: # 副本集名称 replSetName: sharding_02 sharding: # 分片角色 clusterRole: shardsvr #security: # keyFile鉴权文件存放路径 #keyFile: /root/mongodb/mongo.keyfile # 开启认证 #authorization: enabled # arbiter_27218配置文件,路径./cluster/sharding_02/arbiter_27218/mongod.conf systemLog: # MongoDB发送所有日志输出的目标指定为文件 destination: file # 日志文件路径 path: /root/mongodb/cluster/sharding_02/arbiter_27218/log/mongod.log # 日志追加模式 logAppend: true storage: # 数据文件存储目录 dbPath: /root/mongodb/cluster/sharding_02/arbiter_27218/data journal: # 启用永久性日志确保数据文件保持有效和可恢复 enabled: true processManagement: # 在后台运行守护进程模式 fork: true # 进程id文件 pidFilePath: /root/mongodb/cluster/sharding_02/arbiter_27218/log/mongod.pid net: # 服务实例绑定的ip,绑定所有ip使用bindIpAll: true bindIp: localhost,192.168.174.134 port: 27218 replication: # 副本集名称 replSetName: sharding_02 sharding: # 分片角色 clusterRole: shardsvr # 先不开启安全认证,等配置好副本后再进行 #security: # keyFile鉴权文件存放路径 #keyFile: /root/mongodb/mongo.keyfile # 开启认证 #authorization: enabled # 进入bin目录进行启动 ./mongod -f /root/mongodb/cluster/sharding_02/primary_27018/mongod.conf ./mongod -f /root/mongodb/cluster/sharding_02/secondary_27118/mongod.conf ./mongod -f /root/mongodb/cluster/sharding_02/arbiter_27218/mongod.conf # 进入27018节点 ./mongo --port 27018 # 执行初始化副本集命令 rs.initiate() # 查看副本集情况 rs.status() # 主节点配置查看 rs.conf() # 添加副本节点 rs.add("192.168.174.134:27118") # 添加仲裁节点 rs.addArb("192.168.174.134:27218")

配置副本集

# 在192.168.174.133上创建一个 mkdir -p ./cluster/config_01/first_27019/log \ ./cluster/config_01/first_27019/data # 在192.168.174.134上创建两个 mkdir -p ./cluster/config_02/second_27019/log \ ./cluster/config_02/second_27019/data mkdir -p ./cluster/config_03/third_27119/log \ ./cluster/config_03/third_27119/data # first_27019配置文件,路径./cluster/config_01/first_27019/mongod.conf systemLog: # MongoDB发送所有日志输出的目标指定为文件 destination: file # 日志文件路径 path: /root/mongodb/cluster/config_01/first_27019/log/mongod.log # 日志追加模式 logAppend: true storage: # 数据文件存储目录 dbPath: /root/mongodb/cluster/config_01/first_27019/data journal: # 启用永久性日志确保数据文件保持有效和可恢复 enabled: true processManagement: # 在后台运行守护进程模式 fork: true # 进程id文件 pidFilePath: /root/mongodb/cluster/config_01/first_27019/log/mongod.pid net: # 服务实例绑定的ip,绑定所有ip使用bindIpAll: true bindIp: localhost,192.168.174.133 port: 27019 replication: # 副本集名称 replSetName: config_server sharding: # 分片角色 clusterRole: configsvr #security: # keyFile鉴权文件存放路径 #keyFile: /root/mongodb/mongo.keyfile # 开启认证 #authorization: enabled # second_27019配置文件,路径./cluster/config_02/second_27019/mongod.conf systemLog: # MongoDB发送所有日志输出的目标指定为文件 destination: file # 日志文件路径 path: /root/mongodb/cluster/config_02/second_27019/log/mongod.log # 日志追加模式 logAppend: true storage: # 数据文件存储目录 dbPath: /root/mongodb/cluster/config_02/second_27019/data journal: # 启用永久性日志确保数据文件保持有效和可恢复 enabled: true processManagement: # 在后台运行守护进程模式 fork: true # 进程id文件 pidFilePath: /root/mongodb/cluster/config_02/second_27019/log/mongod.pid net: # 服务实例绑定的ip,绑定所有ip使用bindIpAll: true bindIp: localhost,192.168.174.134 port: 27019 replication: # 副本集名称 replSetName: config_server sharding: # 分片角色 clusterRole: configsvr #security: # keyFile鉴权文件存放路径 #keyFile: /root/mongodb/mongo.keyfile # 开启认证 #authorization: enabled # third_27119配置文件,路径./cluster/config_03/third_27119/mongod.conf systemLog: # MongoDB发送所有日志输出的目标指定为文件 destination: file # 日志文件路径 path: /root/mongodb/cluster/config_03/third_27119/log/mongod.log # 日志追加模式 logAppend: true storage: # 数据文件存储目录 dbPath: /root/mongodb/cluster/config_03/third_27119/data journal: # 启用永久性日志确保数据文件保持有效和可恢复 enabled: true processManagement: # 在后台运行守护进程模式 fork: true # 进程id文件 pidFilePath: /root/mongodb/cluster/config_03/third_27119/log/mongod.pid net: # 服务实例绑定的ip,绑定所有ip使用bindIpAll: true bindIp: localhost,192.168.174.134 port: 27119 replication: # 副本集名称 replSetName: config_server sharding: # 分片角色 clusterRole: configsvr #security: # keyFile鉴权文件存放路径 #keyFile: /root/mongodb/mongo.keyfile # 开启认证 #authorization: enabled # 进入bin目录进行启动 ./mongod -f /root/mongodb/cluster/config_01/first_27019/mongod.conf ./mongod -f /root/mongodb/cluster/config_02/second_27019/mongod.conf ./mongod -f /root/mongodb/cluster/config_03/third_27119/mongod.conf # 进入133的27019节点 ./mongo --port 27019 # 执行初始化副本集命令 rs.initiate() # 添加副本集节点 rs.add("192.168.174.134:27019") rs.add("192.168.174.134:27119")

第一个路由节点

# 在133上 mkdir -p ./cluster/router_01/first_27017/log \ ./cluster/router_01/first_27017/data # first_27017配置文件,路径./cluster/router_01/first_27017/mongod.conf systemLog: # MongoDB发送所有日志输出的目标指定为文件 destination: file # 日志文件路径 path: /root/mongodb/cluster/router_01/first_27017/log/mongod.log # 日志追加模式 logAppend: true processManagement: # 在后台运行守护进程模式 fork: true # 进程id文件 pidFilePath: /root/mongodb/cluster/router_01/first_27017/log/mongod.pid net: # 服务实例绑定的ip,绑定所有ip使用bindIpAll: true bindIp: localhost,192.168.174.133 port: 27017 sharding: # 指定配置节点副本集 configDB: config_server/192.168.174.133:27019,192.168.174.134:27019,192.168.174.134:27119 #security: # keyFile鉴权文件存放路径 #keyFile: /root/mongodb/mongo.keyfile # 注意是mongos进行启动 ./mongos -f /root/mongodb/cluster/router_01/first_27017/mongod.conf # 进入命令行添加分片 ./mongo --port 27017 # 添加分片 sh.addShard("sharding_01/192.168.174.133:27018,192.168.174.133:27118,192.168.174.133:27218") sh.addShard("sharding_02/192.168.174.134:27018,192.168.174.134:27118,192.168.174.134:27218") # 查看分片状态情况 sh.status() # 开启分片功能 sh.enableSharding("myblog") # hashed使用哈希策略分片, 1则使用范围分片 sh.shardCollection("myblog.users",{"_id":"hashed"})

第二个路由节点

# 进入134 mkdir -p ./cluster/router_02/second_27017/log \ ./cluster/router_02/second_27017/data # second_27017配置文件,路径./cluster/router_02/second_27017/mongod.conf systemLog: # MongoDB发送所有日志输出的目标指定为文件 destination: file # 日志文件路径 path: /root/mongodb/cluster/router_02/second_27017/log/mongod.log # 日志追加模式 logAppend: true processManagement: # 在后台运行守护进程模式 fork: true # 进程id文件 pidFilePath: /root/mongodb/cluster/router_02/second_27017/log/mongod.pid net: # 服务实例绑定的ip,绑定所有ip使用bindIpAll: true bindIp: localhost,192.168.174.134 port: 27017 sharding: # 指定配置节点副本集 configDB: config_server/192.168.174.133:27019,192.168.174.134:27019,192.168.174.134:27119 #security: # keyFile鉴权文件存放路径 #keyFile: /root/mongodb/mongo.keyfile # 注意是mongos进行启动 ./mongos -f /root/mongodb/cluster/router_02/second_27017/mongod.conf

创建账户

use admin # 创建根节点用户 db.createUser({user:"root",pwd:"123456",roles:["root"]}) # 创建普通数据库读写用户 db.createUser({user: "myblog", pwd: "123456", roles: [{ role: "readWrite", db: "myblog" }]}) # 进行认证登录,需在admin数据库中进行认证登录 db.auth("root","123456")

SpringBoot

# 分片集群有认证的情况下,直接使用路由的ip和端口 mongodb://myblog:123456@192.168.174.133:27017,192.168.174.134:27017/myblog # 如果是连接副本集 mongodb://myblog:123456@host1,host2,host3/articledb?connect=replicaSet&slaveOk=true&replicaSet=副本集名字 # slaveOk=true: 开启副本节点读的功能,可实现读写分离 # connect=replicaSet: 自动到副本集中选择读写的主机,如果slaveOK是打开的,则实现了读写分离