如何在MongoDB中保存小于16MB的图片文件？

Hey there! Let's break down your two options for storing images in MongoDB using Node.js, and help you decide which fits your needs best.

When to Use BinData (Buffer) #

BinData (represented as Buffer in Node.js) is perfect for smaller images (under 16MB)—since MongoDB has a 16MB limit on single document size. It's straightforward to implement, as you can store the image data directly as a field in your MongoDB document.

Example Implementation with Mongoose #

1. First, define a schema that includes a Buffer field for the image data, plus any metadata you want to store (like filename, content type):

const mongoose = require('mongoose');

const imageSchema = new mongoose.Schema({
  filename: { type: String, required: true },
  contentType: { type: String, required: true },
  data: { type: Buffer, required: true }
});

const Image = mongoose.model('Image', imageSchema);

2. Use a middleware like multer to handle file uploads, then save the buffer to MongoDB:

const multer = require('multer');
const upload = multer({ storage: multer.memoryStorage() }); // Store file in memory as buffer

app.post('/upload', upload.single('image'), async (req, res) => {
  try {
    const newImage = new Image({
      filename: req.file.originalname,
      contentType: req.file.mimetype,
      data: req.file.buffer
    });
    await newImage.save();
    res.status(201).json({ message: 'Image saved successfully', imageId: newImage._id });
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

To retrieve the image later, you can fetch the document and send the buffer with the correct content type:

app.get('/image/:id', async (req, res) => {
  try {
    const image = await Image.findById(req.params.id);
    if (!image) return res.status(404).json({ message: 'Image not found' });
    res.set('Content-Type', image.contentType);
    res.send(image.data);
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

When to Use GridFS #

GridFS is MongoDB's solution for files larger than 16MB, or when you need to work with parts of a file (e.g., streaming a large image instead of loading it all into memory). It splits files into 256KB chunks and stores them in two separate collections: fs.files (metadata) and fs.chunks (file chunks).

Example Implementation with MongoDB's GridFSBucket #

1. Initialize the GridFSBucket after connecting to MongoDB:

const { MongoClient, GridFSBucket } = require('mongodb');
const uri = 'your-mongodb-connection-string';
let bucket;

MongoClient.connect(uri)
  .then(client => {
    const db = client.db('your-database-name');
    bucket = new GridFSBucket(db);
    console.log('GridFSBucket initialized');
  })
  .catch(err => console.error(err));

2. Handle file uploads and store them via GridFS:

const multer = require('multer');
const upload = multer({ storage: multer.memoryStorage() });

app.post('/upload-large', upload.single('image'), async (req, res) => {
  try {
    const uploadStream = bucket.openUploadStream(req.file.originalname, {
      contentType: req.file.mimetype
    });

    // Pipe the file buffer to the upload stream
    uploadStream.end(req.file.buffer);

    uploadStream.on('finish', () => {
      res.status(201).json({ 
        message: 'Large image saved successfully', 
        fileId: uploadStream.id 
      });
    });

    uploadStream.on('error', (err) => {
      res.status(500).json({ error: err.message });
    });
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

To retrieve the large image, you can stream it back to the client:

app.get('/large-image/:id', (req, res) => {
  const downloadStream = bucket.openDownloadStream(new ObjectId(req.params.id));
  
  downloadStream.on('error', (err) => {
    res.status(404).json({ message: 'Image not found' });
  });

  downloadStream.pipe(res);
});

Which Should You Choose? #

• Go with BinData if:

  • Your images are consistently under 16MB.
  • You want a simple, direct approach (no extra collections to manage).
  • You prefer loading the entire image into memory when retrieving it.

• Go with GridFS if:

  • You expect images larger than 16MB.
  • You need to stream files (avoid loading the entire file into memory).
  • You want to store additional metadata about large files easily.

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