JavaEE：MongoDB安装与使用

说明：

文档型数据库，采用BSON格式。介于关系型数据库和非关系型数据库之间，属于NoSQL数据库之一。
适合大数据场景使用，大量数据写入操作。

一个文档==表中的一行数据，(多个文档)集合==(多行数据)表，多个集合(表)组成数据库。

一、安装MongoDB服务器：

1.CentOS 7中安装MongoDB：

(1)下载mongodb-linux-x86_64-rhel70-5.0.9.tgz：

商业付费版：
https://www.mongodb.com/try/download/enterprise

社区版：
https://www.mongodb.com/try/download/community

Available Downloads中，选择Version为5.0.9(current)、Platform为RedHat/CentOS 7.0、Package为tgz，点Download，如图：

 (2)用XFtp将安装包上传到/usr/local目录，解压并重命名：

[root@localhost local]# tar -zxvf mongodb-linux-x86_64-rhel70-5.0.9.tgz
[root@localhost local]# mv mongodb-linux-x86_64-rhel70-5.0.9 mongodb

(3)创建data+log+conf目录(cd到/usr/local/mongodb目录)：

[root@localhost mongodb]# mkdir -p data log conf

(4)创建mongodb.conf配置文件(cd到/usr/local/mongodb/conf目录)：

[root@localhost conf]# vi mongodb.conf

内容如下：

bind_ip=0.0.0.0        #允许外部访问
port = 27017           #端口
dbpath = /usr/local/mongodb/data              #数据库文件路径
logpath = /usr/local/mongodb/log/mongodb.log  #日志文件路径
logappend = true       #写日志为追加写入(非覆盖)
fork = true            #设置为守护进程
maxConns = 100         #最大连接数
noauth = true          #关闭验证
journal = true         #写入时记录作日志

(5)配置mongodb环境变量：

[root@localhost ~]# vi /etc/profile

内容如下：

...  #原有配置不变
export PATH=/usr/local/mongodb/bin:$PATH     #添加mongodb环境变量

export PATH USER LOGNAME MAIL HOSTNAME HISTSIZE HISTCONTROL   #此行不要改，在此行之前添加mongodb环境变量
...  #原有配置不变

(6)让环境变量生效：

[root@localhost ~]# source /etc/profile

(7)创建mongodb.service(服务)：

[root@localhost ~]# vi /lib/systemd/system/mongodb.service

内容如下：

[Unit]
Description=mongodb
After=network.target remote-fs.target nss-lookup.target
[Service]
Type=forking
ExecStart=/usr/local/mongodb/bin/mongod --config /usr/local/mongodb/conf/mongodb.conf
ExecReload=/bin/kill -s HUP $MAINPID
ExecStop=/usr/local/mongodb/bin/mongod  --shutdown --config  /usr/local/mongodb/conf/mongodb.conf
PrivateTmp=true
[Install]
WantedBy=multi-user.target

(8)设置mongodb服务为开机启动：

[root@localhost ~]# systemctl enable mongodb.service

(9)启动/查看/停止mongodb服务：

[root@localhost ~]# systemctl start mongodb.service
[root@localhost ~]# systemctl status mongodb.service
[root@localhost ~]# systemctl stop mongodb.service

(10)连接登录mongo数据库：

[root@localhost ~]# mongo 192.168.1.119

2.Docker中安装MongoDB：

(1)创建mongo容器(端口27017)：

docker run -di --name=mall_mongo -p 27017:27017 mongo

(2)连接登录mongo数据库(安装在本机地址为：127.0.0.1)：

mongo 192.168.1.119

(3)退出(>表示已登录)：

> exit

二、数据类型：

1.基本数据类型：

(1)null类型：
{"key1": null}

(2)布尔类型(true或false)：
{"key1": false}

(3)数值类型：
浮点型(默认)：
{"key1": 1.0}
4字节整数：
{"key1": NumberInt("1")}
8字节整数：
{"key1": NumberLong("1")}

(4)字符串类型(UTF-8编码)：
{"key1": "value1"}

(5)日期类型：
{"key1", new Date()}

(6)正则表达式类型(js正则语法)：
{"key1": /[abcdef]/}

(7)数组类型：
{"key1": ["value1", "value2"]}

(8)内嵌文档类型(类似json)：
{"key1": {"key2": "value1"}}

(9)对象ID类型(自动生成12字节长的字符串)：{"_id": ObjectId("xxx...")}

(10)二进制类型(任意字符串的字节方式，用于存储非UTF-8类型的字符串)。

(11)js代码类型：{"key1": function(){/.../}}

三、mongo命令：

1.创建/显示数据库/表的一些命令：

#创建或使用数据库，此处数据库名为mydb
> use mydb
#显示数据库列表
> show dbs
#显示当前数据库
> db
#创建表，此处表名为user
> db.createCollection("user")
#显示所有表
> show collections

2.插入数据：

语法：db.表名.insert({列名1: 值1, 列名2: 值1})

> db.user.insert({_id: "0", name: "先生1", age: 18})

3.查询数据(没有表时自动创建)：

语法：db.表名.find({查询条件})

(1)查全部：

