Enabling Technology

1. String proxyHost = “192.168.204.212″;   
2. String proxyPort = “1080″;   
3.   
4. //通知Java要通过代理进行连接。   
5. System.getProperties().put(“socksProxySet”,“true”);   
6. //指定代理所在的机器   
7. System.getProperties().put(“socksProxyHost”,proxyHost);   
8. //指定代理监听的端口。   
9. System.getProperties().put(“socksProxyPort”,proxyPort);    
10.   
11. String host = “134.01.69.80″;   
12. int port = 12086;   
13. System.out.println(“connetioning:” + host + “:” + port);   
14. server = new Socket(host, port);  

二：老socket传递Object对象：

要传递的对象：

1. public class Employee implements Serializable {    
2.   
3.        private int employeeNumber;    
4.        private String employeeName;    
5.   
6.        Employee(int num, String name) {    
7.           employeeNumber = num;    
8.           employeeName= name;    
9.        }    
10.   
11.         public int getEmployeeNumber() {    
12.           return employeeNumber ;    
13.        }    
14.   
15.        public void setEmployeeNumber(int num) {    
16.           employeeNumber = num;    
17.        }    
18.   
19.        public String getEmployeeName() {    
20.           return employeeName ;    
21.        }    
22.   
23.        public void setEmployeeName(String name) {    
24.           employeeName = name;    
25.        }    
26.     }   

client：

1. public class Client {   
2.     public static void main(String[] arg) {   
3.         try {   
4.             Employee joe = new Employee(150, “Joe”);   
5.             System.out.println(“employeeNumber= ” + joe.getEmployeeNumber());   
6.             System.out.println(“employeeName= ” + joe.getEmployeeName());   
7.             Socket socketConnection = new Socket(“127.0.0.1″, 11111);   
8.             ObjectOutputStream clientOutputStream = new ObjectOutputStream(   
9.                     socketConnection.getOutputStream());   
10.             ObjectInputStream clientInputStream = new ObjectInputStream(   
11.                     socketConnection.getInputStream());   
12.             clientOutputStream.writeObject(joe);   
13.             joe = (Employee) clientInputStream.readObject();   
14.             System.out.println(“employeeNumber= ” + joe.getEmployeeNumber());   
15.             System.out.println(“employeeName= ” + joe.getEmployeeName());   
16.             clientOutputStream.close();   
17.             clientInputStream.close();   
18.         } catch (Exception e) {   
19.             System.out.println(e);   
20.         }   
21.     }   
22. }  

server端：

java 代码

1. public class Server {   
2.     public static void main(String[] arg) {   
3.         Employee employee = null;   
4.         try {   
5.             ServerSocket socketConnection = new ServerSocket(11111);   
6.             System.out.println(“Server Waiting”);   
7.             Socket pipe = socketConnection.accept();   
8.             ObjectInputStream serverInputStream = new ObjectInputStream(pipe   
9.                     .getInputStream());   
10.             ObjectOutputStream serverOutputStream = new ObjectOutputStream(pipe   
11.                     .getOutputStream());   
12.             employee = (Employee) serverInputStream.readObject();   
13.             employee.setEmployeeNumber(256);   
14.             employee.setEmployeeName(“li”);   
15.             serverOutputStream.writeObject(employee);   
16.             serverInputStream.close();   
17.             serverOutputStream.close();   
18.         } catch (Exception e) {   
19.             System.out.println(e);   
20.         }   
21.     }   
22. }  

三：nio socket传递Object：

client：

