上次写了个OIO的的Sokcet编程，现在把最近学习的NIO补上
客户端：Client
import java.io.Closeable;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
/**
* 使用SocketChannel实现TCP协议的文件传输
* NIO中的SocketChannel和OIO中的Socket对应
* NIO中的ServerSocketChannel和OIO中的ServerSocket对应
*/
public class Client{
public static void main(String[] args) {
//先启动服务端，再启动客户端
Client client = new Client();
//发送文件
String filepath = System.getProperty("user.dir")+"\\resource\\client\\";
client.upload(filepath,"client1.jpg");
}
private final Charset charset = Charset.forName("UTF-8");//java默认编码为Unicode，有的操作系统不支持，统一编码格式为UTF-8
private final String serverAddress = "localhost";
private final int serverPort = 9111;
/**
* 传递到服务端的应该有文件路径和文件名
* @param filepath
* @param filename
*/
public void upload(String filepath,String filename) {
try{
File sendfile = new File(filepath+filename);
FileChannel fileChannel = new FileInputStream(sendfile).getChannel();//获取该文件的输入流的通道
SocketChannel socketChannel = SocketChannel.open();//打开Socket通道
socketChannel.connect(new InetSocketAddress(serverAddress,serverPort));//绑定服务器的链接地址和端口号
socketChannel.configureBlocking(false);//设置为非阻塞式
//由于是非阻塞式连接，所以socketChannel.connect()方法不论是否真正的连接成功，都会立即返回，
while(!socketChannel.finishConnect()){
//socket没有真正连接前，不断的自旋、等待，或者做一些其他的事情
System.out.println("等待连接中，做其他事....");
}
System.out.println("成功连接到服务器...");
//将存储在服务器的文件名编码为UTF-8格式的二进制字节序列
ByteBuffer fileNamebuffer = charset.encode(filename);
socketChannel.write(fileNamebuffer);//将文件名传过去
System.out.println("开始传输文件");
ByteBuffer filebuffer = ByteBuffer.allocate(1024);//开启缓冲内存区域，用于存储文件内容
int len = 0;
while((len = fileChannel.read(filebuffer)) != -1){//将文件数据从fileChannel读取并存储到filebuffer缓冲区中
filebuffer.flip();//将内存缓冲区翻转为读模式
socketChannel.write(filebuffer);//读取本次缓冲区所有文件并写入通道
filebuffer.clear();//清空缓冲区
}
//单向关闭，表示客户端数据写完了，如果需要服务端响应数据，就要用这种方式
// socketChannel.shutdownOutput();
//读完文件通道关闭
fileChannel.close();
socketChannel.close();
System.out.println("传输完成...");
}catch (IOException e){
e.printStackTrace();
}
}
}
服务端Server，对每个客户端的请求视为一个单独的对象，所以加了一个静态内部类作为当前处理的客户端对象
服务端涉及了Selector选择器，通过监听不同的通道来实现IO的多路复用。这样既能在非阻塞式的监听客户端请求，还可以只使用一个线程来处理多个客户端请求，比起以前一个线程对应一个客户端而言，节约了线程上下文切换的开销，效率要高很多。
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.nio.charset.Charset;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/**
* 使用SocketChannel实现TCP协议的文件传输
* NIO中的SocketChannel和OIO中的Socket对应
* NIO中的ServerSocketChannel和OIO中的ServerSocket对应
*/
public class Server{
public static void main(String[] args) {
//先启动服务端
Server server = new Server();
server.startServer();
}
private final Charset charset = Charset.forName("UTF-8");
private final int serverPort = 9111;
//将客户端传递的数据封装为一个对象
static class FileData{
String clientAddress;
String filename; //客户端上传的文件名称
FileChannel fileOutChannel;//输出的文件通道
}
//使用Map保存每个客户端传输，当OP_READ通道可读时，根据channel找到对应的对象
Map<SelectableChannel, FileData> map = new ConcurrentHashMap<>();
/**
* 启动服务器
*/
public void startServer(){
try{
// 1、获取Selector选择器
Selector selector = Selector.open();
// 2、创建一个通道，用于获取客户端的请求连接
ServerSocketChannel serverChannel = ServerSocketChannel.open();
ServerSocket serverSocket = serverChannel.socket();
// 3.设置为非阻塞
serverChannel.configureBlocking(false);
// 4、绑定连接
// InetSocketAddress只传入端口号，则自动绑定当前本机IP
serverSocket.bind(new InetSocketAddress(serverPort));//即服务端开放99端口
// 5、将该通道注册到选择器上,并注册的IO事件为：“接收新连接”
serverChannel.register(selector, SelectionKey.OP_ACCEPT);
System.out.println("服务端已开启，监听新连接。。。");
// 6、遍历选择器，轮询感兴趣的I/O就绪事件（选择键集合）
while (selector.select() > 0) {
// 7、获取选择键集合
Iterator<SelectionKey> it = selector.selectedKeys().iterator();
while (it.hasNext()) {
// 8、获取单个的选择键，并处理
SelectionKey key = it.next();
// 9、判断key是具体的什么事件，是否为新连接事件
if (key.isAcceptable()) {
// 10、若接受的事件是“新连接”事件,就获取客户端新连接
ServerSocketChannel server = (ServerSocketChannel) key.channel();
SocketChannel socketChannel = server.accept();
if (socketChannel == null) continue;
// 11、客户端新连接，切换为非阻塞模式
socketChannel.configureBlocking(false);
// 12、将获取到的客户端socket通道再次注册到选择器，并注册为可读事件
// 这样下次遍历选择器时，就进入可读事件
socketChannel.register(selector, SelectionKey.OP_READ);
// 业务处理 - 每次客户端上传一个文件就创建一个对象存到map中
// 一个客户端对象对应一个socket通道
FileData fileData = new FileData();
fileData.clientAddress = socketChannel.getRemoteAddress().toString();
map.put(socketChannel, fileData);
System.out.println("与客户端"+fileData.clientAddress+ "连接成功...");
} else if (key.isReadable()) {
receiveFile(key);
}
// NIO的特点只会累加，已选择的键的集合不会删除
// 如果不删除，下一次又会被select函数选中
it.remove();
}
}
}catch (IOException e){
e.printStackTrace();
}
}
/**
* 接收文件
*/
private void receiveFile(SelectionKey key){
ByteBuffer buffer = ByteBuffer.allocate(1024);//开启内存缓冲区域
FileData fileData = map.get(key.channel());
SocketChannel socketChannel = (SocketChannel) key.channel();
String directory = System.getProperty("user.dir")+"\\resource\\server\\";//服务端收到文件的存储路径
long start = System.currentTimeMillis();
try {
int len = 0;
while ((len = socketChannel.read(buffer)) != -1) {//将客户端写入通道的数据读取并存储到buffer中
buffer.flip();//将缓冲区翻转为读模式
//客户端发送过来的，首先是文件名
if (null == fileData.filename) {
// 文件名 decode解码为UTF-8格式，并赋值给client对象的filename属性
fileData.filename = (System.currentTimeMillis()+"_"+charset.decode(buffer).toString()).substring(5);
//先检查存储的目录是否存在
File dir = new File(directory);
if(!dir.exists()) dir.mkdir();
//再检查文件是否存在，不存在就创建文件，然后通过FikeChanel写入数据
File file = new File(directory + fileData.filename);
if(!file.exists()) file.createNewFile();
//将设定要存放的文件路径+文件名创建一个输出流通道
FileChannel fileChannel = new FileOutputStream(file).getChannel();
fileData.fileOutChannel = fileChannel;//赋值给client对象
}
//客户端发送过来的，最后是文件内容
else{
// 通过已经创建的文件输出流通道向文件中写入数据
fileData.fileOutChannel.write(buffer);
}
buffer.clear();//清除本次缓存区内容
}
fileData.fileOutChannel.close();
key.cancel();
System.out.println("上传完毕，费时："+Long.valueOf(System.currentTimeMillis()-start)+"毫秒");
System.out.println("文件在服务端的存储路径：" + directory + fileData.filename);
System.out.println("");
} catch (IOException e) {
key.cancel();
e.printStackTrace();
return;
}
}
}
最后留个小问题，希望后面自己能来解决，或者有大佬看到了能够指点一二
上面的代码我在windows本地环境测试是完全没问题的，但在linux的远程云服务器上测试就有个小问题，就是客户端的ByteBuffer缓冲区大小会影响服务端接收数据的完整性。
我测试文件是一个约84kb的图片文件
当客户端的ByteBuffer设为1024时，linux云服务器就只能收到64kb的数据
当客户端的ByteBuffer设为10240时，linux云服务器就只能收到70kb的数据
当客户端的ByteBuffer设为102400时，linux云服务器才能收到84kb的完整数据
我寻思缓冲区太小就多循环读取几次不就行了吗？为什么会造成数据得丢失。
如果有大佬能帮忙指教一下，不胜感激，谢谢！！！
