2，分布式文件存储FastDFS

代码实现过程：

1.引入依赖，表示是FastDFS的客户端

2.配置FastDFS配置文件信息，里面包含了FastDFS的路径、端口、连接超时时间等(注意这个我并没有加载，在使用的时候在工具类中加载这个文件的，从而获取Tracker对象)

3.SpringBoot配置文件application.yml配置multipart设置上传文件大小

4.启动类加入@SpringBootApplication(exclude={DataSourceAutoConfiguration.class})：排除数据库自动加载

5.已经搭建完成了

6.前端请求上传，controller层使用Multipart接收，文件的信息封装在里面。

7.创建一个实体类FastDFSFile，用户封装Multipart中的信息，例如文件的名字、内容、后缀名等。然后然后调用工具类发方法把这个实体类传入到工具类中，使用工具类上传到服务器中。返回

8.工具类首先要加载fdfs_client.conf配置文件，然后通过获得实体类FastDFSFile中的信息发送给服务。

9.工具类执行文件上传，会返回字符串集合，然后返回给controller层。

10.controller层再通过工具类获取tracker 的ip和端口的信息，然后和字符串拼接成完整的URL返回给前端

1，简介

简单来说就是部署在服务器中，然后把文件上传到改服务器中的技术。是一个分布式系统。

需要安装到docker上的。

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

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

FastDFS 架构包括 Tracker server 和 Storage server。客户端请求 Tracker server 进行文件上传、下载，通过Tracker server 调度最终由 Storage server 完成文件上传和下载。

Tracker server 作用是负载均衡和调度，通过 Tracker server 在文件上传时可以根据一些策略找到Storage server 提供文件上传服务。可以将 tracker 称为追踪服务器或调度服务器。Storage server 作用是文件存储，客户端上传的文件最终存储在 Storage 服务器上，Storageserver 没有实现自己的文件系统而是利用操作系统的文件系统来管理文件。可以将storage称为存储服务器。

2，上传流程

两个组件：Tracker负责文件管理负载均衡操作，控制中心（注册中心）

​ Storage 文件上传、文件下载、文件删除、文件修改等…

storage Sever定时向Tracker Server注册（Tracker Server更多是调度的作用）。

用户请求上传文件请求Tracker，Tracker调用Storage查找可用的storage，tracker把查找到的storage返回给客户端（storage的IP和端口，作用就可以准确找到哪一个Storage Server)，客户端就根据IP和端口找到storage，客户端上传文件的时候就会到这个Storager中，并且会在storage会创建升恒file_id并把上传文件内容写入磁盘（服务器中）。storage返回信息给客户端，客户端可以吧这些路径信息存到数据库中。这样我们就可以从数据库中获取路径从而找到storage服务器中文件

注意，storage是以组的方式集群

项目中的流程：文件上传到我们的项目，项目从tracker获取storage返回给项目，然后项目就把文件上传到storage就可以了。

客户端上传文件后存储服务器将文件 ID 返回给客户端，此文件 ID 用于以后访问该文件的索引信息。文件索引信息包括：组名，虚拟磁盘路径，数据两级目录，文件名。

组名：文件上传后所在的 storage 组名称，在文件上传成功后有storage 服务器返回，需要客户端自行保存。

虚拟磁盘路径：storage 配置的虚拟路径，与磁盘选项store_path*对应。如果配置了

store_path0 则是 M00，如果配置了 store_path1 则是 M01，以此类推。

数据两级目录：storage 服务器在每个虚拟磁盘路径下创建的两级目录，用于存储数据

文件。

文件名：与文件上传时不同。是由存储服务器根据特定信息生成，文件名包含：源存储

服务器 IP 地址、文件创建时间戳、文件大小、随机数和文件拓展名等信息。

访问服务器中的文件是，是通过Nginx访问的。

3，文件存储微服务

默认FastDFS已经安装好。

创建文件管理微服务changgou-service-file，该工程主要用于实现文件上传以及文件删除等功能。

