6,使用Java同步方式操作POJO对象进行CRUD实例

作者: lcjyzm | 来源:发表于2021-07-19 07:49 被阅读0次

6,使用Java同步方式操作POJO对象进行CRUD实例
5,使用Java同步方式操作Document对象进行CRUD实例
3.3 Beego CRUD操作
Beego Models之二
8,使用Java Reactive反应式方式操作POJO对象进行
protobuf 与 Java 对象互转
Spring Data MongoDB基本操作
2020-11-10-Scala-30(scala中文版的摘录1
多线程之线程同步
Java获取Class对象的方式和实例化对象的方式

1,创建maven项目,并在pom.xml引入以下依赖:

<!--测试包-->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.11</version>
    <scope>compile</scope>
</dependency>

<!--mongodb 同步驱动包-->
<dependency>
    <groupId>org.mongodb</groupId>
    <artifactId>mongodb-driver-sync</artifactId>
    <version>4.3.0</version>
</dependency>

<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>5.3.9</version>
</dependency>

2,启动MongoDB服务实例

mongod.exe --dbpath D:\UserData\mongodb --auth

3,获取MongoClient对象

import com.mongodb.MongoClientSettings;
import com.mongodb.MongoCredential;
import com.mongodb.ServerAddress;
import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoClients;

import java.util.Arrays;

/**
 * @Package: com.lcj.mongodb.sync
 * @ClassName: MongoUtil
 * @Author: Administrator
 * @CreateTime: 2021/7/15 15:10
 * @Description:
 */
public class MongoUtil {

    /**
     * 通过指定host和port获得连接
     * @return MongoClient
     */
    public static MongoClient getInstance1(){
        // 添加认证
        MongoCredential credential = MongoCredential.createScramSha256Credential("admin", "admin", "123456".toCharArray());
        return MongoClients.create(
                MongoClientSettings.builder()
                        .applyToClusterSettings(builder ->
                                builder.hosts(Arrays.asList(new ServerAddress("127.0.0.1", 27017))))
                        .credential(credential)
                        .build());
    }

    /**
     * 通过连接字符串
     * @return MongoClient
     */
    public static MongoClient getInstance2(){
        return MongoClients.create("mongodb://admin:123456@127.0.0.1:27017/?authSource=admin&authMechanism=SCRAM-SHA-256");
    }
    
     /**
     * 创建编解码注册器,用来处理 pojo和bson之间的相互转换
     * @return CodecRegistry
     */
    public static CodecRegistry codecRegistry(){
        return CodecRegistries.fromRegistries(MongoClientSettings.getDefaultCodecRegistry(),
                CodecRegistries.fromProviders(PojoCodecProvider.builder().automatic(true).build()));
    }
}

4,创建Student实体

import org.bson.types.ObjectId;

/**
 * @Package: com.lcj.mongodb.sync.pojo
 * @ClassName: Student
 * @Author: Administrator
 * @CreateTime: 2021/7/16 9:17
 * @Description: 学生实体
 */
public class Student {
    // 学生编号
    private ObjectId id;
    // 姓名
    private String name;
    // 年龄
    private int age;
    // 性别
    private char sex;
    // 家庭住址
    private Address address;

    public Student() {
    }

    public Student(String name, int age, char sex, Address address) {
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.address = address;
    }

    public ObjectId getId() {
        return id;
    }

    public void setId(ObjectId 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;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }
}


public class Address {
    // 国家
    private String country;
    // 省份
    private String province;
    // 市
    private String city;
    // 街道
    private String street;

    public Address() {
    }

    public Address(String country, String province, String city, String street) {
        this.country = country;
        this.province = province;
        this.city = city;
        this.street = street;
    }

    public String getCountry() {
        return country;
    }

    public void setCountry(String country) {
        this.country = country;
    }

    public String getProvince() {
        return province;
    }

    public void setProvince(String province) {
        this.province = province;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    public String getStreet() {
        return street;
    }

    public void setStreet(String street) {
        this.street = street;
    }
}

5,使POJO对象进行CRUD操作

import cn.hutool.core.lang.Console;
import cn.hutool.json.JSONUtil;
import com.lcj.mongodb.sync.MongoUtil;
import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoCursor;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.model.Filters;
import com.mongodb.client.model.Updates;
import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.InsertManyResult;
import com.mongodb.client.result.InsertOneResult;
import com.mongodb.client.result.UpdateResult;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;

import java.util.Arrays;
import java.util.List;
import java.util.Objects;

/**
 * @Package: com.lcj.mongodb.sync
 * @ClassName: UseDocumentCRUDTest
 * @Author: Administrator
 * @CreateTime: 2021/7/16 8:26
 * @Description:
 */
public class UsePOJOCRUDTest {
    // 声明连接对象
    private static MongoClient client;
    // 声明集合变量
    private static MongoCollection<Student> student;

    /*
    使用CodecRegistry注册器方式:

    1,在实例化一个MongoClient对象时设置
    MongoClientSettings settings = MongoClientSettings.builder()
        .codecRegistry(pojoCodecRegistry)
        .build();
    MongoClient mongoClient = MongoClients.create(settings);

    2,使用另一种CodecRegistry与MongoDatabase
    database = database.withCodecRegistry(pojoCodecRegistry);

    3,可以使用另一种CodecRegistry与MongoCollection
    collection = collection.withCodecRegistry(pojoCodecRegistry);
    */
    // 所有方法执行前,创建集合对象
    @BeforeClass
    public static void setUp() {
        client = MongoUtil.getInstance1();
        // 访问指定的数据库,如果数据库不存在,自动创建
        MongoDatabase mongoDatabase = client.getDatabase("test").withCodecRegistry(MongoUtil.codecRegistry());
        // 访问指定的集合,如果集合不存在,在第一次存数据是创建
        student = mongoDatabase.getCollection("student",Student.class);
    }

    // 所有方法执行完后,释放资源
    @AfterClass
    public static void close() {
        // student.drop();
        client.close();
    }

    /**
     * 插入单个文档
     */
    @Test
    public void insertOne() {
       Student s = new Student("张三",18,'男',new Address("中国","湖北","十堰市","北京路38号"));
        // 插入单个文档,如果未指定_id字段,会自动添加
        InsertOneResult insertOneResult = student.insertOne(s);
        if (insertOneResult.wasAcknowledged()) {
            Console.log("插入文档成功,文档id:{}", insertOneResult.getInsertedId().toString());
        } else {
            System.out.println("插入文档失败");
        }
    }


    /**
     * 插入多个文档
     */
    @Test
    public void insertMany() {
       List<Student> students = Arrays.asList(
               new Student("李四",34,'女',new Address("中国","河北","合肥市","北京路38号"))
               ,new Student("王五",10,'女',new Address("中国","湖北","襄樊市","大连路67号"))
               ,new Student("赵六",58,'男',new Address("中国","湖北","宜昌市","北京路38号"))
       );
        // 插入文档,如果未指定_id字段,会自动添加
        InsertManyResult insertManyResult = student.insertMany(students);
        if (insertManyResult.wasAcknowledged()) {
            Console.log("插入文档成功,文档id:{}", insertManyResult.getInsertedIds());
        } else {
            System.out.println("插入文档失败");
        }
    }


    /**
     * 查询集合的第一个文档
     */
    @Test
    public void findFirst() {
        Student s = student.find().first();
        if (Objects.nonNull(s)) {
            System.out.println(JSONUtil.toJsonStr(s));
        }
    }

    /**
     * 查询集合的所有文档
     */
    @Test
    public void findAll() {
        // 返回一个游标
        try (MongoCursor<Student> iterator = student.find().iterator()) {  // 防止游标泄露
            // 遍历数据
            while (iterator.hasNext()) {
                Student next = iterator.next();
                System.out.println(JSONUtil.toJsonStr(next));
            }
        }
    }


    /**
     * 在查询Pojo时，您必须查询文档字段名，而不是Pojo的属性名。默认情况下，它们是相同的，但是可以更改POJO属性名的映射方式
     *
     * 查找 address.city=十堰市
     */
    @Test
    public void findFirstByFilter() {
        Student first = student.find(Filters.eq("address.city", "十堰市")).first();
        if (Objects.nonNull(first)) {
            System.out.println(JSONUtil.toJsonStr(first));
        }
    }


    /**
     * 查询学生年龄大于20的所有数据
     */
    @Test
    public void findAllByFilterGt() {
        // 返回一个游标
        try (MongoCursor<Student> iterator = student.find(Filters.gt("age", 20)).iterator()) {  // 防止游标泄露
            // 遍历数据
            while (iterator.hasNext()) {
                Student next = iterator.next();
                System.out.println(JSONUtil.toJsonStr(next));
            }
        }
    }


    /**
     * 查询学生年龄不小于20,并且性别为女的所有学生
     */
    @Test
    public void findAllByFilterAnd() {
        // 返回一个游标
        try (MongoCursor<Student> iterator = student.find(Filters.and(Filters.gte("age", 20), Filters.eq("sex", "女"))).iterator()) {  // 防止游标泄露
            // 遍历数据
            while (iterator.hasNext()) {
                Student next = iterator.next();
                System.out.println(JSONUtil.toJsonStr(next));
            }
        }
    }


    // 修改姓名为李四的学生,将年龄改为50,省份改为黑龙江
    @Test
    public void updateOne() {
        UpdateResult updateResult = student.updateOne(Filters.eq("name", "李四"), Updates.combine(Updates.set("age", 50),Updates.set("address.province", "黑龙江")));
        if(updateResult.wasAcknowledged()){
            System.out.println("更新数量: " + updateResult.getModifiedCount());
        }
    }

    /**
     * 更新所有省份为湖北的学生,将年龄加2
     */
    @Test
    public void updateMany() {
        UpdateResult updateResult = student.updateMany(Filters.eq("address.province", "湖北"), Updates.inc("age", 2));
        Console.log("更新数量:{}", updateResult.getModifiedCount());
    }


    /**
     * 将匹配的数据,用另一个数据进行替换
     */
    @Test
    public void replaceOne() {
        Student s = new Student("张三",18,'男',new Address("中国","湖北","十堰市","北京路38号"));
        UpdateResult updateResult = student.replaceOne(Filters.eq("name", "张三"), s);
        System.out.println("更新数: " + updateResult.getModifiedCount());
    }

    /**
     * 删除襄樊市的学生
     */
    @Test
    public void deleteOne() {
        DeleteResult deleteResult = student.deleteOne(Filters.eq("address.city", "襄樊市"));
        Console.log("删除数量: {}", deleteResult.getDeletedCount());
    }


    /**
     * 删除湖北省的学生
     */
    @Test
    public void deleteMany() {
        DeleteResult deleteResult = student.deleteMany(Filters.eq("address.province", "湖北"));
        Console.log("删除数量: {}", deleteResult.getDeletedCount());
    }

}

6,单测结果

image-20210716102923403

6,使用Java同步方式操作POJO对象进行CRUD实例
1,创建maven项目,并在pom.xml引入以下依赖: 2,启动MongoDB服务实例 3,获取MongoCli...
5,使用Java同步方式操作Document对象进行CRUD实例
1,创建maven项目,并引入以下依赖: 2,启动MongoDB服务实例 3,获取MongoClient对象 4,...
3.3 Beego CRUD操作
3.3 对象的 CRUD 操作如果已知主键的值，那么可以使用这些方法进行 CRUD 操作对 object 操作...
Beego Models之二
原文对象的 CRUD 操作如果已知主键的值，那么可以使用这些方法进行 CRUD 操作对 object 操作的...
8,使用Java Reactive反应式方式操作POJO对象进行
1,创建maven项目,并引入以下依赖: 2,启动MongoDB服务实例 3,获取MongoClient对象 4,...
protobuf 与 Java 对象互转
Java使用protobuf时,往往需要在Java对象(比如POJO)和protobuf message的Java...
Spring Data MongoDB基本操作
本文主要借号如何使用Spring Data MongoDB进行CRUD操作，有两种方式：注解方式和XML方式。 1...
2020-11-10-Scala-30(scala中文版的摘录1
怎么使用scala中的构造器(避免使用java的方式思考) 怎么理解scala中的pojo 1.不可变对象的权衡 ...
多线程之线程同步
同步的方法： 1.Java 同步关键字（synchronized）实例方法实例方法同步是同步在拥有该方法的对象上...
Java获取Class对象的方式和实例化对象的方式
Java获取Class对象的方式和实例化对象的方式获取Class对象的方式实例化对象的方式