如何将JAR/WAR文件上传至MongoDB？具备Spring Boot文件上传经验

Short Answer #

Absolutely! You can totally upload JAR/WAR files to MongoDB—there’s no inherent difference between these and other binary files like ZIPs you’ve already worked with. Since you have Spring Boot file upload experience, let’s walk through concrete steps to make this work.

Step-by-Step Implementation with Spring Boot #

We’ll cover two common approaches, depending on your file size:

1. Using GridFS (Recommended for Large JAR/WAR Files) #

MongoDB’s GridFS is built for files larger than the 16MB document size limit. It splits files into small chunks (256KB by default) and stores metadata separately.

Add Dependencies

If you haven’t already, include the Spring Data MongoDB starter in your pom.xml (or build.gradle):

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

Configure MongoDB Connection

Update your application.properties with your database connection details:

spring.data.mongodb.uri=mongodb://localhost:27017/your_database_name

Create a Storage Service

Use GridFsTemplate to handle uploads and downloads:

import com.mongodb.client.gridfs.model.GridFSFile;
import org.bson.types.ObjectId;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.gridfs.GridFsTemplate;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;

@Service
public class JarStorageService {

    private final GridFsTemplate gridFsTemplate;

    // Constructor injection (no @Autowired needed in Spring 4.3+)
    public JarStorageService(GridFsTemplate gridFsTemplate) {
        this.gridFsTemplate = gridFsTemplate;
    }

    // Upload JAR/WAR file
    public String uploadJar(MultipartFile file) throws IOException {
        ObjectId fileId = gridFsTemplate.store(
                file.getInputStream(),
                file.getOriginalFilename(),
                file.getContentType()
        );
        return fileId.toHexString(); // Return unique ID for later retrieval
    }

    // Download JAR/WAR file by ID
    public GridFSFile downloadJar(String fileId) {
        return gridFsTemplate.findOne(Query.query(Criteria.where("_id").isEqualTo(new ObjectId(fileId))));
    }
}

Create an Upload Controller

Expose an API endpoint to accept file uploads:

import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;

@RestController
public class JarUploadController {

    private final JarStorageService jarStorageService;

    public JarUploadController(JarStorageService jarStorageService) {
        this.jarStorageService = jarStorageService;
    }

    @PostMapping("/upload-jar")
    public ResponseEntity<String> uploadJar(@RequestParam("file") MultipartFile file) {
        try {
            String fileId = jarStorageService.uploadJar(file);
            return ResponseEntity.ok("JAR/WAR uploaded successfully! File ID: " + fileId);
        } catch (IOException e) {
            return ResponseEntity.internalServerError().body("Upload failed: " + e.getMessage());
        }
    }
}

2. Using a Binary Field (For Small JAR/WAR Files <16MB) #

If your files are under 16MB, you can store them directly in a MongoDB document using a Binary field.

Define a Document Entity

import org.bson.types.Binary;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;

@Document(collection = "small_jar_files")
public class SmallJarFile {

    @Id
    private String id;
    private String fileName;
    private String contentType;
    private Binary content;

    // Getters and Setters
    public String getId() { return id; }
    public void setId(String id) { this.id = id; }
    public String getFileName() { return fileName; }
    public void setFileName(String fileName) { this.fileName = fileName; }
    public String getContentType() { return contentType; }
    public void setContentType(String contentType) { this.contentType = contentType; }
    public Binary getContent() { return content; }
    public void setContent(Binary content) { this.content = content; }
}

Create a Storage Service

Use MongoTemplate to save the file:

import org.bson.types.Binary;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;

@Service
public class SmallJarStorageService {

    private final MongoTemplate mongoTemplate;

    public SmallJarStorageService(MongoTemplate mongoTemplate) {
        this.mongoTemplate = mongoTemplate;
    }

    public String uploadSmallJar(MultipartFile file) throws IOException {
        SmallJarFile jarFile = new SmallJarFile();
        jarFile.setFileName(file.getOriginalFilename());
        jarFile.setContentType(file.getContentType());
        jarFile.setContent(new Binary(file.getBytes()));
        
        SmallJarFile savedFile = mongoTemplate.save(jarFile);
        return savedFile.getId();
    }
}

Key Considerations #

• File Size Limit: MongoDB’s default document size cap is 16MB. Use GridFS for files larger than this to avoid errors.
• Performance: Storing binary files in MongoDB can be less efficient than dedicated storage (like AWS S3 or a local filesystem) for frequent access. Only use this approach if your business logic requires keeping files in the database.
• Metadata: Extend your entities or GridFS metadata to include extra details (upload date, version numbers, owner info) for better file management.

内容的提问来源于stack exchange，提问作者TheProfiler