经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 其他 » 职业生涯 » 查看文章
造轮子之文件管理
来源：cnblogs　　作者：饭勺oO　　时间：2023/10/25 10:13:40　　对本文有异议

前面我们完成了设置管理，接下来正好配合设置管理来实现文件管理功能。
文件管理自然包括文件上传，下载以及文件存储功能。设计要求可以支持扩展多种存储服务，如本地文件，云存储等等。

数据库设计

首先当然是我们的数据库表设计，用于管理文件。创建一个文件信息存储表。

  1. using Wheel.Domain.Common;
  2. using Wheel.Enums;
  4. namespace Wheel.Domain.FileStorages
  5. {
  6.     /// <summary>
  7.     /// 文件信息存储表
  8.     /// </summary>
  9.     public class FileStorage : Entity, IHasCreationTime
  10.     {
  11.         /// <summary>
  12.         /// 文件名
  13.         /// </summary>
  14.         public string FileName { get; set; }
  15.         /// <summary>
  16.         /// 文件类型ContentType
  17.         /// </summary>
  18.         public string ContentType { get; set; }
  19.         /// <summary>
  20.         /// 文件类型
  21.         /// </summary>
  22.         public FileStorageType FileStorageType { get; set; }
  23.         /// <summary>
  24.         /// 大小
  25.         /// </summary>
  26.         public long Size { get; set; }
  27.         /// <summary>
  28.         /// 存储路径
  29.         /// </summary>
  30.         public string Path { get; set; }
  31.         /// <summary>
  32.         /// 创建时间
  33.         /// </summary>
  34.         public DateTimeOffset CreationTime { get; set; }
  35.         /// <summary>
  36.         /// 存储类型
  37.         /// </summary>
  38.         public string Provider { get; set; }
  39.     }
  40. }
  1. namespace Wheel.Enums
  2. {
  3.     public enum FileStorageType
  4.     {
  5.         /// <summary>
  6.         /// 普通文件
  7.         /// </summary>
  8.         File = 0,
  9.         /// <summary>
  10.         /// 图片
  11.         /// </summary>
  12.         Image = 1,
  13.         /// <summary>
  14.         /// 视频
  15.         /// </summary>
  16.         Video = 2,
  17.         /// <summary>
  18.         /// 音频
  19.         /// </summary>
  20.         Audio = 3,
  21.         /// <summary>
  22.         /// 文本类型
  23.         /// </summary>
  24.         Text = 4,
  25.     }
  26. }

FileStorageType是对ContentType类型的包装。后面可根据需求再加上细分类型。

  1. using Wheel.Enums;
  3. namespace Wheel.Domain.FileStorages
  4. {
  5.     public static class FileStorageTypeChecker
  6.     {
  7.         public static FileStorageType CheckFileType(string contentType)
  8.         {
  9.             return contentType switch
  10.             {
  11.                 var _ when contentType.StartsWith("audio") => FileStorageType.Audio,
  12.                 var _ when contentType.StartsWith("image") => FileStorageType.Image,
  13.                 var _ when contentType.StartsWith("text") => FileStorageType.Text,
  14.                 var _ when contentType.StartsWith("video") => FileStorageType.Video,
  15.                 _ => FileStorageType.File
  16.             };
  17.         }
  18.     }
  19. }

Provider对应不同的存储服务。如Minio等。

修改DbContext

在DbContext中添加代码：

  1. #region FileStorage
  2. public DbSet<FileStorage> FileStorages { get; set; }
  3. #endregion
  6. protected override void OnModelCreating(ModelBuilder builder)
  7. {
  8.     base.OnModelCreating(builder);
  10.     ConfigureIdentity(builder);
  11.     ConfigureLocalization(builder);
  12.     ConfigurePermissionGrants(builder);
  13.     ConfigureMenus(builder);
  14.     ConfigureSettings(builder);
  15.     ConfigureFileStorage(builder);
  16. }
  18. void ConfigureFileStorage(ModelBuilder builder)
  19. {
  20.     builder.Entity<FileStorage>(b =>
  21.     {
  22.         b.HasKey(o => o.Id);
  23.         b.Property(o => o.FileName).HasMaxLength(256);
  24.         b.Property(o => o.Path).HasMaxLength(256);
  25.         b.Property(o => o.ContentType).HasMaxLength(32);
  26.         b.Property(o => o.Provider).HasMaxLength(32);
  27.     });
  28. }

