Khan's Notebook GCC/GNU/Linux Delphi/Window Java/Anywhere

public class NBlockingServer {
    int port = 8000;
    int BUFFERSIZE = 1024;
    Selector selector = null;
    ServerSocketChannel serverChannel = null;
    HashMap clientChannelMap = null;//用來存放每一個客戶連接對應的套接字和通道

    public NBlockingServer( int port ) {
        this.clientChannelMap = new HashMap();
        this.port = port;
    }

    public void initialize() throws IOException {
      //初始化，分別實例化一個選擇器，一個服務器端可選擇通道
      this.selector = Selector.open();
      this.serverChannel = ServerSocketChannel.open();
      this.serverChannel.configureBlocking(false);
      InetAddress localhost = InetAddress.getLocalHost();
      InetSocketAddress isa = new InetSocketAddress(localhost, this.port );
      this.serverChannel.socket().bind(isa);//將該套接字綁定到服務器某一可用端口
    }
    //結束時釋放資源
    public void finalize() throws IOException {
        this.serverChannel.close();
        this.selector.close();
    }
    //將讀入字節緩沖的信息解碼
    public String decode( ByteBuffer byteBuffer ) throws 
CharacterCodingException {
        Charset charset = Charset.forName( "ISO-8859-1" );
        CharsetDecoder decoder = charset.newDecoder();
        CharBuffer charBuffer = decoder.decode( byteBuffer );
        String result = charBuffer.toString();
        return result;
    }
    //監聽端口，當通道準備好時進行相應操作
    public void portListening() throws IOException, InterruptedException {
      //服務器端通道注冊OP_ACCEPT事件
      SelectionKey acceptKey =this.serverChannel.register( this.selector,
                                           SelectionKey.OP_ACCEPT );
        //當有已注冊的事件發生時,select()返回值將大于0
        while (acceptKey.selector().select() > 0 ) {
            System.out.println("event happened");
            //取得所有已經準備好的所有選擇鍵
            Set readyKeys = this.selector.selectedKeys();
            //使用迭代器對選擇鍵進行輪詢
            Iterator i = readyKeys.iterator();
            while (i.hasNext()) {
                SelectionKey key = (SelectionKey)i.next();
                i.remove();//刪除當前將要處理的選擇鍵
                if ( key.isAcceptable() ) {//如果是有客戶端連接請求
                    System.out.println("more client connect in!");
                    ServerSocketChannel nextReady =
                        (ServerSocketChannel)key.channel();
                    //獲取客戶端套接字
                    Socket s = nextReady.accept();
                    //設置對應的通道為異步方式并注冊感興趣事件
                    s.getChannel().configureBlocking( false );
                    SelectionKey readWriteKey =
                        s.getChannel().register( this.selector,
                            SelectionKey.OP_READ|SelectionKey.OP_WRITE  );
                    //將注冊的事件與該套接字聯系起來
readWriteKey.attach( s );
//將當前建立連接的客戶端套接字及對應的通道存放在哈希表//clientChannelMap中
                    this.clientChannelMap.put( s, new 
ClientChInstance( s.getChannel() ) );
                    }
                else if ( key.isReadable() ) {//如果是通道讀準備好事件
                    System.out.println("Readable");
                    //取得選擇鍵對應的通道和套接字
                    SelectableChannel nextReady =
                        (SelectableChannel) key.channel();
                    Socket socket = (Socket) key.attachment();
                    //處理該事件，處理方法已封裝在類ClientChInstance中
                    this.readFromChannel( socket.getChannel(),
                    (ClientChInstance)
this.clientChannelMap.get( socket ) );
                }
                else if ( key.isWritable() ) {//如果是通道寫準備好事件
                    System.out.println("writeable");
                    //取得套接字后處理，方法同上
                    Socket socket = (Socket) key.attachment();
                    SocketChannel channel = (SocketChannel) 
socket.getChannel();
                    this.writeToChannel( channel,"This is from server!");
                }
            }
        }
    }
    //對通道的寫操作
    public void writeToChannel( SocketChannel channel, String message ) 
throws IOException {
        ByteBuffer buf = ByteBuffer.wrap( message.getBytes()  );
        int nbytes = channel.write( buf );
    }
     //對通道的讀操作
    public void readFromChannel( SocketChannel channel, ClientChInstance clientInstance )
    throws IOException, InterruptedException {
        ByteBuffer byteBuffer = ByteBuffer.allocate( BUFFERSIZE );
        int nbytes = channel.read( byteBuffer );
        byteBuffer.flip();
        String result = this.decode( byteBuffer );
        //當客戶端發出”@exit”退出命令時，關閉其通道
        if ( result.indexOf( "@exit" ) >= 0 ) {
            channel.close();
        }
        else {
                clientInstance.append( result.toString() );
                //讀入一行完畢，執行相應操作
                if ( result.indexOf( "\n" ) >= 0 ){
                System.out.println("client input"+result);
                clientInstance.execute();
                }
        }
    }
    //該類封裝了怎樣對客戶端的通道進行操作，具體實現可以通過重載execute()方法
    public class ClientChInstance {
        SocketChannel channel;
        StringBuffer buffer=new StringBuffer();
        public ClientChInstance( SocketChannel channel ) {
            this.channel = channel;
        }
        public void execute() throws IOException {
            String message = "This is response after reading from channel!";
            writeToChannel( this.channel, message );
            buffer = new StringBuffer();
        }
        //當一行沒有結束時，將當前字竄置于緩沖尾
        public void append( String values ) {
            buffer.append( values );
        }
    }


    //主程序
    public static void main( String[] args ) {
        NBlockingServer nbServer = new NBlockingServer(8000);
        try {
            nbServer.initialize();
        } catch ( Exception e ) {
            e.printStackTrace();
            System.exit( -1 );
        }
        try {
            nbServer.portListening();
        }
        catch ( Exception e ) {
            e.printStackTrace();
        }
    }
}