的client比较简单，下面是一个复杂点的:

1. package org.guojje.grizzly;  
2.  
3. import java.io.IOException;  
4. import java.net.InetAddress;  
5. import java.net.InetSocketAddress;  
6. import java.net.UnknownHostException;  
7. import java.nio.ByteBuffer;  
8. import java.nio.channels.SelectionKey;  
9. import java.util.concurrent.CountDownLatch;  
10. import java.util.logging.Level;  
11.  
12. import com.sun.grizzly.CallbackHandler;  
13. import com.sun.grizzly.Context;  
14. import com.sun.grizzly.Controller;  
15. import com.sun.grizzly.ControllerStateListenerAdapter;  
16. import com.sun.grizzly.IOEvent;  
17. import com.sun.grizzly.TCPConnectorHandler;  
18. import com.sun.grizzly.TCPSelectorHandler;  
19. import com.sun.grizzly.Controller.Protocol;  
20. import com.sun.grizzly.util.WorkerThreadImpl;  
21.  
22. public class Client {  
23.  
24.     public static void main(String[] args) throws UnknownHostException,  
25.             IOException {  
26.  
27.         Controller controller = new Controller();  
28.  
29.         // it is true for client  
30.         TCPSelectorHandler tcpHandler = new TCPSelectorHandler(true);  
31.         controller.setSelectorHandler(tcpHandler);  
32.  
33.         final CountDownLatch latch = new CountDownLatch(1);  
34.         controller.addStateListener(new ControllerStateListenerAdapter() {  
35.  
36.             public void onStarted() {  
37.                 System.out.println("on started");  
38.             }  
39.  
40.             public void onReady() {  
41.                 System.out.println("on ready");  
42.                 latch.countDown();  
43.             }  
44.  
45.             public void onException(Throwable e) {  
46.                 if (latch.getCount() > 0) {  
47.                     Controller.logger().log(Level.SEVERE,  
48.                             "Exception during " + "starting the controller", e);  
49.                     latch.countDown();  
50.                 } else {  
51.                     Controller.logger().log(Level.SEVERE,  
52.                             "Exception during " + "controller processing", e);  
53.                 }  
54.             }  
55.         });  
56.         // controller.start(); 这里不能再用controller.start()来启动controller  
57.         // 因为他会阻塞当前线程  
58.         new WorkerThreadImpl("client_work", controller).start();  
59.  
60.         try {  
61.             latch.await();  
62.         } catch (InterruptedException e1) {  
63.             // do nothing  
64.         }  
65.  
66.         if (!controller.isStarted()) {  
67.             throw new IllegalStateException("Controller is not started!");  
68.         }  
69.  
70.         final CountDownLatch waitLatch = new CountDownLatch(1);  
71.  
72.         final TCPConnectorHandler tch = (TCPConnectorHandler) controller  
73.                 .acquireConnectorHandler(Protocol.TCP);  
74.         tch.connect(new InetSocketAddress(InetAddress.getLocalHost(), 1900),  
75.                 new CallbackHandler<Context>() {  
76.  
77.                     public void onConnect(IOEvent<Context> ioEvent) {  
78.                         try {  
79.                             SelectionKey k = ioEvent.attachment()  
80.                                     .getSelectionKey();  
81.                             try {  
82.                                 tch.finishConnect(k);  
83.                                 // log("finishConnect");  
84.                             } catch (java.io.IOException ex) {  
85.                                 // ioExceptionHandler.handle(ex);  
86.                                 return;  
87.                             } catch (Throwable ex) {  
88.                                 // logger().log(Level.SEVERE, "onConnect", ex);  
89.                                 return;  
90.                             }  
91.                             // 注册Read事件  
92.                             ioEvent.attachment().getSelectorHandler().register(  
93.                                     k, SelectionKey.OP_READ);  
94.  
95.                         } finally {  
96.                             if (waitLatch != null) {  
97.                                 waitLatch.countDown();  
98.                             }  
99.                         }  
100.                     }  
101.  
102.                     public void onRead(IOEvent<Context> ioEvent) {  
103.                         ByteBuffer bb = ByteBuffer.allocate(100);  
104.                         try {  
105.                             tch.read(bb, false);  
106.                         } catch (IOException e) {  
107.                             e.printStackTrace();  
108.                         }  
109.                         bb.flip();  
110.                         System.out.println(new String(bb.array(), 0, bb  
111.                                 .remaining()));  
112.  
113.                         SelectionKey k = ioEvent.attachment().getSelectionKey();  
114.                         // 重新注册read事件，原因参考TcpSelectorHandler的onReadInterest/onWriteInterest方法  
115.                         ioEvent.attachment().getSelectionKey().interestOps(  
116.                                 k.interestOps() | SelectionKey.OP_READ);  
117.                     }  
118.  
119.                     public void onWrite(IOEvent<Context> ioEvent) {  
120.                     }  
121.                 });  
122.  
123.         System.out.println("current connection:" + tch.getUnderlyingChannel());  
124.  
125.         try {  
126.             waitLatch.await();  
127.         } catch (Exception e) {  
128.             // do nothing  
129.         }  
130.  
131.         ByteBuffer bb = ByteBuffer.wrap("xxxx".getBytes());  
132.         tch.write(bb, true);  
133.     }  
134. }