然后执行数据库迁移操作即可完成表创建。

FileStorageProvider

接下来就是实现我们的文件存储的Provider，首先创建一个IFileStorageProvider基础接口。

  1. using Wheel.DependencyInjection;
  3. namespace Wheel.FileStorages
  4. {
  5.     public interface IFileStorageProvider : ITransientDependency
  6.     {
  7.         string Name { get; }
  9.         Task<UploadFileResult> Upload(UploadFileArgs uploadFileArgs, CancellationToken cancellationToken = default);
  10.         Task<DownFileResult> Download(DownloadFileArgs downloadFileArgs, CancellationToken cancellationToken = default);
  12.         Task<object> GetClient();
  14.         void ConfigureClient<T>(Action<T> configure);
  16.     }
  17. }

提供定义名称，上传下载，以及获取Provider的Client和配置Provider中的Client的方法。

FileProviderSettingDefinition

既然要对接各种存储服务，那么当然少不了对接的配置，那么我们就基于前面设置管理。添加一个FileProviderSettingDefinition

  1. using Wheel.Enums;
  3. namespace Wheel.Settings.FileProvider
  4. {
  5.     public class FileProviderSettingDefinition : ISettingDefinition
  6.     {
  7.         public string GroupName => "FileProvider";
  9.         public SettingScope SettingScope => SettingScope.Global;
  11.         public Dictionary<string, SettingValueParams> Define()
  12.         {
  13.             return new Dictionary<string, SettingValueParams>
  14.             {
  15.                 { "Minio.Endpoint", new(SettingValueType.String, "127.0.0.1:9000") },
  16.                 { "Minio.AccessKey", new(SettingValueType.String, "2QgNxo11uxgULRvkrdaT") },
  17.                 { "Minio.SecretKey", new(SettingValueType.String, "NvzXnh81UMwEcvLJc8BslA1GA0j0sCq0aXRgHSRJ") },
  18.                 { "Minio.Region", new(SettingValueType.String) },
  19.                 { "Minio.SessionToken", new(SettingValueType.String) }
  20.             };
  21.         }
  22.     }
  23. }

这里我暂时只实现对接Minio，所以只加上Minio的配置。

MinioFileStorageProvider

