FastDFS使用

reading: 2024-01-30

1、简介

FastDFS是用c语言编写的一款开源的分布式文件系统，它对文件进行管理，功能包括：文件存储，文件同步，文件访问（文件上传，文件下载）等，解决大容量存储和负载均衡的问题。特别适合以文件为载体的在线服务，如相册网站，视频网站等。

FastDFS分为客户端client(我们的项目)，tracker管理端(管理存储端服务器的，不存储文件)，storage存储端(存储文件) 共三部分

管理端tracker不存储具体的文件，它用来管理storage存储端集群服务器。tracker可以是一主多从，备机每隔一段时间ping主机，主机返回pong命令，具有心跳检测机制。

storage存储端服务器，是两台为一组，一台主机和一台备机。存储时向主机从存储，然后主机将文件同步到备机保存一份，冗余存储防止文件丢失。主机和备机之间也有心跳检测机制，防止主机宕机，高可用。存储端服务器可以水平无限扩展，这样理论上fastDFS分布式文件系统可以存储的文件大小是无限大。

客户端如果想要存储，发送请求到tracker管理端，管理端会返回给客户端一个存储端服务器的ip和端口，然后客户端向具体的存储端服务器中存储，存储后返回一个存储后的路径，并且文件会被自动重命名，防止文件重名。

2、安装

官方文档：https://gitee.com/fastdfs100/fastdfs/wikis/Home

环境准备：

名称	说明
centos	7.x
libfastcommon	FastDFS分离出的公用函数库
libserverframe	FastDFS分离出的网络框架
FastDFS	FastDFS本体
fastdfs-nginx-module	FastDFS和nginx的关联模块
nginx	nginx1.16

安装环境：使用centos7.9

1 2	[root@iZgw02lo2mc5w2j7dgdd5zZ ~]# cat /etc/centos-release CentOS Linux release 7.9.2009 (Core)

环境准备：

安装 gcc 和 g++

1	yum install gcc gcc-c++ -y

安装 perl，用于编译源码

1	yum install perl -y

准备安装包

https://github.com/happyfish100/libfastcommon/archive/refs/tags/V1.0.57.tar.gz
https://github.com/happyfish100/libserverframe/archive/refs/tags/V1.1.15.tar.gz
https://github.com/happyfish100/fastdfs/archive/refs/tags/V6.08.tar.gz

安装libfastcommon，libserverframe，fastdfs

1	./make.sh clean && ./make.sh && ./make.sh install

出现问题：-bash: *.sh: Permission denied。

解决方法：chmod +x *.sh

[root@iZgw02lo2mc5w2j7dgdd5zZ libfastcommon-master]# ./make.sh
-bash: ./make.sh: Permission denied
[root@iZgw02lo2mc5w2j7dgdd5zZ libfastcommon-master]# ll -rt |grep make
-rw-r--r-- 1 root root  5546 Jan 21 09:22 make.sh
[root@iZgw02lo2mc5w2j7dgdd5zZ libfastcommon-master]# chmod +x make.sh
[root@iZgw02lo2mc5w2j7dgdd5zZ libfastcommon-master]# ll -rt |grep make
-rwxr-xr-x 1 root root  5546 Jan 21 09:22 make.sh

说明	位置
所有安装包	/usr/local/src
数据存储位置	/home/dfs/

配置文件准备：

1
2
3

说明	位置
所有安装包	/usr/local/src
数据存储位置	/home/dfs/

启动trackerd、storaged，配置文件目录：/etc/fdfs

1 2	fdfs_trackerd /etc/fdfs/tracker.conf fdfs_storaged /etc/fdfs/storage.conf

上传图片

查看详细信息：fdfs_monitor /etc/fdfs/client.conf

安装nginx

1 2	./configure --add-module=/usr/local/src/fastdfs-nginx-module/src/ make && make install #编译安装

单机部署

tracker配置文件

#服务器ip为 192.168.52.1
#我建议用ftp下载下来这些文件 本地修改
vim /etc/fdfs/tracker.conf
#需要修改的内容如下
port=22122  # tracker服务器端口（默认22122,一般不修改）
base_path=/home/dfs  # 存储日志和数据的根目录

storage配置文件

vim /etc/fdfs/storage.conf
#需要修改的内容如下
port=23000  # storage服务端口（默认23000,一般不修改）
base_path=/home/dfs  # 数据和日志文件存储根目录
store_path0=/home/dfs  # 第一个存储目录
tracker_server=192.168.52.1:22122  # tracker服务器IP和端口
http.server_port=8888  # http访问文件的端口(默认8888,看情况修改,和nginx中保持一致)

