Java NIO 服务器与客户端实现文件下载

写在前面

对于Java NIO已经学习了一段时间了，周末实践了下，折腾了一天，总算对NIO的理论，有了一个感性的认识。下面的实践是：服务器与客户端都采用NIO的方式来实现文件下载。对于传统的SOCKET BIO方式，服务器端会为每一个链接上的客户端分配一个Worker线程来进行doWork，而NIO SERVER却没有为每一个Socket连接分配线程的必要了，避免了大量的线程所需的上下文切换，借助NIO提供的Selector机制，只须要一个或者几个线程来管理成百上千的SOCKET链接。那么下面咱们就来看看吧！

文件下载辅助类

/**
 * 这个类的基本思路是,读取本地文件到缓冲区
 * 由于通道只能操做缓冲区
 */
class DownloadFileProcesser implements Closeable{
private ByteBuffer buffer = ByteBuffer.allocate(8 * 1024);
private FileChannel fileChannel ;
public DownloadFileProcesser() {
    try{
        FileInputStream fis = new FileInputStream("e:/tmp/Shell学习笔记.pdf");
        fileChannel = fis.getChannel();
    }catch(Exception e){
        e.printStackTrace();
    }
}
public int readFile2Buffer() throws IOException{
    int count = 0;
    buffer.clear();
    count = fileChannel.read(buffer);
    buffer.flip();
    return count;
}
public ByteBuffer getByteBuffer(){
    return buffer;
}
@Override
public void close() throws IOException {
    fileChannel.close();
}

}

服务端代码：

public class ServerMain {

public static void main(String[] args) throws IOException {
    ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
    serverSocketChannel.configureBlocking(false);
    serverSocketChannel.socket().bind(new InetSocketAddress(8887));
    Selector selector = Selector.open();
    serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

    while (true) {
        selector.select();
        Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
        while (iterator.hasNext()) {
        SelectionKey s = iterator.next();
        // 若是客户端有链接请求
        if (s.isAcceptable()) {
        System.out.println("客户端链接请求..");
        ServerSocketChannel ssc = (ServerSocketChannel) s.channel();
        SocketChannel sc = ssc.accept();
        sc.configureBlocking(false);
        sc.register(selector, SelectionKey.OP_READ);
        }
        // 若是客户端有发送数据请求
        if (s.isReadable()) {
        System.out.println("接受客户端发送过来的文本消息...");
        //这里拿出的通道就是ACCEPT上注册的SocketChannel通道
        SocketChannel sc = (SocketChannel) s.channel();
        //要读取数据先要准备好BUFFER缓冲区
        ByteBuffer buffer = ByteBuffer.allocate(8 * 1024);
        //准备BYTE数组,造成输出
        sc.read(buffer);
        byte[] clientByteInfo = new byte[buffer.position()];
        buffer.flip();
        buffer.get(clientByteInfo);
        System.out.println("服务器端收到消息：" + new String(clientByteInfo,"utf-8"));
        //CLIENT下一步的动做就是读取服务器端的文件,所以须要注册写事件
        SelectionKey selectionKey = sc.register(selector, SelectionKey.OP_WRITE);
        //在这个selectionKey上绑定一个对象,以供写操做时取出进行处理
        DownloadFileProcesser downloadFileProcesser = new DownloadFileProcesser();
        selectionKey.attach(downloadFileProcesser);
        }
    
    // 若是客户端有下载文件数据请求
    if (s.isWritable()) {
    //这里把p_w_upload取出进行写入操做
    DownloadFileProcesser downloadFileProcesser = (DownloadFileProcesser)s.p_w_upload();
    int count = downloadFileProcesser.readFile2Buffer();
   
    if(count <= 0){
        System.out.println("客户端下载完毕...");
        //关闭通道
        s.channel().close();
        downloadFileProcesser.close();
    }else{
        //须要注意的是咱们这里并无出现常见的while写的结构,这是为什么?
        //由于client其实不断的在read操做，从而触发了SELECTOR的不断写事件!
        SocketChannel sc = (SocketChannel)s.channel();
        sc.write(downloadFileProcesser.getByteBuffer());
     }
   }
        iterator.remove();
  }
 }
 }
}

客户端代码：

class Client4DownloadFile implements Runnable{
    
    //标示
    private String name;
    private FileChannel fileChannel;
    public Client4DownloadFile(String name , RandomAccessFile randomAccessFile){
    this.name = name;
    this.fileChannel = randomAccessFile.getChannel(); 
    }
    
    private ByteBuffer buffer = ByteBuffer.allocate(8 * 1024);

    @Override
public void run() {
try {
    SocketChannel sc = SocketChannel.open();
    Selector selector = Selector.open();
    sc.configureBlocking(false);
    sc.register(selector, SelectionKey.OP_CONNECT);
    sc.connect(new InetSocketAddress("127.0.0.1",8887));
   
    while(true){
        selector.select();
        Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
       
        while(iterator.hasNext()){
        SelectionKey s = iterator.next();
        if(s.isConnectable()){
        System.out.println("客户端[" + name + "]已经链接上了服务器...");
        SocketChannel sc2 = (SocketChannel)s.channel();
        if(sc2.isConnectionPending() && sc2.finishConnect()){
        sc2.configureBlocking(false);
        String msg = "Thread-" + name + " send message!";
        byte[] b = msg.getBytes("utf-8");
        sc2.write(ByteBuffer.wrap(b));
        System.out.println("客户端[" + name + "]给服务器端发送文本消息完毕...");
        sc2.register(selector, SelectionKey.OP_READ);
    }
    }
    
    if(s.isReadable()){
        SocketChannel sc3 = (SocketChannel)s.channel();
        buffer.clear();
        int count = sc3.read(buffer);
        if(count <= 0){
        s.cancel();
        System.out.println("Thread " + name + " 下载完毕...");
    }
    while(count > 0){
        buffer.flip();
        fileChannel.write(buffer);
        count = sc3.read(buffer);
        }
    }
        iterator.remove();
    }
   }
  } catch (IOException e) {
        e.printStackTrace();
  }
}
}

public class ClientMain {
    public static void main(String[] args) throws FileNotFoundException{
        for(int i = 0 ; i < 10 ; i++){
            File file = new File("e:/tmp/" + i + ".pdf");
            RandomAccessFile raf = new RandomAccessFile(file,"rw");
            Client4DownloadFile client4DownloadFile = new Client4DownloadFile("" + i, raf);
            new Thread(client4DownloadFile).start();
        }
    }
}