接下来实现一个MinioFileStorageProvider

  1. using Minio;
  2. using Minio.DataModel.Args;
  3. using Minio.Exceptions;
  4. using Wheel.Settings;
  6. namespace Wheel.FileStorages.Providers
  7. {
  8.     public class MinioFileStorageProvider : IFileStorageProvider
  9.     {
  10.         private readonly ISettingProvider _settingProvider;
  11.         private readonly ILogger<MinioFileStorageProvider> _logger;
  13.         public MinioFileStorageProvider(ISettingProvider settingProvider, ILogger<MinioFileStorageProvider> logger)
  14.         {
  15.             _settingProvider = settingProvider;
  16.             _logger = logger;
  17.         }
  19.         public string Name => "Minio";
  20.         internal Action<IMinioClient>? Configure { get; private set; }
  21.         public async Task<UploadFileResult> Upload(UploadFileArgs uploadFileArgs, CancellationToken cancellationToken = default)
  22.         {
  23.             var client = await GetMinioClient();
  24.             try
  25.             {
  26.                 // Make a bucket on the server, if not already present.
  27.                 var beArgs = new BucketExistsArgs()
  28.                     .WithBucket(uploadFileArgs.BucketName);
  29.                 bool found = await client.BucketExistsAsync(beArgs, cancellationToken).ConfigureAwait(false);
  30.                 if (!found)
  31.                 {
  32.                     var mbArgs = new MakeBucketArgs()
  33.                         .WithBucket(uploadFileArgs.BucketName);
  34.                     await client.MakeBucketAsync(mbArgs, cancellationToken).ConfigureAwait(false);
  35.                 }
  36.                 // Upload a file to bucket.
  37.                 var putObjectArgs = new PutObjectArgs()
  38.                     .WithBucket(uploadFileArgs.BucketName)
  39.                     .WithObject(uploadFileArgs.FileName)
  40.                     .WithStreamData(uploadFileArgs.FileStream)
  41.                     .WithObjectSize(uploadFileArgs.FileStream.Length)
  42.                     .WithContentType(uploadFileArgs.ContentType);
  43.                 await client.PutObjectAsync(putObjectArgs, cancellationToken).ConfigureAwait(false);
  44.                 var path = BuildPath(uploadFileArgs.BucketName, uploadFileArgs.FileName);
  45.                 _logger.LogInformation("Successfully Uploaded " + path);
  46.                 return new UploadFileResult { FilePath = path, Success = true };
  47.             }
  48.             catch (MinioException e)
  49.             {
  50.                 _logger.LogError("File Upload Error: {0}", e.Message);
  51.                 return new UploadFileResult { Success = false };
  52.             }
  53.         }
  54.         public async Task<DownFileResult> Download(DownloadFileArgs downloadFileArgs, CancellationToken cancellationToken = default)
  55.         {
  56.             var client = await GetMinioClient();
  57.             try
  58.             {
  59.                 var stream = new MemoryStream();
  60.                 var args = downloadFileArgs.Path.Split("/");
  61.                 var getObjectArgs = new GetObjectArgs()
  62.                     .WithBucket(args[0])
  63.                     .WithObject(downloadFileArgs.Path.RemovePreFix($"{args[0]}/"))
  64.                     .WithCallbackStream(fs => fs.CopyTo(stream))
  65.                     ;
  66.                 var response = await client.GetObjectAsync(getObjectArgs, cancellationToken).ConfigureAwait(false);
  68.                 _logger.LogInformation("Successfully Download " + downloadFileArgs.Path);
  69.                 stream.Position = 0;
  70.                 return new DownFileResult { Stream = stream, Success = true, FileName = response.ObjectName, ContentType = response.ContentType };
  71.             }
  72.             catch (MinioException e)
  73.             {
  74.                 _logger.LogError("File Download Error: {0}", e.Message);
  75.                 return new DownFileResult { Success = false };
  76.             }
  77.         }
  79.         public async Task<object> GetClient()
  80.         {
  81.             return await GetMinioClient();
  82.         }
  84.         public void ConfigureClient<T>(Action<T> configure)
  85.         {
  86.             if (typeof(T) == typeof(IMinioClient))
  87.                 Configure = configure as Action<IMinioClient>;
  88.             else
  89.                 throw new Exception("MinioFileProvider ConfigureClient Only Can Configure Type With IMinioClient");
  90.         }
  92.         private async Task<IMinioClient> GetMinioClient()
  93.         {
  94.             var minioSetting = await GetSettings();
  95.             var client = new MinioClient()
  96.                 .WithHttpClient(new HttpClient())
  97.                 .WithEndpoint(minioSetting["Endpoint"])
  98.                 .WithCredentials(minioSetting["AccessKey"], minioSetting["SecretKey"])
  99.                 .WithSessionToken(minioSetting["SessionToken"]);
  101.             if (!string.IsNullOrWhiteSpace(minioSetting["Region"]))
  102.             {
  103.                 client.WithRegion(minioSetting["Region"]);
  104.             }
  106.             if (Configure != null)
  107.             {
  108.                 Configure.Invoke(client);
  109.             }
  110.             return client;
  111.         }
  113.         private async Task<Dictionary<string, string>> GetSettings()
  114.         {
  115.             var settings = await _settingProvider.GetGolbalSettings("FileProvider");
  117.             return settings.Where(a => a.Key.StartsWith("Minio")).ToDictionary(a => a.Key.RemovePreFix("Minio."), a => a.Value);
  118.         }
  119.         private string BuildPath(string bucketName, string fileName)
  120.         {
  121.             return string.Join('/', bucketName, fileName);
  122.         }
  123.     }
  124. }

