java代码测试mongoDb的api, 及SpringBoot整合mongoDb

1、创建maven工程

2、引入相关依赖

        <dependency>
            <groupId>org.mongodb</groupId>
            <artifactId>mongodb-driver-sync</artifactId>
            <version>3.9.1</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

3、引入java编译的版本

    <build>
        <plugins>
            <!-- java编译插件 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.2</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>

 

代码实现

连接mongodb测试

package cn.itcast.mongodb;

import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoClients;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import org.bson.Document;

import java.util.function.Consumer;

public class MongoDBDemo {

    public static void main(String[] args) {
        // 建立连接
        MongoClient mongoClient = MongoClients.create("mongodb://192.168.142.128:27017");

        // 选择数据库
        MongoDatabase database = mongoClient.getDatabase("testdb");

        // 选择表
        MongoCollection<Document> userCollection = database.getCollection("user");

        // 操作
        userCollection.find().limit(10).forEach((Consumer<? super Document>) document -> {
            System.out.println(document.toJson());
        });

        // 关闭连接
        mongoClient.close();

    }
}

 

基于文档数据的增删改查

package cn.itcast.mongodb;

import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoClients;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.model.Filters;
import com.mongodb.client.model.Projections;
import com.mongodb.client.model.Sorts;
import com.mongodb.client.model.Updates;
import com.mongodb.client.result.DeleteResult;
import org.bson.Document;
import org.junit.Before;
import org.junit.Test;

import java.util.function.Consumer;

public class TestMongoDb {

    MongoCollection<Document> collection;

    @Before
    public void init() {
        // 建立连接
        MongoClient mongoClient = MongoClients.create("mongodb://192.168.142.128:27017");

        // 选择数据库
        MongoDatabase database = mongoClient.getDatabase("testdb");

        // 选择表
        collection = database.getCollection("user");
    }

    // 查询age<50 并且id>=100的用户信息，并且按照id进行倒序排列， 只返回id,age字段，不返回_id字段
    @Test
    public void testQuery(){
        this.collection.find(
                Filters.and(
                        Filters.lte("age", 50),
                        Filters.gte("id", 100)
                )
        ).sort(
                // 表示通过id的倒序进行排列
                Sorts.descending("id")
        ).projection(
                // 设置返回的字段信息
                Projections.fields(
                        // 设置返回的字段有那些
                        Projections.include("id", "age"),
                        // 设置返回的信息中不包括_id字段
                        Projections.excludeId()

                )
        ).forEach((Consumer<? super Document>) document -> {
            System.out.println(document.toJson());
        });
    }

    // 测试插入数据
    @Test
    public void testInsert(){
        Document document = new Document();
        document.append("id", 999);
        document.append("username", "张三");
        document.append("age", 30);
        this.collection.insertOne(document);
        this.collection.find(Filters.eq("id", 999)).forEach((Consumer<? super Document>) document1 -> {
            System.out.println(document1.toJson());
        });
    }

    // 修改操作
    @Test
    public void testUpdate() {
        this.collection.updateOne(Filters.eq("id", 999), Updates.set("age", 60));
        this.collection.find(Filters.eq("id", 999)).forEach((Consumer<? super Document>) document1 -> {
            System.out.println(document1.toJson());
        });

    }

    // 删除数据
    @Test
    public void testDelete() {
        DeleteResult deleteResult = this.collection.deleteMany(Filters.eq("id", 999));
        System.out.println(deleteResult);
    }
}

 

基于对象的增删改查

定义Person对象 (省略getter and setter、无参构造、全参构造)

package cn.itcast.mongodb;
import org.bson.types.ObjectId;

public class Person {
    private ObjectId id;
    private String name;
    private int age;
    private Address address;
}

定义address对象 (省略getter and setter、无参构造、全参构造)

package cn.itcast.mongodb;

public class Address {
    private String street;
    private String city;
    private String zip;
}

测试代码

package cn.itcast.mongodb;

import com.mongodb.MongoClientSettings;
import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoClients;
import com.mongodb.client.MongoCollection;
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.UpdateResult;
import org.bson.Document;
import org.bson.codecs.configuration.CodecRegistries;
import org.bson.codecs.configuration.CodecRegistry;
import org.bson.codecs.pojo.PojoCodecProvider;
import org.bson.types.ObjectId;
import org.junit.Before;
import org.junit.Test;

import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;

public class TestPerson {

    MongoCollection<Person> personCollection;

    @Before
    public void init() {

        // 定义对象的解码器
        CodecRegistry pojoCodeRegistry = CodecRegistries.fromRegistries(MongoClientSettings.getDefaultCodecRegistry(),
            CodecRegistries.fromProviders(PojoCodecProvider.builder().automatic(true).build())
        );

        // 建立连接
        MongoClient mongoClient = MongoClients.create("mongodb://192.168.142.128:27017");

        // 选择数据库， 并且注册解码器
        MongoDatabase database = mongoClient.getDatabase("testdb").withCodecRegistry(pojoCodeRegistry);

        // 选择表
        this.personCollection = database.getCollection("person", Person.class);
    }

