SpringBoot搭建分布式文件存储FastDFS

已于 2023-03-16 14:06:14 修改
阅读量746 收藏 1
点赞数
文章标签： spring boot 分布式 java
于 2022-12-02 11:54:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49216308/article/details/128145531
版权

简介：

FastDFS是一个开源的轻量级分布式文件系统，对文件进行管理，功能：文件同步、文件存储、文件访问等，解决了大容量存储和负载均衡的问题。

FastDFS充分考虑了冗余备份、负载均衡、线性扩容机制等注重高可用、高性能指标等，使用FastDFS很容易搭建一套高性能的文件服务器集群提供文件上传、下载服务等。

工作原理：
在这里插入图片描述

ContOS7安装FastDFS：

1.使用的网络模式是-net=host，XXX.XXX.XXX.XXX是宿主机的IP
2.group1是组名，既Storage的组
3.如果要增加新的Storage服务器，再次运行改命令(注意更换组名称)

#拉取镜像
docker pull myfastdfs/fastdfs
#运行tracker
docker run -d --name tracker --net=host myfastdfs/fastdfs sh tracker.sh
#运行storage
docker run -d --name storage --net=host -e TRACKER_IP=XXX.XXX.XXX.XXX:22122 -e GROUP_NAME=group1 myfastdfs/fastdfs sh storage.sh

构建Spring Boot微服务：
在这里插入图片描述
父工程pom

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.6.RELEASE</version>
    </parent>
    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>
    <dependencies>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.51</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
    </dependencies>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Greenwich.SR1</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

my-file-store父工程my-eureka子工程pom文件

<dependencies>
   <dependency>
     <groupId>org.springframework.cloud</groupId>
     <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
   </dependency>
</dependencies>

my-file-store父工程my-file子工程pom文件

<dependencies>
   <dependency>
      <groupId>com.filestore</groupId>
      <artifactId>my-file-store</artifactId>
      <version>1.0-SNAPSHOT</version>
   </dependency>
</dependencies>

my-file-store父工程my-file子子pom文件

<dependencies>
   <dependency>
      <groupId>net.oschina.zcx7878</groupId>
      <artifactId>fastdfs-client-java</artifactId>
      <version>1.27.0.0</version>
   </dependency>
   <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-netflix-eureka-client</artifactId>
   </dependency>
</dependencies>

EurekaApplication启动类


package com.filestore;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

/**
 * @author : musir
 */
@SpringBootApplication
@EnableEurekaServer
public class EurekaApplication {
    public static void main(String[] args) {
        SpringApplication.run(EurekaApplication.class, args);
    }
}

application.yml配置文件

server:
  port: 7001
eureka:
  instance:
    hostname: 127.0.0.1
  client:
    register-with-eureka: false #是否将自己注册到eureka中
    fetch-registry: false #是否从eureka中获取信息
    service-url:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/ #动态IP获取
spring:
  application:
    name: eureka

controller文件FileUploadController

package com.changgou.controller;

import com.changgou.file.FastDFSFile;
import com.changgou.util.FastDFSUtil;
import entity.Result;
import entity.StatusCode;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

/**
 * @author ：musir
 */
@RestController
@RequestMapping(value = "/upload")
@CrossOrigin
public class FileUploadController {

    @PostMapping
    public Result upload(@RequestParam(value = "file") MultipartFile multipartFile) throws Exception {
        FastDFSFile fastDFSFile = new FastDFSFile(
                multipartFile.getOriginalFilename(),
                multipartFile.getBytes(),
                StringUtils.getFilenameExtension(multipartFile.getOriginalFilename())
        );
        String[] uploads = FastDFSUtil.upload(fastDFSFile);
        // 拼接访问地址url=http://192.168.xxx.xxx:8080/group1/M00/00/00/XXX.jpg
        // String url = "http://192.168.xxx.xxx:8080/"+uploads[0]+"/"+uploads[1];
        String url = FastDFSUtil.getTrackerInfo()+"/"+uploads[0]+"/"+uploads[1];
        return new Result(true, StatusCode.OK, "上传成功", url);
    }
}

file文件FastDFSFile

package com.changgou.file;

import java.io.Serializable;

/**
 * @author ：musir
 */
public class FastDFSFile implements Serializable {

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

    /**
     * 构造函数
     * @param name
     * @param content
     * @param ext
     */
    public FastDFSFile(String name, byte[] content, String ext) {
        this.name = name;
        this.content = content;
        this.ext = ext;
    }

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

    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;
    }

util文件FastDFSUtil

package com.changgou.util;