这里定义MinioFileStorageProvider的Name是Minio用作标识。
Upload和Download则是正常的使用MinioClient的上传下载操作。
GetClient()返回一个MinioClient实例，用于方便做其他“骚操作”。
ConfigureClient则是用来配置MinioClient实例，代码约定限制只支持IMinioClient的类型。
GetSettings则是从SettingProvider中获取Minio的配置信息。

FileStorageManageAppService

基础的对接搭好了，现在我们来实现我们的业务功能。很简单，就三个功能，上传下载，分页查询。

  1. using Wheel.Core.Dto;
  2. using Wheel.DependencyInjection;
  3. using Wheel.Services.FileStorageManage.Dtos;
  5. namespace Wheel.Services.FileStorageManage
  6. {
  7.     public interface IFileStorageManageAppService : ITransientDependency
  8.     {
  9.         Task<Page<FileStorageDto>> GetFileStoragePageList(FileStoragePageRequest request);
  10.         Task<R<List<FileStorageDto>>> UploadFiles(UploadFileDto uploadFileDto);
  11.         Task<R<DownloadFileResonse>> DownloadFile(long id);
  12.     }
  13. }
  1. using Wheel.Const;
  2. using Wheel.Core.Dto;
  3. using Wheel.Core.Exceptions;
  4. using Wheel.Domain;
  5. using Wheel.Domain.FileStorages;
  6. using Wheel.Enums;
  7. using Wheel.FileStorages;
  8. using Wheel.Services.FileStorageManage.Dtos;
  9. using Path = System.IO.Path;
  11. namespace Wheel.Services.FileStorageManage
  12. {
  13.     public class FileStorageManageAppService : WheelServiceBase, IFileStorageManageAppService
  14.     {
  15.         private readonly IBasicRepository<FileStorage, long> _fileStorageRepository;
  17.         public FileStorageManageAppService(IBasicRepository<FileStorage, long> fileStorageRepository)
  18.         {
  19.             _fileStorageRepository = fileStorageRepository;
  20.         }
  22.         public async Task<Page<FileStorageDto>> GetFileStoragePageList(FileStoragePageRequest request)
  23.         {
  24.             var (items, total) = await _fileStorageRepository.GetPageListAsync(
  25.                 _fileStorageRepository.BuildPredicate(
  26.                     (!string.IsNullOrWhiteSpace(request.FileName), f => f.FileName.Contains(request.FileName!)),
  27.                     (!string.IsNullOrWhiteSpace(request.ContentType), f => f.ContentType.Equals(request.ContentType)),
  28.                     (!string.IsNullOrWhiteSpace(request.Path), f => f.Path.StartsWith(request.Path!)),
  29.                     (!string.IsNullOrWhiteSpace(request.Provider), f => f.Provider.Equals(request.Provider)),
  30.                     (request.FileStorageType.HasValue, f => f.FileStorageType.Equals(request.FileStorageType))
  31.                     ),
  32.                 (request.PageIndex -1) * request.PageSize,
  33.                 request.PageSize,
  34.                 request.OrderBy
  35.                 );
  37.             return new Page<FileStorageDto>(Mapper.Map<List<FileStorageDto>>(items), total);
  38.         }
  39.         public async Task<R<List<FileStorageDto>>> UploadFiles(UploadFileDto uploadFileDto)
  40.         {
  41.             var files = uploadFileDto.Files;
  42.             if (files.Count == 0)
  43.                 return new R<List<FileStorageDto>>(new());
  44.             IFileStorageProvider? fileStorageProvider = null;
  45.             var fileStorageProviders = ServiceProvider.GetServices<IFileStorageProvider>();
  46.             if (string.IsNullOrWhiteSpace(uploadFileDto.Provider))
  47.             {
  48.                 fileStorageProvider = fileStorageProviders.First();
  49.             }
  50.             else
  51.             {
  52.                 fileStorageProvider = fileStorageProviders.First(a => a.Name == uploadFileDto.Provider);
  53.             }
  54.             var fileStorages = new List<FileStorage>();
  55.             foreach (var file in files) 
  56.             {
  57.                 var fileName = uploadFileDto.Cover ? file.FileName : $"{Path.GetFileNameWithoutExtension(file.FileName)}-{SnowflakeIdGenerator.Create()}{Path.GetExtension(file.FileName)}";
  58.                 var fileStream = file.OpenReadStream();
  59.                 var fileStorageType = FileStorageTypeChecker.CheckFileType(file.ContentType);
  60.                 var uploadFileArgs = new UploadFileArgs 
  61.                 {
  62.                     BucketName = fileStorageType switch
  63.                     {
  64.                         FileStorageType.Image => "images",
  65.                         FileStorageType.Video => "videos",
  66.                         FileStorageType.Audio => "audios",
  67.                         FileStorageType.Text => "texts",
  68.                         _ => "files"
  69.                     },
  70.                     ContentType = file.ContentType,
  71.                     FileName = fileName,
  72.                     FileStream = fileStream
  73.                 };
  74.                 var uploadFileResult = await fileStorageProvider.Upload(uploadFileArgs);
  76.                 if (uploadFileResult.Success)
  77.                 {
  78.                     var fileStorage = await _fileStorageRepository.InsertAsync(new FileStorage 
  79.                     {
  80.                         Id = SnowflakeIdGenerator.Create(),
  81.                         ContentType = file.ContentType,
  82.                         FileName = file.FileName,
  83.                         FileStorageType = fileStorageType,
  84.                         Path = uploadFileResult.FilePath,
  85.                         Provider = fileStorageProvider.Name,
  86.                         Size = fileStream.Length
  87.                     });
  88.                     await _fileStorageRepository.SaveChangeAsync();
  89.                     fileStorages.Add(fileStorage);
  90.                 }
  91.             }
  92.             return new R<List<FileStorageDto>>(Mapper.Map<List<FileStorageDto>>(fileStorages));
  93.         }
  95.         public async Task<R<DownloadFileResonse>> DownloadFile(long id)
  96.         {
  97.             var fileStorage = await _fileStorageRepository.FindAsync(id);
  98.             if(fileStorage == null) 
  99.             {
  100.                 throw new BusinessException(ErrorCode.FileNotExist, "FileNotExist")
  101.                     .WithMessageDataData(id.ToString());
  102.             }
  103.             var fileStorageProvider = ServiceProvider.GetServices<IFileStorageProvider>().First(a=>a.Name == fileStorage.Provider);
  105.             var downloadResult = await fileStorageProvider.Download(new DownloadFileArgs { Path = fileStorage.Path });
  106.             if (downloadResult.Success)
  107.             {
  108.                 return new R<DownloadFileResonse>(new DownloadFileResonse { ContentType = downloadResult.ContentType, FileName = downloadResult.FileName, Stream = downloadResult.Stream });
  109.             }
  110.             else
  111.             {
  112.                 throw new BusinessException(ErrorCode.FileDownloadFail, "FileDownloadFail")
  113.                     .WithMessageDataData(id.ToString());
  114.             }
  115.         }
  116.     }
  117. }

