KOA文件上传

1. 动态创建文件夹保存

在Koa中实现图片上传并动态创建文件夹保存图片，你可以使用koa-router来处理路由，koa-body或koa-multer来处理文件上传。以下是一个基本的示例，展示了如何使用koa-multer来上传图片并在保存前动态创建文件夹。

首先，你需要安装必要的包：

npm install koa koa-router koa-multer mkdirp

这里使用mkdirp库来创建目录，因为它可以递归地创建目录路径。

然后，你可以创建一个简单的Koa服务器，并设置文件上传的路由：

  const Koa = require('koa');
  const Router = require('koa-router');
  const multer = require('koa-multer');
  const mkdirp = require('mkdirp');

  const app = new Koa();
  const router = new Router();

  // 配置 multer
  const storage = multer.diskStorage({
    destination: async function (req, file, cb) {
      // 设置图片保存的文件夹
      const uploadPath = 'uploads/' + getDynamicFolderName();
      // 确保文件夹存在，如果不存在则创建它
      await mkdirp(uploadPath);
      cb(null, uploadPath);
    },
    filename: function (req, file, cb) {
      // 设置文件名
      cb(null, file.fieldname + '-' + Date.now() + getFileExtension(file.originalname));
    }
  });

  const upload = multer({ storage: storage });

  // 获取文件扩展名
  function getFileExtension(filename) {
    return filename.slice(((filename.lastIndexOf(".") - 1) >>> 0) + 2);
  }

  // 根据需要生成动态文件夹名
  function getDynamicFolderName() {
    // 这里使用日期作为文件夹名，你可以根据需要自定义
    const date = new Date();
    const year = date.getFullYear();
    const month = ('0' + (date.getMonth() + 1)).slice(-2);
    const day = ('0' + date.getDate()).slice(-2);
    return `${year}-${month}-${day}`;
  }

  // 上传图片的路由
  router.post('/upload', upload.single('image'), async (ctx) => {
    ctx.body = {
      status: 'success',
      path: ctx.file.path
    };
  });

  app.use(router.routes()).use(router.allowedMethods());

  app.listen(3000, () => {
    console.log('Server is running on http://localhost:3000');
  });

在这个例子中，upload.single('image')中间件处理名为image的单个文件上传。storage配置定义了文件应该被保存的位置和文件名。destination函数中使用mkdirp来创建一个包含日期的动态路径，filename函数设置文件名，避免文件名冲突。

确保你的前端表单设置了enctype="multipart/form-data"属性，这样才能正确上传文件。

这个例子提供了一个基本的起点，你可以根据自己的需求进行调整和扩展。例如，你可能需要添加更多的错误处理，或者根据用户会话或其他逻辑来定制文件夹名称。

2. 图片文件更新/删除

在 Koa 应用程序中连接 MongoDB 并删除数据时，如果你想要同时删除数据库中的 URL 对应的图片文件，你需要执行两个步骤：

从 MongoDB 中获取包含图片 URL 的文档。删除服务器上的图片文件。

以下是一个简单的示例，展示了如何在 Koa 应用程序中执行这两个步骤：

首先，确保你已经安装了必要的 npm 包：

npm install koa koa-router mongodb

然后，你可以使用以下代码作为参考：

const Koa = require('koa');
const Router = require('koa-router');
const { MongoClient } = require('mongodb');
const fs = require('fs');
const util = require('util');
const unlinkAsync = util.promisify(fs.unlink);

const app = new Koa();
const router = new Router();

// MongoDB 连接信息
const url = 'mongodb://localhost:27017';
const dbName = 'myDatabase';
const client = new MongoClient(url);

// 连接 MongoDB
async function connectMongo() {
  await client.connect();
  console.log('Connected successfully to MongoDB server');
  return client.db(dbName);
}

// 删除图片文件的函数
async function deleteImageFile(imagePath) {
  try {
    await unlinkAsync(imagePath);
    console.log(`Deleted image file at ${imagePath}`);
  } catch (err) {
    console.error(`Error deleting image file: ${err}`);
  }
}

// Koa 路由，删除数据和图片
router.delete('/delete/:id', async (ctx) => {
  const db = await connectMongo();
  const collection = db.collection('yourCollection');
  const documentId = ctx.params.id;

  // 从 MongoDB 中获取文档
  const document = await collection.findOne({ _id: documentId });

  if (document) {
    // 删除 MongoDB 中的文档
    await collection.deleteOne({ _id: documentId });

    // 删除图片文件
    if (document.imageUrl) {
      await deleteImageFile(document.imageUrl);
    }

    ctx.status = 200;
    ctx.body = { message: 'Document and image deleted successfully' };
  } else {
    ctx.status = 404;
    ctx.body = { message: 'Document not found' };
  }
});

app.use(router.routes()).use(router.allowedMethods());

app.listen(3000, () => {
  console.log('Server running on http://localhost:3000');
});