3.1 依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>changgou-service</artifactId>
        <groupId>com.changgou</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <artifactId>changgou-service-file</artifactId>
    <description>文件上传工程</description>

    <!--依赖包-->
    <dependencies>
        <dependency>
            <groupId>net.oschina.zcx7878</groupId>
            <artifactId>fastdfs-client-java</artifactId>
            <version>1.27.0.0</version>
        </dependency>
        <dependency>
            <groupId>com.changgou</groupId>
            <artifactId>changgou-common</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>
</project>

3.2 FastDFS配置

搭建上传服务需要的配置文件，其中端口和路径是stacker的路径，因为要先通过stacker才能获取到storage

在resources文件夹下创建fasfDFS的配置文件fdfs_client.conf

connect_timeout=60
network_timeout=60
charset=UTF-8
http.tracker_http_port=8080
tracker_server=192.168.211.132:22122

connect_timeout：连接超时时间，单位为秒。

network_timeout：通信超时时间，单位为秒。发送或接收数据时。假设在超时时间后还不能发送或接收数据，则本次网络通信失败

charset： 字符集

http.tracker_http_port ：.tracker的http端口

tracker_server： tracker服务器IP和端口设置

注意这里是tracker的路径，因为要先通过找到tracker才能获取到storage

3.2 SpringBoot配置文件

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

max-file-size是单个文件大小，max-request-size是设置总上传的数据大小

3.3 启动类

创建com.changgou包，创建启动类FileApplication

// 排除数据库自动加载 	 
@SpringBootApplication(exclude={
    
    DataSourceAutoConfiguration.class})
@EnableEurekaClient
public class FileApplication {
    
    

    public static void main(String[] args) {
    
    
        SpringApplication.run(FileApplication.class);
    }
}

上传文件服务的启动类需要加入@SpringBootApplication(exclude={DataSourceAutoConfiguration.class})

排除数据库主动加载，因为该服务引用了changgou-common（里面有加载数据库的依赖）。如果不排除主动加载会报错。

4，文件上传

操作过程：

前端点击上传文件后台是使用MultipartFile来接受，从MultipartFile中获取里面的信息（包括文件名等），把这些信息封装到FastDFSFile对象中，然后使用上传工具类发文件发送到服务器中。把这些封装信息的对象传入到工具类中就能可以实现上传了，因为上传的时候需要的就这这些信息（文件名，字节类型，后缀名）。最后返回URL给前端显示。

4.1 文件信息封装

文件上传一般都有文件的名字、文件的内容、文件的扩展名、文件的md5值、文件的作者等相关属性，我们可以创建一个对象封装这些属性，录入上传一张图片就需要这些信息

代码如下：

创建com.changgou.file.FastDFSFile代码如下：

public class FastDFSFile implements Serializable {
    
    

    //文件名字
    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 md5, String author) {
    
    
        this.name = name;
        this.content = content;
        this.ext = ext;
        this.md5 = md5;
        this.author = author;
    }

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

    public FastDFSFile() {
    
    
    }

    //..get..set..toString
}

4.2 controller文件上传

MultipartFile接受文件上传

创建一个FileController，在该控制器中实现文件上传操作，代码如下：

@RestController
@CrossOrigin
public class FileController {
    
    

    /***
     * 文件上传
     * @return
     */
    @PostMapping(value = "/upload")
    public String upload(@RequestParam("file")MultipartFile file) throws Exception {
    
    
        //封装一个FastDFSFile
        FastDFSFile fastDFSFile = new FastDFSFile(
                file.getOriginalFilename(), //文件名字
                file.getBytes(),            //文件字节数组
                StringUtils.getFilenameExtension(file.getOriginalFilename()));//文件扩展名

        //文件上传
        String[] uploads = FastDFSClient.upload(fastDFSFile);
        // 拼接访问地址
        String url =  FastDFSClient.getTrackerUrl()+"/"+uploads[0]+"/"+uploads[1];
        //组装文件上传地址	
        return new Result(true, StatusCode.OK, url);
    }
}

