MongoDB安装以及使用Java连接MongoDB

MongoDB简介

MongoDB 是一个跨平台的，面向文档的数据库，是当前 NoSQL 数据库产品中最热门的一种。它介于关系数据库和非关系数据库之间，是非关系数据库当中功能最丰富，最像关系数据库的产品。它支持的数据结构非常松散，是类似JSON 的 BSON 格式，因此可以存储比较复杂的数据类型。

特点

MongoDB 最大的特点是他支持的查询语言非常强大，其语法有点类似于面向对象的查询语言，几乎可以实现类似关系数据库单表查询的绝大部分功能，而且还支持对数据建立索引。它是一个面向集合的,模式自由的文档型数据库。
具体特点总结如下：

• （1）面向集合存储，易于存储对象类型的数据
• （2）模式自由
• （3）支持动态查询
• （4）支持完全索引，包含内部对象
• （5）支持复制和故障恢复
• （6）使用高效的二进制数据存储，包括大型对象（如视频等）
• （7）自动处理碎片，以支持云计算层次的扩展性
• （8）支持Python，PHP，Ruby，Java，C，C#，Javascript，Perl 及 C++语言的驱动程序，社区中也提供了对 Erlang 及.NET 等平台的驱动程序
• （9） 文件存储格式为 BSON（一种 JSON 的扩展）

体系结构

MongoDB 的逻辑结构是一种层次结构。主要由：文档(document)、集合(collection)、数据库(database)这三部分组成的。逻辑结构是面向用户
的，用户使用 MongoDB 开发应用程序使用的就是逻辑结构。

• （1）MongoDB 的文档（document），相当于关系数据库中的一行记录。
• （2）多个文档组成一个集合（collection），相当于关系数据库的表。
• （3）多个集合（collection），逻辑上组织在一起，就是数据库（database）。
• （4）一个 MongoDB 实例支持多个数据库（database）。
  文档(document)、集合(collection)、数据库(database)的层次结构如下图:

图片.png

下表是MongoDB与MySQL数据库逻辑结构概念的对比

图片.png

Linux环境安装MongoDB

上传安装包

对应自己的服务器系统，去官网下载对应版本的mongodb，
上传解压

将下载好的安装包，通过FileZilla Client工具上传到服务器，执行解压命令：

tar -zxvf mongodb-linux-x86_64-amazon-3.6.0.tgz

解压后，会多了一个没有后缀的文件，即非压缩文件包，为了方便，我将它重命名为：mongodb-linux。

创建配置文件

在/root目录里（你安装包的位置，可随意），此时有一个mongodb-linux文件，我们再新建一个mongodb文件夹：

mkdir mongodb

然后将mongodb-linux文件移入到这个文件夹：

mv mongodb-linux mongodb

之所以这么做，是为了更好的管理mongodb相关的文件，不要和其他要安装的文件搞混了。

在mongodb文件夹再里创建三个文件夹：

mkdir data   //用来存放数据库数据

mkdir logs   //用来存放日志文件

mkdir etc    //用来存放配置文件

接下来，进入到logs文件夹里创建 mongo.log文件：

touch mongo.log

再到etc文件夹里创建 mongo.conf文件：

touch mongo.conf

通过vi命令打开mongo.conf编辑内容：

vi mongo.conf

输入上面命令后，进入编辑模式，按下 i 即可输入，输入的内容为：

dbpath=/root/mongodb/data
logpath=/root/mongodb/logs/mongo.log
logappend=true journal=true quiet=true port=27017

输入完后，按下esc退出编辑，再输入:wq 回车保存

此时整个文件夹的结构如下：

|-mongodb
|  |-data
|  |-etc
|  |  |-mongo.conf
|  |-logs
|  |  |-mongo.log
|  |-mongodb-linux

创建软链接

同样，我们也为mongodb的命令创建软链接：

ln -s /root/mongodb/mongodb-linux/bin/mongo /usr/local/bin/mongo

ln -s /root/mongodb/mongodb-linux/bin/mongod /usr/local/bin/mongod

如果输入命令没报错，就是软链接成功了，你也可以到 /usr/local/bin 目录下查看一下：

cd /usr/local/bin

ls -la

此时你会看到你所创建的所有软链接，比如我的是：

image

执行

由于执行一个命令的时候不能再去执行下一个，所以可以开两个窗口测试

