关于Java单个TCP(Socket)连接发送多个文件的问题
使用一个TCP连接发送多个文件
为什么会有这篇博客？ 最近在看一些相关方面的东西，简单的使用一下 Socket 进行编程是没有的问题的，但是这样只是建立了一些基本概念。对于真正的问题，还是无能为力。
当我需要进行文件的传输时，我发现我好像只是发送过去了数据（二进制数据），但是关于文件的一些信息却丢失了（文件的扩展名）。而且每次我只能使用一个 Socket 发送一个文件，没有办法做到连续发送文件（因为我是依靠关闭流来完成发送文件的，也就是说我其实是不知道文件的长度，所以只能以一个 Socket 连接代表一个文件）。
这些问题困扰了我好久，我去网上简单的查找了一下，没有发现什么现成的例子（可能没有找到吧），有人提了一下，可以自己定义协议进行发送。 这个倒是激发了我的兴趣，感觉像是明白了什么，因为我刚学过计算机网络这门课，老实说我学得不怎么样，但是计算机网络的概念我是学习到了。
计算机网络这门课上，提到了很多协议，不知不觉中我也有了协议的概念。所以我找到了解决的办法：自己在 TCP 层上定义一个简单的协议。 通过定义协议，这样问题就迎刃而解了。
协议的作用
从主机1到主机2发送数据，从应用层的角度看，它们只能看到应用程序数据，但是我们通过图是可以看出来的，数据从主机1开始，每向下一层数据会加上一个首部，然后在网络上进行传播，当到达主机2后，每向上一层会去掉一个首部，达到应用层时，就只有数据了。（这里只是简单的说明一下，实际上这样还是不够严谨，但是对于简单的理解是够了。）
所以，我可以自己定义一个简单的协议，将一些必要的信息放在协议头部，然后让计算机程序自己解析协议头部信息，而且每一个协议报文就相当于一个文件。这样多个协议就是多个文件了。而且协议之间是可以区分的，不然的话，连续传输多个文件，如果无法区分属于每个文件的字节流，那么传输是毫无意义的。
定义数据的发送格式（协议）
这里的发送格式（我感觉和计算机网络中的协议有点像，也就称它为一个简单的协议吧）。
发送格式：数据头+数据体
数据头：一个长度为一字节的数据，表示的内容是文件的类型。 注：因为每个文件的类型是不一样的，而且长度也不相同，我们知道协议的头部一般是具有一个固定长度的（对于可变长的那些我们不考虑），所以我采用一个映射关系，即一个字节数字表示一个文件的类型。
举一个例子，如下：
| key | value |
| 0 | txt |
| 1 | png |
| 2 | jpg |
| 3 | jpeg |
| 4 | avi |
注：这里我做的是一个模拟，所以我只要测试几种就行了。
数据体： 文件的数据部分（二进制数据）。
代码
客户端
协议头部类
package com.draGon;
public class Header {
private byte type; //文件类型
private long length; //文件长度
public Header(byte type, long length) {
super();
this.type = type;
this.length = length;
}
public byte getType() {
return this.type;
}
public long getLength() {
return this.length;
}
}
发送文件类
package com.dragon;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.net.Socket;
public class FileTransfer {
private byte[] header = new byte[9]; //协议的头部为9字节，第一个字节为文件类型，后面8个字节为文件的字节长度。
public void transfer(Socket client, String src) throws FileNotFoundException, IOException {
File srcFile = new File(src);
File[] files = srcFile.listFiles(f->f.isFile());
//获取输出流
BufferedOutputStream bos = new BufferedOutputStream(client.getOutputStream());
for (File file : files) {
try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file))){
//将文件写入流中
String filename = file.getName();
System.out.println(filename);
//获取文件的扩展名
String type = filename.substring(filename.lastIndexOf(".")+1);
long len = file.length();
//使用一个对象来保存文件的类型和长度信息，操作方便。
Header h = new Header(this.getType(type), len);
header = this.getHeader(h);
//将文件基本信息作为头部写入流中
bos.write(header, 0, header.length);
//将文件数据作为数据部分写入流中
int hasRead = 0;
byte[] b = new byte[1024];
while ((hasRead = bis.read(b)) != -1) {
bos.write(b, 0, hasRead);
}
bos.flush(); //强制刷新，否则会出错！
}
}
}
private byte[] getHeader(Header h) {
byte[] header = new byte[9];
byte t = h.getType();
long v = h.getLength();
header[0] = t; //版本号
header[1] = (byte)(v >>> 56); //长度
header[2] = (byte)(v >>> 48);
header[3] = (byte)(v >>> 40);
header[4] = (byte)(v >>> 32);
header[5] = (byte)(v >>> 24);
header[6] = (byte)(v >>> 16);
header[7] = (byte)(v >>> 8);
header[8] = (byte)(v >>> 0);
return header;
}
private byte getType(String type) {
byte t = 0;
switch (type.toLowerCase()) {
case "txt": t = 0; break;
case "png": t=1; break;
case "jpg": t=2; break;
case "jpeg": t=3; break;
case "avi": t=4; break;
}
return t;
}
}
注：
- 发送完一个文件后需要强制刷新一下。因为我是使用的缓冲流，我们知道为了提高发送的效率，并不是一有数据就发送，而是等待缓冲区满了以后再发送，因为 IO 过程是很慢的（相较于 CPU），所以如果不刷新的话，当数据量特别小的文件时，可能会导致服务器端接收不到数据（这个问题，感兴趣的可以去了解一下。），这是一个需要注意的问题。（我测试的例子有一个文本文件只有31字节）。
getLong（）方法将一个 long 型数据转为 byte 型数据，我们知道 long 占8个字节，但是这个方法是我从Java源码里面抄过来的，有一个类叫做 DataOutputStream，它有一个方法是 writeLong()，它的底层实现就是将 long 转为 byte，所以我直接借鉴过来了。（其实，这个也不是很复杂，它只是涉及了位运算，但是写出来这个代码就是很厉害了，所以我选择直接使用这段代码，如果对于位运算感兴趣，可以参考一个我的博客：位运算）。
测试类
package com.dragon;
import java.io.IOException;
import java.net.Socket;
import java.net.UnknownHostException;
//类型使用代号：固定长度
//文件长度：long->byte 固定长度
public class Test {
public static void main(String[] args) throws UnknownHostException, IOException {
FileTransfer fileTransfer = new FileTransfer();
try (Socket client = new Socket("127.0.0.1", 8000)) {
fileTransfer.transfer(client, "D:/DBC/src");
}
}
}
服务器端
协议解析类
package com.dragon;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.Socket;
import java.util.UUID;
public class FileResolve {
private byte[] header = new byte[9];
public void fileResolve(Socket client, String des) throws IOException {
BufferedInputStream bis = new BufferedInputStream(client.getInputStream());
File desFile = new File(des);
if (!desFile.exists()) {
if (!desFile.mkdirs()) {
throw new FileNotFoundException("无法创建输出路径");
}
}
while (true) {
//先读取文件的头部信息
int exit = bis.read(header, 0, header.length);
//当最后一个文件发送完，客户端会停止，服务器端读取完数据后，就应该关闭了，
//否则就会造成死循环，并且会批量产生最后一个文件，但是没有任何数据。
if (exit == -1) {
System.out.println("文件上传结束！");
break;
}
String type = this.getType(header[0]);
String filename = UUID.randomUUID().toString()+"."+type;
System.out.println(filename);
//获取文件的长度
long len = this.getLength(header);
long count = 0L;
try (BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(new File(des, filename)))){
int hasRead = 0;
byte[] b = new byte[1024];
while (count < len && (hasRead = bis.read(b)) != -1) {
bos.write(b, 0, hasRead);
count += (long)hasRead;
int last = (int)(len-count);
if (last < 1024 && last > 0) {
//这里不考虑网络原因造成的无法读取准确的字节数，暂且认为网络是正常的。
byte[] lastData = new byte[last];
bis.read(lastData);
bos.write(lastData, 0, last);
count += (long)last;
}
}
}
}
}
private String getType(int type) {
String t = "";
switch (type) {
case 0: t = "txt"; break;
case 1: t = "png"; break;
case 2: t = "jpg"; break;
case 3: t = "jpeg"; break;
case 4: t = "avi"; break;
}
return t;
}
private long getLength(byte[] h) {
return (((long)h[1] << 56) +
((long)(h[2] & 255) << 48) +
((long)(h[3] & 255) << 40) +
((long)(h[4] & 255) << 32) +
((long)(h[5] & 255) << 24) +
((h[6] & 255) << 16) +
((h[7] & 255) << 8) +
((h[8] & 255) << 0));
}
}
注：
- 这个将 byte 转为 long 的方法，相信大家也能猜出来了。DataInputStream 有一个方法叫 readLong()，所以我直接拿来使用了。（我觉得这两段代码写的非常好，不过我就看了几个类的源码，哈哈！）
- 这里我使用一个死循环进行文件的读取，但是我在测试的时候，发现了一个问题很难解决：什么时候结束循环。 我一开始使用 client 关闭作为退出条件，但是发现无法起作用。后来发现，对于网络流来说，如果读取到 -1 说明对面的输入流已经关闭了，因此使用这个作为退出循环的标志。如果删去了这句代码，程序会无法自动终止，并且会一直产生最后一个读取的文件，但是由于无法读取到数据，所以文件都是 0 字节的文件。 （这个东西产生文件的速度很快，大概几秒钟就会产生几千个文件，如果感兴趣，可以尝试一下，但是最好快速终止程序的运行，哈哈！）
if (exit == -1) {
System.out.println("文件上传结束！");
break;
}
测试类
这里只测试一个连接就行了，这只是一个说明的例子。
package com.dragon;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
public class Test {
public static void main(String[] args) throws IOException {
try (ServerSocket server = new ServerSocket(8000)){
Socket client = server.accept();
FileResolve fileResolve = new FileResolve();
fileResolve.fileResolve(client, "D:/DBC/des");
}
}
}
测试结果
Client
Server
源文件目录 这里面包含了我测试的五种文件。注意对比文件的大小信息，对于IO的测试，我喜欢使用图片和视频测试，因为它们是很特殊的文件，如果错了一点（字节少了、多了），文件基本上就损坏了，表现为图片不正常显示，视频无法正常播放。
目的文件目录
总结
这个问题应该是解决了，我这里经过测试，应该是没有问题的了。我的代码写的不是太好，有时候都没有怎么思考，想到哪就写到哪，这样看来还是有很大问题。这个例子的代码很简单，不过我发现了一个很有趣的问题，因为我最近看到了一个手写 Http 服务器的（使用Java简单的写一个。），自己也尝试了一下（还没看完）。 我们知道 HTTP 协议，也是具有响应头和响应体，我觉得我这个和 HTTP 协议有点相似，虽然我的想法很简陋，但是好像确实是有点相似，可能我看到的东西，对我也有了影响。
到此这篇关于关于Java单个TCP(Socket)连接发送多个文件的问题的文章就介绍到这了,更多相关单个(Socket)TCP发送多个文件内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！
相关文章