client配置文件

vim /etc/fdfs/client.conf
#需要修改的内容如下
base_path=/home/dfs
tracker_server=192.168.52.1:22122    #tracker服务器IP和端口
#保存后测试,返回ID表示成功 如：group1/M00/00/00/xx.tar.gz
fdfs_upload_file /etc/fdfs/client.conf /usr/local/src/nginx-1.15.4.tar.gz

配置nginx

vim /etc/fdfs/mod_fastdfs.conf
#需要修改的内容如下
tracker_server=192.168.52.1:22122  #tracker服务器IP和端口
url_have_group_name=true
store_path0=/home/dfs
#配置nginx.config
vim /usr/local/nginx/conf/nginx.conf
#添加如下配置
server {
    listen       8888;    ## 该端口为storage.conf中的http.server_port相同
    server_name  localhost;
    location ~/group[0-9]/ {
        ngx_fastdfs_module;
    }
    error_page   500 502 503 504  /50x.html;
    location = /50x.html {
    root   html;
    }
}
#测试下载，用外部浏览器访问刚才已传过的nginx安装包,引用返回的ID
http://192.168.52.1:8888/group1/M00/00/00/wKgAQ1pysxmAaqhAAA76tz-dVgg.tar.gz
#弹出下载单机部署全部跑通

使用成功：

3、整合

导入依赖

<dependency>
	<groupId>cn.bestwu</groupId>
    <artifactId>fastdfs-client-java</artifactId>
	<version>1.27</version>
</dependency>

创建pojo类

package com.jiuzhao73.pojo;

public class FastDFSFile {

    //文件名字
    private String name;
    //文件内容
    private byte[] content;
    //文件扩展名
    private String ext;
    //文件MD5摘要值
    private String md5;
    //文件创建作者
    private String author;

    public FastDFSFile(String name, byte[] content, String ext,  String author) {
        this.name = name;
        this.content = content;
        this.ext = ext;
        this.author = author;
    }

    public FastDFSFile(String name, byte[] content, String ext) {
        this.name = name;
        this.content = content;
        this.ext = ext;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public byte[] getContent() {
        return content;
    }

    public void setContent(byte[] content) {
        this.content = content;
    }

    public String getExt() {
        return ext;
    }

    public void setExt(String ext) {
        this.ext = ext;
    }

    public String getMd5() {
        return md5;
    }

    public void setMd5(String md5) {
        this.md5 = md5;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }
}

编写FastDFSClient类：

package com.jiuzhao73.util;


import com.jiuzhao73.pojo.FastDFSFile;
import org.csource.common.NameValuePair;
import org.csource.fastdfs.*;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;


@Component
public class FastDFSClient {

    private static final org.slf4j.Logger logger = LoggerFactory.getLogger(FastDFSClient.class);
    /***
     * 初始化加载FastDFS的TrackerServer配置
     */
    static {
        try{
            ClientGlobal.init("fdfs_client.conf");
        }catch (Exception e){
            logger.error("FastDFS Client Init Fail!", e);
        }
    }


    /***
     * 文件上传
     * @param file:文件名
     * @return 第一个组名，第二个存储路径
     */
    public static String[] upload(FastDFSFile file) {
        //获取文件的作者
        NameValuePair[] meta_list = new NameValuePair[1];
        meta_list[0] = new NameValuePair("author", file.getAuthor());

        //接收返回数据
        String[] uploadResults = null;
        StorageClient storageClient = null;
        try {
            //创建StorageClient客户端对象
            storageClient = getTrackerClient();

            /***
             * 文件上传
             * 1)文件字节数组
             * 2)文件扩展名
             * 3)文件作者
             */
            uploadResults = storageClient.upload_file(file.getContent(), file.getExt(), meta_list);
        } catch (Exception e) {
            logger.error("Exception when uploading the file:" + file.getName(), e);
        }

        if (uploadResults == null && storageClient != null) {
            logger.error("upload file fail, error code:" + storageClient.getErrorCode());
        }
        return uploadResults;
    }

    /***
     * 获取文件信息
     * @param groupName 组名
     * @param remoteFileName 文件存储完整名
     * @return 文件信息
     */
    public static FileInfo getFile(String groupName, String remoteFileName) {
        try {
            StorageClient storageClient = getTrackerClient();
            return storageClient.get_file_info(groupName, remoteFileName);
        } catch (Exception e) {
            logger.error("Exception: Get File from Fast DFS failed", e);
        }
        return null;
    }

