JAVA -NIO实现(一)

最新推荐文章于 2025-09-06 09:33:29 发布

用户名存在

最新推荐文章于 2025-09-06 09:33:29 发布

阅读量1k

点赞数

CC 4.0 BY-SA版权

分类专栏： JAVA-NIO 文章标签： java 服务器 NIO

本文链接：https://blog.youkuaiyun.com/augustus_liu/article/details/10323055

JAVA-NIO 专栏收录该内容

3 篇文章

订阅专栏

本文介绍了一个基于Java NIO的简单服务器实现过程，包括服务器初始化、非阻塞模式设置及客户端连接处理等核心步骤。文章详细展示了如何利用ServerSocketChannel、Selector等组件搭建服务器，并实现了客户端数据的接收与响应。

package com.liu.server;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;

/*
* 自定义服务器
*/
public class NIOServer {

   private static int SERVER_PORT = 9000;

   private static String SERVER_URI = "127.0.0.1";

   private final static int BLOCK = 4096;

   private static ByteBuffer receiveBuffer = ByteBuffer.allocate(BLOCK);

   private static ByteBuffer sendBuffer = ByteBuffer.allocate(BLOCK);

   private ServerSocketChannel serverSocketChannel = null;

   private Selector selector = null;

   public static void main(String[] args) {
       NIOServer server = new NIOServer();
       server.start();
   }

   private void start(){
       try {
           this.initServer();
           this.initService();
       } catch (IOException e) {
           e.printStackTrace();
       }
   }

   private void initServer(){
       try {
           serverSocketChannel = ServerSocketChannel.open();

           //静态方法实例化selector
           selector = Selector.open();

           //设置为非阻塞方式,如果为true 那么就为传统的阻塞方式
           serverSocketChannel.configureBlocking(false);

           /*
           * 通过这个选项，可以使多个Socket对象绑定在同一个端口上。其实这样做并没有多大意义，但当使用close方法关闭Socket连接后，
           * Socket对象所绑定的端口并不一定马上释放;系统有时在Socket连接关闭才会再确认一下是否有因为延迟面未到达的数据包，
           * 这完全是在底层处理的，也就是说对用户是透明的;因此，在使用Socket类时完全不会感觉到。
　　           * 这种处理机制对于随机绑定端口的Socket对象没有什么影响，
           * 但对于绑定在固定端口的Socket对象就可能会抛出“Address already in use: JVM_Bind”例外。
           * 因此，使用这个选项可以避免个例外的发生。
           */
           serverSocketChannel.socket().setReuseAddress(true);

           //绑定端口
           serverSocketChannel.socket().bind(new InetSocketAddress(SERVER_URI,SERVER_PORT));

           /*
           * 设置服务处于可接受信息的状态,即在服务中注册KEY，告诉服务现在以经处于属于接受状态
           */
           serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

           System.out.println("NIOServer is starting at " + SERVER_PORT + "......");

       } catch (IOException e) {
           e.printStackTrace();
       }
   }

   private void initService() throws IOException{

       while(selector.select()>0){
           Set<SelectionKey> selectionKeys = selector.selectedKeys();

           Iterator<SelectionKey> it = selectionKeys.iterator();

           System.out.println("目前已经接受的key的 size : " + selectionKeys.size());

           while(it.hasNext()){
               SelectionKey selectionKey = it.next();
               it.remove();

               //处理传过来的数据
               handleData(selectionKey);
           }
       }
   }

   private void handleData(SelectionKey key) throws IOException{

       if(key.isAcceptable()){
           System.out.println("Accepting......");
           SocketChannel channel = ((ServerSocketChannel)key.channel()).accept();
           channel.configureBlocking(false);
           channel.register(selector, SelectionKey.OP_READ);
       }else if(key.isReadable()){
           System.out.println("Reading......");
           SocketChannel channel = (SocketChannel) key.channel();
           receiveBuffer.clear();
           int count = channel.read(receiveBuffer);
           if(count>0){
               String receiveText = new String(receiveBuffer.array(),0,count);
               System.out.println("客户端传递的内容:"+receiveText);
               channel.register(selector, SelectionKey.OP_WRITE);
           }
       }else if(key.isWritable()){
           System.out.println("Writting......");
           SocketChannel channel = (SocketChannel) key.channel();
           sendBuffer.clear();
           sendBuffer.put(new String("这是测试数据").getBytes());

           //将缓冲区各标志复位,因为向里面put了数据,标志被改变,复位到起始位置
           sendBuffer.flip();
           channel.write(sendBuffer);
           channel.close();
       }
   }

}

测试结果如下：