UploadFiles时如果没有指定Provider则默认取依赖注入第一个Provider，如果指定则取Provider。

  1. using Microsoft.AspNetCore.Mvc;
  3. namespace Wheel.Services.FileStorageManage.Dtos
  4. {
  5.     public class UploadFileDto
  6.     {
  7.         [FromQuery]
  8.         public bool Cover { get; set; } = false;
  10.         [FromQuery]
  11.         public string? Provider { get; set; }
  13.         [FromForm]
  14.         public IFormFileCollection Files { get; set; }
  15.     }
  16. }

这里上传参数定义，Cover表示是否覆盖原文件，Provider表示指定那种存储服务。Files则是从Form表单中读取文件流。

FileController

接下来就是把Service包成API对外。

  1. using Microsoft.AspNetCore.Mvc;
  2. using Wheel.Core.Dto;
  3. using Wheel.Services.FileStorageManage;
  4. using Wheel.Services.FileStorageManage.Dtos;
  6. namespace Wheel.Controllers
  7. {
  8.     /// <summary>
  9.     /// 文件管理
  10.     /// </summary>
  11.     [Route("api/[controller]")]
  12.     [ApiController]
  13.     public class FileController : WheelControllerBase
  14.     {
  15.         private readonly IFileStorageManageAppService _fileStorageManageAppService;
  17.         public FileController(IFileStorageManageAppService fileStorageManageAppService)
  18.         {
  19.             _fileStorageManageAppService = fileStorageManageAppService;
  20.         }
  21.         /// <summary>
  22.         /// 分页查询列表
  23.         /// </summary>
  24.         /// <param name="request"></param>
  25.         /// <returns></returns>
  26.         [HttpGet]
  27.         public Task<Page<FileStorageDto>> GetFileStoragePageList([FromQuery] FileStoragePageRequest request)
  28.         {
  29.             return _fileStorageManageAppService.GetFileStoragePageList(request);
  30.         }
  31.         /// <summary>
  32.         /// 上传文件
  33.         /// </summary>
  34.         /// <param name="uploadFileDto"></param>
  35.         /// <returns></returns>
  36.         [HttpPost]
  37.         public Task<R<List<FileStorageDto>>> UploadFiles(UploadFileDto uploadFileDto)
  38.         {
  39.             return _fileStorageManageAppService.UploadFiles(uploadFileDto);
  40.         }
  41.         /// <summary>
  42.         /// 下载文件
  43.         /// </summary>
  44.         /// <param name="id"></param>
  45.         /// <returns></returns>
  46.         [HttpGet("{id}")]
  47.         public async Task<IActionResult> DownloadFile(long id)
  48.         {
  49.             var result = await _fileStorageManageAppService.DownloadFile(id);
  50.             return File(result.Data.Stream, result.Data.ContentType, result.Data.FileName);
  51.         }
  52.     }
  53. }