1. public class Client {   
2.     private String hostname;   
3.        
4.     private int port;   
5.        
6.     public Client(String hostname, int port)   
7.     {   
8.         this.hostname = hostname;   
9.         this.port = port;   
10.     }   
11.   
12.     public static void main(String[] args) {   
13.         String hostname = “192.168.0.81″;   
14.         int port = 8234;   
15.         Student stu = new Student();   
16.         stu.setId(849);   
17.         stu.setName(“Squall”);   
18.         Client client = new Client(hostname, port);   
19.         try {   
20.             client.write(stu);   
21.         } catch (IOException e) {   
22.             // TODO Auto-generated catch block   
23.             e.printStackTrace();   
24.         }   
25.     }   
26.   
27.     public void write(Object obj) throws IOException {   
28.         SocketChannel channel = null;   
29.         try {   
30.             channel = SocketChannel.open(new InetSocketAddress(hostname, port));   
31.             ByteBuffer buf = Client.getByteBuffer(obj);   
32.             channel.write(Client.getByteBuffer(obj));   
33.             channel.write(Client.getByteBuffer(obj));   
34.         } catch (Exception e) {   
35.             e.printStackTrace();   
36.         } finally {   
37.             channel.close();   
38.         }   
39.     }   
40.        
41.     public static ByteBuffer getByteBuffer(Object obj) throws IOException   
42.     {   
43.         ByteArrayOutputStream bOut = new ByteArrayOutputStream();   
44.         ObjectOutputStream out = new ObjectOutputStream(bOut);   
45.         out.writeObject(obj);   
46.         out.flush();   
47.         byte[] arr = bOut.toByteArray();   
48.         System.out.println(“Object in ” + arr.length + “ bytes”);   
49.         ByteBuffer bb = ByteBuffer.wrap(arr);   
50.         out.close();   
51.            
52.         return bb;   
53.     }   
54. }  

server端：

java 代码

1. public class Server {   
2.   
3.     public static void main(String[] args) {   
4.         System.out.println(“in server!”);   
5.         ServerThread server = new ServerThread();   
6.         new Thread(server).start();   
7.     }   
8.   
9.     static class ServerThread implements Runnable {   
10.   
11.         public void run() {   
12.             try {   
13.                 ServerSocketChannel sc = ServerSocketChannel.open();   
14.   
15.                 ServerSocket s = sc.socket();   
16.                 s.bind(new InetSocketAddress(8234));   
17.                 while (true) {   
18.                     Socket incoming = s.accept();   
19.                     Runnable r = new GetObjThread(incoming);   
20.                     Thread t = new Thread(r);   
21.                     t.start();   
22.                 }   
23.             } catch (Exception e) {   
24.                 e.printStackTrace();   
25.             }   
26.         }   
27.     }   
28.   
29.     static class GetObjThread implements Runnable {   
30.         public GetObjThread(Socket s) {   
31.             incoming = s;   
32.         }   
33.   
34.         public void run() {   
35.             try {   
36.                 SocketChannel sc = incoming.getChannel();   
37.                 ByteBuffer bbIn = ByteBuffer.allocate(1024);   
38.                 sc.read(bbIn);   
39.                    
40.                 sc.close();   
41.                 bbIn.flip();   
42.                 ByteArrayInputStream bIn = new ByteArrayInputStream(bbIn   
43.                         .array());   
44.                 ObjectInputStream in = new ObjectInputStream(bIn);   
45.                 Student nStu = (Student) in.readObject();   
46.                 System.out.println(“student id is ” + nStu.getId() + “\n”  
47.                         + “student name is ” + nStu.getName());   
48.             } catch (IOException e) {   
49.                 e.printStackTrace();   
50.             } catch (ClassNotFoundException e) {   
51.                 e.printStackTrace();   
52.             }   
53.         }   
54.   
55.         private Socket incoming;   
56.     }   
57. }  

四：备份一个有用的util class：对象序列化，反序列化（序列化对象转byte[],ByteBuffer, byte[]转object：　

java 代码

1. public class ByteUtil {   
2.     public static byte[] getBytes(Object obj) throws IOException   
3.     {   
4.         ByteArrayOutputStream bout = new ByteArrayOutputStream();   
5.         ObjectOutputStream out = new ObjectOutputStream(bout);   
6.         out.writeObject(obj);   
7.         out.flush();   
8.         byte[] bytes = bout.toByteArray();   
9.         bout.close();   
10.         out.close();   
11.            
12.         return bytes;   
13.     }   
14.        
15.     public static Object getObject(byte[] bytes) throws IOException, ClassNotFoundException   
16.     {   
17.            ByteArrayInputStream bi = new ByteArrayInputStream(bytes);   
18.            ObjectInputStream oi = new ObjectInputStream(bi);   
19.            Object obj = oi.readObject();   
20.            bi.close();   
21.            oi.close();   
22.         return obj;   
23.     }   
24.        
25.     public static ByteBuffer getByteBuffer(Object obj) throws IOException   
26.     {   
27.         byte[] bytes = ByteUtil.getBytes(obj);   
28.         ByteBuffer buff = ByteBuffer.wrap(bytes);   
29.            
30.         return buff;   
31.     }   
32. }  