在第一个窗口，任意目录下输入：

mongod -f /root/mongodb/etc/mongo.conf

-f指定了配置文件，在windows下是--config

此时再去第二个窗口，输入：

mongo

此时熟悉的界面就出来了，可以执行数据库操作了，输入show dbs进行测试。

image

基本增删改查操作

创建maven工程并引入依赖

  
    
        org.mongodb
        mongodb-driver
        3.4.1
    
  

增加

使用insertOne方法来插入文档。

package cn.mongodb.demo;

import java.util.HashMap;
import java.util.Map;

import org.bson.Document;

import com.mongodb.MongoClient;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;

public class TestAdd {

    public static void main(String[] args) {
        //获取连接
        MongoClient client=new MongoClient();
        //得到数据库
        MongoDatabase database = client.getDatabase("mongodb");
        //得到集合封装对象
        MongoCollection collection = database.getCollection("student");
        Map map=new HashMap();
        map.put("name", "诸葛亮");
        map.put("sex", "男");
        map.put("age", 35.0);
        map.put("address", "南阳");       
        Document doc=new Document(map);     
        collection.insertOne(doc);//插入一条记录
        //collection.insertMany(documents);//一次性插入多条文档
    }
}

删除

package cn.mongodb.demo;

import org.bson.Document;

import com.mongodb.BasicDBObject;
import com.mongodb.MongoClient;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;

public class TestDelete {

    public static void main(String[] args) {
        
        //获取连接
        MongoClient client=new MongoClient();
        //得到数据库
        MongoDatabase database = client.getDatabase(mongodb);
        //得到集合封装对象
        MongoCollection collection = database.getCollection("student");
        
        BasicDBObject bson=new BasicDBObject("name", "诸葛亮");
                
        collection.deleteOne(bson);//删除记录（符合条件的第一条记录）
        //collection.deleteMany(bson);//删除符合条件的全部记录
    }
}

修改

package cn.mongodb.demo;

import org.bson.Document;

import com.mongodb.BasicDBObject;
import com.mongodb.MongoClient;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;

public class TestUpdate {

    public static void main(String[] args) {
        
        //获取连接
        MongoClient client=new MongoClient();
        //得到数据库
        MongoDatabase database = client.getDatabase("mongodb");
        //得到集合封装对象
        MongoCollection collection = database.getCollection("student");
        
        //修改的条件
        BasicDBObject bson= new BasicDBObject("name", "诸葛亮");
        //修改后的值
        BasicDBObject bson2 = new BasicDBObject("$set",  new BasicDBObject("address", "新野"));
        //参数1：修改条件  参数2：修改后的值
        collection.updateOne(bson, bson2);
        //collection.updateMany(filter, update);//修改符合条件的所有记录
    }
}

查询全部记录

MongoDB的数字类型默认使用64位浮点型数值。{“x”：3.14}或{“x”：3}。对于整型值，可以使用NumberInt（4字节符号整数），{“x”:NumberInt(“3”)} 或NumberLong（8字节符号整数）{“x”:NumberLong(“3”)}

package cn.mongodb.demo;

import org.bson.Document;

import com.mongodb.MongoClient;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;

public class TestFindAll {

    public static void main(String[] args) {
        //获取连接
        MongoClient client=new MongoClient();
        //得到数据库
        MongoDatabase database = client.getDatabase("mongodb");
        //得到集合封装对象
        MongoCollection collection = database.getCollection("student");
        //得到查询结果
        FindIterable find = collection.find();
        //遍历查询结果
        for(Document doc:find ){
            System.out.println("name:"+ doc.getString("name") );
            System.out.println("sex:"+doc.getString("sex"));
            System.out.println("age:"+doc.getDouble("age"));
            System.out.println("address:"+doc.getString("address"));
        }   
    }
}

匹配查询

MongoDB使用BasicDBObject类型封装查询条件，构造方法的参数为key 和value。

package cn.mongodb.demo;

import org.bson.Document;
import org.bson.conversions.Bson;

import com.mongodb.BasicDBObject;
import com.mongodb.MongoClient;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;

public class TestFindEq {