    /***
     * 文件下载
     * @param groupName 组名
     * @param remoteFileName 文件名
     * @return 输入流
     */
    public static InputStream downFile(String groupName, String remoteFileName) {
        try {
            //创建StorageClient
            StorageClient storageClient = getTrackerClient();

            //下载文件
            byte[] fileByte = storageClient.download_file(groupName, remoteFileName);
            InputStream ins = new ByteArrayInputStream(fileByte);
            return ins;
        } catch (Exception e) {
            logger.error("Exception: Get File from Fast DFS failed", e);
        }
        return null;
    }

    /***
     * 文件删除
     * @param groupName 组名
     * @param remoteFileName 文件名
     * @throws Exception 抛异常
     */
    public static void deleteFile(String groupName, String remoteFileName)
            throws Exception {
        //创建StorageClient
        StorageClient storageClient = getTrackerClient();

        //删除文件
        int i = storageClient.delete_file(groupName, remoteFileName);
    }

    /***
     * 获取Storage组
     * @param groupName 组名
     * @return Storage组
     * @throws IOException IO异常
     */
    public static StorageServer[] getStoreStorages(String groupName)
            throws IOException {
        //创建TrackerClient
        TrackerClient trackerClient = new TrackerClient();
        //获取TrackerServer
        TrackerServer trackerServer = trackerClient.getConnection();
        //获取Storage组
        return trackerClient.getStoreStorages(trackerServer, groupName);
    }

    /***
     * 获取Storage信息,IP和端口
     * @param groupName 组名
     * @param remoteFileName 文件名
     * @return Storage信息,IP和端口
     * @throws IOException IO异常
     */
    public static ServerInfo[] getFetchStorages(String groupName,
                                                String remoteFileName) throws IOException {
        TrackerClient trackerClient = new TrackerClient();
        TrackerServer trackerServer = trackerClient.getConnection();
        return trackerClient.getFetchStorages(trackerServer, groupName, remoteFileName);
    }

    /***
     * 获取Tracker服务地址
     * @return Tracker服务地址
     * @throws IOException IO异常
     */
    public static String getTrackerUrl() throws IOException {
        return "http://" + getTrackerServer().getInetSocketAddress().getHostString() + ":" + ClientGlobal.getG_tracker_http_port() + "/";
    }

    /***
     * 获取Storage客户端
     * @return Storage客户端
     * @throws IOException IO异常
     */
    private static StorageClient getTrackerClient() throws IOException {
        TrackerServer trackerServer = getTrackerServer();
        return new StorageClient(trackerServer, null);
    }

    /***
     * 获取Tracker
     * @return Tracker
     * @throws IOException IO异常
     */
    private static TrackerServer getTrackerServer() throws IOException {
        TrackerClient trackerClient = new TrackerClient();
        return trackerClient.getConnection();
    }

}

编写Controller：

package com.jiuzhao73.controller;


import com.jiuzhao73.pojo.FastDFSFile;
import com.jiuzhao73.util.FastDFSClient;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;

@RestController
@RequestMapping("/file")
public class FileController {
    @GetMapping("/test")
    public String test(){
        return "success";
    }

    /**
     * 上传接口
     * @param file 接收文件参数, 参数名必须叫做file
     * @Author 久曌
     */
    @PostMapping("/upload")
    public String upload(@RequestParam("file") MultipartFile file) {
        String path ="";
        try {
            path=saveFile(file);
            System.out.println(path);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return path;
    }

    /**
     * 上传文件到FastDFS分布式文件系统
     * @param multipartFile：文件
     * @Author 久曌
     */
    public String saveFile(MultipartFile multipartFile) throws IOException {
        //1. 获取文件名
        String fileName = multipartFile.getOriginalFilename();
        //2. 获取文件内容
        byte[] content = multipartFile.getBytes();
        //3. 获取文件扩展名
        String ext = "";
        if (fileName != null && !"".equals(fileName)) {
            ext = fileName.substring(fileName.lastIndexOf("."));
        }
        //4. 创建文件实体类对象
        FastDFSFile fastDFSFile = new FastDFSFile(fileName, content, ext);
        //5. 上传
        String[] uploadResults = FastDFSClient.upload(fastDFSFile);
        //6. 拼接上传后的文件的完整路径和名字, uploadResults[0]为组名, uploadResults[1]为文件名称和路径
        String path = FastDFSClient.getTrackerUrl() + uploadResults[0] + "/" + uploadResults[1];
        //7. 返回
        return path;
    }
}