使用nio传输文件需要注意的是会出现粘包和服务器端缓冲区满的情况。第一种情况，客户端发送30次数据，而服务器端只接收到18次的情况，这种情况出现 主要是服务器端是以流的方式接收数据，它并不知道每次客户端传输数据的大小而造成的。第二种情况是服务器端缓冲区满，导致客户端数据传输失败，这种情况 下，需要判断传输int send = client.write(sendBuffer)的send值，如果send值为0,则服务器端的数据缓冲区可能满了。
客户端实现代码：
import java.io.FileInputStream;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.Set;
public class FileClient {
private int port = 8000;
/* 发送数据缓冲区 */
private static ByteBuffer sendBuffer = ByteBuffer.allocate(1024);
/* 接受数据缓冲区 */
private static ByteBuffer revBuffer = ByteBuffer.allocate(1024);
private InetSocketAddress SERVER;
private static Selector selector;
private static SocketChannel client;
public FileClient(){
try{
SERVER = new InetSocketAddress("localhost", port);
init();
}
catch(Exception e){
e.printStackTrace();
}
}
private void init(){
try {
SocketChannel socketChannel = SocketChannel.open();
socketChannel.configureBlocking(false);
selector = Selector.open();
socketChannel.register(selector, SelectionKey.OP_CONNECT);
socketChannel.connect(SERVER);
while (true) {
selector.select();
Set<SelectionKey> keySet = selector.selectedKeys();
for (final SelectionKey key : keySet) {
if(key.isConnectable()){
client = (SocketChannel)key.channel();
client.finishConnect();
client.register(selector, SelectionKey.OP_WRITE);
}
else if(key.isWritable()){
sendFile(client);
}
}
keySet.clear();
}
} catch (Exception e) {
e.printStackTrace();
}
}
private void sendFile(SocketChannel client) {
FileInputStream fis = null;
FileChannel channel = null;
try {
// fis = new FileInputStream("E:\\1.txt");
// fis = new FileInputStream("E:\\1.rar");
fis = new FileInputStream("G:\\3.rar");
channel = fis.getChannel();
int i = 1;
int count = 0;
while((count = channel.read(sendBuffer)) != -1) {
sendBuffer.flip();
int send = client.write(sendBuffer);
System.out.println("i===========" + (i++) + " count:" + count + " send:" + send);
// 服务器端可能因为缓存区满，而导致数据传输失败，需要重新发送
while(send == 0){
Thread.sleep(10);
send = client.write(sendBuffer);
System.out.println("i重新传输====" + i + " count:" + count + " send:" + send);
}
sendBuffer.clear();
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
channel.close();
fis.close();
client.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
public static void main(String[] args){
new FileClient();
}
}服务器端
import java.io.FileOutputStream;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Set;
public class FileServer {
private int port = 8000;
/* 发送数据缓冲区 */
private static ByteBuffer revBuffer = ByteBuffer.allocate(1024);
private static Selector selector;
private static FileOutputStream fout;
private static FileChannel ch;
public FileServer(){
try{
init();
}
catch(Exception e){
e.printStackTrace();
}
}
private void init() throws Exception{
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
serverSocketChannel.configureBlocking(false);
ServerSocket serverSocket = serverSocketChannel.socket();
serverSocket.bind(new InetSocketAddress(port));
selector = Selector.open();
serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
System.out.println("server start on port:" + port);
while (true) {
try {
selector.select();// 返回值为本次触发的事件数
Set<SelectionKey> selectionKeys = selector.selectedKeys();
for (SelectionKey key : selectionKeys) {
ServerSocketChannel server = null;
SocketChannel client = null;
int count = 0;
if (key.isAcceptable()) {
server = (ServerSocketChannel) key.channel();
System.out.println("有客户端连接进入=============)");
client = server.accept();
client.configureBlocking(false);
client.register(selector, SelectionKey.OP_READ);
fout = new FileOutputStream("G:\\" + client.hashCode() + ".rar");
ch = fout.getChannel();
} else if (key.isReadable()) {
client = (SocketChannel) key.channel();
revBuffer.clear();
count = client.read(revBuffer);
int k = 0;
// 循环读取缓存区的数据，
while(count > 0){
System.out.println("k=" + (k++) + " 读取到数据量:" + count);
revBuffer.flip();
ch.write(revBuffer);
fout.flush();
revBuffer.clear();
count = client.read(revBuffer);
}
if(count == -1){
client.close();
ch.close();
fout.close();
}
}
else if (key.isWritable()) {
System.out.println("selectionKey.isWritable()");
}
}
System.out.println("=======selectionKeys.clear()");
selectionKeys.clear();
} catch (Exception e) {
e.printStackTrace();
break;
}
}
}
public static void main(String[] args){
new FileServer();
}
}
