04.Java操作MongoDB

最新推荐文章于 2024-05-17 18:02:32 发布

sswqzx

最新推荐文章于 2024-05-17 18:02:32 发布

阅读量473

点赞数

分类专栏： MongoDB 文章标签： Java操作MongoDB

本文链接：https://blog.csdn.net/sswqzx/article/details/88985855

版权

MongoDB 专栏收录该内容

5 篇文章 1 订阅

订阅专栏

一、java原生操作MongoDB的crud

说明：mongodb-driver是mongo官方推出的java连接mongoDB的驱动包，相当于JDBC驱动、这用即可

1、创建工程、引入依赖

<?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 
http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.mongodb</groupId>
    <artifactId>mongodbdemo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!--MongoDB驱动-->
        <dependency>
            <groupId>org.mongodb</groupId>
            <artifactId>mongodb-driver</artifactId>
            <version>3.8.0</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>

</project>

2、创建测试类

package com.mongodbTest.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;
import org.junit.Test;


import java.util.Date;

public class MongoFirstTest {

    //插入一条数据
    @Test
    public void testInsert(){
        MongoClient mongoClients = MongoClients.create("mongodb://127.0.0.1:27017");
        MongoDatabase mongoDatabase = mongoClients.getDatabase("spitdb");
        MongoCollection<Document> collection = mongoDatabase.getCollection("spit");
        Document document = new Document("context","原生pai").append("userid","11").append("vistis","99").append("time",new Date());
        collection.insertOne(document);
        mongoClients.close();
    }
}

运行后、查看mongo

3、创建测试类curd

package com.mongodbTest.demo;

import com.mongodb.client.*;
import com.mongodb.client.model.Filters;
import org.bson.Document;
import org.bson.types.ObjectId;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;


import java.util.Date;

public class MongoCrudTest {
    //连接对象
    private MongoClient mongoClient=null;
    //数据库对象
    private MongoDatabase spitdbDatabase=null;
    //集合对象
    private MongoCollection<Document> collection=null;
    @Before
    public void setUp() throws Exception {
        //创建一个连接，自带连接池效果
        mongoClient= MongoClients.create("mongodb://127.0.0.1:27017");
        //操作一个数据库，如果数据库不存在，当您为该数据库首次存储数据时，会自动创建数据库。
        spitdbDatabase = mongoClient.getDatabase("spitdb");
        //得到一个集合对象，如果集合不存在，当您为该数据库首次存储数据时，会自动创建集合。
        collection = spitdbDatabase.getCollection("spit");
    }

    @After
    public void tearDown() throws Exception {
        //释放资源，关闭连接
        mongoClient.close();
    }

    //插入一个文档
    @Test
    public void testInsertOne(){

        //创建一个文档，参数可以接收键值对，也可以直接接收一个Map对象
        //文档对象的本质是BSON类型，该类型对应java.util.Map;BSON数组对应的是java.util.List
        Document document=new Document("content","1111").append("userid","111").append("visits",1234).append("publishtime",new Date());

        //插入一个文档，如果文档没有指定_id，则自动生成_id和值
        // 如果批量插入，使用insertMany(list)
        collection.insertOne(document);
    }
    //更新一个文档
    @Test
    public void testUpdateOne(){
        //条件文档数据，注意，主键_id的类型比较特殊，如果是自动生成的主键，则是ObjectId类型
        Document conditionDocument=new Document("_id",new ObjectId("5ca4c0877245b96d1060eb2d"));
        //要修改后的文档数据，其中$set代表只更新部分字段
        Document document=new Document("$set",new Document("content","原生"));

        //更新一个文档，参数1：条件，参数2：要更新的内容
        collection.updateOne(conditionDocument,document);
        // 如果批量更新，使用updateMany(bson1,bson2)，条件文档中可以编写更复杂的条件。
    }

    //删除一个文档
    @Test
    public void testDeleteOne(){
        //条件文档数据，注意，主键_id的类型比较特殊，如果是自动生成的主键，则是ObjectId类型
        Document conditionDocument=new Document("_id",new ObjectId("5ca461d37245b9a3d0525203"));
        //更新一个文档，参数1：条件
        collection.deleteOne(conditionDocument);
        // 如果批量删除，使用deleteMany(bson1,bson2)，条件文档中可以编写更复杂的条件。
    }
    
    //查询所有
    @Test
    public void testFindAll(){
        //查询所有文档
        FindIterable<Document> documents = collection.find();
        printDocument(documents);
        //如果需要限制返回行数，可以在find()方法后添加first()、limit()等方法
    }

