java操作MongoDB

java操作MongoDB

一、 添加依赖

1、 创建项目

2. 添加依赖

<dependencies>
    <dependency>
        <groupId>org.mongodb</groupId>
        <artifactId>mongo-java-driver</artifactId>
        <version>3.9.1</version>
    </dependency>
</dependencies>

二、 数据库操作

1.创建连接

/**
 * 无需用户名密码验证连接MongoDB
 */
@Test
public void testInit01() {
    try {
        // 连接到 mongodb 服务
        MongoClient mongoClient = new MongoClient("192.168.10.100", 27017);

        // 连接到数据库
        MongoDatabase mongoDatabase = mongoClient.getDatabase("shsxt");
        System.out.println("Connect to database successfully");

        // 释放资源
        if (mongoClient != null)
            mongoClient.close();
    } catch (Exception e) {
        System.err.println(e.getClass().getName() + ": " + e.getMessage());
    }
}

如果你的 Mongo 需要验证用户名及密码，可以使用以下代码

/**
 * 需要用户名密码验证连接MongoDB
 */
@Test
public void testInit02() {
    try {
        // 连接到MongoDB服务 如果是远程连接可以替换"localhost"为服务器所在IP地址
        // ServerAddress()两个参数分别为 服务器地址 和 端口
        ServerAddress serverAddress = new ServerAddress("localhost", 27017);
        List<ServerAddress> addrs = new ArrayList<>();
        addrs.add(serverAddress);

        // MongoCredential.createScramSha1Credential()三个参数分别为 用户名 数据库名称 密码
        MongoCredential credential = MongoCredential.createScramSha1Credential("username", "databaseName", "password".toCharArray());
        List<MongoCredential> credentials = new ArrayList<>();
        credentials.add(credential);

        // 通过连接认证获取MongoDB连接
        MongoClient mongoClient = new MongoClient(addrs, credentials);

        // 连接到数据库
        MongoDatabase mongoDatabase = mongoClient.getDatabase("databaseName");
        System.out.println("Connect to database successfully");

        // 释放资源
       if (mongoClient != null)
            mongoClient.close();
    } catch (Exception e) {
        System.err.println(e.getClass().getName() + ": " + e.getMessage());
    }
}

2. 封装工具类通过连接池获取对象访问服务器

package com.shsxt.util;

import com.mongodb.MongoClient;
import com.mongodb.MongoClientOptions;
import com.mongodb.ServerAddress;

/**
 * 封装MongoDB工具类通过连接池获取对象访问服务器
 */
public class MongoDBUtil {

    private static MongoClient mongoClient = null;
    private static MongoClientOptions.Builder buide = null;
    private static MongoClientOptions myOptions = null;

    // 服务器IP
    private static String HOST = "192.168.10.100";

    // 端口
    private static int PORT = 27017;

    // 用户名
    // 密码

    // 与目标数据库可以建立的最大链接数
    private static int CONNECTIONS_PERHOST = 100;

    // 这个参数是跟connectionsPerHost配套的，当连接数超过connectionsPerHost的时候，需要建立新的连接，
    // 连接请求会被阻塞，这个参数就代表允许阻塞请求的最大值，超过这个值之后的请求都会报错。
    private static int THREADS_ALLOWED_TO_BLOCK_FOR_CONNECTION_MULTIPLIER = 100;

    // 与数据库建立链接的超时时间
    private static int CONNECT_TIMEOUT = 1000 * 60 * 20;

    // 一个线程成功获取到一个可用数据库之前的最大等待时间
    private static int MAX_WAITTIME = 100 * 60 * 5;

    // 执行IO操作的超时时间，默认为0，代表不超时。
    private static int SOCKE_TTIMEOUT = 0;