> db.user.find()

(2)按条件查(name=先生1)：

> db.user.find({name: "先生1"})

(3)查第1条：

> db.user.findOne()

(4)查前面N条(skip为跳过几条，limit为取几条)：

> db.user.find().skip(0).limit(10)

(5)模糊查询(语法：/要匹配的字符串/)：

#匹配所有name列带"先"的
> db.user.find({name: /先/})
#匹配name列以"先"开头的
> db.user.find({name: /^先/})

(6)比较操作符(<、<=、>、>=)：

#age>18
> db.user.find({age: {$gt: 18}})
#age>=18
> db.user.find({age: {$gte: 18}})
#age<18
> db.user.find({age: {$lt: 18}})
#age<=18
> db.user.find({age: {$lte: 18}})
#age!=18
> db.user.find({age: {$ne: 18}})

(7)包含/不包含：

#name包含多个值：
> db.user.find({name: {$in: ["先生1", "先生2"]}})
#name不含这些值：
> db.user.find({name: {$nin: ["先生1", "先生2"]}})

(8)条件连接(同时满足多个条件)：

#逻辑与：$and: [{条件1}, {条件2}, ...]
> db.user.find({$and: [{name: "先生1"}, {name: "先生2"}]})
#逻辑或：$or: [{条件1}, {条件2}, ...]
> db.user.find({$or: [{name: "先生1"}, {name: "先生2"}]})

4.修改数据：

(1)语法：db.表名.update({查询条件}, {$set: {新数据}})

> db.user.update({_id: "0"}, {$set: {name: "先生2"}})

(2)列值增长(将原有列数值增加指定值)：

语法：db.表名.update({查询条件}, {$inc: {列名: 要增加的值}})

> db.user.update({_id: "0"}, {$inc: {age: 1}})

5.删除数据：

语法：db.表名.remove({条件})

(1)删全部：

> db.user.remove({})

(2)按条件删：

> db.user.remove({_id: "0"})

6.统计条数：

语法：db.表名.count({条件})

> db.user.count({name: "先生"})

四、用MongoDB-Api操作MongoDB数据：

1.导入MongoDB驱动包：

<dependencies>
    <dependency>
        <groupId>org.mongodb</groupId>
        <artifactId>mongodb-driver</artifactId>
        <version>3.12.5</version>
    </dependency>
</dependencies>

2.增删改查(Dao类要加上@Component被扫描创建实例)：

连接/关闭：

//获取表操作对象
private MongoCollection<Document> getTableObject() {
    //建立数据库连接
    mClient = new MongoClient("192.168.3.119");
    //获取mydb数据库操作对象
    MongoDatabase db = mClient.getDatabase("mydb");
    //获取User表操作对象
    MongoCollection<Document> table = db.getCollection("user");
    return table;
}
//关闭连接
private void close() {
    if (mClient != null) {
        //关闭连接
        mClient.close();
        mClient = null;
    }
}

(1)插入数据：

//插入数据
public void insert(User user) {
    //1.获取User表操作对象
    MongoCollection<Document> table = getTableObject();
    //2.创建数据
    Map<String, Object> map = new HashMap<String, Object>();
    map.put("_id", user.getId());
    map.put("name", user.getName());
    map.put("age", user.getAge());
    //3.创建一条文档记录
    Document item = new Document(map);
    //4.执行插入操作
    table.insertOne(item);
    //4.table.insertMany(null);  //插入多个
    //5.关闭连接
    close();
}

(2)删除数据：

//删除数据
public void delete(String id) {
    //1.获取User表操作对象
    MongoCollection<Document> table = getTableObject();
    //2.创建条件
    BsonDocument bson = new BsonDocument();
    bson.put("_id", new BsonString(id)); //BsonInt32为int，BsonBoolean为boolean
    //3.执行删除
    table.deleteOne(bson);
    //4.关闭连接
    close();
}

(3)更新数据：

//更新数据
public void update(User user) {
    //1.获取User表操作对象
    MongoCollection<Document> table = getTableObject();
    //2.创建新数据
    Map<String, Object> newData = new HashMap<>();
    newData.put("name", user.getName());
    newData.put("age", user.getAge());
    //3.执行更新，第1个参数Filters.eq为条件，第2个参数为新数据，$set表示设值
    table.updateMany(Filters.eq("_id", user.getId()), new Document("$set", newData));
    //4.关闭连接
    close();
}

(4)查询数据：

//查询全部
public List<User> findAll() {
    List<User> users = new ArrayList<User>();
    //1.获取User表操作对象
    MongoCollection<Document> table = getTableObject();
    //2.查询所有
    FindIterable<Document> result = table.find();
    if (result == null) {
        return users;
    }
    //3.取出数据
    for (Document item : result) {
        /*
        item.getString("key1");  //取String类型的值
        item.getInteger("key1"); //取int类型
        item.getDouble("key1");  //取double类型
        item.getBoolean("key1");  //取boolean类型
        item.getDate("key1");    //取Date类型
        item.getLong("key1");    //取long类型
        */
        users.add(new User(item.getString("_id"), item.getString("name"), item.getInteger("age")));
    }
    //4.关闭连接
    close();
    return users;
}