    //打印文档
    private void printDocument(FindIterable<Document> documents) {
        for (Document document : documents) {

            System.out.println("-------------------------------");
//            System.out.println("编号：" + (document.getObjectId("_id")));
            System.out.println("内容：" + document.getString("content"));
            System.out.println("用户编号：" + document.getString("userid"));
            System.out.println("浏览量 ：" + document.getInteger("visits"));
            System.out.println("发布时间：" + document.getDate("publishtime"));
        }
    }


    //条件查询
    @Test
    public void testFindByCondition(){
        //查询userid为8888，且浏览量大于等于1000的所有文档：{$and:[{$eq:{"userid":"8888"},$gte:{"visits":1000}}]}
        //Filters是一个构造条件的帮助类
        FindIterable<Document> documents = collection.find(Filters.and(Filters.eq("userid","8888"),Filters.gte("visits",1000)));
        printDocument(documents);
    }

}

二、SpringDataMongoDB使用

SpringDataMongo是DBSpringData家族成员之一，用于操作MongoDB的持久层框架，封装了底层的mongodb-driver。

1、创建工程、引入依赖

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

2、创建application.yml

 #数据源配置
  data:
    mongodb:
      # 主机地址
      host: 127.0.0.1
      # 数据库
      database: spitdb
      # 默认端口是27017
      port: 27017

3、启动类

@SpringBootApplication
public class SpitApplication {

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

	@Bean
	public IdWorker idWorker(){
		return new IdWorker(1, 1);
	}
	
}

4、增删改查

--实体类

//把一个java类声明为mongodb的文档，可以通过collection参数指定这个类对应的文档。
@Document(collection="spit")
public class Spit implements Serializable {
    //主键标识，该属性的值会自动对应mongodb的主键字段"_id"，如果该属性名就叫“id”,则该注解可以省略，否则必须写
    @Id
    private String id;//主键
    //该属性对应mongodb的字段的名字，如果一致，则无需该注解
    @Field("content")
    private String content;//吐槽内容
    private Date publishtime;//发布日期
    private String userid;//发布人ID
    private String nickname;//昵称
    private Integer visits;//浏览量
    private Integer thumbup;//点赞数
    private Integer share;//分享数
    private Integer comment;//回复数
    private String state;//状态
    private String parentid;//上级ID
    //getter and setter.....

--数据访问接口

public interface SpitRepository extends MongoRepository<Spit,String> {
}

--业务逻辑层

@Service
public class SpitService {
    @Autowired
    private SpitRepository spitRepository;

    @Autowired
    private IdWorker idWorker;

    /**
     * 增加
     *
     * @param spit
     */
    public void saveSpit(Spit spit) {
        spit.setId(idWorker.nextId() + "");
        spitRepository.save(spit);
    }

    /**
     * 修改
     *
     * @param spit
     */
    public void updateSpit(Spit spit) {
        spitRepository.save(spit);
    }

    /**
     * 删除
     *
     * @param id
     */
    public void deleteSpitById(String id) {
        spitRepository.deleteById(id);
    }

    /**
     * 查询全部列表
     *
     * @return
     */
    public List<Spit> findSpitList() {
        return spitRepository.findAll();
    }

    /**
     * 根据ID查询实体
     *
     * @param id
     * @return
     */
    public Spit findSpitById(String id) {
        return spitRepository.findById(id).get();
    }
}

--controll层

@RestController
@CrossOrigin
@RequestMapping("/spit")
public class SpitController {

    @Autowired
    private SpitService spitService;
    /**
     * 增加
     * @param spit
     */
    @PostMapping
    public ResultDTO add(@RequestBody Spit spit){
        spitService.saveSpit(spit);
        return new ResultDTO(true, StatusCode.OK,"增加成功");
    }

    /**
     * 修改
     * @param spit
     */
    @PutMapping("/{id}")
    public ResultDTO edit(@RequestBody Spit spit, @PathVariable String id ){
        spit.setId(id);
        spitService.updateSpit(spit);
        return new ResultDTO(true,StatusCode.OK,"修改成功");
    }

    /**
     * 删除
     * @param id
     */
    @DeleteMapping("/{id}")
    public ResultDTO remove(@PathVariable String id ){
        spitService.deleteSpitById(id);
        return new ResultDTO(true,StatusCode.OK,"删除成功");
    }

    /**
     * 查询全部数据
     * @return
     */
    @GetMapping
    public ResultDTO list(){
        return new ResultDTO(true,StatusCode.OK,"查询成功",spitService.findSpitList());
    }

    /**
     * 根据ID查询
     * @param id ID
     * @return
     */
    @GetMapping("/{id}")
    public ResultDTO listById(@PathVariable String id){
        return new ResultDTO(true,StatusCode.OK,"查询成功",spitService.findSpitById(id));
    }
}