# fdfs

**Repository Path**: hanyuana/fdfs

## Basic Information

- **Project Name**: fdfs
- **Description**: 搭建springboot+fastdfs文件系统，
- **Primary Language**: Unknown
- **License**: MIT
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2021-10-12
- **Last Updated**: 2021-11-03

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# 一、FastDFS 文件系统介绍

### 1. 简介

FastDFS 是一个开源的高性能分布式文件系统（DFS）。 它的主要功能包括：文件存储，文件同步和文件访问，以及高容量和负载平衡。主要解决了海量数据存储问题，特别适合以中小文件（建议范围：4KB < file_size <500MB）为载体的在线服务。

FastDFS 系统有三个角色：跟踪服务器(Tracker Server)、存储服务器(Storage Server)和客户端(Client)。

　　**Tracker Server**：跟踪服务器，主要做调度工作，起到均衡的作用；负责管理所有的 storage server和 group，每个 storage 在启动后会连接 Tracker，告知自己所属 group 等信息，并保持周期性心跳。

　　**Storage Server**：存储服务器，主要提供容量和备份服务；以 group 为单位，每个 group 内可以有多台 storage server，数据互为备份。

　　**Client**：客户端，上传下载数据的服务器，也就是我们自己的项目所部署在的服务器。



### 2、FastDFS的存储策略

为了支持大容量，存储节点（服务器）采用了分卷（或分组）的组织方式。存储系统由一个或多个卷组成，卷与卷之间的文件是相互独立的，所有卷的文件容量累加就是整个存储系统中的文件容量。一个卷可以由一台或多台存储服务器组成，一个卷下的存储服务器中的文件都是相同的，卷中的多台存储服务器起到了冗余备份和负载均衡的作用。

在卷中增加服务器时，同步已有的文件由系统自动完成，同步完成后，系统自动将新增服务器切换到线上提供服务。当存储空间不足或即将耗尽时，可以动态添加卷。只需要增加一台或多台服务器，并将它们配置为一个新的卷，这样就扩大了存储系统的容量。



### 3、FastDFS的上传过程

FastDFS向使用者提供基本文件访问接口，比如upload、download、append、delete等，以客户端库的方式提供给用户使用。

Storage Server会定期的向Tracker Server发送自己的存储信息。当Tracker Server Cluster中的Tracker Server不止一个时，各个Tracker之间的关系是对等的，所以客户端上传时可以选择任意一个Tracker。

当Tracker收到客户端上传文件的请求时，会为该文件分配一个可以存储文件的group，当选定了group后就要决定给客户端分配group中的哪一个storage server。当分配好storage server后，客户端向storage发送写文件请求，storage将会为文件分配一个数据存储目录。然后为文件分配一个fileid，最后根据以上的信息生成文件名存储文件。