五：如何通过xml传递Object对象：

可以先把object转成一个byte[]数组，然后用base64编码成一个base64格式的String，放入xml的CDATA中，就可以传了。

接收方，收到该xml后，把CDATA中的String用base64解码为byte[]，进而根据四中的方法，还原为object：

java 代码

1. public class Base64 {   
2.   
3.     public static String getEncodedText(byte[] bytes) {   
4.   
5.         try {   
6.             BASE64Encoder encoder = new BASE64Encoder();   
7.             String text = encoder.encode(bytes);   
8.             return text;           
9.         } catch (Exception e) {   
10.             e.printStackTrace();   
11.             return null;   
12.         }          
13.   
14.     }   
15.        
16.     public static byte[] decode(String src)    
17.     {   
18.         BASE64Decoder decoder = new BASE64Decoder();   
19.         try {   
20.             return decoder.decodeBuffer(src);   
21.         } catch (IOException e) {   
22.             // TODO Auto-generated catch block   
23.             e.printStackTrace();   
24.             return null;   
25.         }   
26.     }   
27.        
28.     public static void main(String[] args) {   
29.         String s = “ly89″;   
30.         byte[] bytes = s.getBytes();   
31.         String  encode = Base64.getEncodedText(bytes);   
32.         System.out.println(“the encode string is: ” + encode);   
33.   
34.         byte[] dbytes = Base64.decode(encode);   
35.         for (int i = 0; i < bytes.length; i++) {   
36.             System.out.println(dbytes[i]);             
37.         }   
38.     }   
39. }  

3.1 IoFilters：
IoFilter为MINA的功能扩展提供了接口。它拦截所有的IO事件进行事件的预处理和后处理(AOP)。我们可以把它想象成
Servlet的filters。
IoFilter能够实现以下几种目的：
事件日志
性能检测
数据转换(e.g. SSL support)，codec
防火墙…等等

3.2 codec: ProtocolCodecFactory
MINA提供了方便的Protocol支持。如上说讲，codec在IoFilters中设置。
通过它的Encoder和Decoder，可以方便的扩展并支持各种基于Socket的网络协议，比如HTTP服务器、FTP服务器、Telnet服务器等等。

要实现自己的编码/解码器(codec)只需要实现interface: ProtocolCodecFactory即可.
在MINA 1.0版本，MINA已经实现了几个常用的(codec factory):

DemuxingProtocolCodecFactory,
NettyCodecFactory,
ObjectSerializationCodecFactory,
TextLineCodecFactory
 
其中：
TextLineCodecFactory:
 A ProtocolCodecFactory that performs encoding and decoding between a text line data and a Java
 string object. This codec is useful especially when you work with a text-based protocols such as SMTP and IMAP.

ObjectSerializationCodecFactory:
A ProtocolCodecFactory that serializes and deserializes Java objects. This codec is very useful when
you have to prototype your application rapidly without any specific codec.

DemuxingProtocolCodecFactory：
A composite ProtocolCodecFactory that consists of multiple MessageEncoders and MessageDecoders. ProtocolEncoder
and ProtocolDecoder this factory returns demultiplex incoming messages and buffers to appropriate MessageEncoders
and MessageDecoders.

NettyCodecFactory:
A MINA ProtocolCodecFactory that provides encoder and decoder for Netty2 Messages and MessageRecognizers.

3.3 business logic: IoHandler

MINA中，所有的业务逻辑都有实现了IoHandler的class完成
interfaceHandles:
 all protocol events fired by MINA. There are 6 event handler methods, and they are all invoked by MINA automatically.
 当事件发生时，将触发IoHandler中的方法:
 sessionCreated(),
sessionOpened(),
sessionClosed(),
sessionIdle(),
exceptionCaught(),
messageReceived(),
messageSent()

