【Java】多发送端多文件网络传输（初版）

最新推荐文章于 2024-07-06 11:46:55 发布

funyoo

最新推荐文章于 2024-07-06 11:46:55 发布

阅读量810

点赞数 3

分类专栏： java 文章标签： java 网络传输文件传输

本文链接：https://blog.csdn.net/weixin_41978722/article/details/86428595

版权

java 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

多文件多发送端网络传输：顾名思义，就是多个发送端通过网络通信同时给一个接收端发送文件。

为什么说多文件？就那一个Java项目来说，要完成项目发送，就需要发送许多.java或.class或者一些配置文件，这些文件常常相互依存。

如何实现？采用TCP协议

实现逻辑图如下：

对于文件接收方来说： 他需要接收来自多个发送方发送的文件，所以，要以接收方为服务器，让多发送方连接他。

对于文件发送方来说：他只要负责去发送他所需要发送的文件就好。

基础类：

ReceiveFileModel 接收文件

UnreceivedBlockRecord 未接收的文件块记录

接收方：

ResourceReceiveServer 接收端服务器

ResourceSenderCenter 发送中心

进度条：

IResourceReceiveProgress 进度条接口

ResourceReceiveTopProgress 任务弹窗

FileReceiveProgressPanel 进度条

测试：

总结：

文件发送，文件发送，当然要有“文件”，所以咱先从发送方和接收方都需要的公共类出发

基础类：

ReceiveFileModel 接收文件

对于要接收方要接收的文件，需要知晓其文件长度，以及文件需保存到的位置，还有保存未接收到的“文件块”信息。

为什么要分为相对路径和绝对路径呢？对于一个项目来说，其文件所在包(文件夹)是规定好的，这点就算发送到接收端也是不能改变的，这是相对路径。但，该项目保存的位置接收端和发送端可以不同，这是绝对路径。例如：发送端：E:\\sender\\Test\\test.java 接收端只需保证Test\\test,java一致即可

当然，因为这样，当ReceiveFileModel比较时，无须比较其绝对路径

package com.funyoo.fileTransmission.core;

import java.util.Objects;

/**
 * 文件信息类<br>
 *     文件长度
 *     相对路径：文件路径
 *     绝对路径：考虑到不同根目录
 *     未接收部分
 * @author funyoo
 */
public class ReceiveFileModel {
    private long length;                                   // 文件长度
    private String filePath;                               // 相对路径
    private String fileAbsolutePath;                       // 绝对路径
    private UnreceivedBlockRecord unreceivedBlockRecord;   // 未接收文件块

    public ReceiveFileModel(long length, String fileAbsolutePath, String filePath) {
        this.length = length;
        this.filePath = filePath;
        this.fileAbsolutePath = fileAbsolutePath;
        unreceivedBlockRecord = new UnreceivedBlockRecord(length);
    }

    public boolean equals(String filePath) {
        return this.filePath.equals(filePath);
    }

    /**
     * 重写equals方法<br>
     * 比较文件是否相等不必比较绝对路径
     * @param o
     * @return
     */
    @Override
     public boolean equals(Object o) {
        if (this == o) return true;
        System.out.println(getClass());
        System.out.println("o.getClass :   " + o.getClass());
        if (o == null || getClass() != o.getClass()) return false;
        ReceiveFileModel receiveFileModel = (ReceiveFileModel) o;
        return length == receiveFileModel.length &&
                Objects.equals(filePath, receiveFileModel.filePath);
    }

    @Override
    public int hashCode() {
        return Objects.hash(length, filePath);
    }

    String getFilePath() {
        return filePath;
    }

    String getFileAbsolutePath() {
        return fileAbsolutePath;
    }

    public long getLength() {
        return length;
    }

    UnreceivedBlockRecord getUnreceivedBlockRecord() {
        return unreceivedBlockRecord;
    }

    @Override
    public String toString() {
        return "ReceiveFileModel{" +
                "length=" + length +
                ", filePath='" + filePath + '\'' +
                ", fileAbsolutePath='" + fileAbsolutePath + '\'' +
                '}';
    }
}

上面说到“文件块”，文件块就是：组成每个fileModel的“单位”。每个文件由多个“文件块”组成，对于文件收发来说，发送端一块一块发文件，接收端则一块一块收文件。

ResourceBlock 文件块

对于接收到的每一块文件块来说，我当然需要知道

哪个文件？用文件id来区分

