标签搜索

目 录CONTENT

文章目录

SpringBoot集成MongoDB以及GridFS

陈铭
2023-09-01 / 0 评论 / 0 点赞 / 52 阅读 / 1,632 字 / 正在检测是否收录...

pom

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

application.yaml

注意: uri中的username和password需要进行URI编码,再填进去(避免出现@等非法字符)

spring:
  data:
    mongodb:
      uri: mongodb://username:password@ip:27017
      database: llm-mp

基本使用

@Autowired
private MongoTemplate mongoTemplate;

检索数据

//  查询name=zs
Query query = Query.query(Criteria.where("name").is("zs"));
mongoTemplate.find(query,User.class);
mongoTemplate.find(query,User.class,"mongodb_user");
 
//  查询所有
mongoTemplate.findAll(User.class);
mongoTemplate.findAll(User.class,"mongodb_user");
 
//  分页查询	page页码,pageSize每页展示几个
Pageable pageable = PageRequest.of(page - 1, pageSize, Sort.by(Sort.Order.desc("date")));
Query query = new Query().with(pageable);
return this.mongoTemplate.find(query, User.class,"mongodb_user");
 
//  查询多个
Query query= Query.query(Criteria.where("id").in("id1","id2","id3")).with(Sort.by(Sort.Order.desc("date")));
List<Publish> list= this.mongoTemplate.find(query, User.class);
 
//  查询数量
Criteria criteria = Criteria.where("userId").is("12345")
                .and("name").is(new ObjectId("张三"))
                .and("address").is("上海");
Query query = Query.query(criteria);
long count = this.mongoTemplate.count(query, User.class);

插入数据

List<User> list = new ArrayList<>();
User user= new User();//
user.setName("admin");
user.setAddress("测试");
list.add(user);
 
//  保存对象到mongodb
mongoTemplate.save(user);
mongoTemplate.insert(user);
//  根据集合名称保存对象到mongodb
mongoTemplate.save(user,"mongodb_user");
mongoTemplate.insert(user,"mongodb_user");
//  根据集合名称保存list到mongodb
mongoTemplate.save(list,"mongodb_user");
mongoTemplate.insert(list,"mongodb_user");
mongoTemplate.insert(list,User.class);

更新数据

User user = new User();
user.setId("5d1312aeb1829c279c6c256b");
user.setName("admin");
user.setAddress("测试");
 
Query query = Query.query(Criteria.where("_id").is("5d1312aeb1829c279c6c256b"));
Update update = Update.update("name","zs");
//  更新一条数据
mongoTemplate.updateFirst(query,update, User.class);
mongoTemplate.updateFirst(query,update, "mongodb_user");
mongoTemplate.updateFirst(query,update, User.class,"mongodb_user");
//  更新多条数据
mongoTemplate.updateMulti(query,update, User.class);
mongoTemplate.updateMulti(query,update,"mongodb_user");
mongoTemplate.updateMulti(query,update, User.class,"mongodb_user");
//  更新数据,如果数据不存在就新增
mongoTemplate.upsert(query,update, User.class);
mongoTemplate.upsert(query,update,"mongodb_user");
mongoTemplate.upsert(query,update, User.class,"mongodb_user");

删除数据

List<MongoDbJavaTest> list = new ArrayList<>();
User user= new User();
user.setId("5d1312aeb1829c279c6c256b");
list.add(user);
 
Query query = Query.query(Criteria.where("_id").in("5d1312aeb1829c279c6c256b","5d13133ab1829c29d02ce29c"));
//  根据条件删除
mongoTemplate.remove(query);
mongoTemplate.remove(user);
mongoTemplate.remove(User.class);
//  根据条件删除(可删除多条)
mongoTemplate.remove(query,User.class,"mongodb_user");

GridFS

GridFS简介

GridFS is a specification for storing and retrieving files that exceed the BSON-document size limit of 16 MB.
字面直译就是说GridFS是用来存储大于BSON文档限制的16MB的文件。
官方文档

存储原理: GridFS 会将大文件对象分割成多个小的chunk(文件片段), 一般为256k/个,每个chunk将作为MongoDB的一个文档(document)被存储在chunks集合中。
每一个数据库有一个GridFS区域,用来存储。
需要通过先创建bucket(和OSS中一样的概念)来存储,一个bucket创建后,一旦有文件存入,在collections中就会自动生成2个集合来存储文件的数据和信息,一般是bucket名字+files和bucket名字+chunks。
每个文件的实际内容被存在chunks(二进制数据)中,和文件有关的meta数据(filename,content_type,还有用户自定义的属性)将会被存在files集合中。

