NIO之ServerSocketChannel应用实例

服务器端：

package test.hhd.Socket;

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

public class SocketServer {
    private int port = 9000;
    private ServerSocketChannel serverSocketChannel;
    private Charset charset = Charset.forName("UTF-8");
    private Selector selector = null;

    public SocketServer() throws IOException {
        selector = Selector.open();
        serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.socket().setReuseAddress(true);
        serverSocketChannel.socket().bind(
                new InetSocketAddress(port));
        System.out.println("服务器启动");
    }

    public void service() throws IOException {
        serverSocketChannel.configureBlocking(false);
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT); 
        while (selector.select() > 0) {  
            /* 得到已经被捕获了的SelectionKey的集合 */  
            Iterator iterator = selector.selectedKeys().iterator();  
            while (iterator.hasNext()) {  
                SelectionKey key = null;  
                try {  
                    key = (SelectionKey) iterator.next();  
                    iterator.remove();  
                    if (key.isAcceptable()) {  
                        ServerSocketChannel ssc = (ServerSocketChannel) key.channel();  
                        SocketChannel sc = ssc.accept();  
                        System.out.println("客户端机子的地址是 "  
                                        + sc.socket().getRemoteSocketAddress()  
                                        + "  客户端机机子的端口号是 "  
                                        + sc.socket().getLocalPort());  
                        sc.configureBlocking(false);  
                        ByteBuffer buffer = ByteBuffer.allocate(1024);  
                        sc.register(selector, SelectionKey.OP_READ , buffer);//buffer通过附件方式，传递  
                    }  
                    if (key.isReadable()) {  
                        reveice(key);  
                    }  
                    if (key.isWritable()) {  
                        //send(key);  
                    }  
                } catch (IOException e) {  
                    e.printStackTrace();  
                    try {  
                        if (key != null) {  
                            key.cancel();  
                            key.channel().close();  
                        }  
                    } catch (ClosedChannelException cex) {  
                        e.printStackTrace();  
                    }  
                }  
            }    
        }  
    } 
    /* 接收 */  
    public void reveice(SelectionKey key) throws IOException {  
       if (key == null)  
           return;   

       //***用channel.read()获取客户端消息***//  
       //：接收时需要考虑字节长度        
       SocketChannel sc = (SocketChannel) key.channel();  
       String content = "";      
       ByteBuffer buf = ByteBuffer.allocate(128); 
       int bytesRead = sc.read(buf); //read into buffer.  

       while (bytesRead >0) {  
         buf.flip();  //make buffer ready for read 
         content += charset.decode(buf);          
         buf.clear(); //make buffer ready for writing        
         bytesRead = sc.read(buf);   
       }  
       System.out.println("接收：" + content.trim());  
   }  

    /**
     * @param args
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
        new SocketServer().service();
    }

}

读取线程：

package test.hhd.Socket;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.util.Iterator; 

public class ReadThread  implements Runnable {  
    // 监听器，如果缓冲区有数据，通知程序接收  
    private Selector selector;  
    private Charset charset = Charset.forName("UTF-8");
    String imei;  

    public ReadThread(Selector selector, String imei) {  
        this.selector = selector;  
        this.imei = imei;  
        new Thread(this).start();  
    }  

    @Override  
    public void run() {  
        try {  
            // 轮询访问selector  
            while (true) {  
                selector.select();//如果队列有新的Channel加入，那么Selector.select()会被唤醒  
                // 获得selector中选中的项的迭代器  
                Iterator ite = this.selector.selectedKeys().iterator();  
                while (ite.hasNext()) {  
                    SelectionKey key = (SelectionKey) ite.next();  
                    // 删除已选的key,以防重复处理  
                    ite.remove();  
                    // 连接事件发生  
                    if (key.isConnectable()) {  
                        SocketChannel channel = (SocketChannel) key.channel();  
                        // 如果正在连接，则完成连接  
                        if (channel.isConnectionPending()) {  
                            channel.finishConnect();  

                        }  
                        // 设置成非阻塞  
                        channel.configureBlocking(false);  

                        //给服务端发送信息   
                        channel.write(ByteBuffer.wrap(new String("SocketChannel与ByteBuffer应用!").getBytes(charset)));  
                        //在和服务端连接成功之后，为了可以接收到服务端的信息，需要给通道设置读的权限。  
                        channel.register(this.selector, SelectionKey.OP_READ );  

                    } else if (key.isReadable()) {  
                        read(key);  
                    }  

                }  

            }  

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

    }  

    /** 
     * 处理读取服务端发来的信息 的事件 
     * 
     * @param key 
     * @throws IOException 
     */  
    public void read(SelectionKey key) throws IOException {  

        // 服务器可读取消息:得到事件发生的Socket通道  
        SocketChannel channel = (SocketChannel) key.channel();  
        // 创建读取的缓冲区  
        ByteBuffer buffer = ByteBuffer.allocate(10);  
        channel.read(buffer);  
        byte[] data = buffer.array();  
        String msg = new String(data).trim();  
        System.out.println("服务端收到信息：" + msg);  
    }  

    public static final String btyetoString(byte[] bArray) {  
        StringBuffer sb = new StringBuffer(bArray.length);  
        String sTemp;  
        for (int i = 0; i < bArray.length; i++) {  
            sTemp = Integer.toHexString(0xFF & bArray[i]);  
            if (sTemp.length() == 1) {  
                sb.append(0);  

            }  
            sb.append(sTemp.toUpperCase());  
            sb.append(" ");  
        }  
        return sb.toString();  
    }  
}  

客户端：

package test.hhd.Socket;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;

import org.apache.commons.logging.Log;

public class SocketClient {
    // 信道选择器  
    private Selector selector;  

    // 与服务器通信的信道  
    SocketChannel socketChannel;  

    // 要连接的服务器Ip地址  
    private String hostIp;  

    // 要连接的远程服务器在监听的端口  
    private int hostListenningPort;
    String imei;  

    public SocketClient(String HostIp, int HostListenningPort, String imei) throws IOException {  
        this.hostIp = HostIp;  
        this.hostListenningPort = HostListenningPort;  
        this.imei = imei;  
        initialize();  
    }   

    /** 
     * 初始化 
     * 
     * @throws IOException 
     */  
    private void initialize() throws IOException {  
        try {  
            // 获得一个Socket通道  
            SocketChannel channel = SocketChannel.open();  
            // 设置通道为非阻塞  
            channel.configureBlocking(false);  
            // 获得一个通道管理器  
            this.selector = Selector.open();  

            // 客户端连接服务器,其实方法执行并没有实现连接，需要在listen（）方法中调  
            //用channel.finishConnect();才能完成连接  
            channel.connect(new InetSocketAddress(hostIp, hostListenningPort));  
            //将通道管理器和该通道绑定，并为该通道注册SelectionKey.OP_CONNECT事件。  
            channel.register(selector, SelectionKey.OP_CONNECT);  

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

        // 启动读取线程  
        new ReadThread(selector, imei);  
    } 
}

应用执行：
package test.hhd.Socket;

import java.io.IOException;

public class SocketApp {

/**
 * @param args
 */
public static void main(String[] args) {
    new Thread() {  
        @Override  
        public void run() {  
            try {  
                new SocketClient("127.0.0.1", 9000, "dddd");  

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

}