4.2 文件操作工具类

(1)初始化Tracker信息

在com.changgou.util.FastDFSClient类中初始化Tracker信息,在类中添加如下静态块：

就是要加载这个配置文件

/***
 * 初始化tracker信息
 */
static {
    
    
    try {
    
    
        //获取tracker的配置文件fdfs_client.conf的位置
        String filePath = new ClassPathResource("fdfs_client.conf").getPath();
        //加载tracker配置信息
        ClientGlobal.init(filePath);
    } catch (Exception e) {
    
    
        e.printStackTrace();
    }
}

(2)操作文件

方法中都会涉及到获取TrackerServer或者StorageClient，我们可以把它们单独抽取出去，分别在类中添加如下2个方法：

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

/***
 * 获取StorageClient
 * @return
 * @throws Exception
 */
public static StorageClient getStorageClient() throws Exception{
    
    
    //获取TrackerServer
    TrackerServer trackerServer = getTrackerServer();
    //通过TrackerServer创建StorageClient
    StorageClient storageClient = new StorageClient(trackerServer,null);
    return storageClient;
}

修改其他方法，在需要使用TrackerServer和StorageClient的时候，直接调用上面的方法,完整代码如下：

public class FastDFSClient {
    
    

    /***
     * 初始化tracker信息
     */
    static {
    
    
        try {
    
    
            //获取tracker的配置文件fdfs_client.conf的位置
            String filePath = new ClassPathResource("fdfs_client.conf").getPath();
            //加载tracker配置信息
            ClientGlobal.init(filePath);
        } catch (Exception e) {
    
    
            e.printStackTrace();
        }
    }

    /****
     * 文件上传
     * @param file : 要上传的文件信息封装->FastDFSFile
     * @return String[]
     *          1:文件上传所存储的组名
     *          2:文件存储路径
     */
    public static String[] upload(FastDFSFile file){
    
    
        //获取文件作者
        NameValuePair[] meta_list = new NameValuePair[1];
        meta_list[0] =new NameValuePair(file.getAuthor());

        /***
         * 文件上传后的返回值
         * uploadResults[0]:文件上传所存储的组名，例如:group1
         * uploadResults[1]:文件存储路径,例如：M00/00/00/wKjThF0DBzaAP23MAAXz2mMp9oM26.jpeg
         */
        String[] uploadResults = null;
        try {
    
    
            //获取StorageClient对象
            StorageClient storageClient = getStorageClient();
            /**执行文件上传
             *1 上传文件字节数组
             *2 文件的后缀名
             * 3 附加参数 例如拍摄场地：广州
             其中file.getExt在controller层就把后缀名加到FastDFSFile中了
            */
            uploadResults = storageClient.upload_file(file.getContent(), file.getExt(), meta_list);
        } catch (Exception e) {
    
    
            e.printStackTrace();
        }
        return uploadResults;
    }


    /***
     * 获取文件信息
     * @param groupName:组名
     * @param remoteFileName：文件存储完整名
     */
    public static FileInfo getFile(String groupName,String remoteFileName){
    
    
        try {
    
    
            //获取StorageClient对象
            StorageClient storageClient = getStorageClient();
            //获取文件信息
            return storageClient.get_file_info(groupName,remoteFileName);
        } catch (Exception e) {
    
    
            e.printStackTrace();
        }
        return null;
    }

    /***
     * 文件下载
     * @param groupName:组名
     * @param remoteFileName：文件存储完整名
     * @return
     */
    public static InputStream downFile(String groupName,String remoteFileName){
    
    
        try {
    
    
            //获取StorageClient
            StorageClient storageClient = getStorageClient();
            //通过StorageClient下载文件
            byte[] fileByte = storageClient.download_file(groupName, remoteFileName);
            //将字节数组转换成字节输入流
            return new ByteArrayInputStream(fileByte);
        } catch (Exception e) {
    
    
            e.printStackTrace();
        }
        return null;
    }