在这个示例中，我们定义了一个 DELETE 路由，它接受一个文档的 ID 作为参数。当这个路由被请求时，它会从 MongoDB 中查找对应的文档，然后删除该文档，并且使用 fs.unlink 方法删除服务器上的图片文件。我们使用了 util.promisify 来将 fs.unlink 转换为返回 Promise 的函数，这样我们就可以在 async 函数中使用 await 来等待文件删除操作完成。

请注意，这个示例假设图片的 URL 是文件系统上的路径。如果你的图片存储在远程服务器或云存储服务上，你需要使用相应的 API 来删除这些文件。例如，如果你使用的是 Amazon S3，你需要使用 AWS SDK 来删除 S3 上的文件。

此外，确保在实际应用中处理好错误情况，例如数据库连接失败、文档不存在、文件删除失败等，并且根据你的应用需求调整代码。

在 Koa 应用程序中更新 MongoDB 数据库中的文档，并且同时更新文件系统中的图片，通常涉及以下步骤：

接收更新请求，包括新的图片文件和需要更新的文档信息。
从数据库中找到对应的文档。
删除旧的图片文件（如果需要）。
保存新的图片文件到文件系统。
更新数据库中的文档，包括新图片的路径。

以下是一个简化的示例，展示了如何在 Koa 应用程序中执行这些步骤。这个例子假设你已经有了文件上传的逻辑（例如使用 koa-multer）和图片存储的路径。

首先，确保你已经安装了必要的 npm 包：

npm install koa koa-router koa-body mongodb

然后，你可以使用以下代码作为参考：

const Koa = require('koa');
const Router = require('koa-router');
const koaBody = require('koa-body');
const { MongoClient } = require('mongodb');
const fs = require('fs');
const util = require('util');
const unlinkAsync = util.promisify(fs.unlink);

const app = new Koa();
const router = new Router();

// MongoDB 连接信息
const url = 'mongodb://localhost:27017';
const dbName = 'myDatabase';
const client = new MongoClient(url);

// 连接 MongoDB
async function connectMongo() {
  await client.connect();
  console.log('Connected successfully to MongoDB server');
  return client.db(dbName);
}

// 删除图片文件的函数
async function deleteImageFile(imagePath) {
  try {
    await unlinkAsync(imagePath);
    console.log(`Deleted image file at ${imagePath}`);
  } catch (err) {
    console.error(`Error deleting image file: ${err}`);
  }
}

// Koa 路由，更新数据和图片
router.post('/update/:id', koaBody({ multipart: true }), async (ctx) => {
  const db = await connectMongo();
  const collection = db.collection('yourCollection');
  const documentId = ctx.params.id;
  const newImage = ctx.request.files.newImage; // 假设使用 koa-body 处理文件上传

  // 从 MongoDB 中获取文档
  const document = await collection.findOne({ _id: documentId });

  if (document) {
    // 删除旧的图片文件
    if (document.imageUrl) {
      await deleteImageFile(document.imageUrl);
    }

    // 保存新的图片文件到文件系统
    // 这里需要你的文件上传逻辑，例如使用 koa-multer 或其他方式保存文件
    // 并获取新的图片路径 newImagePath

    // 更新数据库中的文档，包括新图片的路径
    await collection.updateOne({ _id: documentId }, { $set: { imageUrl: newImagePath } });

    ctx.status = 200;
    ctx.body = { message: 'Document and image updated successfully' };
  } else {
    ctx.status = 404;
    ctx.body = { message: 'Document not found' };
  }
});

app.use(router.routes()).use(router.allowedMethods());

app.listen(3000, () => {
  console.log('Server running on http://localhost:3000');
});

在这个示例中，我们定义了一个 POST 路由，它接受一个文档的 ID 和一个新的图片文件作为参数。当这个路由被请求时，它会从 MongoDB 中查找对应的文档，删除旧的图片文件，保存新的图片文件，并更新数据库中的文档信息。

请注意，这个示例假设图片的 URL 是文件系统上的路径，并且你已经有了处理文件上传的逻辑。如果你的图片存储在远程服务器或云存储服务上，你需要使用相应的 API 来上传和删除这些文件。

此外，确保在实际应用中处理好错误情况，例如数据库连接失败、文档不存在、文件上传失败等，并且根据你的应用需求调整代码。

3. 动态创建文件夹保存相对图片

在一个 Koa 应用程序中，如果你想根据不同的页面将上传的图片保存到不同的文件夹中，你可以在处理文件上传的逻辑中动态创建文件夹。这通常涉及到以下步骤：

确定上传图片的页面或分类，并据此决定文件夹的名称。检查相应的文件夹是否存在，如果不存在，则创建它。将上传的图片保存到相应的文件夹中。

以下是一个使用 koa-router 和 koa-body（支持文件上传）的示例代码，展示了如何根据页面动态创建文件夹并保存图片：

方案1. koa-router 和 koa-body

const Koa = require('koa');
const Router = require('koa-router');
const koaBody = require('koa-body');
const fs = require('fs');
const path = require('path');
const util = require('util');

const mkdirAsync = util.promisify(fs.mkdir);
const existsAsync = util.promisify(fs.exists);

const app = new Koa();
const router = new Router();

