JavaApi操作MongoDB

最新推荐文章于 2023-05-11 18:16:46 发布

虞泽

最新推荐文章于 2023-05-11 18:16:46 发布

阅读量348

点赞数

分类专栏：实用技术文章标签： mongodb java 数据库

本文链接：https://blog.csdn.net/qq_41940721/article/details/109247041

版权

实用技术专栏收录该内容

39 篇文章 1 订阅

订阅专栏

1.通过java操作MongoDB

上一篇：MongoDB安装和基本操作
创建test-mongodb工程

1.pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.3.4.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.echo</groupId>
	<artifactId>mongo</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>mongo</name>
	<description>Demo project for Spring Boot</description>

	<properties>
		<java.version>1.8</java.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-mongodb</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<optional>true</optional>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
			<exclusions>
				<exclusion>
					<groupId>org.junit.vintage</groupId>
					<artifactId>junit-vintage-engine</artifactId>
				</exclusion>
			</exclusions>
		</dependency>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

</project>

2. 编写Demo

package com.echo.mongo.demo;

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

/**
 * @create 2020-10-23 17:04
 * @description:
 */
public class MongoDBDemo {
    public static void main(String[] args) {
        //1.建立连接
        MongoClient mongoClients = MongoClients.create("mongodb://38.99.158.50:27017");
        //2.选择数据库
        MongoDatabase database = mongoClients.getDatabase("testdb");
        //3.选择表
        MongoCollection<Document> user = database.getCollection("user");
        //执行操作
        user.find().limit(10).forEach(document -> {
            System.out.println(document.toJson());
        });
        //关闭连接
        mongoClients.close();
    }
}

3.CURD操作

// 查询age<=50并且id>=100的用户信息，并且按照id倒序排序，只返回id，age字段，不返回_id字段

package com.echo.mongo;

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 org.bson.Document;
import org.junit.Before;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.Collection;

@SpringBootTest
class MongoApplicationTests {
	private MongoCollection<Document> collection;

	@BeforeEach
	public void init(){
		//1.建立连接
		MongoClient mongoClients = MongoClients.create("mongodb://38.99.158.50:27017");
		//2.选择数据库
		MongoDatabase database = mongoClients.getDatabase("testdb");
		//3.选择表
		collection = database.getCollection("user");
	}	
	@Test
	public void testQuery(){
	// 查询age<=50并且id>=100的用户信息，并且按照id倒序排序，只返回id，age字段，不返回_id字段
		collection.find(Filters.and(
			Filters.lte("age",50),
			Filters.gte("id",100)
	)).sort(Sorts.descending("id"))
				.projection(Projections.fields(Projections.include("id","age")))
				.forEach(document -> {
		System.out.println(document.toJson());
	});
	}

}

Filters:建立查询条件
sort：建立排序条件
projection：建立显示字段

	@Test
	public void testInsert(){
	    Document document = new Document();
	    document.append("id",9999);
	    document.append("username","张三");
	    document.append("age",30);
	    collection.insertOne(document);

	    collection.find(Filters.eq("id",9999)).projection(Projections.excludeId()).forEach(document1 -> {
			System.out.println(document.toJson());
		});
	}

@Test
	public void testUpdate(){

	    collection.updateOne(Filters.eq("id",9999), Updates.set("age",35));

	    collection.find(Filters.eq("id",9999)).projection(Projections.excludeId()).forEach(document1 -> {
			System.out.println(document1.toJson());
		});
	}

	@Test
	public void testDelete(){
		DeleteResult age = collection.deleteMany(Filters.eq("age", 35));
		System.out.println(age);

	}

4.JavaApi操作之面向对象操作

package com.echo.mongo;

import com.echo.mongo.demo.Address;
import com.echo.mongo.demo.Person;
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 org.junit.jupiter.api.BeforeEach;

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


public class TestPerson {

    MongoCollection<Person> personCollection;

    @Before
    public void init() {
        //定义对象的解码注册器
        CodecRegistry pojoCodecRegistry = CodecRegistries.
                fromRegistries(MongoClientSettings.getDefaultCodecRegistry(),
                        CodecRegistries.fromProviders(PojoCodecProvider.builder().automatic(true).build())
                );
        // 建立连接
        MongoClient mongoClient =
                MongoClients.create("mongodb://39.99.158.50:27017");
        // 选择数据库 并且 注册解码器
        MongoDatabase mongoDatabase = mongoClient.getDatabase("testdb")
                .withCodecRegistry(pojoCodecRegistry);
        // 选择表
        this.personCollection = mongoDatabase
                .getCollection("person", Person.class);
    }

    @Test
    public void testInsert() {
        Person person = new Person(ObjectId.get(), "张三", 20,new Address("人民路", "上海市", "666666"));
        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);
    }

}

5.springboot整合MongoDB

1.导入jar包

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

2.改application.properties文件

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

3.写api方法（正常情况下写的接口，测试就直接写类了）

package com.echo.mongo.spring;


import com.echo.mongo.demo.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);
    }

}

4.测试api

package com.echo.mongo;

import com.echo.mongo.demo.Address;
import com.echo.mongo.demo.Person;
import com.echo.mongo.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(), "刘德华", 50, new Address("人民路", "香港市", "666666"));
        this.personDao.savePerson(person);
    }

    @Test
    public void testQueryPersonListByName() {
        List<Person> list = this.personDao.queryPersonListByName("李四");
        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 testUpdatae() {
        Person person = new Person();
        person.setId(new ObjectId("5c0c8a19235e194494ae65cc"));
        person.setAge(23);
        UpdateResult update = this.personDao.update(person);
        System.out.println(update);
    }

    @Test
    public void testDelete() {
        DeleteResult deleteResult = this.personDao.deleteById("5f968f07cec1f5626abdc629");
        System.out.println(deleteResult);
    }
}