demo

package com.ruijie.cloud.llm.mp.model;

import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.gridfs.GridFSBucket;
import com.mongodb.client.gridfs.GridFSBuckets;
import com.mongodb.client.gridfs.model.GridFSUploadOptions;
import lombok.extern.slf4j.Slf4j;
import org.bson.Document;
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.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.util.FileCopyUtils;

import java.io.*;
import java.util.List;

@Slf4j
@RunWith(SpringRunner.class)
@SpringBootTest(classes = ModelApplication.class)
public class ModelApplicationTest {

    @Autowired
    private MongoTemplate mongoTemplate;

    @Autowired
    private MongoClient mongoClient;

    // GridFS下的bucket,自行指定要把文件存储到哪个bucket。
    private String BUCKET_NAME = "modules";
    // 源文件,即要被存储的文件的绝对路径
    private String FILE_PATH = "C:\\Users\\13110\\Desktop\\temp\\jdk-8u192-windows-x64.exe";
    // 存储文件后自动生成的存储文件信息的collection,一般是xx.files。
    private String COLLECTION_NAME = "modules.files";
    // 用于演示接收输出文件的路径
    private String FILE_OUTPUT_PATH = "C:\\Users\\13110\\Desktop\\jdk-8u192-windows-x64.exe";

    @Test
    public void testGridFSSaveFiles() {
//        saveToGridFS();
        System.out.println("------------");
        readFromGridFS();
    }

    @Test
    public void createDB(){
        User user = new User("zz");
        User user1 = new User("zz1");
        MongoTemplate cm_test = new MongoTemplate(mongoClient, "cm_test");
        cm_test.save(user,"mongodb_user");
        cm_test.insert(user1,"mongodb_user");

        Query query = Query.query(Criteria.where("name").is("zz"));
        List<User> users = cm_test.find(query, User.class);
        System.out.println(user);
    }

    /**
     * 传入bucketName得到指定bucket操作对象。
     *
     * @param bucketName
     * @return
     */
    public GridFSBucket createGridFSBucket(String bucketName) {
        MongoDatabase db = mongoTemplate.getDb();
        return GridFSBuckets.create(db, bucketName);
    }

    /**
     * 储存文件到GridFS
     */
    public void saveToGridFS() {
        // 先调用上面方法得到一个GridFSBucket的操作对象
        GridFSBucket gridFSBucket = createGridFSBucket(BUCKET_NAME);
        File file = new File(FILE_PATH);
        FileInputStream inputStream = null;
        try {
            inputStream = new FileInputStream(file);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        // 设置GridFS存储配置,这里是设置了每个chunk(块)的大小为1024个字节,也可以设置大一点。 MetaData是对文件的说明,如果不需要可以不写。 也是以键值对存在,BSON格式。
        GridFSUploadOptions options = new GridFSUploadOptions().chunkSizeBytes(1024).metadata(new Document("user", "onepiece"));
        // 调用GridFSBucket中的uploadFromStream方法,把对应的文件流传递进去,然后就会以binary(二进制格式)存储到GridFS中,并得到一个文件在xx.files中的主键ID,后面可以用这个ID来查找关联的二进制文件数据。
        ObjectId objectId = gridFSBucket.uploadFromStream(file.getName(), inputStream, options);
        System.out.println(file.getName() + "已存入mongodb gridFS, 对应id是:" + objectId);
    }

    /**
     * 从GridFS中读取文件
     */
    public void readFromGridFS() {
        // 这里查找条件我先不写,默认查所有,取第一条做验证演示。 用Document类接收。
        List<Document> files = mongoTemplate.find(new Query(), Document.class, COLLECTION_NAME);
        Document file = files.get(0);
        // 得到主键ID,作为等下要查询的文件ID值。
        ObjectId fileId = file.getObjectId("_id");
        String filename = file.getString("filename");
        // 先调用上面方法得到一个GridFSBucket的操作对象
        GridFSBucket gridFSBucket = createGridFSBucket(BUCKET_NAME);
        // 调用openDownloadStream方法得到文件IO流。
        InputStream downloadStream = gridFSBucket.openDownloadStream(fileId);
        FileOutputStream fileOutputStream = null;
        try {
            fileOutputStream = new FileOutputStream(FILE_OUTPUT_PATH + filename);
            // 把IO流直接到指定路径的输出流对象实现输出。
            FileCopyUtils.copy(downloadStream, fileOutputStream);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
0

评论区