    public static void main(String[] args) {
        //获取连接
        MongoClient client=new MongoClient();
        //得到数据库
        MongoDatabase database = client.getDatabase("mongodb");
        //得到集合封装对象
        MongoCollection collection = database.getCollection("student");
        
        //构建查询条件
        BasicDBObject bson=new BasicDBObject("name", "诸葛亮");
        
        //得到查询结果
        FindIterable find = collection.find(bson);
        //遍历查询结果
        for(Document doc:find ){
            System.out.println("name:"+ doc.getString("name") );
            System.out.println("sex:"+doc.getString("sex"));
            System.out.println("age:"+doc.getDouble("age"));
            System.out.println("address:"+doc.getString("address"));
        }
    }
}

模糊查询

构建模糊查询条件是通过正则表达式的方式来实现的

• （1）完全匹配Pattern pattern = Pattern.compile("^name$");
• （2）右匹配Pattern pattern = Pattern.compile("^.*name$");
• （3）左匹配Pattern pattern = Pattern.compile("^name.*$");
• （4）模糊匹配Pattern pattern = Pattern.compile("^.name.$");

package cn.mongodb.demo;

import java.util.regex.Pattern;

import org.bson.Document;

import com.mongodb.BasicDBObject;
import com.mongodb.MongoClient;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;

public class TestFindLike {

    public static void main(String[] args) {
        //获取连接
        MongoClient client=new MongoClient();
        //得到数据库
        MongoDatabase database = client.getDatabase("mongodb");
        //得到集合封装对象
        MongoCollection collection = database.getCollection("student");
        //模糊查询
        Pattern queryPattern=Pattern.compile("^.*南.*$");
        //构建查询条件
        BasicDBObject bson=new BasicDBObject("address",queryPattern);
        
        //得到查询结果
        FindIterable find = collection.find(bson);
        //遍历查询结果
        for(Document doc:find ){
            System.out.println("name:"+ doc.getString("name") );
            System.out.println("sex:"+doc.getString("sex"));
            System.out.println("age:"+doc.getDouble("age"));
            System.out.println("address:"+doc.getString("address"));
        }
    }
}

条件查询：大于小于

在MongoDB提示符下条件json字符串为{ age: { $lt :20 } } ，对应的java代码也是BasicDBObject 的嵌套。
示例：查询student集合中age小于20的文档记录

package cn.mongodb.demo;

import org.bson.Document;

import com.mongodb.BasicDBObject;
import com.mongodb.MongoClient;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;

public class TestFindLt {

    public static void main(String[] args) {
        //获取连接
        MongoClient client=new MongoClient();
        //得到数据库
        MongoDatabase database = client.getDatabase("mongodb");
        //得到集合封装对象
        MongoCollection collection = database.getCollection("student");
        
        //构建查询条件
        BasicDBObject bson=new BasicDBObject("age", new BasicDBObject("$lt", 20));
        
        //得到查询结果
        FindIterable find = collection.find(bson);
        //遍历查询结果
        for(Document doc:find ){
            System.out.println("name:"+ doc.getString("name") );
            System.out.println("sex:"+doc.getString("sex"));
            System.out.println("age:"+doc.getDouble("age"));
            System.out.println("address:"+doc.getString("address"));
        }
    }
}

条件连接--并且

$and 表示并且

package cn.mongodb.demo;

import java.util.Arrays;

import org.bson.Document;

import com.mongodb.BasicDBObject;
import com.mongodb.MongoClient;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;

public class TestFindAnd {

    public static void main(String[] args) {
        //获取连接
        MongoClient client=new MongoClient();
        //得到数据库
        MongoDatabase database = client.getDatabase("mongodb");
        //得到集合封装对象
        MongoCollection collection = database.getCollection("student");
        
        BasicDBObject bson1=new BasicDBObject("age", new BasicDBObject("$gte",20));
        BasicDBObject bson2=new BasicDBObject("age", new BasicDBObject("$lt",30));
        //构建查询条件
        BasicDBObject bson=new BasicDBObject("$and", Arrays.asList( bson1, bson2 )  );
        
        //得到查询结果
        FindIterable find = collection.find(bson);
        //遍历查询结果
        for(Document doc:find ){
            System.out.println("name:"+ doc.getString("name") );
            System.out.println("sex:"+doc.getString("sex"));
            System.out.println("age:"+doc.getDouble("age"));
            System.out.println("address:"+doc.getString("address"));
        }
    }
}

条件连接--或者

$or表示或者

package cn.mongodb.demo;

import java.util.Arrays;

import org.bson.Document;