MINA 1.O中，IoHandler的实现类：
ChainedIoHandler,
DemuxingIoHandler,
IoHandlerAdapter,
SingleSessionIoHandlerDelegate,
StreamIoHandler
具体细节可参考javadoc。

3.4   MINA的高级主题：线程模式
MINA通过它灵活的filter机制来提供多种线程模型。
没有线程池过滤器被使用时MINA运行在一个单线程模式。
如果添加了一个IoThreadPoolFilter到IoAcceptor，将得到一个leader-follower模式的线程池。
如果再添加一个ProtocolThreadPoolFilter，server将有两个线程池；
一个(IoThreadPoolFilter)被用于对message对象进行转换，另外一个(ProtocolThreadPoolFilter)被用于处理业务逻辑。
SimpleServiceRegistry加上IoThreadPoolFilter和ProtocolThreadPoolFilter的缺省实现即可适用于需
要高伸缩性的应用。如果想使用自己的线程模型，请参考SimpleServiceRegistry的源代码，并且自己

初始化Acceptor。

java 代码

1. IoThreadPoolFilter threadPool = new IoThreadPoolFilter();threadPool.start();   
2. IoAcceptor acceptor = new SocketAcceptor();   
3. acceptor.getFilterChain().addLast( “threadPool”, threadPool);   
4. ProtocolThreadPoolFilter threadPool2 = new ProtocolThreadPoolFilter();   
5. threadPool2.start();   
6. ProtocolAcceptor acceptor2 = new IoProtocolAcceptor( acceptor );   
7. acceptor2.getFilterChain().addLast( “threadPool”, threadPool2 );   
8. …   
9. threadPool2.stop();   
10. threadPool.stop();  

3.5 采用MINA进行socket开发，一般步骤如下：
1：

1. IoAcceptor acceptor = new SocketAcceptor(); //建立client接收器   
2. or client:   
3. SocketConnector connector = new SocketConnector();  //建立一个连接器  

2：server的属性配置：

java 代码

1. SocketAcceptorConfig cfg = new SocketAcceptorConfig();   
2. cfg.setReuseAddress(true);   
3. cfg.getFilterChain().addLast(   
4.             “codec”,   
5.             new ProtocolCodecFilter( new ObjectSerializationCodecFactory() ) ); //对象序列化 codec factory   
6. cfg.getFilterChain().addLast( “logger”, new LoggingFilter() );  

3：绑定address和business logic
server:

java 代码

1. acceptor.bind(   
2.         new InetSocketAddress( SERVER_PORT ),   
3.         new ServerSessionHandler( ), cfg ); // 绑定address和handler   
4.   
5.   
6. connector.connect(new InetSocketAddress( HOSTNAME, PORT ),   
7.                 new ClientSessionHandler(msg), cfg );   

下面的这个简单的example演示client和server传递object的过程：
Message.java

java 代码

1. public class Message implements Serializable {   
2.   
3.     private int type;   
4.     private int status;   
5.     private String msgBody;   
6.        
7.     public Message(int type, int status, String msgBody)   
8.     {   
9.         this.type = type;   
10.         this.status = status;   
11.         this.msgBody = msgBody;   
12.     }   
13.   
14.     public String getMsgBody() {   
15.         return msgBody;   
16.     }   
17.   
18.     public void setMsgBody(String msgBody) {   
19.         this.msgBody = msgBody;   
20.     }   
21.   
22.     public int getStatus() {   
23.         return status;   
24.     }   
25.   
26.     public void setStatus(int status) {   
27.         this.status = status;   
28.     }   
29.   
30.     public int getType() {   
31.         return type;   
32.     }   
33.   
34.     public void setType(int type) {   
35.         this.type = type;   
36.     }   
37. }   
38.   

Client.java

java 代码