哪块数据？用偏移量和长度定位

什么数据？字节数组

同时文件块还完成了保存文件的功能，即，收到一块保存一块

这里采用了线程池来保存文件块，防止频繁创建和销毁线程造成的资源浪费。

package com.funyoo.fileTransmission.core;

import com.funyoo.fileTransmission.view.IResourceReceiveProgress;

import java.io.IOException;
import java.io.RandomAccessFile;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * 文件块：<br>
 * @author funyoo
 */
public class ResourceBlock implements Runnable {
    private int fileId;                     // 文件编号
    private long offset;                    // 偏移量
    private int length;                     // 文件块长度
    private byte[] content;                 // 文件块
    private ReceiveFileSet receiveFileSet;  // 接收文件集合
    private ThreadPoolExecutor threadPool;  // 线程池
    private IResourceReceiveProgress receiveProgress;

    ResourceBlock(ReceiveFileSet receiveFileSet, ThreadPoolExecutor threadPool,
                  IResourceReceiveProgress receiveProgress) {
        this.receiveFileSet = receiveFileSet;
        this.threadPool = threadPool;
        this.receiveProgress = receiveProgress;
    }

    int getFileId() {
        return fileId;
    }

    ResourceBlock setFileId(int fileId) {
        this.fileId = fileId;
        return this;
    }

    long getOffset() {
        return offset;
    }

    ResourceBlock setOffset(long offset) {
        this.offset = offset;
        return this;
    }

    long getLength() {
        return length;
    }

    ResourceBlock setLength(int length) {
        this.length = length;
        return this;
    }

    ResourceBlock setContent(byte[] content) {
        this.content = content;
        return this;
    }

    /**
     * 启动保存文件线程
     */
    public void startWriteBlock() {
        threadPool.execute(this);
    }

    /**
     * 保存文件
     * @param receiveFileModel
     * @throws IOException
     * @throws FileNoFunnd
     */
    private void writeBlock(ReceiveFileModel receiveFileModel) throws IOException, FileNoFunnd {
        if (receiveFileModel == null) {
            throw new FileNoFunnd("文件号[" + fileId + "]不存在");
        }
        RandomAccessFile raf = new RandomAccessFile(
                receiveFileModel.getFileAbsolutePath() + receiveFileModel.getFilePath(),
                "rwd");
        raf.seek(offset);
        raf.write(content);

        raf.close();

        if (receiveProgress != null) {
            receiveProgress.receiveOneBlock(fileId, content.length);
        }
    }