import com.mongodb.BasicDBObject;
import com.mongodb.MongoClient;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;

public class TestFindOr {

    public static void main(String[] args) {
        //获取连接
        MongoClient client=new MongoClient();
        //得到数据库
        MongoDatabase database = client.getDatabase("mongodb");
        //得到集合封装对象
        MongoCollection collection = database.getCollection("student");
        
        BasicDBObject bson1=new BasicDBObject("age", new BasicDBObject("$lte",20));     
        BasicDBObject bson2=new BasicDBObject("sex", "女");
        //构建查询条件
        BasicDBObject bson=new BasicDBObject("$or", Arrays.asList( bson1, bson2 )  );
        
        //得到查询结果
        FindIterable find = collection.find(bson);
        //遍历查询结果
        for(Document doc:find ){
            System.out.println("name:"+ doc.getString("name") );
            System.out.println("sex:"+doc.getString("sex"));
            System.out.println("age:"+doc.getDouble("age"));
            System.out.println("address:"+doc.getString("address"));
        }
    }
}

MongoDB连接池

MongoClient 被设计为线程安全的类，也就是我们在使用该类时不需要考虑并发的情况，这样我们可以考虑把MongoClient 做成一个静态变量，为所有线程公用，不必每次都销毁。这样可以极大提高执行效率。实际上，这是MongoDB提供的内置的连接池来实现的。

MongoDB写入策略。
WriteConcern.NONE:没有异常抛出
WriteConcern.NORMAL:仅抛出网络错误异常，没有服务器错误异常
WriteConcern.SAFE:抛出网络错误异常、服务器错误异常；并等待服务器完成写操作。
WriteConcern.MAJORITY: 抛出网络错误异常、服务器错误异常；并等待一个主服务器完成写操作。
WriteConcern.FSYNC_SAFE: 抛出网络错误异常、服务器错误异常；写操作等待服务器将数据刷新到磁盘。
WriteConcern.JOURNAL_SAFE:抛出网络错误异常、服务器错误异常；写操作等待服务器提交到磁盘的日志文件。
WriteConcern.REPLICAS_SAFE:抛出网络错误异常、服务器错误异常；等待至少2台服务器完成写操作。

首先我们先创建一个“管理类”，相当于我们原来的BaseDao

package cn.mongodb.demo;
import com.mongodb.MongoClient;
import com.mongodb.MongoClientOptions;
import com.mongodb.MongoClientOptions.Builder;
import com.mongodb.WriteConcern;
import com.mongodb.client.MongoDatabase;

public class MongoManager {

    private static MongoClient mongoClient=null;
    
    //对mongoClient初始化
    private static void init(){
        //连接池选项
        Builder builder = new MongoClientOptions.Builder();//选项构建者  
        builder.connectTimeout(5000);//设置连接超时时间
        builder.socketTimeout(5000);//读取数据的超时时间
        builder.connectionsPerHost(30);//每个地址最大请求数      
        builder.writeConcern(WriteConcern.NORMAL);//写入策略，仅抛出网络异常
        MongoClientOptions options = builder.build();
        mongoClient=new MongoClient("192.168.25.200",options);  
}

    
    public static MongoDatabase getDatabase(){
        if(mongoClient==null){
            init();
        }       
        return mongoClient.getDatabase("mongodb");
    }
}

然后我们创建一个StudentDao

package cn.mongodb.demo;
import org.bson.Document;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;

public class StudentDao {

    public void save(String name,String sex,double age,String address){
        MongoDatabase database = MongoManager.getDatabase();
        MongoCollection collection = database.getCollection("student2");
        Document docment=new Document();
        docment.put("name", name);
        docment.put("sex", sex);        
        docment.put("age", age);
        docment.put("address", address);
        collection.insertOne(docment);
    }   
}

插入数据进行测试

package cn.mongodb.demo;
import java.util.Date;
public class TestPool {

    public static void main(String[] args) {
        long startTime = new Date().getTime();//开始时间
        
        StudentDao studentDao=new StudentDao();
        for(int i=0;i<20000;i++){
            studentDao.save("测试"+i, "男", 25.0, "测试地址"+i);
        }
        long endTime = new Date().getTime();//完成时间
        System.out.println("完成时间："+(endTime-startTime)+"毫秒");
    }
}

经过测试：插入20000条数据所用毫秒数为1544。