Java原始客户端操作Mongodb 增删改查

1、导入Pom依赖

 <dependency>
            <groupId>org.mongodb</groupId>
            <artifactId>mongo-java-driver</artifactId>
            <version>3.11.2</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>

2、java客户端代码

import com.mongodb.MongoClient;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;
import org.bson.Document;
import org.bson.conversions.Bson;
import org.junit.Before;
import org.junit.Test;

import java.math.BigDecimal;
import java.util.*;
import java.util.function.Consumer;
import static com.mongodb.client.model.Updates.*;
import static com.mongodb.client.model.Filters.*;
/**
 * @program: demo
 * @description: this is a class
 * @author: Mr.zeng
 * @create: 2021-06-17 18:16
 **/
public class QuickStartJavaDocumentTest {
    //数据库
    private MongoDatabase db;
    //文档集合
    private MongoCollection<Document> doc;
    //连接客户端(内置连接池)
    private MongoClient client;

    @Before
    public void init(){
        client=new MongoClient("ip",27017);
        db=client.getDatabase("lison");
        doc = db.getCollection("users");
    }
    @Test
    public void insertDemo(){
        Document doc1=new Document();
        doc1.append("username","cang");
        doc1.append("country","China");
        doc1.append("age",20);
        doc1.append("lenght",1.77f);
        doc1.append("salary",new BigDecimal("6565.22"));

        //添加 address 子文档
        Map<String,String> address1=new HashMap<>();
        address1.put("aCode","0000");
        address1.put("add","xxx000");
        doc1.append("address",address1);

        //添加favorites 子文档，其中两个属性是数组
        Map<String,Object> favorites=new HashMap<>();
        favorites.put("movies", Arrays.asList("aa","bb"));
        favorites.put("cites",Arrays.asList("东莞","东京"));
        doc1.append("favorites",favorites);

        Document doc2=new Document();
        doc2.append("username","Chen");
        doc2.append("country","China");
        doc2.append("age",30);
        doc2.append("lenght",1.77f);
        doc2.append("salary", new BigDecimal("8888.22"));
        Map<String, String> address2 = new HashMap<>();
        address2.put("aCode", "411000");
        address2.put("add", "我的地址 2");
        doc2.append("address", address2);
        Map<String, Object> favorites2 = new HashMap<>();
        favorites2.put("movies", Arrays.asList("东游记", "一路向东"));
        favorites2.put("cites", Arrays.asList("珠海", "东京"));
        doc2.append("favorites", favorites2);

        //使用insertMany插入多条数据
        doc.insertMany(Arrays.asList(doc1,doc2));
    }
    @Test
    public void testFind(){
        final List<Document> ret=new ArrayList<>();
        //block接口专门用于处理查询出来的数据
        Consumer<Document> printDocument=new Consumer<Document>() {
            @Override
            public void accept(Document document) {
                System.out.println(document);
                ret.add(document);
            }
        };
        //db.users.find({favorites.cites:{"$all":["东京","东莞"]}}).pretty()
        Bson all = all("favorites.cites", Arrays.asList("东莞", "东京"));//定义过滤器，喜欢的城市中要包含东莞，东京
        FindIterable<Document> find=doc.find();
        find.forEach(printDocument);

        System.out.println("------------------>"+String.valueOf(ret.size()));
        ret.remove(ret);


        //db.users.find({"$and":[{"username":{"$regex":".*c.*"}},{"$or":[{"country":"English"},{"country":"UAS"}]}]})
        String regexStr=".*c.*";
        Bson regex = regex("username", regexStr);//定义数据过滤器，username like '%s%'
        Bson or = or(eq("country", "English"), eq("country", "USA"));//定义数据过滤器，(country=English or country=USA)
        Bson and = and(regex, or);
        FindIterable<Document> find2 = doc.find(and);
        find2.forEach(printDocument);
        System.out.println("------------------------->"+String.valueOf(ret.size()));

    }
    @Test
    public void testUpdate(){
        //db.users.updateMany({"username":lison},{"$set":{"age":6}},true)
        Bson eq = eq("username", "cang");//定义数据过滤器，username='cang'
        Bson set = set("age", 8);
        UpdateResult updateMany = doc.updateMany(eq, set);
        System.out.println("---------->"+String.valueOf(updateMany.getModifiedCount()));//打印受影响的行数

        //db.users.updateMany({"favorites.cites":"东莞"},{"$addToSet":{"favorites.movies":{"$each":["小电影2","小电影3"]}}},true)
        Bson eq2 = eq("favorites.cites", "东莞");
        Bson addEachToSet= addEachToSet("favorites.movies", Arrays.asList("小电影2", "小电影3"));更新的字段.来自于 Updates 包的静态导入
        UpdateResult updateResult = doc.updateMany(eq2, addEachToSet);
        System.out.println("------------>"+String.valueOf(updateResult.getModifiedCount()));
    }

    @Test
    public void testDelete(){
        //db.users.deleteMany({"username":"lison"})
        Bson eq = eq("username", "lison");//定义数据过滤器 username='lison'
        DeleteResult deleteMany = doc.deleteMany(eq);
        System.out.println("-------------->"+String.valueOf(deleteMany.getDeletedCount()));//打印受影响的行数

        //db.users.deleteMany({"$and":[{"age":{"$gt":8}},{"age":{"$lt":25}}]})
        //定义数据过滤器，age > 8，所有过滤器的定义来自于 Filter 这个包的静态方法，需要频繁使用所以静态导入
        Bson gt = gt("age", 8);//定义数据过滤器 age>8
        Bson lt = lt("age", 25);//定义数据过滤器 age<25
        Bson and = and(gt, lt); //定义数据过滤器 将条件用and拼接
        DeleteResult deleteMany2 = doc.deleteMany(and);
        System.out.println("---------------->"+String.valueOf(deleteMany2.getDeletedCount()));//打印受影响的行数
    }