【网课平台】Day3.网关与分布式文件系统

迷南。 2023-10-08 22:08 12阅读 0赞

#### 文章目录 ####

*  一 、媒资模块环境搭建
 *   *  1、 网关gateway
     *  2、Nacos
     *  3、搭建gateway
 *  二、分布式文件系统
 *   *  2.1 文件系统
     *  2.2 分布式文件系统
     *  2.3 MinIO
 *  四、上传图片
 *   *  4.1 需求分析
     *  4.2 数据模型与环境配置
     *  4.3 接口定义
     *  4.4 开发mapper层
     *  4.5 开发service层
     *  4.6 完善controller层
     *  4.7 Service层事务优化

## 一 、媒资模块环境搭建 ##

### 1、 网关gateway ###

接下来是媒资管理服务，目前为止共三个微服务：内容管理、系统管理、媒资管理:

![在这里插入图片描述][9837d87937da4b4b8e2d487b85785c94.png]  
如此,前端得知道每个微服务实例的地址和端口, 且这样写死IP, 维护也不方便:

![在这里插入图片描述][d13962e367574e0d9d7b1c533bd92d3b.png]  
考虑引入网关, (复习下网关的几个作用:

*  身份认证和权限校验
 *  服务路由和负载均衡
 *  请求限流

![在这里插入图片描述][869bef235e8c4f13a2d08b9f29f9a928.png]  
如此 , 请求统一到网关,有由网关路由到不同的微服务上, 网关在这儿有点像400电话, 根据不同的需求转接电话到不同的业务员 . 这样, 前端代码中只需要写接口的相对路径:  
![在这里插入图片描述][84bfdd8a51314a298c889e33adc582a9.png]

### 2、Nacos ###

> **2.1 认识Nacos**

网关想请求路由, 就必须知道每个微服务实例的地址，项目使用Nacos作用`服务发现中心和配置中心`:  
![在这里插入图片描述][3f9856fc8ec04b768874ef5714045569.png]

流程如下:

*  微服务启动, 将自己的信息注册到Nacos, Nacos记录各个微服务的地址
 *  网关从Nacos读取服务列表, 包括服务名称和服务地址
 *  请求到达网关, 网关将请求路由到具体的微服务

由此也可以看到Nacos的两个作用:

*  服务发现中心 : 微服务`将自身信息注册登记至Nacos，网关从Nacos获取微服务列表`
 *  服务配置中心 : 微服务众多, 配置信息复杂 , `微服务的配置信息统一在Nacos配置`

Nacos中的两个概念:

*  namespace：用于区分环境、比如：开发环境、测试环境、生产环境  
    ![在这里插入图片描述][e1a167b1cd5d40209f62562d9490f964.png]
 *  group：用于区分项目，比如：xuecheng-plus项目、xuecheng2.0项目

> **2.2 实现服务的发现**

*  先在一级父工程的pom文件添加Spring Cloud Alibaba的依赖

<dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-alibaba-dependencies</artifactId>
        <version>${spring-cloud-alibaba.version}</version>
        <type>pom</type>
        <scope>import</scope>
    </dependency>

*  在需要注册的模块的pom文件中添加nacos的服务发现和配置文件依赖

<dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    </dependency>

<dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
    </dependency>

*  在需要注册的模块的bookstrap.yml中添加信息:

spring:
      application:
        name: de-system  # 应用名称
      cloud:
        nacos:
          server-addr: localhost:8848
          discovery:
            namespace: develop
            group: DEFAULT_GROUP

*  重启服务,查看nacos, 可以看到注册成功,以及该服务实例的IP和端口等信息  
    ![在这里插入图片描述][2ab1cf0d52d4436aae1e1ac5c0963b72.png]

> **2.3 配置中心**

通过nacos来管理微服务的相关配置, 配置中有每个微服务独有的, 如:spring.application.name, 也有公共的信息, 如mysql、redis , nacos定位一个具体的配置文件通过：`namespace、group、dataid.`

*  通过namespace、group找到具体的环境和具体的项目
 *  通过dataid找到具体的配置文件

dataid有三部分组成, 如content-service-dev.yaml配置文件:

*  第一部分是配置的应用名，即`spring.application.name`的值
 *  第二部分是环境名, 由`spring.profiles.active`指定
 *  第三部分即后缀名, nacos支持properties、`yaml`

启动项目中传入spring.profiles.active的参数决定引用哪个环境的配置文件，例如：传入spring.profiles.active=dev表示使用dev环境的配置文件即content-service-dev.yaml

--------------------

这里以content-service工程为例进行配置:

*  点击新建  
    ![在这里插入图片描述][813f8db4e3d4499ab4f0aeda57ee3555.png]
 *  输入dataid、group、以及配置内容:  
    ![在这里插入图片描述][f5a43b1de11c43439911b55bc7a7157c.png]
 *  点击发布

/spring.application.name等不在nacos中配置，而是要在工程的本地进行配置
    /因为nacos客户端要根据此值确定配置文件名称
    
    spring:
      application:
        name: content-service
      cloud:
        nacos:
          server-addr: 192.168.101.65:8848
          discovery:  # 服务注册
            namespace: dev
            group: xuecheng-plus-project
          config: # 配置文件相关
            namespace: dev
            group: xuecheng-plus-project
            file-extension: yaml
            refresh-enabled: true
    
    #profiles默认为dev
      profiles:
        active: dev

nacos提供了`shared-configs`可以引入公用配置 :

*  定义公用配置:  
    ![在这里插入图片描述][4fe819be5fd94ef7ae865fc3dd0b76f7.png]
 *  在工程本地配置中引入公用配置:

...
    		shared-configs:
              - data-id: swagger-${
        spring.profiles.active}.yaml
                group: xuecheng-plus-common
                refresh: true
    ...

> **2.4 配置优先级**

到此 , 微服务的配置统一在nacos进行配置，用到的配置文件有**本地的配置文件 bootstrap.yaml和nacos上的配置文件** , 服务启动的时候, SpringBoot读取配置文件的顺序如下:  
![在这里插入图片描述][5b9216ccfff34d12bc67282c384717d2.png]  
微服务引入配置文件的形式有:

*  以项目应用名方式引入
 *  以扩展配置文件方式引入
 *  以共享配置文件 方式引入
 *  本地配置文件

当配置有冲突的时候, 优先级：`项目应用名配置文件 > 扩展配置文件 > 共享配置文件 > 本地配置文件。`想要让本地配置文件优先级最高,可在Nacos中添加:

#配置本地优先
    spring:
     cloud:
      config:
        override-none: true

### 3、搭建gateway ###

*  创建一个工程:  
    ![在这里插入图片描述][ff062b6eadb149c5b1a5775d18199225.png]
 *  在pom文件中引入相关依赖

<dependencies>
    
        
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-gateway</artifactId>
        </dependency>
    
        
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-logging</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    
        
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-log4j2</artifactId>
        </dependency>
    
    
    </dependencies>

*  配置网关的bootstrap.yaml配置文件

#微服务配置
    spring:
      application:
        name: gateway
      profiles:
        active: dev
      cloud:
        nacos:
          # 服务注册地址
          server-addr: localhost:8848
          discovery:
            namespace: dev
            group: DEFAULT_GROUP
          config:
            # 配置中心地址
            server-addr: localhost:8848
            namespace: dev
            group: DEFAULT_GROUP
            # 配置文件格式
            file-extension: yaml
            refresh-enabled: true
            # 共享配置
            shared-configs:
              - data-id: application-${
        spring.profiles.active}.yaml
                group: DEFAULT_GROUP
                refresh: true

*  `在nacos上配置网关路由策略`

server:
      port: 63010 # 网关端口
    spring:
      cloud:
        gateway:
    #      filter:
    #        strip-prefix:
    #          enabled: true
          routes: # 网关路由配置
            - id: content-api # 路由id，自定义，只要唯一即可
              # uri: http://127.0.0.1:8081 # 路由的目标地址 http就是固定地址
              uri: lb://content-api # 路由的目标地址 lb就是负载均衡，后面跟服务名称
              predicates: # 路由断言，也就是判断请求是否符合路由规则的条件
                - Path=/content/** # 这个是按照路径匹配，只要以/content/开头就符合要求
    #          filters:
    #            - StripPrefix=1
            - id: system-api
              # uri: http://127.0.0.1:8081
              uri: lb://system-api
              predicates:
                - Path=/system/**
    #          filters:
    #            - StripPrefix=1
            - id: media-api
              # uri: http://127.0.0.1:8081
              uri: lb://media-api
              predicates:
                - Path=/media/**
    #          filters:
    #            - StripPrefix=1
    
    # 不校验白名单
    ignore:
      whites:
        - /auth/logout

*  启动网关工程, 在http-client-env.json中配置网关的地址  
    ![在这里插入图片描述][2b105a0d77fb419aadf36331967bbf77.png]

## 二、分布式文件系统 ##

### 2.1 文件系统 ###

操作系统通过文件系统提供的接口取存取文件,用户则通过操作系统来访问磁盘上的文件:

![在这里插入图片描述][8951462b85bd4879856d30c5449b51bf.png]  
常见的文件系统：FAT16/FAT32、NTFS、HFS、UFS、APFS、XFS、Ext4等. 看一下我Windos使用的文件系统:

![在这里插入图片描述][8a91c7631239405c896cd71d1dba7456.png]

### 2.2 分布式文件系统 ###

官话:  
![在这里插入图片描述][5a49461871a94d6ab3e25f2a153c19f3.png]

直白的说: 一台计算机无法去进行海量文件的存储和响应海量用户的请求, 因此通过网络将若干计算机组织起来共同去完成这个任务

![在这里插入图片描述][b49ba92d1a6145c69082731cfbbdb5f0.png]  
这样的好处有:

*  一台计算机的文件系统处理能力扩充到多台计算机同时处理
 *  一台计算机挂了还有另外副本计算机提供数据
 *  每台计算机可以放在不同的地域，这样用户就可以就近访问，提高访问速度

市面上分布式文件系统的相关产品有: NFS、GFS、HDFS:

NFS:

![在这里插入图片描述][0837b7d39ddd4c19825f43146986c11a.png]  
网络文件系统, 客户端通过网络访问NFS服务器的硬盘

![在这里插入图片描述][a13d3a4536d24e0392e2f2cbd49246a9.png]

GFS:

![在这里插入图片描述][de050b4248b64beda6d6989df07782ec.png]

*  GFS采用主从结构，一个GFS集群由一个master和大量的chunkserver组成
 *  master存储了数据文件的元数据，如大小名称类型, 一个文件被分成了若干块存储在多个chunkserver中
 *  用户从master中获取数据元信息，向chunkserver存储数据

![在这里插入图片描述][d44b423ee400405fb15631ff8ee2f871.png]

HDFS:

![在这里插入图片描述][237adc8bd40d4e1bac48ec7e27258513.png]

*  HDFS采用主从结构，一个HDFS集群由一个名称结点和若干数据结点组成
 *  名称结点存储数据的元信息，一个完整的数据文件分成若干块存储在数据结点
 *  客户端从名称结点获取数据的元信息及数据分块的信息，得到信息客户端即可从数据块来存取数据

![在这里插入图片描述][876c8216f1a04bbfa48fd67bfc5b170b.png]

云计算厂家:

*  阿里云对象存储服务OOS  
    ![在这里插入图片描述][831d14573c4647279bbda6a512d88133.png]
 *  百度对象存储BOS

在实际项目中, 根据场景来进行技术选型

### 2.3 MinIO ###

> **认识MinIO**

*  MinIO适合于存储大容量非结构化的数据, 提供了 Java、Python、GO等多版本SDK支持
 *  MinIO集群采用去中心化共享架构，每个结点是对等关系，通过Nginx可对MinIO进行负载均衡访问  
    ![在这里插入图片描述][a1d941e6cef2421ab7fda0fca76ef24e.png]
 *  将数据**分块冗余**的分散存储在各各节点的磁盘上，所有的可用磁盘组成一个集合
 *  当上传一个文件时通过纠删码算法对文件进行分块，文件本身分成4个数据块，还会生成4个校验块，数据块和校验块会分散的存储在这8块硬盘上
 *  使用纠删码的好处是不超过一半数量（N/2）的硬盘损坏时，仍然可以恢复数据

> **使用**

*  下载

链接: https://pan.baidu.com/s/16x9K1j1XPxCHKzqWRmh-mw?pwd=9527 
    提取码: 9527 复制这段内容后打开百度网盘手机App，操作更方便哦

*  启动

在exe文件的目录下打开DOS窗口:
    minio.exe server xx xx xx

![在这里插入图片描述][da031d1e35214caba048c63df319344b.png]

*  登录  
    http://localhost:9000进行登录，账号和密码为：minioadmin/minioadmin  
    ![在这里插入图片描述][87f67ee86d1544a4ab35aeb12769f236.png]
 *  创建桶bucket, 相当于存储文件的目录，可以创建若干的桶  
    ![在这里插入图片描述][7a34d599dfdd4a0b8f22c611d467afad.png]
 *  点击upload上传文件, 观察分块存储的效果  
    ![在这里插入图片描述][f0de6ea403bb46fa8a56f69a285f9f6d.png]

> **MinIO与Java**

MinIO提供多个语言版本SDK的支持, Java相关的文档[https://docs.min.io/docs/java-client-quickstart-guide.html][https_docs.min.io_docs_java-client-quickstart-guide.html]

*  添加Maven依赖

<dependency>
        <groupId>io.minio</groupId>
        <artifactId>minio</artifactId>
        <version>8.4.3</version>
    </dependency>
    <dependency>
        <groupId>com.squareup.okhttp3</groupId>
        <artifactId>okhttp</artifactId>
        <version>4.8.1</version>
    </dependency>

*  设置bucket的权限为public  
    ![在这里插入图片描述][bfd2c682e04b4a99804eaf581636658a.png]  
    ![在这里插入图片描述][c556e7b0291f4710a0b81916d804fa51.png]
 *  官方示例程序

import io.minio.BucketExistsArgs;
    import io.minio.MakeBucketArgs;
    import io.minio.MinioClient;
    import io.minio.UploadObjectArgs;
    import io.minio.errors.MinioException;
    import java.io.IOException;
    import java.security.InvalidKeyException;
    import java.security.NoSuchAlgorithmException;
    public class FileUploader {
        
      public static void main(String[] args)throws IOException, NoSuchAlgorithmException, InvalidKeyException {
        
        try {
        
          // Create a minioClient with the MinIO server playground, its access key and secret key.
          MinioClient minioClient =
              MinioClient.builder()
                  .endpoint("https://play.min.io")
                  .credentials("Q3AM3UQ867SPQQA43P2F", "zuf+tfteSlswRu7BJ86wekitnifILbZam1KYY3TG")
                  .build();
          // Make 'asiatrip' bucket if not exist.
          boolean found =
              minioClient.bucketExists(BucketExistsArgs.builder().bucket("asiatrip").build());
          if (!found) {
        
            // Make a new bucket called 'asiatrip'.
            minioClient.makeBucket(MakeBucketArgs.builder().bucket("asiatrip").build());
          } else {
        
            System.out.println("Bucket 'asiatrip' already exists.");
          }
          // Upload '/home/user/Photos/asiaphotos.zip' as object name 'asiaphotos-2015.zip' to bucket
          // 'asiatrip'.
          minioClient.uploadObject(
              UploadObjectArgs.builder()
                  .bucket("asiatrip")
                  .object("asiaphotos-2015.zip")
                  .filename("/home/user/Photos/asiaphotos.zip")
                  .build());
          System.out.println(
              "'/home/user/Photos/asiaphotos.zip' is successfully uploaded as "
                  + "object 'asiaphotos-2015.zip' to bucket 'asiatrip'.");
        } catch (MinioException e) {
        
          System.out.println("Error occurred: " + e);
          System.out.println("HTTP trace: " + e.httpTrace());
        }
      }
    }

*  测试向MinIO上传文件

public class MinioTest {
        
    
        static MinioClient minioClient =
                MinioClient.builder()
                        .endpoint("http://192.168.101.65:9000")
                        .credentials("minioadmin", "minioadmin")
                        .build();
    
       //上传文件
        @Test
        public  void upload() {
        
            try {
        
                UploadObjectArgs testbucket = UploadObjectArgs.builder()
                        .bucket("testbucket")
                        //这样是上传在根目录
                        //.object("test001.mp4")
                        .object("001/test001.mp4")//指定子目录
                        .filename("D:\\develop\\upload\\1mp4.temp")
                        .contentType("video/mp4")//默认根据扩展名确定文件内容类型，也可以指定
                        .build();
                minioClient.uploadObject(testbucket);
                System.out.println("上传成功");
            } catch (Exception e) {
        
                e.printStackTrace();
                System.out.println("上传失败");
            }
    
        }
    
    }

其中contentType可以通过com.j256.simplemagic.ContentType枚举类查看常用的mimeType（媒体类型）,下面通过扩展名得到mimeType:

@Test
    public  void upload() {
        
        //根据扩展名取出mimeType
        ContentInfo extensionMatch = ContentInfoUtil.findExtensionMatch(".mp4");
        String mimeType = MediaType.APPLICATION_OCTET_STREAM_VALUE;//通用mimeType，字节流
        if(extensionMatch!=null){
        
            mimeType = extensionMatch.getMimeType();
        }
        try {
        
            UploadObjectArgs testbucket = UploadObjectArgs.builder()
                    .bucket("testbucket")
    				//.object("test001.mp4")
                    .object("001/test001.mp4")//添加子目录
                    .filename("D:\\develop\\upload\\1mp4.temp")
                    .contentType(mimeType)//直接传入获取到的值
                    .build();
            minioClient.uploadObject(testbucket);
            System.out.println("上传成功");
        } catch (Exception e) {
        
            e.printStackTrace();
            System.out.println("上传失败");
        }
    
    }

*  测试删除文件

@Test
    public void delete(){
        
        try {
        
            minioClient.removeObject(
                   RemoveObjectArgs.builder().bucket("testbucket").object("001/test001.mp4").build());
            System.out.println("删除成功");
        } catch (Exception e) {
        
           e.printStackTrace();
            System.out.println("删除失败");
        }
    }

*  测试下载

@Test
    public void getFile() {
        
        GetObjectArgs getObjectArgs = GetObjectArgs.builder().bucket("testbucket").object("test001.mp4").build();
        try(
            FilterInputStream inputStream = minioClient.getObject(getObjectArgs);
            //设置本地位置,创建输出流
            FileOutputStream outputStream = new FileOutputStream(new File("D:\\develop\\upload\\1_2.mp4"));
         ) {
        
         	//流拷贝
            IOUtils.copy(inputStream,outputStream);
         } catch (Exception e) {
        
            e.printStackTrace();
         }
    }

校验文件的完整性，对文件计算出md5值，比较原始文件的md5和目标文件的md5 ,注意这里, 别用上面代码中的inputStream, 它在这里受网络影响, 可能有偏差

//校验文件的完整性对文件的内容进行md5
    FileInputStream fileInputStream1 = new FileInputStream(new File("D:\\develop\\upload\\1.mp4"));
    String source_md5 = DigestUtils.md5Hex(fileInputStream1);
    
    FileInputStream fileInputStream = new FileInputStream(new File("D:\\develop\\upload\\1a.mp4"));
    String local_md5 = DigestUtils.md5Hex(fileInputStream);
    
    if(source_md5.equals(local_md5)){
        
        System.out.println("下载成功");
    }

## 四、上传图片 ##

### 4.1 需求分析 ###

![在这里插入图片描述][56163f012af34239b07fd7cd50e6702a.png]

整个上传过程有两点:

*  点击上传课程图片, 前端请求媒资管理服务将文件上传至分布式文件系统，并`且在媒资管理数据库保存文件信息`
 *  上传图片成功保存图片地址到课程基本信息表中

![在这里插入图片描述][3d0996605a3346c39e30750190ff072c.png]

### 4.2 数据模型与环境配置 ###

> 数据模型

![在这里插入图片描述][f6a6b043a6da4ecfaef656554646a8f8.png]  
其中有字段md5值的字段, 用来判断文件是否已经上传过, 有相同文件,可不用重复上传, 以提高效率

> Nacos配置

*  在nacos配置中minio的相关信息，进入media-service-dev.yaml:

minio:
      endpoint: http://localhost:9000
      accessKey: minioadmin
      secretKey: minioadmin
      bucket:
        files: mediafiles
        videofiles: video

*  在media-service工程编写minio的配置类：

@Configuration
    public class MinioConfig {
        
    
    //加@Configuration后从nacos中拿信息
     @Value("${minio.endpoint}")
     private String endpoint;
     @Value("${minio.accessKey}")
     private String accessKey;
     @Value("${minio.secretKey}")
     private String secretKey;
    
    
    //创建minioClient的bean,方便以后注入
     @Bean
     public MinioClient minioClient() {
        
    
      MinioClient minioClient =
              MinioClient.builder()
                      .endpoint(endpoint)
                      .credentials(accessKey, secretKey)
                      .build();
      return minioClient;
     }
    }

### 4.3 接口定义 ###

*  请求地址: /media/upload/coursefile
 *  请求内容: `Content-Type: multipart/form-data;`  
    form-data; name=“filedata”; filename=“具体的文件名称”
 *  响应:

{
        
      "id": "a16da7a132559daf9e1193166b3e7f52",
      "companyId": 1232141425,
      "companyName": null,
      "filename": "1.jpg",
      "fileType": "001001",
      "tags": "",
      "bucket": "/testbucket/2022/09/12/a16da7a132559daf9e1193166b3e7f52.jpg",
      "fileId": "a16da7a132559daf9e1193166b3e7f52",
      "url": "/testbucket/2022/09/12/a16da7a132559daf9e1193166b3e7f52.jpg",
      "timelength": null,
      "username": null,
      "createDate": "2022-09-12T21:57:18",
      "changeDate": null,
      "status": "1",
      "remark": "",
      "auditStatus": null,
      "auditMind": null,
      "fileSize": 248329
    }

*  定义vo类

@Data
    public class UploadFileResultVo extends MediaFiles {
        
      
    
    }
    //注意这里虽然前端要求返回的字段和表对应的po一样
    //但别直接用po,万一以后前端要求少返回一个字段, 你又不能动po

*  定义接口

@ApiOperation("上传文件")
    @RequestMapping(value = "/upload/coursefile", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
    public UploadFileResultDto upload(@RequestPart("filedata") MultipartFile upload) throws IOException {
        
    
        return null;
    }

### 4.4 开发mapper层 ###

最后是向media\_files表插入一条记录，使用media\_files表生成的mapper即可

### 4.5 开发service层 ###

定义上传文件的Dto,即从前端能拿到的数据:

/**
     * @description 上传普通文件请求参数Dto
     */
     @Data
    public class UploadFileParamsDto {
        
    
     /** 文件名称*/
     private String filename;
     /** 文件类型（文档，音频，视频）*/
     private String fileType;
     /**文件大小*/
     private Long fileSize;
    
     /**标签*/
     private String tags;
    
     /**上传人*/
     private String username;
    
     /**备注*/
     private String remark;
    
    }

定义接口中的方法:

/**
     * 上传文件
     * @param companyId 机构id
     * @param uploadFileParamsDto 上传文件信息
     * @param localFilePath 文件磁盘路径
     * @return 文件信息
     */
    public UploadFileResultDto uploadFile(Long companyId, UploadFileParamsDto uploadFileParamsDto, String localFilePath);

写service方法的实现类:

@Autowired
    MinioClient minioClient;
    
    @Autowired
    MediaFilesMapper mediaFilesMapper;
    
    //普通文件桶
    @Value("${minio.bucket.files}")
    private String bucket_Files;
    
    
    //获取文件默认存储目录路径 年/月/日
    private String getDefaultFolderPath() {
        
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        String folder = sdf.format(new Date()).replace("-", "/")+"/";
        return folder;
    }
    
    //获取文件的md5
    private String getFileMd5(File file) {
        
        try (FileInputStream fileInputStream = new FileInputStream(file)) {
        
            String fileMd5 = DigestUtils.md5Hex(fileInputStream);
            return fileMd5;
        } catch (Exception e) {
        
            e.printStackTrace();
            return null;
        }
    }
    
    
    private String getMimeType(String extension){
        
        if(extension==null)
            extension = "";
        //根据扩展名取出mimeType
        ContentInfo extensionMatch = ContentInfoUtil.findExtensionMatch(extension);
        //通用mimeType，字节流
        String mimeType = MediaType.APPLICATION_OCTET_STREAM_VALUE;
        if(extensionMatch!=null){
        
            mimeType = extensionMatch.getMimeType();
        }
        return mimeType;
    }
    /**
     * @description 将文件写入minIO
     * @param localFilePath  文件地址
     * @param bucket  桶
     * @param objectName 对象名称
     * @return void
     * @author Mr.M
     * @date 2022/10/12 21:22
     */
    public boolean addMediaFilesToMinIO(String localFilePath,String mimeType,String bucket, String objectName) {
        
        try {
        
            UploadObjectArgs testbucket = UploadObjectArgs.builder()
                    .bucket(bucket)
                    .object(objectName)
                    .filename(localFilePath)
                    .contentType(mimeType)
                    .build();
            minioClient.uploadObject(testbucket);
            log.debug("上传文件到minio成功,bucket:{},objectName:{}",bucket,objectName);
            System.out.println("上传成功");
            return true;
        } catch (Exception e) {
        
            e.printStackTrace();
            log.error("上传文件到minio出错,bucket:{},objectName:{},错误原因:{}",bucket,objectName,e.getMessage(),e);
            XueChengPlusException.cast("上传文件到文件系统失败");
        }
        return false;
    }
    
    /**
     * @description 将文件信息添加到文件表
     * @param companyId  机构id
     * @param fileMd5  文件md5值
     * @param uploadFileParamsDto  上传文件的信息
     * @param bucket  桶
     * @param objectName 对象名称
     * @return com.xuecheng.media.model.po.MediaFiles
     */
    @Transactional
    public MediaFiles addMediaFilesToDb(Long companyId,String fileMd5,UploadFileParamsDto uploadFileParamsDto,String bucket,String objectName){
        
        //从数据库查询文件
        MediaFiles mediaFiles = mediaFilesMapper.selectById(fileMd5);
        //无重复md5, 开始插入
        if (mediaFiles == null) {
        
            mediaFiles = new MediaFiles();
            //拷贝基本信息
            BeanUtils.copyProperties(uploadFileParamsDto, mediaFiles);
            mediaFiles.setId(fileMd5);
            mediaFiles.setFileId(fileMd5);
            mediaFiles.setCompanyId(companyId);
            mediaFiles.setUrl("/" + bucket + "/" + objectName);
            mediaFiles.setBucket(bucket);
            mediaFiles.setFilePath(objectName);
            mediaFiles.setCreateDate(LocalDateTime.now());
            mediaFiles.setAuditStatus("002003");
            mediaFiles.setStatus("1");
            //保存文件信息到文件表
            int insert = mediaFilesMapper.insert(mediaFiles);
            if (insert < 0) {
        
                log.error("保存文件信息到数据库失败,{}",mediaFiles.toString());
                XueChengPlusException.cast("保存文件信息失败");
            }
            log.debug("保存文件信息到数据库成功,{}",mediaFiles.toString());
    
        }
        return mediaFiles;
    
    }
    @Transactional
    @Override
    public UploadFileResultVo uploadFile(Long companyId, UploadFileParamsDto uploadFileParamsDto, String localFilePath) {
        
        File file = new File(localFilePath);
        if (!file.exists()) {
        
            XueChengPlusException.cast("文件不存在");
        }
        //文件名称
        String filename = uploadFileParamsDto.getFilename();
        //文件扩展名
        String extension = filename.substring(filename.lastIndexOf("."));
        //文件mimeType
        String mimeType = getMimeType(extension);
        //文件的md5值
        String fileMd5 = getFileMd5(file);
        //文件的默认目录
        String defaultFolderPath = getDefaultFolderPath();
        //存储到minio中的对象名(带目录)
        String  objectName = defaultFolderPath + fileMd5 + exension;
        //将文件上传到minio
        boolean b = addMediaFilesToMinIO(localFilePath, mimeType, bucket_files, objectName);
        //文件大小
        uploadFileParamsDto.setFileSize(file.length());
        //将文件信息存储到数据库
        MediaFiles mediaFiles = addMediaFilesToDb(companyId, fileMd5, uploadFileParamsDto, bucket_files, objectName);
        //准备返回数据
        UploadFileResultVo uploadFileResultVo = new UploadFileResultVo();
        BeanUtils.copyProperties(mediaFiles, uploadFileResultVo);
        return uploadFileResultVo;
    
    }

注意这里的几个点:

*  对于`公共代码抽取成单独的方法`的习惯
 *  @Slf4j注解和 `log.error("上传文件到minio出错,bucket:{},objectName:{},错误原因:{}",bucket,objectName,e.getMessage(),e);`的使用
 *  使用日期当作各级目录, 使用md5值当作文件名
 *  使用@Value注解从Nacos配置文件中读值`@Value("${minio.bucket.files}")`

### 4.6 完善controller层 ###

@ApiOperation("上传文件")
    @RequestMapping(value = "/upload/coursefile",consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
    @ResponseBody
    public UploadFileResultVo upload(@RequestPart("filedata") MultipartFile upload,@RequestParam(value = "folder",required=false) String folder,@RequestParam(value = "objectName",required=false) String objectName) throws IOException {
        
    	//机构id暂时写死,还没加登录模块
        Long companyId = 1232141425L;
        UploadFileParamsDto uploadFileParamsDto = new UploadFileParamsDto();
        //文件大小
        uploadFileParamsDto.setFileSize(filedata.getSize());
        //图片
        uploadFileParamsDto.setFileType("001001");
        //文件名称
        uploadFileParamsDto.setFilename(filedata.getOriginalFilename());//文件名称
        //文件大小
        long fileSize = filedata.getSize();
        uploadFileParamsDto.setFileSize(fileSize);
        //创建临时文件
        File tempFile = File.createTempFile("minio", "temp");
        //上传的文件拷贝到临时文件
        filedata.transferTo(tempFile);
        //文件路径
        String absolutePath = tempFile.getAbsolutePath();
        //上传文件
        UploadFileResultDto uploadFileResultDto = mediaFileService.uploadFile(companyId, uploadFileParamsDto, absolutePath);
        
        return uploadFileResultDto;
    }

*  注意这里获取临时文件后拷贝上传文件到临时文件, 来获得文件路径
 *  `File tempFile = File.createTempFile("minio", "temp");`

### 4.7 Service层事务优化 ###

上面的代码中，给整个uploadFile文件开启事务（包括文件上传和文件信息入库），即调用uploadFile方法前会开启数据库事务，如果上传文件时间很长，此时数据库事务的持续时间就会很长，数据库链接释放慢，最后导致数据库链接不够用。优化为：只在addMediaFilesToDb方法添加事务控制即可。

@Transactional
    public MediaFiles addMediaFilesToDb(Long companyId,String fileMd5,UploadFileParamsDto uploadFileParamsDto,String bucket,String objectName){
        
    
    	...
    	int insert = mediaFilesMapper.insert(mediaFiles);
    	int a = 1/0; //模拟发生异常
    	....
    }

测试发现，事务控制失败。失败的原因是一个非事务方法调同类一个事务方法，事务无法控制。

--------------------

之前在uploadFile方法上添加@Transactional注解时：代理对象MediaFileServiceProxy会在方法执行前开启事务：  
![在这里插入图片描述][9c6f22b88460460582b2f91004394e7c.png]  
而@Transactional注解改到addMediaFilesToDb上后，controller再调uploadFile方法，则代理对象不再进行事务控制。

![在这里插入图片描述][b3ca09db816c480ab78b0b4b709c831a.png]  
判断该方法是否可以事务控制必须保证是通过代理对象调用此方法，且此方法上添加了@Transactional注解。现在事务注解在addMediaFilesToDb方法，在调用这个方法的地方打断点，debug看到调用这个同类中方法的对象（this）并不是代理对象：

![在这里插入图片描述][d455ff04fe9e4938b233b1b83df12269.png]

根据“事务控制必须保证是通过代理对象调用此方法，且此方法上添加了@Transactional注解”，在MediaFileService的实现类中注入MediaFileService的代理对象（自己注入自己）：

@Autowired
    MediaFileService currentProxy;

原uploadFile方法中对事务方法addMediaFilesToDb的调用改为：

.....
    //写入文件表
    MediaFiles mediaFiles = currentProxy.addMediaFilesToDb(companyId, fileMd5, uploadFileParamsDto, bucket_files, objectName);
     ....

关于非事务方法调用事务方法的另一种解决思路：[【方法2】][2]

[9837d87937da4b4b8e2d487b85785c94.png]: https://img-blog.csdnimg.cn/9837d87937da4b4b8e2d487b85785c94.png
[d13962e367574e0d9d7b1c533bd92d3b.png]: https://img-blog.csdnimg.cn/d13962e367574e0d9d7b1c533bd92d3b.png
[869bef235e8c4f13a2d08b9f29f9a928.png]: https://img-blog.csdnimg.cn/869bef235e8c4f13a2d08b9f29f9a928.png
[84bfdd8a51314a298c889e33adc582a9.png]: https://img-blog.csdnimg.cn/84bfdd8a51314a298c889e33adc582a9.png
[3f9856fc8ec04b768874ef5714045569.png]: https://img-blog.csdnimg.cn/3f9856fc8ec04b768874ef5714045569.png
[e1a167b1cd5d40209f62562d9490f964.png]: https://img-blog.csdnimg.cn/e1a167b1cd5d40209f62562d9490f964.png
[2ab1cf0d52d4436aae1e1ac5c0963b72.png]: https://img-blog.csdnimg.cn/2ab1cf0d52d4436aae1e1ac5c0963b72.png
[813f8db4e3d4499ab4f0aeda57ee3555.png]: https://img-blog.csdnimg.cn/813f8db4e3d4499ab4f0aeda57ee3555.png
[f5a43b1de11c43439911b55bc7a7157c.png]: https://img-blog.csdnimg.cn/f5a43b1de11c43439911b55bc7a7157c.png
[4fe819be5fd94ef7ae865fc3dd0b76f7.png]: https://img-blog.csdnimg.cn/4fe819be5fd94ef7ae865fc3dd0b76f7.png
[5b9216ccfff34d12bc67282c384717d2.png]: https://img-blog.csdnimg.cn/5b9216ccfff34d12bc67282c384717d2.png
[ff062b6eadb149c5b1a5775d18199225.png]: https://img-blog.csdnimg.cn/ff062b6eadb149c5b1a5775d18199225.png
[2b105a0d77fb419aadf36331967bbf77.png]: https://img-blog.csdnimg.cn/2b105a0d77fb419aadf36331967bbf77.png
[8951462b85bd4879856d30c5449b51bf.png]: https://img-blog.csdnimg.cn/8951462b85bd4879856d30c5449b51bf.png
[8a91c7631239405c896cd71d1dba7456.png]: https://img-blog.csdnimg.cn/8a91c7631239405c896cd71d1dba7456.png
[5a49461871a94d6ab3e25f2a153c19f3.png]: https://img-blog.csdnimg.cn/5a49461871a94d6ab3e25f2a153c19f3.png
[b49ba92d1a6145c69082731cfbbdb5f0.png]: https://img-blog.csdnimg.cn/b49ba92d1a6145c69082731cfbbdb5f0.png
[0837b7d39ddd4c19825f43146986c11a.png]: https://img-blog.csdnimg.cn/0837b7d39ddd4c19825f43146986c11a.png
[a13d3a4536d24e0392e2f2cbd49246a9.png]: https://img-blog.csdnimg.cn/a13d3a4536d24e0392e2f2cbd49246a9.png
[de050b4248b64beda6d6989df07782ec.png]: https://img-blog.csdnimg.cn/de050b4248b64beda6d6989df07782ec.png
[d44b423ee400405fb15631ff8ee2f871.png]: https://img-blog.csdnimg.cn/d44b423ee400405fb15631ff8ee2f871.png
[237adc8bd40d4e1bac48ec7e27258513.png]: https://img-blog.csdnimg.cn/237adc8bd40d4e1bac48ec7e27258513.png
[876c8216f1a04bbfa48fd67bfc5b170b.png]: https://img-blog.csdnimg.cn/876c8216f1a04bbfa48fd67bfc5b170b.png
[831d14573c4647279bbda6a512d88133.png]: https://img-blog.csdnimg.cn/831d14573c4647279bbda6a512d88133.png
[a1d941e6cef2421ab7fda0fca76ef24e.png]: https://img-blog.csdnimg.cn/a1d941e6cef2421ab7fda0fca76ef24e.png
[da031d1e35214caba048c63df319344b.png]: https://img-blog.csdnimg.cn/da031d1e35214caba048c63df319344b.png
[87f67ee86d1544a4ab35aeb12769f236.png]: https://img-blog.csdnimg.cn/87f67ee86d1544a4ab35aeb12769f236.png
[7a34d599dfdd4a0b8f22c611d467afad.png]: https://img-blog.csdnimg.cn/7a34d599dfdd4a0b8f22c611d467afad.png
[f0de6ea403bb46fa8a56f69a285f9f6d.png]: https://img-blog.csdnimg.cn/f0de6ea403bb46fa8a56f69a285f9f6d.png
[https_docs.min.io_docs_java-client-quickstart-guide.html]: https://docs.min.io/docs/java-client-quickstart-guide.html
[bfd2c682e04b4a99804eaf581636658a.png]: https://img-blog.csdnimg.cn/bfd2c682e04b4a99804eaf581636658a.png
[c556e7b0291f4710a0b81916d804fa51.png]: https://img-blog.csdnimg.cn/c556e7b0291f4710a0b81916d804fa51.png
[56163f012af34239b07fd7cd50e6702a.png]: https://img-blog.csdnimg.cn/56163f012af34239b07fd7cd50e6702a.png
[3d0996605a3346c39e30750190ff072c.png]: https://img-blog.csdnimg.cn/3d0996605a3346c39e30750190ff072c.png
[f6a6b043a6da4ecfaef656554646a8f8.png]: https://img-blog.csdnimg.cn/f6a6b043a6da4ecfaef656554646a8f8.png
[9c6f22b88460460582b2f91004394e7c.png]: https://img-blog.csdnimg.cn/9c6f22b88460460582b2f91004394e7c.png
[b3ca09db816c480ab78b0b4b709c831a.png]: https://img-blog.csdnimg.cn/b3ca09db816c480ab78b0b4b709c831a.png
[d455ff04fe9e4938b233b1b83df12269.png]: https://img-blog.csdnimg.cn/d455ff04fe9e4938b233b1b83df12269.png
[2]: https://blog.csdn.net/m0_38027656/article/details/84190949