docker方式安装fastDFS单机版，带java工具，测试用例

最新推荐文章于 2024-01-12 11:05:34 发布
最新推荐文章于 2024-01-12 11:05:34 发布
阅读量287 收藏
点赞数
分类专栏： java 文章标签： fastDFS 环境搭建 docker
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cainiao0589/article/details/103851808
版权

参考docker构建文档，记得开放阿里云8088端口，作为访问入口

安装过程参考：https://blog.csdn.net/alinyua/article/details/82464496

maven坐标

<!--fastdfs操作工具包-->
<dependency>
    <groupId>org.csource</groupId>
    <artifactId>fastdfs-client-java</artifactId>
    <version>1.27-SNAPSHOT</version>
</dependency>

FastDFSUtil.java

import org.csource.common.MyException;
import org.csource.common.NameValuePair;
import org.csource.fastdfs.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.util.HashMap;
import java.util.Map;

/**
 * @author     ：yyj.
 * @ Date       ：Created in 15:08 2019/9/18
 * @ Description：fastDFSUtil工具类
 * @Version: 1.0
 */
public class FastDFSUtil {

    private final static


    Logger logger = LoggerFactory.getLogger(FastDFSUtil.class);


    /**
     *上传服务器本地文件-通过Linux客户端,调用客户端命令上传
     * @param filePath 文件绝对路径
     * @return Map<String,Object> code-返回代码, group-文件组, msg-文件路径/错误信息
     */
    public static Map<String, Object> uploadLocalFile(String filePath) {
        Map<String, Object> retMap = new HashMap<String, Object>(3);
        /**
         * 1.上传文件的命令
         */
        String command = "fdfs_upload_file /etc/fdfs/client.conf  " + filePath;
        /**
         * 2.定义文件的返回信息
         */
        String fileId = "";
        InputStreamReader inputStreamReader = null;
        BufferedReader bufferedReader = null;
        try {
            /**
             * 3.通过调用api, 执行linux命令上传文件
             */
            Process process = Runtime.getRuntime().exec(command);
            /**
             * 4.读取上传后返回的信息
             */
            inputStreamReader = new InputStreamReader(process.getInputStream());
            bufferedReader = new BufferedReader(inputStreamReader);
            String line;
            if ((line = bufferedReader.readLine()) != null) {
                fileId = line;
            }
            /**
             * 5.如果fileId包含M00，说明文件已经上传成功。否则文件上传失败
             */
            if (fileId.contains("M00")) {
                retMap.put("code", "0000");
                retMap.put("group", fileId.substring(0, 6));
                retMap.put("msg", fileId.substring(7, fileId.length()));
            } else {
                //上传错误
                retMap.put("code", "0001");
                //返回信息
                retMap.put("msg", fileId);
            }

        } catch (Exception e) {
            logger.error("IOException:" + e.getMessage());
            retMap.put("code", "0002");
            retMap.put("msg", e.getMessage());
        }finally {
            if (inputStreamReader!=null){
                try {
                    inputStreamReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (bufferedReader != null) {
                try {
                    bufferedReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return retMap;
    }


    /**
     * Description: 直接通过fdfs java客户端上传到服务器-读取本地文件上传
     *
     * @param filePath 本地文件绝对路径
     * @return Map<String,Object> code-返回代码, group-文件组, msg-文件路径/错误信息
     */
    public static Map<String, Object> upload(String filePath) {
        Map<String, Object> retMap = new HashMap<String, Object>(3);
        File file = new File(filePath);
        TrackerServer trackerServer = null;
        StorageServer storageServer = null;
        if (file.isFile()) {
            try {
                String tempFileName = file.getName();
                byte[] fileBuff = FastDFSFileUtil.getBytesFromFile(file);
                String fileId = "";
                //截取后缀
                String fileExtName = tempFileName.substring(tempFileName.lastIndexOf(".") + 1);
                ConfigAndConnectionServer configAndConnectionServer = new ConfigAndConnectionServer().invoke(1);
                StorageClient1 storageClient1 = configAndConnectionServer.getStorageClient1();
                storageServer = configAndConnectionServer.getStorageServer();
                trackerServer = configAndConnectionServer.getTrackerServer();

                /**
                 * 4.设置文件的相关属性。调用客户端的upload_file1的方法上传文件
                 */
                NameValuePair[] metaList = new NameValuePair[3];
                //原始文件名称
                metaList[0] = new NameValuePair("fileName", tempFileName);
                //文件后缀
                metaList[1] = new NameValuePair("fileExtName", fileExtName);
                //文件大小
                metaList[2] = new NameValuePair("fileLength", String.valueOf(file.length()));
                //开始上传文件
                fileId = storageClient1.upload_file1(fileBuff, fileExtName, metaList);
                retMap = handleResult(retMap, fileId);
            } catch (Exception e) {
                e.printStackTrace();
                retMap.put("code", "0002");
                retMap.put("msg", e.getMessage());
            } finally {
                /**
                 * 5.关闭跟踪服务器的连接
                 */
                colse(storageServer, trackerServer);
            }
        } else {
            retMap.put("code", "0001");
            retMap.put("msg", "error:本地文件不存在!");
        }
        return retMap;
    }


    /**
     * Description:远程选择上传文件-通过MultipartFile
     *
     * @param file 文件流
     * @return Map<String,Object> code-返回代码, group-文件组, msg-文件路径/错误信息
     */
    public static Map<String, Object> upload(MultipartFile file) {
        Map<String, Object> retMap = new HashMap<String, Object>(3);
        TrackerServer trackerServer = null;
        StorageServer storageServer = null;
        try {
            if (file.isEmpty()) {
                retMap.put("code", "0001");
                retMap.put("msg", "error:文件为空!");
            } else {
                ConfigAndConnectionServer configAndConnectionServer = new ConfigAndConnectionServer().invoke(1);
                StorageClient1 storageClient1 = configAndConnectionServer.getStorageClient1();
                storageServer = configAndConnectionServer.getStorageServer();
                trackerServer = configAndConnectionServer.getTrackerServer();

                String tempFileName = file.getOriginalFilename();
                //设置元信息
                NameValuePair[] metaList = new NameValuePair[3];
                //原始文件名称
                metaList[0] = new NameValuePair("fileName", tempFileName);
                //文件后缀
                byte[] fileBuff = file.getBytes();
                String fileId = "";
                //截取后缀
                String fileExtName = tempFileName.substring(tempFileName.lastIndexOf(".") + 1);

                metaList[1] = new NameValuePair("fileExtName", fileExtName);
                //文件大小
                metaList[2] = new NameValuePair("fileLength", String.valueOf(file.getSize()));
                /**
                 * 4.调用客户端呢的upload_file1的方法开始上传文件
                 */
                fileId = storageClient1.upload_file1(fileBuff, fileExtName, metaList);
//                System.out.println("fileIIIIIID--?>>>>:"+fileId);
                retMap = handleResult(retMap, fileId);
            }
        } catch (Exception e) {
            e.printStackTrace();
            retMap.put("code", "0002");
            retMap.put("msg", "error:文件上传失败!");
        }finally {
            /**
             * 5.关闭跟踪服务器的连接
             */
            colse(storageServer, trackerServer);
        }
        return retMap;
    }


    /**
     * 下载文件
     *
     * @param response
     * @param filepath 数据库存的文件路径
     * @param downname 下载后的名称
     *                 filepath M00/开头的文件路径
     *                 group 文件所在的组 如：group0
     * @throws IOException
     */
    public static void download(HttpServletResponse response, String group, String filepath, String downname) {
        StorageServer storageServer = null;
        TrackerServer trackerServer = null;
        try {
            ConfigAndConnectionServer configAndConnectionServer = new ConfigAndConnectionServer().invoke(0);
            StorageClient storageClient = configAndConnectionServer.getStorageClient();
            storageServer = configAndConnectionServer.getStorageServer();
            trackerServer = configAndConnectionServer.getTrackerServer();

            /**
             *4.调用客户端的下载download_file的方法
             */
            byte[] b = storageClient.download_file(group, filepath);
            if (b == null) {
                logger.error("Error1 : file not Found!");
                response.getWriter().write("Error1 : file not Found!");
            } else {
                logger.info("下载文件..");
                downname = new String(downname.getBytes("utf-8"), "ISO8859-1");
                response.setHeader("Content-Disposition", "attachment;fileName=" + downname);
                OutputStream out = response.getOutputStream();
                out.write(b);
                out.close();
            }
        } catch (Exception e) {
            e.printStackTrace();
            try {
                response.getWriter().write("Error1 : file not Found!");
            } catch (IOException e1) {
                e1.printStackTrace();
            }
        }finally {
            /**
             * 5.关闭跟踪服务器的连接
             */
            colse(storageServer, trackerServer);
        }
    }

    /**
     * 删除文件
     *
     * @param group 文件分组,  filepath 已M00/ 开头的文件路径
     * @return Map<String,Object> code-返回代码,  msg-错误信息
     */
    public static Map<String, Object> delete(String group, String filepath) {
        Map<String, Object> retMap = new HashMap<String, Object>(3);
        StorageServer storageServer = null;
        TrackerServer trackerServer = null;
        try {
            ConfigAndConnectionServer configAndConnectionServer = new ConfigAndConnectionServer().invoke(0);
            StorageClient storageClient = configAndConnectionServer.getStorageClient();
            storageServer = configAndConnectionServer.getStorageServer();
            trackerServer = configAndConnectionServer.getTrackerServer();
            /**
             * 4.调用客户端的delete_file方法删除文件
             */
            int i = storageClient.delete_file(group, filepath);
            if (i == 0) {
                retMap.put("code", "0000");
                retMap.put("msg", "删除成功！");
            } else {
                retMap.put("code", "0001");
                retMap.put("msg", "文件不存在!");
            }
        } catch (Exception e) {
            e.printStackTrace();
            retMap.put("code", "0002");
            retMap.put("msg", "删除失败！");
        } finally {
            /**
             * 5.关闭跟踪服务器的连接
             */
            colse(storageServer, trackerServer);
        }

        return retMap;

    }

    /**
     * 关闭服务器
     *
     * @param storageServer
     * @param trackerServer
     */
    private static void colse(StorageServer storageServer, TrackerServer trackerServer) {
        if (storageServer != null && trackerServer != null) {
            try {
                storageServer.close();
                trackerServer.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }

    /**
     * 处理上传到文件服务器之后，返回来的结果
     *
     * @param retMap
     * @param fileId
     * @return
     */
    private static Map<String, Object> handleResult(Map<String, Object> retMap, String fileId) {
        if (!fileId.equals("") && fileId != null) {
            retMap.put("code", "0000");
            retMap.put("group", fileId.substring(0, 6));
            retMap.put("msg", fileId.substring(7, fileId.length()));
        } else {
            retMap.put("code", "0003");
            retMap.put("msg", "error:上传失败!");
        }

        return retMap;
    }

    /**
     * FastDFS客户端配置
     */
    private static class ConfigAndConnectionServer {
        private TrackerServer trackerServer;
        private StorageServer storageServer;
        private StorageClient storageClient;
        private StorageClient1 storageClient1;


        public TrackerServer getTrackerServer() {
            return trackerServer;
        }

        public StorageServer getStorageServer() {
            return storageServer;
        }

        public StorageClient getStorageClient() {
            return storageClient;
        }

        public StorageClient1 getStorageClient1() {
            return storageClient1;
        }

        public ConfigAndConnectionServer invoke(int flag) throws IOException, MyException {
            /**
             * 1.读取fastDFS客户端配置文件
             */
            ClassPathResource cpr = new ClassPathResource("fdfs_client.conf");
            /**
             * 2.配置文件的初始化信息
             */
            ClientGlobal.init(cpr.getClassLoader().getResource("fdfs_client.conf").getPath());
            TrackerClient tracker = new TrackerClient();
            /**
             * 3.建立连接
             */
            trackerServer = tracker.getConnection();
            storageServer = null;
            /**
             * 如果flag=0时候，构造StorageClient对象否则构造StorageClient1
             */
            if (flag == 0) {
                storageClient = new StorageClient(trackerServer, storageServer);
            } else {
                storageClient1 = new StorageClient1(trackerServer, storageServer);
            }
            return this;
        }
    }
}

放入controller中测试上传

/**
     *    临时测试@RequestMapping("/upload")
     * @param files
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping( "/upload.do")
    public String upload(@RequestParam("file") CommonsMultipartFile[] files,
                         HttpServletRequest request){
        System.out.println("》》》》》》》》》》》》》》》》》》》》》》》》》》》》》jinru方法");

        for(int i = 0;i<files.length;i++){
            Map<String, Object> retMap = FastDFSUtil.upload(files[i]);
            String code = (String) retMap.get("code");
            String group = (String) retMap.get("group");
            String msg = (String) retMap.get("msg");
            System.out.println(retMap);
            if ("0000".equals(code)){
                System.out.println("成功");
                logger.info("文件上传成功");
                //TODO:将上传文件的路径保存到mysql数据库
            }else {
                System.out.println("失败");
                logger.info("文件上传失败");
            }


        }
        return "/success";
    }

postman测试用例

 测试结果

访问资源:(xxxx代表服务器ip)

http://xxxx:8088/group1/M00/00/00/rBMAA14SkLaAXI9pAAC4RY_O1qE628.png 

未来场景
关注
专栏目录
4.Docker容器学习之Dockerfile入门到放弃
WeiyiGeek 唯一极客IT知识分享
10-09 1419
文章目录0x01 Dockerfile 编写1.基本结构与格式2.指令参数1)FROM - 基础镜像信息2)LABEL - 标签信息3)MAINTAINER - 维护者信息4)RUN - 镜像操作命令:5)CMD- 容器启动时执行指令6)EXPOSE - 端口映射指令7)env - 修改环境变量指令8)ARG - 构建参数9)ADD - 添加指定目录文件到容器指令10)COPY - 复制指定文件或者目录到容器中11)ENTRYPOINT - 配置容器启动进入后的执行命令-应用运行前的准备工作13)VOLUM
SpringBoot 整合 Minio 上传文件
java1527的博客
10-06 438
MinIO与传统的存储和其他的对象存储不同的是：它一开始就针对性能要求更高的私有云标准进行软件架构设计。所以他采用了更易用的方式进行设计，它能实现对象存储所需要的全部功能，在性能上也更加强劲，它不会为了更多的业务功能而妥协，失去MinIO的易用性、高效性。这样的结果所带来的好处是：它能够更简单的实现局有弹性伸缩能力的原生对象存储服务。同时，它在机器学习、大数据、私有云、混合云等方面的存储技术上也独树一帜。MinIO 是一款高性能、分布式的对象存储系统. 它是一款软件产品, 可以100%的运行在标准硬件。
基于docker - 单机版FastDFS搭建
InSun的专栏
12-31 349
基于docker - 单机版FastDFS搭建 ###### 安装单机版 ###### # make docker container docker run -it -P -v /home/insun/:/insun/:rw --name single-fastdfs-test -h single-fastdfs ubuntu:18.04 bash # apt apt-get install ...
docker安装fastdfs单机版
weixin_30955617的博客
12-11 371
docker search fastdfs INDEX NAME DESCRIPTION STARS OFFICIAL AUTOMATED docker.io docker.io/season/fastdfs ...
docker安装单机版fastdfs
linux_yyp的博客
08-11 142
创建安装目录 mkdir -p /fastdfs docker run -d --network=host --name tracker -e TZ=Asia/Shanghai -v /fastdfs/tracker:/var/fdfs delron/fastdfs tracker #TRACKER_SERVER IP地址需要修改成本机的ip docker run -d --network=host --name storage -e TRACKER_SERVER=192.168.200.182:22122
docker版fastdfs单机版搭建
总分全班第一
09-27 465
fastdfs介绍 FastDFS是一个以C语言开发的开源轻量级分布式文件系统，由阿里巴巴开发并开源。它对文件进行管理，功能包括：文件存储、文件同步、文件访问（上传、下载）等。解决了大容量存储和负载均衡的问题。特别适合以文件为载体的在线服务，如相册网站、视频网站等等。 优点 FastDFS作为一个分布式服务器，对轻量级、横向扩展、容灾备份、高可用、高性能、负载均衡都有着充分的考虑 组成 FastDFS由跟踪服务器(Tracker Server)、存储服务器(Storage Server)和客户端..
Docker fastdfs 【单机】
zjh1n795的专栏
11-19 427
Docker fastdfs 【单机】系统环境fastdfs 搭建1.拉取fastdfs 镜像2.创建调度服务(tracker)容器3.创建存储服务(storage)容器4.查看端口监听5.服务监听测试6.上传测试 系统环境 centos7.2 docker 1.13.1 宿主机ip:192.168.99.149 fastdfs 搭建 1.拉取fastdfs 镜像 docker pull se...
最新背诵版 Java 面经汇总囊括了基本所有考点（建议收藏）
m0_73256420的博客
09-06 921
集群就是多台机器，是一种线上的部署方案，很多机器加起来，性能就比一台机器强，一般用这种部署方案来解决高并发，高可用，容灾，集群也有不同的叫法，负载均衡集群，高可用集群，扩容集群等。什么是分布式分布式也叫做SOA，是一种设计方案，以前使用所有模块在一个项目中的写法，叫做垂直架构，后来由于互联网的兴起，为了模块间的解耦和扩展性以及部署的灵活性，会将一个项目按照模块进行拆分，一个模块就是一个项目这种设计方案叫做分布式架构，也叫做SOA架构。什么是负载均衡器以及作用？
《后端架构师技术图谱》
weixin_70730532的博客
06-15 827
（Toc generated by simple-php-github-toc ）《java队列——queue详细分析》《LinkedList、ConcurrentLinkedQueue、LinkedBlockingQueue对比分析》每个节点最多有两个叶子节点。左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。二叉查找树（Binary Search Tree），也称有序二叉树（ordered binary tree）,排序二叉树（sorted binary tree）。MySQL是
21 张思维导图，你想知道我肝了半个月的「后端技术学习路线」长啥样么？
墨鱼菜鸡
09-09 664
话不多说，直接上刚画完的「后端技术学习路线」思维导图框架： 图中的每一个节点都可以点开，我都做了细分，在后面章节逐个展开介绍。 计算机基础 不管是后端开发还是前端开发，说到底我们所有的软件开发都是在计算上编写程序，虽然对于大部分人来说，真正开始写代码的时候很少会让你去解决计算机底层的问题，不接触不代表不重要，计算机基础是最重要的。 ...
Docker安装及fastdfs安装（单机版本）
SuperlcBlog
06-12 353
Docker安装及fastdfs安装（单机版本） 运行环境：centos7.0，docker-18.06.1-ce，fastdfs v6.0.7 ip地址：192.168.189.15 1.获取安装包及安装脚本文件（百度云连接） 链接：https://pan.baidu.com/s/18Z2ahkjFXBfJiVYf7eT2fw 提取码：69hw 2.上传文件到linux服务器dockerfastdfsservice.sh脚本文件和docker.tar.gz在同一目录 3.赋dockerfastdfss
docker安装fastdfs与java客户端测试
weixin_30294021的博客
12-09 337
一、docker 安装FastDFS 1、拉取镜像 docker pull morunchang/fastdfs 2、创建并启动tracker容器 docker run -d --name=tracker -v /home/fastdfs_docker/fdfs/tracker:/data/fast_data --privileged=true --net=host morun...
Docker搭建单机FastDfs
weixin_44355908的博客
05-13 289
目录标题概念操作测试Java代码配置 概念       FastDFS是一个开源的轻量级分布式文件系统，它对文件进行管理，功能包括：文件存储、文件同步、文件访问（文件上传、文件下载）等，解决了大容量存储和负载均衡的问题。特别适合以文件为载体的在线服务，如相册网站、视频网站等等。      FastDFS为互联网量身定制，充分考虑了冗余备份、负载均衡、线性扩容
Docker部署fastdfs单机版
大爱仙尊
02-24 387
docker部署fastdfs单机版
docker 安装 fastdfs
最新发布
ZGSDMAN的博客
01-12 2992
安装前准备：一个云服务器或本地服务器。
docker搭建单机FastDFS文件存储服务器
Valiners的博客
10-15 1149
目录一、FastDFS是什么？二、工作原理1.FastDFS服务端角色2.工作原理3.工作流程二、Linux环境配置1.下载所需要的包2.安装依赖1.12.读入数据总结 一、FastDFS是什么？ FastDFS是一个开源的轻量级分布式文件系统，它对文件进行管理，功能包括： 文件存储 文件同步 文件访问（文件上传、文件下载）等 解决了大容量存储和负载均衡的问题。特别适合以文件为载体的在线服务，如相册网站、视频网站等。 FastDFS为互联网量身定制，充分考虑了冗余备份、负载均衡、线性扩容等机制，并注重
【Docker】docker创建单机版的fastdfs
kingdz618的博客
08-02 4108
构建单机版的fastdfs
Docker安装FastDFS
NT的博客
09-11 1626
Docker安装FastDFS（分布式文件系统）并演示图片存储与下载   首先自己已经安装好docker并配置好镜像加速器 1.获取FastDFS Docker镜像来运行FastDFS docker image pull delron/fastdfs 也可以直接使用打包的镜像备份文件 docker load -i 文件路径/fastdfs_docker.tar 加载好镜像后，就可以开...
Docker与FastDFS安装教程及使用解析
"这篇文章主要讲解了Docker与FastDFS的安装和使用方法，旨在帮助读者理解和掌握这两种技术。Docker以其快速、逻辑清晰、高效开发周期以及面向服务的架构特性，成为了开发和运维的得力工具。而FastDFS是一种开源的高...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值