    /**
     * 保存文件线程
     */
    @Override
    public void run() {
        ReceiveFileModel receiveFile = receiveFileSet.getFile(fileId);
        try {
            writeBlock(receiveFile);
            receiveFile.getUnreceivedBlockRecord().receiveBlock(this);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (FileNoFunnd fileNoFunnd) {
            fileNoFunnd.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

上个类提到了文件集合，对于多文件多发送端传输而言，接收端有其需要的接收文件信息的集合，发送端有其需要发送文件信息的的集合，这两个集合的相同文件需要通过公有的属性联系起来。

ReceiveFileSet 文件集合

这其中的map用来存储文件编号与文件的一一对应关系表

package com.funyoo.fileTransmission.core;

import java.util.*;

/**
 * 接收文件集合<br>
 *     该类存储着文件编号和文件的对应关系
 * @author funyoo
 */
public class ReceiveFileSet {
    private Map<Integer, ReceiveFileModel> fileMap;
    private long totalReceiveBytes;

    public ReceiveFileSet() {
        fileMap = new HashMap<>();
    }

    long getTotalReceiveBytes() {
        return totalReceiveBytes;
    }

    /**
     * 通过文件编号获得文件
     *
     * @param fileId
     * @return
     */
    ReceiveFileModel getFile(int fileId) {
        return fileMap.get(fileId);
    }

    /**
     * 通过文件路径查找文件编号
     *
     * @param path
     * @return
     */
    int getFileIdByPath(String path) {
        for (int fileId : fileMap.keySet()) {
            ReceiveFileModel receiveFileModel = fileMap.get(fileId);
            if (receiveFileModel.equals(path))
                return fileId;
        }
        return -1;
    }

    /**
     * 增加文件
     *
     * @param fileId
     * @param receiveFileModel
     */
    public void addReceiveFile(int fileId, ReceiveFileModel receiveFileModel) throws ReceiveFileAlreadyExist {
        ReceiveFileModel file = fileMap.get(fileId);
        if (file != null) {
            throw new ReceiveFileAlreadyExist("文件编号[" + fileId + "]重复！");
        }
        totalReceiveBytes += receiveFileModel.getLength();
        fileMap.put(fileId, receiveFileModel);
    }

    public int getTotalReceiveFiles() {
        return fileMap.size();
    }
}

当然，发送方发送的文件也需要定义

SendFileModel 发送文件

package com.funyoo.fileTransmission.core;

/**
 * 发送的文件
 * @author funyoo
 */
public class SendFileModel {
    private String fileAbsolutePath;    // 文件绝对路径
    private String filePath;            // 文件相对路径
    private int length;                 // 发送长度
    private long offset;                // 发送偏移量

    public SendFileModel(String fileAbsolutePath, String filePath, long offset, int length) {
        this.fileAbsolutePath = fileAbsolutePath;
        this.filePath = filePath;
        this.length = length;
        this.offset = offset;
    }

    SendFileModel() {
    }

    String getFileAbsolutePath() {
        return fileAbsolutePath;
    }

    void setFileAbsolutePath(String fileAbsolutePath) {
        this.fileAbsolutePath = fileAbsolutePath;
    }

    String getFilePath() {
        return filePath;
    }

    void setFilePath(String filePath) {
        this.filePath = filePath;
    }


    int getLength() {
        return length;
    }

    void setLength(int length) {
        this.length = length;
    }

    long getOffset() {
        return offset;
    }

    void setOffset(long offset) {
        this.offset = offset;
    }
}

还有一点未提到，记不记得文件的传输是以文件块为单位传输的，细心的可以发现，每个接收文件类中都包含了一个未接受的文件块对象。我们如何表示文件块记录信息呢？当然是偏移量 + 长度

BlockRecord 文件块记录

package com.funyoo.fileTransmission.core;

/**
 * 文件块记录
 * @author funyoo
 */
public class BlockRecord {
    private long offset;
    private long length;

    BlockRecord(long offset, long length) {
        this.offset = offset;
        this.length = length;
    }

    long getOffset() {
        return offset;
    }

    void setOffset(long offset) {
        this.offset = offset;
    }

    long getLength() {
        return length;
    }

    void setLength(long length) {
        this.length = length;
    }
}

UnreceivedBlockRecord 未接收的文件块记录

每接收并一个文件块的时候都需要将未接受到的文件块记录列表更新

如何更新？请看代码后附图

package com.funyoo.fileTransmission.core;

import java.util.LinkedList;
import java.util.List;

/**
 * 未接收到的文件块记录<br>
 *     为以后实现的断点续传做准备
 */
public class UnreceivedBlockRecord {
    private List<BlockRecord> blockList;     // 未接受到的块列表

    /**
     * 根据文件长度初始化记录表的长度
     * @param fileLength
     */
    UnreceivedBlockRecord(long fileLength) {
        blockList = new LinkedList<>();
        blockList.add(new BlockRecord(0, fileLength));
    }

    /**
     * 定位块位置
     * @param curOffset
     * @return
     * @throws Exception
     */
    private int getTheBlock(long curOffset) throws Exception {
        for (int index = 0; index < blockList.size(); index++) {
            BlockRecord record = blockList.get(index);
            if (curOffset <= record.getOffset() + record.getLength()) {
                return index;
            }
        }
        throw new Exception("块编号未找到:" + curOffset);
    }

    /**
     * 接收到文件块，更新列表操作
     * @param curBlock
     * @throws Exception
     */
    synchronized void receiveBlock(ResourceBlock curBlock) throws Exception {
        long curOffset = curBlock.getOffset();
        long curLength = curBlock.getLength();
        int orgBlockIndex = getTheBlock(curOffset);
        BlockRecord orgBlock = blockList.get(orgBlockIndex);
        long orgOffset = orgBlock.getOffset();
        long orgLength = orgBlock.getLength();

        long leftOffset = orgOffset;
        long leftLength = curOffset - orgOffset;
        long rightOffset = curOffset + curLength;
        long rightLength = orgOffset + orgLength - rightOffset;

        blockList.remove(orgBlock);
        if (rightLength > 0)
            blockList.add(orgBlockIndex, new BlockRecord(rightOffset, rightLength));
        if (leftLength > 0)
            blockList.add(orgBlockIndex, new BlockRecord(leftOffset, leftLength));
    }
}

这个记录列表有什么用？为以后未实现的断点续传功能打基础。

至此，基础类就告一段落了。

下面从构建接收方服务器这边开始：

接收方：

ResourceReceiveServer 接收端服务器

接收端服务器需要做什么？1.侦听多发送端连接 2.启动服务器 3.关闭服务器

接收方每接收到一个发送端的连接请求，就会生成一个接收者ResourceReceiver与该发送端通信，待侦听到计划的所有的发送端，开始判断所有接收者是否都完成任务（接受和保存），这里进行接收完毕的操作(关闭线程池等)。

这里同时提供了进度条的选项，使用者可以使用默认进度条。

package com.funyoo.fileTransmission.core;

import com.funyoo.fileTransmission.view.IResourceReceiveProgress;

import javax.swing.*;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.*;

/**
 * 接收端服务器：<br>
 * 接受文件方应建立服务器<br>
 * 以接受多个发送端发送文件<br>
 * @author funyoo
 */
public class ResourceReceiveServer implements Runnable {
    private ServerSocket receiver;            // 文件接收端
    private int port;                         // 接收端端口
    private Object lock;                      // 锁
    private boolean continueWaittingSender;   // 判断是否继续侦听标志
    private ReceiveFileSet receiveFileSet;    // 需要接收的文件集合
    private ThreadPoolExecutor threadPool;    // 线程池
    private int senderCount;
    private IResourceReceiveProgress receiveProgress;

    public ResourceReceiveServer() {
        this(0, null);
    }

    public ResourceReceiveServer(int port, IResourceReceiveProgress receiveProgress) {
        threadPool = new ThreadPoolExecutor(50, 100,
                500, TimeUnit.MICROSECONDS, new LinkedBlockingDeque<>());
        this.port = port;
        this.receiveProgress = receiveProgress;
    }

    public void setPort(int port) {
        this.port = port;
    }

    public void setReceiveFileSet(ReceiveFileSet receiveFileSet) {
        this.receiveFileSet = receiveFileSet;
        if (receiveProgress != null) {
            receiveProgress.setSenderPlan(
                    receiveFileSet.getTotalReceiveFiles(),
                    receiveFileSet.getTotalReceiveBytes());
        }
    }

    public void setSenderCount(int senderCount) {
        this.senderCount = senderCount;
    }

    /**
     * 启动接收端服务器
     */
    public void startup() {
        try {
            receiver = new ServerSocket(port);
            continueWaittingSender = true;
            Thread thread = new Thread(this,"Receiver");
            thread.start();
            // 确保侦听线程已经启动
            synchronized (ResourceReceiveServer.class) {
                ResourceReceiveServer.class.wait();
            }
            if (receiveProgress != null) {
                receiveProgress.startShowProgress();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /**
     * 关闭接收端服务器
     */
    private void shutdown() {
        if (receiver != null && !receiver.isClosed()) {
            try {
                receiver.close();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                receiver = null;
            }
        }
    }

    /**
     * 文件传输线程
     * 每侦听到一个发送端的连接，处理其与接受端的对话
     */
    @Override
    public void run() {
        int currentSenderCount = 0;
        synchronized (ResourceReceiveServer.class) {
            ResourceReceiveServer.class.notify();
        }
        if (receiveProgress != null) {
            boolean receiveProgressIsShow = false;
            while (!receiveProgressIsShow) {
                receiveProgressIsShow = ((JDialog) receiveProgress).isActive();
            }
        }
        while (continueWaittingSender && currentSenderCount < senderCount) {
            try {
                Socket sender = receiver.accept();
                if (receiveProgress != null) {
                    String senderInfo = sender
                            .getInetAddress()
                            .getHostName();
                    receiveProgress.acceptOneSender(senderInfo);
                }
                // 开始接收文件
                new ResourceReceiver(sender, receiveFileSet, threadPool, receiveProgress);
                currentSenderCount++;
            } catch (IOException e) {
                e.printStackTrace();
                continueWaittingSender = false;
            }
        }
        boolean threadIsAllFinished = threadPool.getActiveCount() > 0;
        while (threadIsAllFinished) {
            threadIsAllFinished = threadPool.getActiveCount() > 0;
        }
        threadPool.shutdown();
        if (receiveProgress != null) {
            receiveProgress.finishedReceive();
        }
        shutdown();
    }

}

需要解释的是，在启动侦听线程的时候加了一个锁，该锁的目的是保证侦听线程的代码在启动服务器方法结束前执行。避免启动服务器后操作因为侦听代码未真正执行起来而出现错误。

进度条需外界设置，若为null，则不进行进度条呢的操作。

ResourceReceiver 接收者

这个类用来处理和其对应发送端的通信，其主要功能是接收文件和保存文件。

接收文件：先接收由发送端发来的16字节文件头部信息，解析信息，根据解析的文件信息，创建对应的长度的“容器”（block），接收对应长度的文件内容，并保存。

当接收到文件编号为-1时，停止接收。

保存文件：见ResourceBlock类

package com.funyoo.fileTransmission.core;

import com.funyoo.fileTransmission.util.ByteAndString;
import com.funyoo.fileTransmission.view.IResourceReceiveProgress;

import java.io.DataInputStream;
import java.io.IOException;
import java.net.Socket;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * 处理与发送端的对话<br>
 * @author funyoo
 */
public class ResourceReceiver implements Runnable {
    private Socket sender;                              // 与之通信的发送端
    private DataInputStream dis;                        // 输入信道
    private ReceiveFileSet receiveFileSet;              // 需要接受的文件集合
    private ThreadPoolExecutor threadPool;              // 线程池
    private volatile Object lock;                       // 锁
    private IResourceReceiveProgress receiveProgress;   // 接收进度条

    static final ThreadLocal threadFileId
            = new ThreadLocal<Integer>() {
        @Override
        protected Integer initialValue() {
            return -1;
        }
    };

    ResourceReceiver(Socket sender, ReceiveFileSet receiveFileSet,
                     ThreadPoolExecutor threadPool, IResourceReceiveProgress receiveProgress) {
        this.sender = sender;
        this.receiveFileSet = receiveFileSet;
        this.threadPool = threadPool;
        this.receiveProgress = receiveProgress;
        lock = new Object();
        try {
            dis = new DataInputStream(sender.getInputStream());
            threadPool.execute(this);
            synchronized (lock) {
                lock.wait();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /**
     * 接收文件
     */
    private boolean receiverOneBlock() throws IOException {
        byte[] header = receiveBytes(16, -2);
        // 解析字节信息
        int fileId = ByteAndString.getIntAt(header, 0);
        long offset = ByteAndString.getLongAt(header, 4);
        int length = ByteAndString.getIntAt(header, 12);

        if (fileId == -1) {
            return true;
        }

        if (receiveProgress != null) {
            int oldFileId = (int) threadFileId.get();
            if (oldFileId != fileId) {
                threadFileId.set(fileId);
                ReceiveFileModel rfm = receiveFileSet.getFile(fileId);
                String fileName = rfm.getFilePath();
                int fileLength = (int) rfm.getLength();
                receiveProgress.receiveNewFile(fileId, fileName, fileLength);
            }
        }

        ResourceBlock block = new ResourceBlock(receiveFileSet, threadPool, receiveProgress);
        // 接收文件内容
        byte[] content = receiveBytes(length, fileId);
        block.setFileId(fileId)
                .setOffset(offset)
                .setLength(length)
                .setContent(content);
        // 保存文件
        block.startWriteBlock();

        return false;
    }

    /**
     * 接收文件内容
     * @param length
     * @return
     */
    private byte[] receiveBytes(int length, int fileId) throws IOException {
        byte[] content = new byte[length];
        int offset = 0;
        int realReceiveLength = 0;

        while (length > 0) {
            realReceiveLength = dis.read(content, offset, length);
            length -= realReceiveLength;
            offset += realReceiveLength;
            if (receiveProgress != null && fileId != -2) {
                receiveProgress.receiveOneBlock(fileId, realReceiveLength);
            }
        }

        return content;
    }

    /**
     * 接收文件线程
     */
    @Override
    public void run() {
        boolean finished = false;
        synchronized (lock) {
            lock.notify();
        }
        while (!finished) {
            // 接收文件
            try {
                finished = receiverOneBlock();
            } catch (IOException e) {
                e.printStackTrace();
                stop();
            }
        }
    }

    /**
     * 关闭
     */
    private void stop() {
        if (sender != null || !sender.isClosed()) {
            try {
                sender.close();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                sender = null;
            }
        }
        if (dis != null) {
            try {
                dis.close();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                dis = null;
            }
        }
    }

}

说到这里，不得不提到字节工具，发送端需要将自己的文件信息“编辑”成16字节，接收者需要解析这16字节。