1. public class Client   
2. {   
3.     private static final String HOSTNAME = “localhost”;   
4.     private static final int PORT = 8080;   
5.     private static final int CONNECT_TIMEOUT = 30; // seconds   
6.   
7.   
8.     public static void main( String[] args ) throws Throwable   
9.     {   
10.         SocketConnector connector = new SocketConnector();           
11.         // Configure the service.   
12.         SocketConnectorConfig cfg = new SocketConnectorConfig();   
13.         cfg.setConnectTimeout( CONNECT_TIMEOUT );   
14.           cfg.getFilterChain().addLast(   
15.                     “codec”,   
16.                     new ProtocolCodecFilter( new ObjectSerializationCodecFactory() ) );   
17.   
18.         cfg.getFilterChain().addLast( “logger”, new LoggingFilter() );   
19.            
20.         IoSession session;   
21.         Message msg = new Message(0,1,“hello”);   
22.         connector.connect(new InetSocketAddress( HOSTNAME, PORT ),   
23.                         new ClientSessionHandler(msg), cfg );   
24.   
25.     }   
26. }   

ClientSessionHandler.java

java 代码

1. public class ClientSessionHandler extends IoHandlerAdapter   
2. {   
3.     private Object msg;   
4.        
5.     public ClientSessionHandler(Object msg)   
6.     {   
7.         this.msg = msg;   
8.     }   
9.   
10.   
11.     public void sessionOpened( IoSession session )   
12.     {   
13.         session.write(this.msg);   
14.     }   
15.   
16.     public void messageReceived( IoSession session, Object message )   
17.     {   
18.         System.out.println(“in messageReceived!”);   
19.         Message rm = (Message ) message;           
20.         SessionLog.debug(session, rm.getMsgBody());   
21.         System.out.println(“message is: ” + rm.getMsgBody());   
22.         session.write(rm);   
23.     }   
24.   
25.     public void exceptionCaught( IoSession session, Throwable cause )   
26.     {   
27.         session.close();   
28.     }   
29. }   
30.   

Server.java

java 代码

1. public class Server   
2. {   
3.     private static final int SERVER_PORT = 8080;   
4.   
5.     public static void main( String[] args ) throws Throwable   
6.     {   
7.         IoAcceptor acceptor = new SocketAcceptor();   
8.            
9.         // Prepare the service configuration.   
10.         SocketAcceptorConfig cfg = new SocketAcceptorConfig();   
11.         cfg.setReuseAddress( true );   
12.   
13.         cfg.getFilterChain().addLast(   
14.                     “codec”,   
15.                     new ProtocolCodecFilter( new ObjectSerializationCodecFactory() ) );   
16.         cfg.getFilterChain().addLast( “logger”, new LoggingFilter() );   
17.   
18.         acceptor.bind(   
19.                 new InetSocketAddress( SERVER_PORT ),   
20.                 new ServerSessionHandler( ), cfg );   
21.   
22.         System.out.println( “The server Listening on port ” + SERVER_PORT );   
23.     }   
24. }  

ServerSessionHandler.java

java 代码

1. public class ServerSessionHandler extends IoHandlerAdapter   
2. {   
3.     public void sessionOpened( IoSession session )   
4.     {   
5.         // set idle time to 60 seconds   
6.         session.setIdleTime( IdleStatus.BOTH_IDLE, 60 );   
7.         session.setAttribute(“times”,new Integer(0));   
8.     }   
9.   
10.     public void messageReceived( IoSession session, Object message )   
11.     {   
12.         System.out.println(“in messageReceived”);   
13.         int times = ((Integer)(session.getAttribute(“times”))).intValue();   
14.         System.out.println(“tiems = ” + times);   
15.         // communicate 30 times,then close the session.   
16.         if (times < 30)   
17.         {   
18.             times++;   
19.             session.setAttribute(“times”, new Integer(times));              
20.          Message msg;   
21.          msg = (Message) message;   
22.          msg.setMsgBody(“in server side: ” + msg.getMsgBody());    
23.          System.out.println(“begin send msg: ” + msg.getMsgBody());   
24.          session.write(msg);   
25.         }   
26.         else  
27.         {   
28.             session.close();   
29.         }   
30.     }   
31.   
32.     public void sessionIdle( IoSession session, IdleStatus status )   
33.     {   
34.         SessionLog.info( session, “Disconnecting the idle.” );   
35.         // disconnect an idle client   
36.         session.close();   
37.     }   
38.   
39.     public void exceptionCaught( IoSession session, Throwable cause )   
40.     {   
41.         // close the connection on exceptional situation   
42.         session.close();   
43.     }   
44. }   
45.   