import com.changgou.file.FastDFSFile;
import org.csource.common.NameValuePair;
import org.csource.fastdfs.*;
import org.springframework.core.io.ClassPathResource;

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

/**
 * @author ：musir
 */
public class FastDFSUtil {

    /**
     * 加载Tracker连接信息
     */
    static {
        try {
            //查询classpath下的文件路径
            String filename = new ClassPathResource("fdfs_client.conf").getPath();
            //载Tracker连接信息
            ClientGlobal.init(filename);
        } catch (Exception exception) {
            exception.printStackTrace();
        }
    }

    /**
     * 创建Tracker访问的客户端对象TrackerClient、通过TrackerClient访问TrackerServer服务，获取连接信息
     * @return
     * @throws Exception
     */
    public static TrackerServer getTrackerServer() throws Exception {
        TrackerClient trackerClient = new TrackerClient();
        TrackerServer trackerServer = trackerClient.getConnection();
        return trackerServer;
    }

    /**
     * 通过TrackerServer的连接信息可以获取Storage的连接信息，创建StorageClient对象存储的Storage的连接信息
     * @param trackerServer
     * @return
     * @throws Exception
     */
    public static StorageClient getStorageClient(TrackerServer trackerServer) throws Exception {
        StorageClient storageClient = new StorageClient(trackerServer, null);
        return storageClient;
    }

    /**
     * 文件上传，上传的文件的信息封装
     * @param fastDFSFile
     * @return
     * @throws Exception
     */
    public static String[] upload(FastDFSFile fastDFSFile) throws Exception {
        //附加参数
        NameValuePair[] meta_list = new NameValuePair[1];
        meta_list[0] = new NameValuePair("author", fastDFSFile.getAuthor());
        // 获取TrackerServer
        TrackerServer trackerServer = getTrackerServer();
        //获取StorageClient
        StorageClient storageClient = getStorageClient(trackerServer);
        //通过StorageCLient访问Storage，实现文件上传，并且获取文件上传后的存储信息，第一个参数:上传文件的字节数组、文件扩展名、附加参数
        String[] uploads = storageClient.upload_file(fastDFSFile.getContent(), fastDFSFile.getExt(), meta_list);
        return uploads;
    }

    /**
     * 获取文件信息
     * @param groupName 文件的组名
     * @param remoteFileName 文件的存储路径名字 M00/00/00/XXX.jpg
     * @return
     * @throws Exception
     */
    public static FileInfo getFile(String groupName, String remoteFileName) throws Exception {
        //获取Tracker
        TrackerServer trackerServer = getTrackerServer();
        //获取StorageClient
        StorageClient storageClient = getStorageClient(trackerServer);
        //获取文件信息
        return storageClient.get_file_info(groupName, remoteFileName);
    }

    /**
     * 文件下载
     * @param groupName
     * @param remoteFileName
     * @throws Exception
     */
    public static InputStream downloadFile(String groupName, String remoteFileName) throws Exception{
        // 获取TrackerServer
        TrackerServer trackerServer = getTrackerServer();
        // 获取StorageClient
        StorageClient storageClient = getStorageClient(trackerServer);
        // 文件下载
        byte[] buffer = storageClient.download_file(groupName, remoteFileName);
        return new ByteArrayInputStream(buffer);
    }

    /**
     * 文件删除
     * @param groupName
     * @param remoteFileName
     * @throws Exception
     */
    public static void deleteFile(String groupName, String remoteFileName) throws Exception{
        // 获取Tracker
        TrackerServer trackerServer = getTrackerServer();
        // 获取StorageClient
        StorageClient storageClient = getStorageClient(trackerServer);
        // 文件删除
        storageClient.delete_file(groupName, remoteFileName);
    }

    /**
     * 获取Storage信息
     * @throws Exception
     * @return
     */
    public static StorageServer getStorage() throws Exception{
        TrackerClient trackerClient = new TrackerClient();
        TrackerServer trackerServer = trackerClient.getConnection();
        // 获取Storage信息
        trackerClient.getStoreStorage(trackerServer);
        return trackerClient.getStoreStorage(trackerServer);
    }

    /**
     * 根据文件组名和文件存储路径获取Storage服务的IP、端口信息
     * @param groupName
     * @param remoteFileName
     * @throws Exception
     * @return
     */
    public static ServerInfo[] getServerInfo(String groupName, String remoteFileName) throws Exception{
        TrackerClient trackerClient = new TrackerClient();
        TrackerServer trackerServer = trackerClient.getConnection();
        // 获取Storage服务的IP、端口信息
        return trackerClient.getFetchStorages(trackerServer, groupName, remoteFileName);
    }