    // 插入单条数据
    @Test
    public void testInsert() {
        Person person = new Person(ObjectId.get(), "张三", 20, new Address("人民路", "上海市", "0007"));
        this.personCollection.insertOne(person);
        System.out.println("数据插入成功");
    }

    // 插入多条数据
    @Test
    public void testInserts() {
        List<Person> personList = Arrays.asList(
                new Person(ObjectId.get(), "张三", 20, new Address("人民路", "上海市", "666666")),
                new Person(ObjectId.get(), "李四", 21,new Address("北京西路", "上海 市", "666666")),
                new Person(ObjectId.get(), "王五", 22, new Address("南京东路", "上海市", "666666")),
                new Person(ObjectId.get(), "赵六", 23, new Address("陕西南路", "上海市", "666666")),
                new Person(ObjectId.get(), "孙七", 24, new Address("南京西路", "上海市", "666666"))
        );
        this.personCollection.insertMany(personList);
        System.out.println("插入数据成功");
    }

    // 对象查询
    @Test
    public void testQuery() {
        this.personCollection.find(Filters.eq("name", "张三"))
            .forEach((Consumer<? super Person>) person -> {
                System.out.println(person);
            });
    }

    // 测试数据更新
    @Test
    public void testUpdate() {
        UpdateResult updateResult =this.personCollection.updateMany(Filters.eq("name", "张三"), Updates.set("age",22));
        System.out.println(updateResult);
    }

    // 测试数据 删除
    @Test
    public void testDelete() {
        DeleteResult deleteResult = this.personCollection.deleteMany(Filters.eq("name", "张三"));
        System.out.println(deleteResult);
    }
}

---------------------------------------------------------------------------------------------------------------------------------------------------

SpringBoot整合mongoDb

导入相关依赖

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.0.RELEASE</version>
    </parent>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-mongodb</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>

 

编写application.properties配置文件，（注意修改成自己服务器的ip）

# Spring boot application 
spring.application.name = itcast-mongodb
spring.data.mongodb.uri=mongodb://192.168.142.128:27017/testdb

编写SpringBoot的启动类

package cn.itcast.mongodb;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class MongoApplication {

    public static void main(String[] args) {
        SpringApplication.run(MongoApplication.class, args);
    }

}

编写测试的dao层类

package cn.itcast.mongodb.spring;

import cn.itcast.mongodb.Person;
import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;
import org.springframework.stereotype.Component;

import java.util.List;

@Component
public class PersonDao {
    @Autowired
    private MongoTemplate mongoTemplate;
    
    public Person savePerson(Person person){
        return this.mongoTemplate.save(person);
    }

    // 测试通过名字进行查询
    public List<Person> queryPersonListByName(String name) {
        Query query = Query.query(Criteria.where("name").is(name));
        return this.mongoTemplate.find(query, Person.class);
    }

    // 进行分页查询
    public List<Person> queryPagePersonList(Integer page, Integer rows) {
        Query query = new Query().limit(rows).skip((page - 1) * rows);
        return this.mongoTemplate.find(query, Person.class);
    }

    public UpdateResult update(Person person) {
        Query query = Query.query(Criteria.where("id").is(person.getId()));
        Update update = Update.update("age", person.getAge());
        return this.mongoTemplate.updateFirst(query, update, Person.class);
    }


    public DeleteResult deleteById(String id) {
        Query query = Query.query(Criteria.where("id").is(id));
        return this.mongoTemplate.remove(query, Person.class);
    }
}

编写测试类

package cn.itcast.mongodb;

import cn.itcast.mongodb.spring.PersonDao;
import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;
import org.bson.types.ObjectId;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.List;

@RunWith(SpringRunner.class)
@SpringBootTest
public class TestSpringPerson {

    @Autowired
    private PersonDao personDao;

    @Test
    public void testSave(){
        Person person = new Person(ObjectId.get(), "woodie", 20, new Address("人民路", "上海市", "0007"));
        this.personDao.savePerson(person);

    }

    @Test
    public void testQueryPersonListByName(){
        List<Person> list = this.personDao.queryPersonListByName("woodie");
        for (Person person: list) {
            System.out.println(person);
        }
    }

    @Test
    public void testQueryPagePersonList(){
        List<Person> list = this.personDao.queryPagePersonList(2, 2);
        for (Person person: list) {
            System.out.println(person);
        }
    }

    @Test
    public void testUpdate() {
        Person person = new Person();
        person.setId(new ObjectId("5e2e06ce683f2031d487f75d"));
        person.setAge(60);
        UpdateResult updateResult = this.personDao.update(person);
        System.out.println(updateResult);
    }

    @Test
    public void testDelete() {

        DeleteResult deleteResult = this.personDao.deleteById("5e2e06ce683f2031d487f75d");
        System.out.println(deleteResult);
    }
}