    /***
     * 文件删除实现
     * @param groupName:组名
     * @param remoteFileName：文件存储完整名
     */
    public static void deleteFile(String groupName,String remoteFileName){
    
    
        try {
    
    
            //获取StorageClient
            StorageClient storageClient = getStorageClient();
            //通过StorageClient删除文件
            storageClient.delete_file(groupName,remoteFileName);
        } catch (Exception e) {
    
    
            e.printStackTrace();
        }
    }


    /***
     * 获取组信息
     * @param groupName :组名
     */
    public static StorageServer getStorages(String groupName){
    
    
        try {
    
    
            //创建TrackerClient对象
            TrackerClient trackerClient = new TrackerClient();
            //通过TrackerClient获取TrackerServer对象
            TrackerServer trackerServer = trackerClient.getConnection();
            //通过trackerClient获取Storage组信息
            return trackerClient.getStoreStorage(trackerServer,groupName);
        } catch (Exception e) {
    
    
            e.printStackTrace();
        }
        return null;
    }

    /***
     * 根据文件组名和文件存储路径获取Storage服务的IP、端口信息
     * @param groupName :组名
     * @param remoteFileName ：文件存储完整名
     */
    public static ServerInfo[] getServerInfo(String groupName, String remoteFileName){
    
    
        try {
    
    
            //创建TrackerClient对象
            TrackerClient trackerClient = new TrackerClient();
            //通过TrackerClient获取TrackerServer对象
            TrackerServer trackerServer = trackerClient.getConnection();
            //获取服务信息
            return trackerClient.getFetchStorages(trackerServer,groupName,remoteFileName);
        } catch (Exception e) {
    
    
            e.printStackTrace();
        }
        return null;
    }

    /***
     * 获取Tracker服务地址
     */
    public static String getTrackerUrl(){
    
    
        try {
    
    
            //创建TrackerClient对象
            TrackerClient trackerClient = new TrackerClient();
            //通过TrackerClient获取TrackerServer对象
            TrackerServer trackerServer = trackerClient.getConnection();
            //获取Tracker地址
            return "http://"+trackerServer.getInetSocketAddress().getHostString()+":"+ClientGlobal.getG_tracker_http_port();
        } catch (IOException e) {
    
    
            e.printStackTrace();
        }
        return null;
    }

    /***
     * 获取TrackerServer
     */
    public static TrackerServer getTrackerServer() throws Exception{
    
    
        //创建TrackerClient对象
        TrackerClient trackerClient = new TrackerClient();
        //通过TrackerClient获取TrackerServer对象
        TrackerServer trackerServer = trackerClient.getConnection();
        return trackerServer;
    }

    /***
     * 获取StorageClient
     * @return
     * @throws Exception
     */
    public static StorageClient getStorageClient() throws Exception{
    
    
        //获取TrackerServer
        TrackerServer trackerServer = getTrackerServer();
        //通过TrackerServer创建StorageClient
        StorageClient storageClient = new StorageClient(trackerServer,null);
        return storageClient;
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Bv6fN8Ak-1596182843330)(C:\Users\MT\AppData\Local\Temp\1596182789950.png)]

etConnection();
return trackerServer;
}

/***
 * 获取StorageClient
 * @return
 * @throws Exception
 */
public static StorageClient getStorageClient() throws Exception{
    //获取TrackerServer
    TrackerServer trackerServer = getTrackerServer();
    //通过TrackerServer创建StorageClient
    StorageClient storageClient = new StorageClient(trackerServer,null);
    return storageClient;
}

}

![\[外链图片转存中...(img-Bv6fN8Ak-1596182843330)\]](https://img-blog.csdnimg.cn/20200731171810188.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1ODUwODcy,size_16,color_FFFFFF,t_70)