//按条件查询
public List<User> query(String id, String name, int age) {
    List<User> users = new ArrayList<User>();
    //1.获取User表操作对象
    MongoCollection<Document> table = getTableObject();

    //2.建立条件对象
    //条件：_id = 0
    BasicDBObject where1 = new BasicDBObject("_id", "0");
    //条件：age >= 18
    BasicDBObject where2 = new BasicDBObject("age", new BasicDBObject("$gte", 18));
    //模糊查询：name中有"先生"字的
    BasicDBObject where3 = new BasicDBObject("name", new BasicDBObject("$regex", "先生"));

    //3.执行查询
    FindIterable<Document> result = table.find(where1);
    if (result == null) {
        return users;
    }
    //4.取出查询结果
    for (Document item : result) {
        users.add(new User(item.getString("_id"), item.getString("name"), item.getInteger("age")));
    }
    //5.关闭连接
    return users;
}

五、SpringData-MongoDB使用：

1.导入SpringData-MongoDB依赖包：

<dependencies>
    <!-- 导入SpringData-MongoDB依赖包 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-mongodb</artifactId>
    </dependency>
</dependencies>

2.创建application.yml，配置mongodb服务器地址与数据库名:

server:
  port: 10003  #本微服务端口
spring:
  application:
    name: mall-mongodb   #本微服务名称
  data:
    mongodb:
      host: 192.168.3.119  #mongodb服务器地址
      database: mydb   #数据库名称

3.创建实体类：

@Document(collection = "user")  //映射表的名字
public class User implements Serializable {
    @Id  //数据库_id
    private String _id;
    private String name;
    private int age;
    public String get_id() {
        return _id;
    }
    public void set_id(String _id) {
        this._id = _id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

4.创建Dao接口类(SpringData-MongoDB数据操作类)：

//SpringData-MongoDB数据操作类
@Component
public interface UserDao extends MongoRepository<User, String> { //dao需要继承MongoRepository
}

5.调用Dao实现类进行增删改查操作：

@Transactional  //开启事务
@Service  //标识此类为业务层类(service层)
public class UserBiz {//操作Dao的业务类
    @Autowired
    private UserDao userDao; //dao操作类
    @Autowired
    private MongoTemplate mongoTemplate; //MongoDB原生API操作类
    //插入数据
    public void insert(User user) {
        userDao.insert(user);
    }
    //删除数据
    public void delete(String id) {
        userDao.deleteById(id);
    }
    //更新数据
    public void update(User user) {
        userDao.save(user);
    }
    //使用MongoTemplate更新数据
    public void updateByTemplate(User user) {
        //1.增加查询条件：_id=xxx
        Query q = new Query();
        q.addCriteria(Criteria.where("_id").is(user.get_id()));
        //2.设置新数据
        Update u = new Update();
        u.set("name", user.getName());
        u.set("age", user.getAge());
        //3.执行更新
        mongoTemplate.updateFirst(q, u, "user");
    }
    //查询全部
    public List<User> findAll() {
        return userDao.findAll();
    }
    //按条件查询单个
    public User findById(String id) {
        return userDao.findById(id).get();
    }
    //分页查询
    public List<User> queryPage(int pageIndex, int pageSize) {//pageIndex页码从0开始，pageSize一页多少条
        Pageable pageable = PageRequest.of(pageIndex, pageSize);  //创建分页条件
        return userDao.queryPage(pageable).getContent(); //分页查询
    }
}

六、SpringData-MongoDB-GridFs使用：

说明：GridFS是MongoDB提供的用于存储文件的功能，文件会按256KB的大小分割成多块存储。

1.配置config类：

@Configuration
public class GridfsConfig {
    @Value("${spring.data.mongodb.database}") //获取application.yml中的数据库名称
    private String dbName;
    @Bean
    public GridFSBucket getGridFSBucket(MongoClient mongoClient) {
        MongoDatabase db = mongoClient.getDatabase(dbName);
        GridFSBucket b = GridFSBuckets.create(db);
        return b;
    }
}

2.文件存/取/删：

public class GridfsBiz {
    @Autowired
    GridFsTemplate gridFsTemplate;
    @Autowired
    GridFSBucket gridFSBucket;
    //保存文件到gridfs
    public String saveFile(String path) {
        try {
            File file = new File(path);
            FileInputStream in = new FileInputStream(file);
            ObjectId fileID = gridFsTemplate.store(in, "文件名", "内容类别"); //将文件存入GridFS
            if (fileID != null) {
                return fileID.toString();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    //获取文件流
    public InputStream findFile(String fileID) {
        try {
            GridFSFile gridFSFile = gridFsTemplate.findOne(Query.query(Criteria.where("_id").is(fileID)));
            GridFSDownloadStream ds = gridFSBucket.openDownloadStream(gridFSFile.getObjectId());
            GridFsResource resource = new GridFsResource(gridFSFile, ds);
            return resource.getInputStream();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    //删除文件
    public void deleteFile(String fileID) {
        gridFsTemplate.delete(Query.query(Criteria.where("_id").is(fileID)));
    }
}