• MinIO （二） .net core中实现上传下载

    这篇文章里，我们介绍在.net core webapi项目中操作MinIO。

    首先要创建一个桶，命名为demo

    英文文档看不太顺畅，在网上找了一个api中文文档，可供参考

    .NET Client API参考文档 - MinIO 帮助文档 - 开发文档 - 文江博客

    创建桶

    点击Buckets→Create Bucket创建桶

    桶名可以命名为demo，点击确认

    创建用户和秘钥

    创建用户

    创建AccessKey和SecretKey，点击Identity→Users→点击上一步创建的用户

    把上面的AccessKey和SecretKey的值保存下来，可以在配置文件中使用。

    创建WebApi项目

    创建个webapi项目，并添加Minio的NuGet包，这里我选3.1.13版本

    将Minio注入进来，并将minio连接信息配置在appsetting,json文件中Startup.cs

    1. public void ConfigureServices(IServiceCollection services)
    2. {
    3.     services.AddHttpClient();
    4.  
    5.     #region minio客户端注入
    6.     var minioClient = new MinioClient(Configuration["MinIO:Endpoint"]
    7.         , Configuration["MinIO:AccessKey"]
    8.         , Configuration["MinIO:SecretKey"]);
    9.     services.AddSingleton(minioClient);
    10.     #endregion
    11.  
    12.     #region 带权限的swagger
    13.     services.AddSwaggerGen(options =>
    14.     {
    15.         //定义api文档
    16.         options.SwaggerDoc("v1", new Microsoft.OpenApi.Models.OpenApiInfo { Title = "My API", Version = "v1" });
    17.         //包含vs生成的注释文档
    18.         //var xmlPath = Path.Combine(webHostEnvironment.ContentRootPath, Assembly.GetExecutingAssembly().GetName().Name + ".xml");
    19.         //if (File.Exists(xmlPath))
    20.         //{
    21.         //    options.IncludeXmlComments(xmlPath, true);
    22.         //}
    23.         //描述安全信息
    24.         options.AddSecurityDefinition(CookieAuthenticationDefaults.AuthenticationScheme, new OpenApiSecurityScheme()
    25.         {
    26.             Name = CookieAuthenticationDefaults.AuthenticationScheme,
    27.             Scheme = CookieAuthenticationDefaults.AuthenticationScheme
    28.         });
    29.     });
    30.     #endregion
    31.  
    32.     services.AddControllers();
    33.  
    34.     #region 不带权限的swagger
    35.     //services.AddSwaggerGen(c =>
    36.     //{
    37.     //    c.SwaggerDoc("v1", new OpenApiInfo { Title = "MinioDemo.WebApi", Version = "v1" });
    38.     //});
    39.     #endregion
    40.  
    41.  
    42.  services.AddAuthentication(CookieAuthenticationDefaults.AuthenticationScheme).AddCookie();
    43.     services.AddAuthorization();
    44.  
    45. }

    appsetting,json

    "AccessKey"和"SecretKey"可以用账号密码，也可以用配置中，新加用户中的配置信息

    1. {
    2.   "Logging": {
    3.     "LogLevel": {
    4.       "Default": "Information",
    5.       "Microsoft": "Warning",
    6.       "Microsoft.Hosting.Lifetime": "Information"
    7.     }
    8.   },
    9.   "AllowedHosts": "*",
    10.   //minIO配置
    11.   "MinIO": {
    12.     //服务器IP
    13.     "Endpoint": "localhost:9090",
    14.     //账号
    15.     "AccessKey": "minioadmin",
    16.     //密码
    17.     "SecretKey": "minioadmin",
    18.     //默认存储桶
    19.     "Bucket": "demo",
    20.     //保存文件的根目录
    21.     "BucketDirectory": "D:\\aaa\\bbb\\ccc"
    22.   },
    23.   "Kestrel": {
    24.     "EndPoints": {
    25.       "Http": {
    26.         "Url": "http://*:5000"
    27.       }
    28.     }
    29.   },
    30.   "PDM": {
    31.     "Secret": "",
    32.     "Uri": ""
    33.   }
    34. }

    完整上传、下载代码

    1. using Microsoft.AspNetCore.Http;
    2. using Microsoft.AspNetCore.Mvc;
    3. using System.Collections.Generic;
    4. using System.IO;
    5. using System.Threading.Tasks;
    6. using System;
    7. using Minio;
    8. using System.Linq;
    9. using Minio.Exceptions;
    10. using Microsoft.AspNetCore.Authorization;
    11. using Minio.DataModel;
    12. using System.Reactive.Linq;
    13. using System.Data;
    14. using System.Reactive.Threading.Tasks;
    15. using Microsoft.Extensions.Configuration;
    16. using Microsoft.Extensions.Logging;
    17. using System.Net.Http;
    18. using System.Text;
    19. using System.Text.Json;
    20. using Newtonsoft.Json;
    21.  
    22. namespace MinIOTest.Controllers
    23. {
    24.     [ApiController]
    25.     [Route("api/[controller]/[action]")]
    26.     //[Authorize]
    27.     public class MinIOController : ControllerBase
    28.     {
    29.         string _bucketName = string.Empty;//默认桶
    30.         private readonly MinioClient _client;
    31.         private readonly IConfiguration _configuration;
    32.  
    33.         public MinIOController(
    34.             MinioClient client,
    35.             IConfiguration configuration
    36.             )
    37.         {
    38.             _client = client;
    39.             _configuration = configuration;
    40.             _bucketName = configuration["MinIO:Bucket"];
    41.         }
    42.  
    43.         #region 测试
    44.         [HttpGet]
    45.         public async Task<dynamic> test()
    46.         {
    47.             return new { bb = "bbb", cc = "ccc" };
    48.         }
    49.         #endregion
    50.  
    51.         #region 上传文件
    52.         /// 
    53.         /// 上传文件
    54.         /// 
    55.         /// 文件保存路径
    56.         /// 文件
    57.         /// 
    58.         [HttpPost]
    59.         [AllowAnonymous]
    60.         public async Task<dynamic> UploadFile(string filePath, List files)
    61.         {
    62.             long size = files.Sum(f => f.Length);
    63.             try
    64.             {
    65.                 bool isExists = await _client.BucketExistsAsync(_bucketName);//桶是否存在
    66.                 //如果桶不存在则创建桶
    67.                 if (!isExists)
    68.                 {
    69.                     await _client.MakeBucketAsync(_bucketName);
    70.                 }
    71.                 foreach (var formFile in files)
    72.                 {
    73.                     string saveFileName = $"{Path.GetFileName(formFile.FileName)}";//存储        的文件名
    74.                     string objectName = $"/{filePath}/{saveFileName}";//文件保存路径
    75.                     if (formFile.Length > 0)
    76.                     {
    77.                         Stream stream = formFile.OpenReadStream();
    78.                         await _client.PutObjectAsync(_bucketName,
    79.                             objectName,
    80.                             stream,
    81.                             formFile.Length,
    82.                             formFile.ContentType);
    83.                     }
    84.                 }
    85.             }
    86.             catch (MinioException ex)
    87.             {
    88.                 _logger.LogError($"文件上传错误：{ex}");
    89.                 return Ok(new { Success = false, Message = $"文件上传错误：{ex.Message}"                                         });
    90.             }
    91.             return Ok(new { Success = true, Count = files.Count, Size = size });
    92.         }
    93.         #endregion 上传文件
    94.  
    95.         #region 下载文件
    96.         /// 
    97.         /// 下载文件
    98.         /// 
    99.         /// 文件地址
    100.         /// 
    101.         [HttpGet]
    102.         [AllowAnonymous]
    103.         public async Task DownloadFile(string fileName)
    104.         {
    105.             var memoryStream = new MemoryStream();
    106.  
    107.             try
    108.             {
    109.                 await _client.StatObjectAsync(_bucketName, fileName);
    110.                 await _client.GetObjectAsync(_bucketName, fileName,
    111.                                     (stream) =>
    112.                                     {
    113.                                         stream.CopyTo(memoryStream);
    114.                                     });
    115.                 memoryStream.Position = 0;
    116.             }
    117.             catch (MinioException ex)
    118.             {
    119.                 _logger.LogError($"下载附件发生错误：{ex}");
    120.                 return Ok(new { Success = false, Message = $"下载附件发生错误：{ex.Message}" });
    121.             }
    122.  
    123.             return File(memoryStream, GetContentType(fileName));
    124.         }
    125.         #endregion 下载文件
    126.  
    127.         #region 获取文件ContentType类型
    128.         private static string GetContentType(string fileName)
    129.         {
    130.             if (fileName.Contains(".jpg"))
    131.             {
    132.                 return "image/jpg";
    133.             }
    134.             else if (fileName.Contains(".jpeg"))
    135.             {
    136.                 return "image/jpeg";
    137.             }
    138.             else if (fileName.Contains(".png"))
    139.             {
    140.                 return "image/png";
    141.             }
    142.             else if (fileName.Contains(".gif"))
    143.             {
    144.                 return "image/gif";
    145.             }
    146.             else if (fileName.Contains(".pdf"))
    147.             {
    148.                 return "application/pdf";
    149.             }
    150.             else if (fileName.Contains(".docx"))
    151.             {
    152.                 return "application/msword";
    153.             }
    154.             else if (fileName.Contains(".txt"))
    155.             {
    156.                 return "text/plain";
    157.             }
    158.             else
    159.             {
    160.                 return "application/octet-stream";
    161.             }
    162.         }
    163.         #endregion 获取文件类型
    164.  
    165.         #region 获取指定文件目录
    166.         /// 
    167.         /// 获取指定文件目录
    168.         /// 
    169.         /// 文件路径（格式：["工程图纸/001","工程图纸/002"]）        
    170.         /// 文件名，模糊查询
    171.         /// 
    172.         [HttpPost]
    173.         public async Task<object> GetFileListAsycn(string[] prefixArr, string fileName)
    174.         {
    175.             try
    176.             {
    177.                 bool found = await _client.BucketExistsAsync(_bucketName);
    178.                 if (found)
    179.                 {
    180.                     List filePathList = new List();
    181.                     foreach (string prefix in prefixArr)
    182.                     {
    183.                         var files = _client.ListObjectsAsync(_bucketName, prefix, true);
    184.                         var filePaths = files.ToList().Wait();
    185.                         filePathList.InsertRange(filePathList.Count(), filePaths);
    186.                     }
    187.                     if (!string.IsNullOrEmpty(fileName))
    188.                     {
    189.                         filePathList = filePathList.Where(d =>         d.Key.Split('/').Last().Contains(fileName)).ToList();
    190.                     }
    191.                     return Ok(new { Success = true, Count = filePathList.Count(), Data = filePathList });
    192.                 }
    193.                 else
    194.                 {
    195.                     return Ok(new { Success = false, Data = $"桶[{_bucketName}]不存在" });
    196.                 }
    197.             }
    198.             catch (MinioException ex)
    199.             {
    200.                 _logger.LogError($"MinIO发生错误:{ex}");
    201.                 return Ok(new { Success = false, Data = $"MinIO发生错误:{ex.Message}" });
    202.             }
    203.         }
    204.         #endregion 获取指定文件目录
    205.  
    206.         #region 获取最上层目录
    207.         /// 
    208.         /// 获取最上层目录
    209.         /// 
    210.         /// 
    211.         [HttpGet]
    212.         public async Task<object> GetDirectoryAsycn()
    213.         {
    214.             try
    215.             {
    216.                 bool found = await _client.BucketExistsAsync(_bucketName);
    217.                 if (found)
    218.                 {
    219.                     var files = _client.ListObjectsAsync(_bucketName, "", false);
    220.                     var fileDirectory = files.ToList().Wait();
    221.                     foreach (var file in fileDirectory)
    222.                     {
    223.                         file.Key = file.Key.Replace("/", "");
    224.                     }
    225.                     return Ok(new { Success = true, Data = fileDirectory });
    226.                 }
    227.                 else
    228.                 {
    229.                     return Ok(new { Success = false, Data = $"桶[{_bucketName}]不存在" });
    230.                 }
    231.             }
    232.             catch (MinioException ex)
    233.             {
    234.                 _logger.LogError($"MinIO发生错误:{ex}");
    235.                 return Ok(new { Success = false, Data = $"MinIO发生错误:{ex}" });
    236.             }
    237.         }
    238.         #endregion 获取最上层目录  
    239.  
    240.     }
    241. }

    运行程序，如下图，上传接口

    下载接口，输入文件地址

    获取某个文件夹下的所有文件目录，递归获取

    获取文件列表接口这里要要注意下，因为ListObjectsAsync这个接口是异步的，当自己写的接口执行完的时候，调用MinIO获取文件列表的接口还没执行完，所以，获取MinIO文件列表接口（ListObjectsAsync），要使用方法Wait()改成同步，即

    1. var files = _client.ListObjectsAsync(_bucketName, prefix, true);
    2. var filePaths = files.ToList().Wait();

    这样，才能获取全部路径

    获取根目录，非递归

    其他api接口方法，查看官方文档，文档地址

    Windows 的 MinIO 对象存储 — MinIO Object Storage for Windows

    .NET Client API参考文档 - MinIO 帮助文档 - 开发文档 - 文江博客

    上一篇：MinIO （一）安装并生成windows服务

    下一篇：MinIO （三） 使用Webhook实时同步文件

  • 相关阅读:
    洛谷P4324 扭动的回文串
    Java实现简易版的【图书管理系统】
    VScode 关闭鼠标悬停提示
    为什么要让员工入职流程实现自动化
    vue——基于element嵌套表格+多选
    GitLab Runner 服务出现问题排查步骤
    [C++][opengl]使用opengl绘制一个简单三角形
    金仓数据库KingbaseES服务器应用参考手册--9. sys_test_fsync
    不想改bug?程序员必须学会使用的报错函数assert!(断言函数详解)
    springboot，spring框架返回204 status code的时候，会吞掉返回值
  • 原文地址：https://blog.csdn.net/qq_22325259/article/details/133874942