    /**
     * 获取Tracker的IP、服务端口
     * @throws Exception
     * @return
     */
    public static String getTrackerInfo() throws Exception{
        // 获取TrackerServer
        TrackerServer trackerServer = getTrackerServer();
        // 获取Tracker的IP、服务端口
        String hostString = trackerServer.getInetSocketAddress().getHostString();
        int tracker_http_port = ClientGlobal.getG_tracker_http_port();
        String url = "http://"+hostString+":"+tracker_http_port;
        return url;
    }
}

FileApplication启动类


package com.changgou;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

/**
 * @author ：musir
 */
@SpringBootApplication(exclude = DataSourceAutoConfiguration.class)
@EnableEurekaClient
public class FileApplication {
    public static void main(String[] args) {
        SpringApplication.run(FileApplication.class, args);
    }
}

my-file-service-application.yml、fdfs_client.conf


spring:
  servlet:
    multipart:
      max-file-size: 10MB
      max-request-size: 10MB
  application:
    name: file
server:
  port: 18082
eureka:
  client:
    service-url:
      defaultZone: http://192.168.xxx.xxx:7001/eureka
  instance:
    prefer-ip-address: true
feign:
  hystrix:
    enabled: true

connect_timeout=60
network_timeout=60
charset=UTF-8
http.tracker_http_port=8080
tracker_server=192.168.xxx.xxx:22122
运维爱好者
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
基于SpringBoot下使用分布式文件存储FastDFS
我不是啊嫩的博客
03-24 1071
一、FastDFS简介 1.1 FastDFS体系结构 FastDFS是一个开源的轻量级分布式文件系统，它对文件进行管理，功能包括：文件存储、文件同步、文件访问（文件上传、文件下载）等，解决了大容量存储和负载均衡的问题。特别适合以文件为载体的在线服务，如相册网站、视频网站等等。 FastDFS为互联网量身定制，充分考虑了冗余备份、负载均衡、线性扩容等机制，并注重高可用、高性能等指标，使用FastDFS很容易搭建一套高性能的文件服务器集群提供文件上传、下载等服务。 FastDFS 架构包括 Tracker s
SpringBoot 整合 FastDFS 中间件，实现文件分布式管理
花开半夏 · 流年似水
07-02 786
一、FastDFS简介 分布式文件系统FastDFS：是一个开源的轻量级分布式文件系统，由跟踪服务器（tracker server）、存储服务器（storage server）和客户端（client）三个部分组成，作为一个分布式文件系统，它对文件进行管理，功能包括：文件存储、文件同步、文件访问（文件上传、文件下载）等，解决了大容量存储和负载均衡的问题，特别适合中小文件（建议范围：4KB < file_size <500MB），对以文件为载体的在线服务，如相册网站、视频网站等等具有显著的效果。
SpringBoot项目作为文件服务器配置
qq_50867577的博客
04-03 753
springboot项目配置为文件服务器，实现url下载文件
Spring boot实现上传文件至本地或服务器
欢迎阅读程序猿小张的博客~
07-03 3229
大家好 我是程序猿小张。
SpringBoot集成FastDFS实现文件服务
最新发布
lhssy的博客
06-18 372
分布式文件系统FastDFS
SpringBoot文件上传存储解决方案
util123的博客
07-18 1260
使用Spring Boot框架实现一个完善的文件上传功能，在Spring Boot中配置文件上传的方法，并提供了详细的代码说明。通过学习本文，你将获得实战经验，能够快速应用文件上传功能在自己的项目中。如果你对Spring Boot文件上传感兴趣，那么这篇文章将为你提供一套较为完善的解决方案，助你快速搭建和应用文件上传功能，并且具备很大的扩展性。
Spring Cloud：微服务之构建支持多存储方式的分布式文件存储服务
言尭的博客
05-24 1261
概述 在微务系统架构中，分布式文件系统（Distributed File System,DFS）是必不可少的中间件。分布式文件系统是面对互联网的需求而产生，互联网时代对海量数据如何存储？靠简单的增加硬盘的个数已经满足不了我们的要求，因为硬盘传输速度有限但是数据在急剧增长，另外我们还要要做好数据备份、数据安全等。通过分布式文件系统我们可以将相同的文件同时存储到网络上多台服务器上，从而实现提供文件的访问效率和提高文件的可用性。 目前各大主流云服务商都提供对象存储服务（OSS）,也存在许多成熟的开源本地化部署
Windows服务器部署SpringBoot及文件服务器MinIO
Zarathusa的博客
09-07 1033
在C:\目录下创建minio.bat文件，并把以下脚本copy到文件内，双击打开，即可启动minio。
SpringBoot 结合分布式文件系统FastDFS实现文件上传实例demo2.zip
03-23
在本项目中，"SpringBoot 结合分布式文件系统FastDFS实现文件上传实例demo2.zip"，我们关注的核心技术是SpringBoot框架与FastDFS的集成，用于实现高效的文件上传功能。SpringBoot是Java领域广泛使用的轻量级框架，以...
FastDFS分布式文件系统部署及springboot集成
11-24
《FastDFS分布式文件系统部署及Springboot集成》 在当今的互联网环境中，分布式文件系统FastDFS因其高效、轻量级的特性，被广泛应用于存储大量非结构化数据，如图片、文档等。本文将详细介绍如何在单机环境下部署...
FastDFS SpringBoot 客户端 Demo搭建，支持文件上传下载
06-14
FastDFS是一个开源的、高性能的、轻量级的分布式文件系统，专为互联网应用设计。它具有高可用性、扩展性和容错性，适合存储大量小文件，如图片、文档等。本教程将介绍如何使用SpringBoot集成FastDFS客户端，实现文件...
集成FastDFS实现文件的分布式存储.zip
08-26
本项目旨在集成FastDFS到SpringBoot应用中，以实现文件的分布式存储功能。下面将详细阐述这个过程涉及的知识点。 1. **FastDFS介绍** FastDFS是一个开源的高性能、轻量级的分布式文件系统，它对文件进行管理，包括...
springboot接入fastdfs示例
10-14
FastDFS是一个开源的、高性能的、轻量级的分布式文件系统，它对文件进行管理，包括文件存储、文件同步、文件访问（文件上传、文件下载）等功能，解决了大容量存储和负载均衡的问题。 本示例主要介绍如何将FastDFS与...
如何让springboot项目充当文件服务器
wilbur_bb的博客
09-19 1297
springboot项目充当文件服务器
基于springboot实现一个文件服务器
qq_44525150的博客
11-16 2790
本文介绍了如何使用springboot来搭建一个个人文件服务器。 本系统具有文件上传、下载、预览等基本功能，此外，还实现了回收站，日志统计及基本的权限控制
Spring Boot如何实现分布式文件系统
it_xushixiong的博客
06-01 1063
在分布式系统中，分布式文件系统是非常重要的一部分，可以帮助开发人员实现大规模数据存储和访问。本文介绍了使用 FastDFS 实现分布式文件系统的示例代码。在实际使用中，需要根据具体场景选择合适的工具和方案，并注意文件的存储和访问性能，确保系统的可靠性和性能。
FastDFS入门一篇就够
weixin_33860553的博客
02-22 404
完整安装流程 下载的包都存放在~/caibh/fdfs-package目录下。 下载libfastcommon、fastdfs、fastdfs-nginx-module： cd ~/caibh/fdfs-package # -S print server response # -O write documents to file wget...
SpringCloud---分布式缓存-Redis
firstof的博客
06-11 463
全量同步：master将完整内存数据生成RDB，发送RDB到slave。后续命令则记录在repl_baklog，逐个发送给slave。增量同步：slave提交自己的offset到master，master获取repl_baklog中从offset之后的命令给slave什么时候执行全量同步?slave第一次连接到mater节点slave断开连接时间太久,导致尚未备份的数据被覆盖什么时候执行增量同步?slave节点断开又恢复，并且在repl_baklog中能找到offset时# 进入/tmp目录。
使用SpringBoot实现文件存储
禅与计算机程序设计艺术
01-25 1150
1.背景介绍 1. 背景介绍 在现代应用程序开发中，文件存储是一个非常重要的功能。它允许应用程序存储和检索数据，例如用户上传的文件、配置文件、日志文件等。Spring Boot 是一个用于构建现代 Java 应用程序的框架，它提供了一些内置的文件存储功能，使得开发人员可以轻松地实现文件存储。 在本文中，我们将讨论如何使用 Spring Boot 实现文件存储。我们将涵盖以下主题： 核心概...
"快速搭建分布式文件系统FastDFS安装及介绍
为此，本文将介绍 FastDFS 的安装方法，并提供详细的安装步骤，帮助用户轻松搭建文件存储系统。 首先，用户需要下载 FastDFS 安装文档（fasdfs安装.doc），该文档包含了所有安装所需的必备信息。在获取必备信息后，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值