// 动态创建文件夹并保存图片
router.post('/upload/:page', koaBody({ multipart: true }), async (ctx) => {
  const page = ctx.params.page; // 页面或分类的名称
  const file = ctx.request.files.file; // 获取上传的文件
  const uploadDir = path.join(__dirname, 'uploads', page); // 根据页面名称创建文件夹路径

  // 检查文件夹是否存在，如果不存在则创建
  if (!await existsAsync(uploadDir)) {
    await mkdirAsync(uploadDir, { recursive: true });
  }

  // 读取上传的文件流并写入到目标文件夹
  const reader = fs.createReadStream(file.path);
  const fileName = Date.now() + path.extname(file.name); // 创建唯一的文件名
  const filePath = path.join(uploadDir, fileName);
  const writer = fs.createWriteStream(filePath);

  reader.pipe(writer);

  ctx.body = {
    message: 'File uploaded successfully',
    filePath: `/uploads/${page}/${fileName}`
  };
});

app.use(router.routes()).use(router.allowedMethods());

app.listen(3000, () => {
  console.log('Server running on http://localhost:3000');
});

在这个示例中，我们定义了一个 POST 路由 /upload/:page，其中 :page 是动态参数，用于表示上传图片的页面或分类。当文件上传请求到达时，我们根据 page 参数创建一个文件夹（如果它还不存在的话），然后将上传的文件保存到这个文件夹中。

请注意，这个示例假设你的 Koa 应用程序已经配置了静态文件服务，以便可以通过 URL 访问上传的图片。如果没有，你可以使用 koa-static 中间件来提供静态文件服务。

此外，这个示例没有包含错误处理逻辑，你应该在实际应用中添加适当的错误处理，以确保应用程序的健壮性。例如，你可能需要处理文件读写错误、确保上传的是图片文件、限制文件大小等。

当然，除了上述示例中使用的 koa-body 和直接操作文件系统的方法外，还有其他几种方式可以在 Koa 应用程序中处理文件上传和动态创建文件夹来保存图片。

方案2. 使用 koa-multer

中间件 koa-multer 是一个基于 multer 的 Koa 中间件，专门用于处理 multipart/form-data 类型的表单数据，它通常用于上传文件。multer 提供了丰富的配置选项，包括动态设置文件存储位置。

const Koa = require('koa');
const Router = require('koa-router');
const multer = require('@koa/multer');
const path = require('path');

const app = new Koa();
const router = new Router();

// 配置 multer 的存储选项
const storage = multer.diskStorage({
  destination: function (req, file, cb) {
    const page = req.params.page;
    const uploadDir = path.join(__dirname, 'uploads', page);
    fs.mkdirSync(uploadDir, { recursive: true }); // 确保目录存在
    cb(null, uploadDir);
  },
  filename: function (req, file, cb) {
    const uniqueSuffix = Date.now() + '-' + Math.round(Math.random() * 1E9);
    cb(null, file.fieldname + '-' + uniqueSuffix + path.extname(file.originalname));
  }
});

const upload = multer({ storage: storage });

router.post('/upload/:page', upload.single('file'), (ctx) => {
  ctx.body = {
    message: 'File uploaded successfully',
    filePath: ctx.file.path
  };
});

app.use(router.routes()).use(router.allowedMethods());

app.listen(3000, () => {
  console.log('Server running on http://localhost:3000');
});

方案3. 使用云存储服务

如果你的应用程序需要更高的可靠性和可扩展性，你可能会考虑使用云存储服务，如 Amazon S3、Google Cloud Storage 或 Microsoft Azure Storage。这些服务通常提供 SDK 来帮助你上传文件，并且可以很容易地通过 API 动态创建“桶”（buckets）或文件夹。

以下是使用 AWS S3 SDK 上传文件的一个简化示例：

const AWS = require('aws-sdk');
const s3 = new AWS.S3();
const bucketName = 'your-bucket-name';

router.post('/upload/:page', async (ctx) => {
  const page = ctx.params.page;
  const file = ctx.request.files.file;
  const fileName = `${page}/${Date.now()}_${file.name}`;

  const params = {
    Bucket: bucketName,
    Key: fileName,
    Body: fs.createReadStream(file.path)
  };

  try {
    const uploadResult = await s3.upload(params).promise();
    ctx.body = {
      message: 'File uploaded successfully',
      fileLocation: uploadResult.Location
    };
  } catch (error) {
    ctx.status = 500;
    ctx.body = { message: 'Error uploading file', error: error.message };
  }
});

选择哪种方法取决于你的具体需求、预算、应用规模和可维护性。对于大多数应用程序来说，直接在文件系统中管理文件是最简单和最直接的方法，但对于需要高可用性和可扩展性的大型应用程序，使用云存储服务可能是更好的选择。

KOA文件上传 ​

1. 动态创建文件夹保存 ​

2. 图片文件 更新/删除 ​

3. 动态创建文件夹 保存相对图片 ​

方案1. koa-router 和 koa-body ​

方案2. 使用 koa-multer ​

方案3. 使用云存储服务 ​