MINA自己附带的Demo已经很好的说明了它的运用。
值得一提的是它的SumUp：客户端发送几个数字，服务端求和后并返回结果。这个简单的程序演示了如何自己实现CODEC。

补充提示：
下载并运行MINA的demo程序还颇非周折:
运行MINA demo appli擦tion：
1:在JDK5
产生错误:
Exception in thread “main” java.lang.NoClassDefFoundError: edu/emory/mathcs/backport/java/util/concurrent/Executor
 at org.apache.mina.example.reverser.Main.main(Main.java:44)
 
察看mina的QA email:
 http://www.mail-archive.com/mina-dev@directory.apache.org/msg02252.html

原来需要下载:backport-util-concurrent.jar并加入classpath
http://dcl.mathcs.emory.edu/util/backport-util-concurrent

继续运行还是报错:
Exception in thread “main” java.lang.NoClassDefFoundError: org/slf4j/LoggerFactory

原来MINA采用了slf4j项目作为log，继续下载
slf4j-simple.jar等，并加入classpath:
http://www.slf4j.org/download.html

附件是mina demo的eclipse工程。导入就可运行，所有的相关jar包在bin目录下
http://lcllcl987.javaeye.com/blog/70708

每建立一个Socket连接时，同时创建一个新线程对该Socket进行单独通信（采用阻塞的方式通信）。这种方式具有很高的响应速度，并且控制起来也很简单，在连接数较少的时候非常有效，但是如果对每一个连接都产生一个线程的无疑是对系统资源的一种浪费，如果连接数较多将会出现资源不足的情况。

example:
server code:

java 代码

1. public class MultiUserServer extends Thread {   
2.     private Socket client;   
3.        
4.     public MultiUserServer(Socket c) {   
5.         this.client = c;   
6.     }   
7.   
8.     public void run() {   
9.         try {   
10.             BufferedReader in = new BufferedReader(new InputStreamReader(client   
11.                     .getInputStream()));   
12.             PrintWriter out = new PrintWriter(client.getOutputStream());   
13.             //  Mutil User but can’t parallel   
14.             while (true) {   
15.                 String str = in.readLine();   
16.                 System.out.println(str);   
17.                 SocketLog.debug(“receive message: ” + str);   
18.                 out.println(“has receive….”);   
19.                 out.flush();   
20.                 if (str.equals(“end”))   
21.                     break;   
22.             }   
23.             client.close();   
24.         } catch (IOException ex) {   
25.         }    
26.     }   
27.   
28.     public static void main(String[] args) throws IOException {   
29.         int port = 5678;   
30.         if (args.length > 0)   
31.             port = Integer.parseInt(args[0]);   
32.         ServerSocket server = new ServerSocket(port);   
33.         SocketLog.debug(“the server socket application is created!”);   
34.         while (true) {   
35.             //  transfer location change Single User or Multi User   
36.             MultiUserServer mu = new MultiUserServer(server.accept());   
37.             mu.start();   
38.         }   
39.     }   
40. }  

client code：

java 代码

1. public class Client {   
2.   
3.     static Socket server;   
4.   
5.     public static void main(String[] args) throws Exception {   
6.            
7.         //set socket proxy.   
8.         String proxyHost = “192.168.254.212″;   
9.         String proxyPort = “1080″;   
10.         System.getProperties().put(“socksProxySet”,“true”);   
11.         System.getProperties().put(“socksProxyHost”,proxyHost);   
12.         System.getProperties().put(“socksProxyPort”,proxyPort);    
13.            
14.         String host = “132.201.69.80″;   
15.         int port = 13086;   
16.         if (args.length > 1)   
17.         {   
18.             host = args[0];   
19.             port = Integer.parseInt(args[1]);   
20.         }   
21.         System.out.println(“connetioning:” + host + “:” + port);   
22.         server = new Socket(host, port);   
23.         BufferedReader in = new BufferedReader(new InputStreamReader(server   
24.                 .getInputStream()));   
25.         PrintWriter out = new PrintWriter(server.getOutputStream());   
26.         BufferedReader wt = new BufferedReader(new InputStreamReader(System.in));   
27.         while (true) {   
28.             String str = wt.readLine();   
29.             out.println(str);   
30.             out.flush();   
31.             if (str.equals(“end”)) {   
32.                 break;   
33.             }   
34.             System.out.println(in.readLine());   
35.         }   
36.         server.close();   
37.     }   
38. }  

 2.nio:非阻塞通讯模式