DownloadFile返回一个FileResult，浏览器会自动下载。

测试

这里我使用本地的Minio服务进行测试。
查询
image.png
上传
image.png
可以看到我们FileName和Path不一样，默认不覆盖的情况，所有文件在后面自动拼接雪花Id。
下载文件
image.png
这里swagger可以看到有个Download file，点击即可下载出来
image.png
image.png

测试顺利完成，到这我们就完成了我们简单的文件管理功能了。

轮子仓库地址https://github.com/Wheel-Framework/Wheel
欢迎进群催更。

image.png

原文链接：https://www.cnblogs.com/fanshaoO/p/17781914.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

职业生涯热门文章

  • 读哪些书可以提高思维逻辑和语言表达能力？
  • 一篇为你解读商业模式的文章
  • 2019 上半年软件设计师真题及参考答案
  • 我在华为OD的275天
  • Unity 基于 WebRTC 的云功能
  • 那些自律到极致的人，都拥有了开挂的人生
  • 那些拼命加班的程序员们，后来都怎么样了？
  • ssm整合各配置文件
  • 如何提升你在职场中的洞察力？
  • 堪比慢性自杀的习惯它排第一 你中招了吗？

    • 职业生涯推荐文章

  • 好的职场关系，都是有条件的
  • 如何有效管理高敏感的员工？
  • 记录兼职运维的一天
  • 老弟想自己做个微信，被我一个问题劝退了。。
  • 数据库与我：一段关于学习与成长的深情回顾
  • 激活员工，别讲大道理
  • 我可以写代码写到退休吗？记录我的10年前端技术之旅
  • 裸辞后，我成为全职占星师
  • 如何做笔记？
  • 我的自白书之简历

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号