![img](https://images2017.cnblogs.com/blog/856154/201710/856154-20171012121639387-1574147926.png)





### 4、FastDFS的文件同步

写文件时，客户端将文件写至group内一个storage server即认为写文件成功，storage server写完文件后，会由后台线程将文件同步至同group内其他的storage server。

每个storage写文件后，同时会写一份binlog，binlog里不包含文件数据，只包含文件名等元信息，这份binlog用于后台同步，storage会记录向group内其他storage同步的进度，以便重启后能接上次的进度继续同步；进度以时间戳的方式进行记录，所以最好能保证集群内所有server的时钟保持同步。

storage的同步进度会作为元数据的一部分汇报到tracker上，tracke在选择读storage的时候会以同步进度作为参考。



### 5、FastDFS的文件下载

客户端uploadfile成功后，会拿到一个storage生成的文件名，接下来客户端根据这个文件名即可访问到该文件。

![img](https://images2015.cnblogs.com/blog/380252/201704/380252-20170415090611017-204910775.png)

跟upload file一样，在downloadfile时客户端可以选择任意tracker server。tracker发送download请求给某个tracker，必须带上文件名信息，tracke从文件名中解析出文件的group、大小、创建时间等信息，然后为该请求选择一个storage用来服务读请求。

 



# 二、安装fastdfs环境（基于docker）

首先查看一下docker仓库中有那些镜像可以使用

```shell
docker search fastdfs
```

![image-20211009100427623](C:\Users\talent\AppData\Roaming\Typora\typora-user-images\image-20211009100427623.png)

为了安装方便，我们这里选择集成nginx的版本

```shell
docker pull morunchang/fastdfs
```

**创建docker容器的网络组**

```shell
docker network create docker-network  // docker-network是局域网的名字，自定义 
docker network ls  // 查看已有的network
```

![image-20211011094001583](C:\Users\talent\AppData\Roaming\Typora\typora-user-images\image-20211011094001583.png)

**构建Tracker容器**

使用docker镜像构建tracker容器，用于启动跟踪服务器，起到调度的作用。

```shell
docker run -d --network=host --name tracker -v /home/app/fastdfs/tracker:/var/fdfs delron/fastdfs tracker
```



**构建Storage容器**

使用docker镜像构建storage容器，用于启动存储服务器，提供容量和备份服务。

在执行下面命令时特别需要提醒的时，对应的IP地址，需要修改为tracker服务的IP地址，由于是在同一台电脑上操作，这里使用本机的内网地址即可，22122是tracker对应的端口。

示例，下面命令需要替换IP地址。

```shell
docker run -d  --network=host --name storage -e TRACKER_SERVER=192.168.112.130:22122 -v /home/app/fastdfs/storage:/var/fdfs -e GROUP_NAME=group1 delron/fastdfs storage
```



**测试**

```shell
docker exec -it storage bash
cd /var/fdfs
/usr/bin/fdfs_upload_file  /etc/fdfs/client.conf my.jpg

group1/M00/00/00/wKhwgmFj6iaAMZiPAClftE-sF88183.jpg
group1/M00/00/00/wKhwgmFkCU2Ab-_kAACtC2HLulg167.jpg
```



# 三、springboot 整合fastdfs



添加依赖

```xml
      <dependency>
            <groupId>com.github.tobato</groupId>
            <artifactId>fastdfs-client</artifactId>
            <version>1.27.2</version>
        </dependency>
```



代码

```java
package com.fdfs.service;

import com.fdfs.vo.UploadFileResponse;
import com.fdfs.vo.UploadImageResponse;
import org.springframework.web.multipart.MultipartFile;

/**
 * @author talent
 * @since 2021/10/11 16:05
 */
public interface FastDFSService {

    /**
     * 上传文件
     * @param file 文件流
     * @return 文件访问路径
     */
    UploadFileResponse uploadFile(MultipartFile file);

    /**
     * 删除文件
     * @param filePath 文件路径
     */
    void deleteFile(String filePath);

    /**
     * 上传图片，不生成缩略图
     * @param file 文件流
     * @return 文件访问路径
     */
    UploadImageResponse uploadImage(MultipartFile file);

    /**
     * 上传图片，并生成缩略图
     * @param file  文件流
     * @return 图片访问路径
     */
    UploadImageResponse uploadThumbImage(MultipartFile file);

    /**
     * 上传图片, 同时对图片添加水印
     * @param file 文件流
     * @param sixCode 图片访问路径
     * @return 图片访问路径
     */
    UploadImageResponse uploadImage(MultipartFile file, String sixCode);
}

```



```java
package com.fdfs.service.impl;

import com.fdfs.config.UploadConfig;
import com.fdfs.service.FastDFSService;
import com.fdfs.utils.ImageUtil;
import com.fdfs.vo.UploadFileResponse;
import com.fdfs.vo.UploadImageResponse;
import com.github.tobato.fastdfs.domain.fdfs.StorePath;
import com.github.tobato.fastdfs.domain.fdfs.ThumbImageConfig;
import com.github.tobato.fastdfs.exception.FdfsException;
import com.github.tobato.fastdfs.service.FastFileStorageClient;
import org.apache.commons.io.FilenameUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import java.io.*;

/**
 * @author talent
 * @since 2021/10/11 16:08
 */
@Service
@EnableConfigurationProperties(UploadConfig.class)
public class FastDFSServiceImpl implements FastDFSService {

    private Logger logger = LoggerFactory.getLogger(FastDFSServiceImpl.class);

    @Autowired
    private FastFileStorageClient fastFileStorageClient;
    @Autowired
    private UploadConfig uploadConfig;
    @Autowired
    private ThumbImageConfig thumbImageConfig;

    @Override
    public UploadFileResponse uploadFile(MultipartFile file) {
        try {
            // 上传
            StorePath storePath = fastFileStorageClient.uploadFile(file.getInputStream(),
                    file.getSize(), checkFile(file), null);
            // 返回路径
            UploadFileResponse response = new UploadFileResponse();
            response.setFileUrl(uploadConfig.getBaseUrl() + storePath.getFullPath());
            return response;
        } catch (IOException ex) {
            logger.error("【文件上传】文件上传失败!...{}", ex);
            throw new RuntimeException("【文件上传】文件上传失败" + ex.getMessage());
        }
    }

    @Override
    public void deleteFile(String filePath) {
        logger.info("【删除文件】删除{}文件开始", filePath);
        try {
            fastFileStorageClient.deleteFile(filePath);
        } catch (Exception ex) {
            logger.error("【文件删除】文件{}删除失败", filePath);
            throw new RuntimeException("【文件删除】文件删除失败" + ex.getMessage());
        }
    }

    @Override
    public UploadImageResponse uploadImage(MultipartFile file) {
        try {
            // 上传
            StorePath storePath = fastFileStorageClient.uploadFile(file.getInputStream(),
                    file.getSize(), checkFile(file), null);
            // 返回路径
            UploadImageResponse response = new UploadImageResponse();
            response.setImageUrl(uploadConfig.getBaseUrl() + storePath.getFullPath());
            return response;
        } catch (IOException ex) {
            logger.error("【图片上传】图片上传失败!...{}", ex);
            throw new RuntimeException("【图片上传】图片上传失败" + ex.getMessage());
        }
    }

    @Override
    public UploadImageResponse uploadThumbImage(MultipartFile file) {
        try {
            // 上传图片，返回图片缩略路径
            StorePath storePath = fastFileStorageClient.uploadImageAndCrtThumbImage(file.getInputStream(),
                    file.getSize(), checkFile(file), null);
            // 返回路径
            UploadImageResponse response = new UploadImageResponse();
            String imagePath = uploadConfig.getBaseUrl() + storePath.getFullPath();
            // 缩略图地址
            String thumbImagePath = thumbImageConfig.getThumbImagePath(storePath.getFullPath());
            response.setImageUrl(imagePath);
            response.setThumbImageUrl(uploadConfig.getBaseUrl() + thumbImagePath);
            return response;
        } catch (IOException ex) {
            logger.error("【文件上传】文件上传失败!...{}", ex);
            throw new RuntimeException("【文件上传】文件上传失败" + ex.getMessage());
        }
    }

    @Override
    public UploadImageResponse uploadImage(MultipartFile file, String sixCode) {
        try {
            InputStream in = ImageUtil.addWatermark(file, sixCode);
            // 上传
            StorePath storePath = fastFileStorageClient.uploadFile(in,
                    file.getSize(), checkFile(file), null);
            // 返回路径
            UploadImageResponse response = new UploadImageResponse();
            response.setImageUrl(uploadConfig.getBaseUrl() + storePath.getFullPath());
            return response;
        } catch (FdfsException ex) {
            logger.error("【图片上传】图片上传失败!...");
            throw new RuntimeException("【图片上传】图片上传失败" + ex.getMessage());
        }
    }

    /**
     * 文件预检查
     * @param file 文件
     * @return 返回文件后缀
     */
    private String checkFile(MultipartFile file) {
        // 校验文件类型
        String contentType = file.getContentType();
        if (!uploadConfig.getAllowTypes().contains(contentType)) {
            throw new RuntimeException("文件类型不支持");
        }
        return FilenameUtils.getExtension(file.getOriginalFilename());
    }

}

```