２．１NIO 设计背后的基石：反应器模式，用于事件多路分离和分派的体系结构模式。
反应器模式的核心功能如下：
将事件多路分用
将事件分派到各自相应的事件处理程序

NIO 的非阻塞 I/O 机制是围绕 选择器和 通道构建的。Channel 类表示服务器和客户机之间的一种通信机制。Selector 类是 Channel 的多路复用器。 Selector 类将传入客户机请求多路分用并将它们分派到各自的请求处理程序。
通道(Channel 类)：表示服务器和客户机之间的一种通信机制。
选择器(Selector类)：是 Channel 的多路复用器。

Selector 类将传入的客户机请求多路分用并将它们分派到各自的请求处理程序。简单的来说：NIO是一个基于事件的IO架构，最基本的思想就是：有事件我通知你，你再去做你的事情．而且NIO的主线程只有一个，不像传统的模型，需要多个线程以应对客户端请求，也减轻了JVM的工作量。
当Channel注册至Selector以后，经典的调用方法如下：       nio中取得事件通知，就是在selector的select事件中完成的。在selector事件时有一个线程向操作系统询问，selector中注册的Channel&&SelectionKey的键值对的各种事件是否有发生，如果有则添加到selector的selectedKeys属性Set中去，并返回本次有多少个感兴趣的事情发生。如果发现这个值>0，表示有事件发生，马上迭代selectedKeys中的SelectionKey，
根据Key中的表示的事件，来做相应的处理。实际上，这段说明表明了异步socket的核心，即异步socket不过是将多个socket的调度（或者还有他们的线程调度）全部交给操作系统自己去完成，异步的核心Selector，不过是将这些调度收集、分发而已。

java 代码

1. while (somecondition) {   
2.     int n = selector.select(TIMEOUT);   
3.     if (n == 0)   
4.         continue;   
5.     for (Iterator iter = selector.selectedKeys().iterator(); iter   
6.             .hasNext();) {   
7.         if (key.isAcceptable())   
8.             doAcceptable(key);   
9.         if (key.isConnectable())   
10.             doConnectable(key);   
11.         if (key.isValid() && key.isReadable())   
12.             doReadable(key);   
13.         if (key.isValid() && key.isWritable())   
14.             doWritable(key);   
15.         iter.remove();   
16.     }   
17. }  

2.2 nio example:
server code：

java 代码

1. public class NonBlockingServer   
2. {   
3.     public Selector sel = null;   
4.     public ServerSocketChannel server = null;   
5.     public SocketChannel socket = null;   
6.     public int port = 4900;   
7.     String result = null;   
8.   
9.   
10.     public NonBlockingServer()   
11.     {   
12.         System.out.println(“Inside default ctor”);   
13.     }   
14.        
15.     public NonBlockingServer(int port)   
16.     {   
17.         System.out.println(“Inside the other ctor”);   
18.         this.port = port;   
19.     }   
20.   
21.     public void initializeOperations() throws IOException,UnknownHostException   
22.     {   
23.         System.out.println(“Inside initialization”);   
24.         sel = Selector.open();   
25.         server = ServerSocketChannel.open();   
26.         server.configureBlocking(false);   
27.         InetAddress ia = InetAddress.getLocalHost();   
28.         InetSocketAddress isa = new InetSocketAddress(ia,port);   
29.         server.socket().bind(isa);   
30.     }   
31.        
32.     public void startServer() throws IOException   
33.     {   
34.         System.out.println(“Inside startserver”);   
35.         initializeOperations();   
36.         System.out.println(“Abt to block on select()”);   
37.         SelectionKey acceptKey = server.register(sel, SelectionKey.OP_ACCEPT );    
38.        
39.         while (acceptKey.selector().select() > 0 )   
40.         {      
41.            
42.             Set readyKeys = sel.selectedKeys();   
43.             Iterator it = readyKeys.iterator();   
44.   
45.             while (it.hasNext()) {   
46.                 SelectionKey key =