    /**
     * 初始化连接池
     */
    static {
        try {
            buide = new MongoClientOptions.Builder();
            buide.connectionsPerHost(CONNECTIONS_PERHOST);
            buide.threadsAllowedToBlockForConnectionMultiplier(THREADS_ALLOWED_TO_BLOCK_FOR_CONNECTION_MULTIPLIER);
            buide.connectTimeout(CONNECT_TIMEOUT);
            buide.maxWaitTime(MAX_WAITTIME);
            buide.socketTimeout(SOCKE_TTIMEOUT);
            myOptions = buide.build();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 通过连接池获取连接对象并操作服务器
     */
    public static MongoClient getMongoClient() {
        if (mongoClient != null)
            return null;

        try {
            mongoClient = new MongoClient(new ServerAddress(HOST, PORT), myOptions);
            return mongoClient;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 释放资源
     */
    public static void close(MongoClient mongoClient) {
        if (mongoClient != null)
            mongoClient.close();
    }

}

3.操作数据库

MongoClient mongoClient = null;

/**
 * 获取连接
 */
@Before
public void testInit() {
    // 获取连接
    mongoClient = MongoDBUtil.getMongoClient();
}

/**
 * 释放连接
 */
@After
public void testClose() {
    MongoDBUtil.close(mongoClient);
}

/**
 * 操作数据库
 */
@Test
public void testDB() {
    // 连接数据库，存在选中，不存在创建
    MongoDatabase db = mongoClient.getDatabase("sxt");

    // 删除数据库
    mongoClient.dropDatabase("sxt");
}

4.操作集合

4.1.1 @Before @After

@Before
    public void testInit(){
        //获取连接
        mongoClient = MongoDBUtils.getMongoClient();
    }
	
    @After
    public void testClose(){
        //关闭连接
        MongoDBUtils.close(mongoClient);
    }

4.1.2 获取DB实例–指定DB

@Test
    public void getDB(){
        MongoDatabase shsxt = mongoClient.getDatabase("shsxt");
        System.out.println(shsxt);
    }

4.1.3 获取collection对象 - 指定Collection

@Test
    public void getColls(){
        MongoDatabase shsxt = mongoClient.getDatabase("shsxt");
        MongoCollection<Document> user = shsxt.getCollection("user");
        System.out.println(user);
    }

4.1.4 获取所有数据库名称列表

@Test
    public void getAllDBNames(){
        MongoIterable<String> names = mongoClient.listDatabaseNames();
        for (String name:names){
            System.out.println(name);
        }
    }

4.1.5 获取DB下的所有表名

@Test
    public void getALlColls(){
        MongoIterable<String> names = mongoClient.getDatabase("shsxt").
                listCollectionNames();
        for (String name:names){
            System.out.println(name);
        }
    }

4.2.1 删除一个数据库

@Test
    public void dropDB(){
        mongoClient.getDatabase("test").drop();
    }

4.2.2 查询对象，根据主键_id

@Test
    public void findObjectById(){
        MongoCollection<Document> collection = mongoClient.getDatabase("shsxt").
                getCollection("user");
        Document document = collection.
                find(Filters.eq("name", "wangwu")).first();

        System.out.println(document);
    }

4.2.3 统计数

 @Test
    public void getCount(){
        MongoCollection<Document> user = mongoClient.getDatabase("shsxt").
                getCollection("user");
        long i = user.countDocuments();
        System.out.println(i);
    }

4.3 条件查询

@Test
    public void findTest(){
        MongoCollection<Document> user = mongoClient.getDatabase("shsxt").getCollection("user");
        //查询所有名字是wangwu的
        FindIterable<Document> documents = user.find(Filters.eq("name", "wangwu"));

        //查询所有年龄大于10岁的
        FindIterable<Document> documents1 = user.find(Filters.lt("age", 10));

        //查询所有年龄大于10和名字是wangwu的
        FindIterable<Document> age = user.find(Filters.and(Filters.gte("age", 10),
                Filters.eq("name","1313")));

        for (Document document:age){
            System.out.println(document);
        }
    }

4.4 分页查询

@Test
    public void queryForPage(){
        MongoCollection<Document> user = mongoClient.getDatabase("shsxt").
                getCollection("user");

        //按照_id 正序排序
        Bson orderBy = new BasicDBObject("_id",1);

        //分页找所有年龄大于2的，查询出前两条数据
        MongoCursor<Document> docus = user.find(Filters.gt("age", 2)).sort(orderBy).
                skip((1 - 1) * 2).limit(2).iterator();

        while (docus.hasNext()){
            System.out.println(docus.next());
        }
    }

4.5.1 通过ID删除

@Test
    public void deleteById(){
        MongoCollection<Document> user = mongoClient.getDatabase("shsxt").
                getCollection("user");

        //定义删除的条件
        Bson filter = Filters.eq("_id",2);

        //通过ID删除返回结果
        DeleteResult result = user.deleteOne(filter);

        System.out.println(result);
    }

4.5.2 通过ID更新数据

@Test
    public void updateById(){
        MongoCollection<Document> user = mongoClient.getDatabase("shsxt").
                getCollection("user");

        Document newDoc = new Document();
        newDoc.put("name","wcb");
        newDoc.put("age",20);
        newDoc.put("hobbies","eat");

        Bson filter = Filters.eq("_id",1);

        user.updateOne(filter,new Document("$set",newDoc));
    }

4.6 索引相关

@Test
    public void index(){
        //连接到指定数据库
        MongoDatabase shsxt = mongoClient.getDatabase("shsxt");

        //连接到指定集合中（表中）
        MongoCollection<Document> user = shsxt.getCollection("user");

        //查询所有索引
        ListIndexesIterable<Document> listIndexes= user.listIndexes();

        for (Document docu:listIndexes){
            System.out.println(docu);
        }

        //创建索引
        user.createIndex(new Document("validata",1));
        user.createIndex(new Document("validata",2));
        user.createIndex(new Document("validata",3));
        //删除索引 --->删除所有索引（不包括默认的 _id ）
        //user.dropIndexes();

        //根据索引名删除某个索引
        user.dropIndex("validata_1");
    }