简介
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:客户端,上传下载数据的服务器,也就是我们自己的项目所部署在的服务器。
FastDFS的存储策略
为了支持大容量,存储节点(服务器)采用了分组的组织方式。存储系统由一个或多个组组成,组与组之间的文件是相互独立的,所有组的文件容量累加就是整个存储系统中的文件容量。一个组可以由一台或多台存储服务器组成,一个组下的存储服务器中的文件都是相同的,组中的多台存储服务器起到了冗余备份和负载均衡的作用。
在组中增加服务器时,同步已有的文件由系统自动完成,同步完成后,系统自动将新增服务器切换到线上提供服务。当存储空间不足或即将耗尽时,可以动态添加组。只需要增加一台或多台服务器,并将它们配置为一个新的组,这样就扩大了存储系统的容量。
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,最后根据以上的信息生成文件名存储文件。
FastDFS的文件同步
写文件时,客户端将文件写至group内一个storage server即认为写文件成功,storage server写完文件后,会由后台线程将文件同步至同group内其他的storage server。
每个storage写文件后,同时会写一份binlog,binlog里不包含文件数据,只包含文件名等元信息,这份binlog用于后台同步,storage会记录向group内其他storage同步的进度,以便重启后能接上次的进度继续同步;进度以时间戳的方式进行记录,所以最好能保证集群内所有server的时钟保持同步。
storage的同步进度会作为元数据的一部分汇报到tracker上,tracke在选择读storage的时候会以同步进度作为参考。
FastDFS的文件下载
客户端uploadfile成功后,会拿到一个storage生成的文件名,接下来客户端根据这个文件名即可访问到该文件。
跟upload file一样,在downloadfile时客户端可以选择任意tracker server。tracker发送download请求给某个tracker,必须带上文件名信息,tracke从文件名中解析出文件的group、大小、创建时间等信息,然后为该请求选择一个storage用来服务读请求。
单机部署FastDFS环境
- 必备的软件环境
yum -y install gcc gcc-c++ perl unzip
- 下载软件包
# 下载libfastcommon环境包:
wget https://github.com/happyfish100/libfastcommon/archive/V1.0.7.tar.gz
# 下载FastDFS包:
wget https://github.com/happyfish100/fastdfs/archive/V5.05.tar.gz
#下载nginx源码包:
wget -c https://nginx.org/download/nginx-1.12.1.tar.gz
#下载 fastdfs-nginx-module插件包:
wget https://github.com/happyfish100/fastdfs-nginx-module/archive/5e5f3566bbfa57418b5506aaefbe107a42c9fcb1.zip
- 安装 libfastcommon
#解压
tar -zxvf V1.0.7.tar.gz
#编译安装
cd libfastcommon-1.0.7
./make.sh
./make.sh install
#libfastcommon.so 默认安装到了/usr/lib64/libfastcommon.so。但是后续我们安装的FastDFS主程序设置的lib目录是/usr/local/lib,因此需要创建软链接。
ln -s /usr/lib64/libfastcommon.so /usr/local/lib/libfastcommon.so
ln -s /usr/lib64/libfastcommon.so /usr/lib/libfastcommon.so
ln -s /usr/lib64/libfdfsclient.so /usr/local/lib/libfdfsclient.so
ln -s /usr/lib64/libfdfsclient.so /usr/lib/libfdfsclient.so
- 安装FastDFS
#解压
tar -zxvf V5.05.tar.gz
#编译、安装
cd fastdfs-5.05
./make.sh
./make.sh install
#安装完成后生成的fastdfs的服务脚本
/etc/init.d/fdfs_storaged
/etc/init.d/fdfs_tracker
#安装完成后生成的临时配置文件
/etc/fdfs/client.conf.sample
/etc/fdfs/storage.conf.sample
/etc/fdfs/tracker.conf.sample
#安装完成后生成的命令工具在 /usr/bin/ 目录下
#但FastDFS 服务脚本设置的 bin 目录是 /usr/local/bin, 但实际命令安装在 /usr/bin/ 下。我们需要建立 /usr/bin 到 /usr/local/bin 的软链接。
ln -s /usr/bin/fdfs_trackerd /usr/local/bin
ln -s /usr/bin/fdfs_storaged /usr/local/bin
ln -s /usr/bin/stop.sh /usr/local/bin
ln -s /usr/bin/restart.sh /usr/local/bin
- 配置Tracker(跟踪器)
#进入 /etc/fdfs,复制 FastDFS 跟踪器样例配置文件 tracker.conf.sample,并重命名为 tracker.conf。
cd /etc/fdfs
cp tracker.conf.sample tracker.conf
#编辑tracker.conf ,标红的需要修改下,其它的默认即可
vim tracker.conf
# 配置文件是否不生效,false 为生效
disabled=false
# 提供服务的端口
port=22122
# Tracker 数据和日志目录地址(根目录必须存在,子目录会自动创建)
base_path=/home/FastDFS/tracker
# HTTP 服务端口
http.server_port=80
#创建base_path路径文件夹
mkdir -p /home/FastDFS/tracker
#启动tracker.
service fdfs_trackerd start
#查看 FastDFS Tracker 是否已成功启动 ,22122端口正在被监听,则算是Tracker服务安装成功。
netstat -unltp|grep fdfs
#关闭Tracker的命令
service fdfs_trackerd stop
#Tracker服务启动成功后,会在base_path下创建data、logs两个目录。目录结构如下:
${base_path}
|__data
| |__storage_groups.dat:存储分组信息
| |__storage_servers.dat:存储服务器列表
|__logs
| |__trackerd.log: tracker server 日志文件
- 配置 Storage(FastDFS 存储服务)
# 进入 /etc/fdfs 目录,复制 FastDFS 存储器样例配置文件 storage.conf.sample,并重命名为 storage.conf
cd /etc/fdfs
cp storage.conf.sample storage.conf
# 编辑storage.conf(标红的需要修改,其它的默认即可。)
vim storage.conf
# 配置文件是否不生效,false 为生效
disabled=false
# 指定此 storage server 所在组(卷)
group_name=group1
# storage server 服务端口
port=23000
# 心跳间隔时间,单位为秒 (这里是指主动向 tracker server 发送心跳)
heart_beat_interval=30
# Storage 数据和日志目录地址(根目录必须存在,子目录会自动生成)
base_path=/home/FastDFS/storage
#存放文件时 storage server 支持多个路径。这里配置存放文件的基路径数目,通常只配一个目录。
store_path_count=1
# 如果不配置 store_path0,那它就和 base_path 对应的路径一样,此处直接注释掉。
#store_path0=/home/FastDFS/storage
# FastDFS 存储文件时,采用了两级目录。这里配置存放文件的目录个数。
# 如果本参数只为 N(如: 256),那么 storage server 在初次运行时,会在 store_path 下自动创建 N * N 个存放文件的子目录。
subdir_count_per_path=256
# tracker_server 的列表 ,会主动连接 tracker_server
# 有多个 tracker server 时,每个 tracker server 写一行
tracker_server=192.168.244.8:22122
# 允许系统同步的时间段 (默认是全天) 。一般用于避免高峰同步产生一些问题而设定。
sync_start_time=00:00
sync_end_time=23:59
# 访问端口
http.server_port=80
#创建base_path路径文件夹
mkdir -p /home/FastDFS/storage
#启动 Storage
service fdfs_storaged start
#查看 Storage 是否成功启动,23000 端口正在被监听,就算 Storage 启动成功。
netstat -unltp|grep fdfs
#关闭Storage命令
service fdfs_storaged stop
#查看Storage和Tracker是否在通信
/usr/bin/fdfs_monitor /etc/fdfs/storage.conf
#Storage目录(Storage 启动成功后,在base_path 下创建了data、logs目录,记录着 Storage Server 的信息)
- 配置client (客户端 )
#进入 /etc/fdfs 目录,复制 FastDFS 存储器样例配置文件 client.conf.sample,并重命名为 client.conf
cd /etc/fdfs
cp client.conf.sample client.conf
#修改客户端配置文件
vim client.conf
# Client 的数据和日志目录
base_path=/home/fastdfs/client
# Tracker端口
tracker_server=192.168.244.8:22122
#tracker服务器的端口
http.tracker_server_port=8081
#上传测试
/usr/bin/fdfs_upload_file /etc/fdfs/client.conf xxx.jpg
上传成功后返回文件ID号: group1/M00/00/00/wKgz6lnduTeAMdrcAAEoRmXZPp870.jpg
- 安装Nginx
#安装nginx环境依赖
yum install -y pcre pcre-devel zlib zlib-devel openssl openssl-devel
#解压
tar -zxvf nginx-1.12.1.tar.gz
#编译安装(使用默认配置)
cd nginx-1.12.1
./configure
make && make install
#修改nginx.conf
vim /usr/local/nginx/conf/nginx.conf
添加如下行,将 /group1/M00 映射到 /home/FastDFS/storage/data
location /group1/M00 {
alias /home/FastDFS/storage/data;
}
#启动nginx
/usr/local/nginx/sbin/nginx
#其它命令
/usr/local/nginx/sbin/nginx -s stop
/usr/local/nginx/sbin/nginx -s quit
/usr/local/nginx/sbin/nginx -s reload
#查看nginx的版本及模块
/usr/local/nginx/sbin/nginx -V
#在浏览器访问之前上传的文件、成功。
http://192.168.227.131/group1/M00/00/00/wKj0CF0cTBKAYwBiAABdrZgsqUU227.jpg
- 配置 Nginx的fastdfs 模块
#fastdfs-nginx-module 模块说明
FastDFS 通过 Tracker 服务器,将文件放在 Storage 服务器存储, 但是同组存储服务器之间需要进行文件复制, 有同步延迟的问题。
假设 Tracker 服务器将文件上传到了 192.168.244.132,上传成功后文件 ID已经返回给客户端。
此时 FastDFS 存储集群机制会将这个文件同步到同组存储 192.168.244.131,在文件还没有复制完成的情况下,客户端如果用这个文件 ID 在 192.168.244.131 上取文件,就会出现文件无法访问的错误。
而 fastdfs-nginx-module 可以重定向文件链接到源服务器取文件,避免客户端由于复制延迟导致的文件无法访问错误。
#解压 fastdfs-nginx-module,并重命名
unzip 5e5f3566bbfa57418b5506aaefbe107a42c9fcb1.zip
mv fastdfs-nginx-module-5e5f3566bbfa57418b5506aaefbe107a42c9fcb1 fastdfs-nginx-module
#重新编译安装Nginx
#停止nginx服务
/usr/local/nginx/sbin/nginx -s stop
#重新编译安装(使用指定的fastdfs-nginx-module模块)
cd /usr/local/src/nginx-1.12.1/
./configure --add-module=../fastdfs-nginx-module/src
make && make install
#查看Nginx的版本模块(有configure fastdfs-nginx-module-master 字眼的标识说明添加模块成功)
/usr/local/nginx/sbin/nginx -V
#复制 fastdfs-nginx-module 源码中的配置文件到/etc/fdfs 目录。并修改
cd /usr/local/src/fastdfs-nginx-module/src
cp mod_fastdfs.conf /etc/fdfs/
vim /etc/fdfs/mod_fastdfs.conf
# 连接超时时间
connect_timeout=10
# Tracker Server
tracker_server=192.168.244.8:22122
# StorageServer 默认端口
storage_server_port=23000
# 如果文件ID的uri中包含/group**,则要设置为true
url_have_group_name = true
# Storage 配置的store_path0路径,必须和storage.conf中的一致,统一注释掉
#store_path0= /home/yuqing/fastdfs
#复制 FastDFS 的部分配置文件到/etc/fdfs 目录
cd /usr/local/src/fastdfs-5.05/conf/
cp anti-steal.jpg http.conf mime.types /etc/fdfs/
#修改nginx.conf
vim /usr/local/nginx/conf/nginx.conf
#修改内容如下
location ~/group0/M00 {
ngx_fastdfs_module;
}
集群部署FastDFS环境
以下图为例进行部署
1、tracker服务两台分别部署在192.168.227.131和192.168.227.132上
2、storage存储服务三台(分为二组),一组 192.168.227.131 ,二组 192.168.227.132 、192.168.227.133
- 集群部署
#修改所有机器上的storage.conf和mod_fastdfs.conf
#(将其tracker配置成两台机器:192.168.227.131和192.168.227.132)
tracker_server=192.168.227.131:22122
tracker_server=192.168.227.132:22122
# 修改192.168.227.131服务器上的storage.conf和mod_fastdfs.conf指定所在组(卷)为group1
group_name=group1
#修改192.168.227.132 和 192.168.227.133 服务器上的storage.conf和mod_fastdfs.conf指定所在组(卷)为group2
group_name=group2
#修改所有tracker服务器上的tracker.conf配置文件
#选择上传文件组的方法
#0:循环赛
#1:指定组
#2:负载均衡,选择最大可用空间组来上传文件
store_lookup = 2
#上传文件的组
#当store_lookup设置为1时,必须将store_group设置为组名
store_group = group2
#要上传文件的存储服务器
#0:循环(默认)
#1:第一个服务器按IP地址排序
#2:按优先级排列的第一个服务器顺序(最小)
store_server = 0
#存储服务器上载文件的路径(表示磁盘或挂载点)
#0:循环赛
#2:负载均衡,选择最大可用空间路径上传文件
store_path = 0
FastDFS与SpringBoot的整合
- 引入pom
<!--源码地址: https://github.com/tobato/FastDFS_Client-->
<dependency>
<groupId>com.github.tobato</groupId>
<artifactId>fastdfs-client</artifactId>
<version>1.26.7</version>
</dependency>
引入是需要注意:fastdfs-client 与 Springboot的版本问题。最新的版本对于关系可以在源码地址中查看
- 添加配置
fdfs:
so-timeout: 1501
connect-timeout: 601
thumb-image: #缩略图生成参数
width: 150
height: 150
tracker-list: #TrackerList参数,支持多个
- 192.168.227.131:22122
- 192.168.227.132:22122
- 编写配置类
package com.example.fastfds.config;
import com.github.tobato.fastdfs.FdfsClientConfig;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableMBeanExport;
import org.springframework.context.annotation.Import;
import org.springframework.jmx.support.RegistrationPolicy;
/**
* @EnableMBeanExport 解决jmx重复注册bean的问题
*/
@Configuration
@Import(FdfsClientConfig.class)
@EnableMBeanExport(registration = RegistrationPolicy.IGNORE_EXISTING)
public class FastFDSConfig {
}
- 封装客户端
package com.example.fastfds.service.basic;
import com.github.tobato.fastdfs.domain.fdfs.StorePath;
import com.github.tobato.fastdfs.domain.proto.storage.DownloadByteArray;
import com.github.tobato.fastdfs.service.FastFileStorageClient;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.io.FilenameUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.multipart.MultipartFile;
import java.io.*;
@Slf4j
@Component
public class FastFDSClient {
@Autowired
private FastFileStorageClient storageClient;
/**
* 上传文件
*
* @param file 文件对象
* @return 文件访问地址
* @throws IOException
*/
public String uploadFile(MultipartFile file) {
if (file.isEmpty()) {
log.error("文件不存在!");
return null;
}
InputStream inputStream;
try {
inputStream = file.getInputStream();
} catch (IOException e) {
log.error("获取文件的InputStream出错! " + e.getMessage());
return null;
}
StorePath storePath = storageClient.uploadFile(inputStream, file.getSize(), FilenameUtils.getExtension(file.getOriginalFilename()), null);
return storePath.getFullPath();
}
/**
* 上传文件
*
* @param file 文件对象
* @return 文件访问地址
* @throws IOException
*/
public String uploadFile(File file) {
if (!file.exists()) {
log.error("文件不存在!");
return null;
}
FileInputStream inputStream;
try {
inputStream = new FileInputStream(file);
} catch (FileNotFoundException e) {
log.error("获取文件的InputStream出错! " + e.getMessage());
return null;
}
StorePath storePath = storageClient.uploadFile(inputStream, file.length(), FilenameUtils.getExtension(file.getName()), null);
return storePath.getFullPath();
}
/**
* 上传本地文件
*
* @param filePath 文件路径
* @return
* @throws FileNotFoundException
*/
public String uploadFileByLocal(String filePath) {
if (StringUtils.isEmpty(filePath)) {
log.error("文件路径不能为空!");
return null;
}
File file = new File(filePath);
if (!file.exists()) {
log.error("文件不存在!");
return null;
}
FileInputStream inputStream = null;
try {
inputStream = new FileInputStream(filePath);
} catch (FileNotFoundException e) {
e.printStackTrace();
}
StorePath storePath = storageClient.uploadFile(inputStream, file.length(), FilenameUtils.getExtension(file.getName()), null);
return storePath.getFullPath();
}
/**
* 下载文件
*
* @param fileUrl
* @return
*/
public byte[] downloadFile(String fileUrl) {
if (StringUtils.isEmpty(fileUrl)) {
log.error("文件路径不能为空!");
return null;
}
String group = fileUrl.substring(0, fileUrl.indexOf("/"));
String path = fileUrl.substring(fileUrl.indexOf("/") + 1);
return storageClient.downloadFile(group, path, new DownloadByteArray());
}
/**
* 文件删除
*
* @param fileUrl
*/
public void deleteFile(String fileUrl) {
if (StringUtils.isEmpty(fileUrl)) {
log.error("文件路径不能为空!");
return;
}
String group = fileUrl.substring(0, fileUrl.indexOf("/"));
String path = fileUrl.substring(fileUrl.indexOf("/") + 1);
storageClient.deleteFile(group, path);
}
}
- 封装一个可设置文件过期时间的接口
#接口返回数据格式封装
package com.example.fastfds.bean;
import lombok.Data;
@Data
public class Result<T> {
private int code;
private String msg;
private T data;
private long traceTime = System.nanoTime();
public Result() {
this.code = 1;
this.msg = "操作成功";
}
}
#过期文件存储在redis中数据的实体类
package com.example.fastfds.bean;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class FileExpireTime {
//文件存储时间
private long storageTime;
//文件过期时长
private long expireTime;
}
#自定义一个Delayed的实现类
package com.example.fastfds.bean;
import lombok.Data;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;
/**
* 自定义Delayed
* 存放到阻塞队列的元素,对业务数据进行了包装
*
* @author JayeTian
*/
@Data
public class ItemVo<T> implements Delayed {
//到期时间,单位毫秒
private long activeTime;
//业务数据,泛型
private T data;
public ItemVo(long activeTime, T data) {
super();
this.activeTime = TimeUnit.NANOSECONDS.convert(activeTime, TimeUnit.MILLISECONDS) + System.nanoTime();
this.data = data;
}
/**
* Delayed接口继承了Comparable接口,按剩余时间排序
*/
@Override
public int compareTo(Delayed o) {
long d = (getDelay(TimeUnit.NANOSECONDS) - o.getDelay(TimeUnit.NANOSECONDS));
return (d == 0) ? 0 : ((d < 0) ? -1 : 1);
}
/**
* 这个方法返回,到激活时间的剩余时间,时间单位由单位参数指定。
*/
@Override
public long getDelay(TimeUnit unit) {
long d = unit.convert(this.activeTime - System.nanoTime(), TimeUnit.NANOSECONDS);
return d;
}
}
package com.example.fastfds.config;
import com.example.fastfds.service.basic.CheckFileProcessor;
import com.github.tobato.fastdfs.FdfsClientConfig;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableMBeanExport;
import org.springframework.context.annotation.Import;
import org.springframework.jmx.support.RegistrationPolicy;
/**
* @EnableMBeanExport 解决jmx重复注册bean的问题
*/
@Configuration
@Import(FdfsClientConfig.class)
@EnableMBeanExport(registration = RegistrationPolicy.IGNORE_EXISTING)
public class FastFDSConfig {
//注册一个 CheckFileProcessor Bean实例
@Bean
public CheckFileProcessor checkFileProcessor() {
return new CheckFileProcessor();
}
}
#初始化加载过期文件数据信息
package com.example.fastfds.init;
import com.example.fastfds.bean.FileExpireTime;
import com.example.fastfds.constant.Constant;
import com.example.fastfds.service.basic.CheckFileProcessor;
import com.example.fastfds.service.basic.FastFDSClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.core.annotation.Order;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import java.util.Map;
import java.util.Set;
@Component
@Order(value = 1)
public class FileDelayQueueInit implements CommandLineRunner {
@Autowired
private CheckFileProcessor checkFileProcessor;
@Autowired
private FastFDSClient fastFDSClient;
@Autowired
private RedisTemplate redisTemplate;
/**
* 为了防止队列中的数据因重启而导致丢失需要将数据进行持久化(如:存储到redis中)
*
* <p>
* 剩余过期时长 = 总的过期时长 - 已经过去的过期时长
* 已经过去的过期时长 = 当前时间 - 存储时间
* </P>
*/
@Override
public void run(String... args) throws Exception {
Map hashMap = redisTemplate.opsForHash().entries(Constant.FILE_EXPIRE_TIME_KEY);
Set<Map.Entry<String, FileExpireTime>> entries = hashMap.entrySet();
entries.parallelStream().forEach(x -> {
String storagePath = x.getKey();
long remainingExpireTime = x.getValue().getExpireTime() - (System.currentTimeMillis() - x.getValue().getStorageTime());
remainingExpireTime = remainingExpireTime > 0 ? remainingExpireTime : 0;
checkFileProcessor.putJob(storagePath, remainingExpireTime);
});
checkFileProcessor.initCheck(fastFDSClient, redisTemplate);
}
}
#检测过期文件的处理器
package com.example.fastfds.service.basic;
import com.example.fastfds.bean.ItemVo;
import com.example.fastfds.constant.Constant;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.util.StringUtils;
import java.util.concurrent.DelayQueue;
@Slf4j
public class CheckFileProcessor {
//存放文件到期时间的队列
public static DelayQueue<ItemVo<String>> queue = new DelayQueue();
//上传完成后,放入队列,经过expireTime时间后,从整个框架中移除
public void putJob(String storagePath, long expireTime) {
if (StringUtils.isEmpty(storagePath) || expireTime < 0) {
return;
}
queue.offer(new ItemVo<>(expireTime, storagePath));
}
//启动检查队列的线程,设置为守护线程
public void initCheck(FastFDSClient fastFDSClient, RedisTemplate redisTemplate) {
Thread thread = JobThread(fastFDSClient, redisTemplate);
thread.setDaemon(true);
thread.start();
}
//移除FastFDS服务器中到期的文件
private static Thread JobThread(FastFDSClient fastFDSClient, RedisTemplate redisTemplate) {
return new Thread(() -> {
while (true) {
try {
ItemVo<String> item = queue.take();
String storagePath = item.getData();
fastFDSClient.deleteFile(storagePath);
redisTemplate.opsForHash().delete(Constant.FILE_EXPIRE_TIME_KEY, storagePath);
log.info(System.currentTimeMillis() + " 删除了文件: " + storagePath);
} catch (InterruptedException e) {
log.error("获取DelayQueue出错:" + e.getMessage());
}
}
});
}
}
#接口定义
package com.example.fastfds.service;
import com.example.fastfds.bean.Result;
import org.springframework.web.multipart.MultipartFile;
import java.io.File;
public interface IRpcFileUploadService {
/**
* 上传本地文件
*
* @param filePath 文件路径
* @param expireDate 过期时间[单位ms] (小于0 代表不过期)
* @return
*/
Result<String> fileUploadByLocal(String filePath, long expireDate);
/**
* 上传文件
*
* @param file 文件路径
* @param expireDate 过期时间[单位ms] (小于0 代表不过期)
* @return
*/
Result<String> fileUpload(File file, long expireDate);
/**
* 上传文件
*
* @param file 文件路径
* @param expireDate 过期时间[单位ms] (小于0 代表不过期)
* @return
*/
Result<String> fileUpload(MultipartFile file, long expireDate);
}
#接口实现
package com.example.fastfds.service.impl;
import com.example.fastfds.bean.FileExpireTime;
import com.example.fastfds.bean.Result;
import com.example.fastfds.constant.Constant;
import com.example.fastfds.service.IRpcFileUploadService;
import com.example.fastfds.service.basic.CheckFileProcessor;
import com.example.fastfds.service.basic.FastFDSClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import org.springframework.web.multipart.MultipartFile;
import java.io.File;
import java.util.function.Function;
@Service
public class RpcFileUploadServiceImpl implements IRpcFileUploadService {
@Autowired
private FastFDSClient fastFDSClient;
@Autowired
private CheckFileProcessor checkFileProcessor;
@Autowired
private RedisTemplate redisTemplate;
@Override
public Result<String> fileUploadByLocal(String filePath, long expireTime) {
return filter(redisTemplate, checkFileProcessor, filePath, expireTime, (x) -> fastFDSClient.uploadFileByLocal(filePath));
}
@Override
public Result<String> fileUpload(File file, long expireTime) {
return filter(redisTemplate, checkFileProcessor, file, expireTime, (x) -> fastFDSClient.uploadFile(file));
}
@Override
public Result<String> fileUpload(MultipartFile file, long expireTime) {
return filter(redisTemplate, checkFileProcessor, file, expireTime, (x) -> fastFDSClient.uploadFile(file));
}
private static Result<String> filter(RedisTemplate redisTemplate, CheckFileProcessor checkFileProcessor, Object file, long expireTime, Function<Object, String> f) {
String storagePath = f.apply(file);
Result<String> stringResult = new Result<>();
if (StringUtils.isEmpty(storagePath)) {
stringResult.setCode(0);
stringResult.setMsg("文件上传失败!");
return stringResult;
}
stringResult.setData(storagePath);
checkFileProcessor.putJob(storagePath, expireTime);
FileExpireTime fileExpireTime = new FileExpireTime(System.currentTimeMillis(), expireTime);
redisTemplate.opsForHash().put(Constant.FILE_EXPIRE_TIME_KEY, storagePath, fileExpireTime);
return stringResult;
}
}