public class SoupSpoon extends AbstractSpoon
{
　　public SoupSpoon()
　　{
　　　　setSpoonName("Soup Spoon");
　　}
}

/**
*
* @author Administrator
* @version
*/
public class NBTest {

　　/** Creates new NBTest */
　　public NBTest()
　　{
　　}

　　public void startServer() throws Exception
　　{
　　int channels = 0;
　　int nKeys = 0;
　　int currentSelector = 0;

　　//使用Selector
　　Selector selector = Selector.open();

　　//建立Channel 并绑定到9000端口
　　ServerSocketChannel ssc = ServerSocketChannel.open();
　　InetSocketAddress address = new InetSocketAddress(InetAddress.getLocalHost(),9000);
　　ssc.socket().bind(address);

　　//使设定non-blocking的方式。
　　ssc.configureBlocking(false);

　　//向Selector注册Channel及我们有兴趣的事件
　　SelectionKey s = ssc.register(selector, SelectionKey.OP_ACCEPT);
　　printKeyInfo(s);

　　while(true) //不断的轮询
　　{
　　　　debug("NBTest: Starting select");

　　　　//Selector通过select方法通知我们我们感兴趣的事件发生了。
　　　　nKeys = selector.select();
　　　　//如果有我们注册的事情发生了，它的传回值就会大于0
　　　　if(nKeys > 0)
　　　　{
　　　　　　debug("NBTest: Number of keys after select operation: " +nKeys);

　　　　　　//Selector传回一组SelectionKeys
　　　　　　//我们从这些key中的channel()方法中取得我们刚刚注册的channel。
　　　　　　Set selectedKeys = selector.selectedKeys();
　　　　　　Iterator i = selectedKeys.iterator();
　　　　　　while(i.hasNext())
　　　　　　{
　　　　　　 　 s = (SelectionKey) i.next();
　　　　　　 　 printKeyInfo(s);
　　　　　　 　 debug("NBTest: Nr Keys in selector: " +selector.keys().size());

　　　　　　 　 //一个key被处理完成后，就都被从就绪关键字（ready keys）列表中除去
　　　　　　 　 i.remove();
　　　　　　 　 if(s.isAcceptable())
　　　　　　 　 {
　　　　　　 　 　 // 从channel()中取得我们刚刚注册的channel。
　　　　　　 　 　 Socket socket = ((ServerSocketChannel)s.channel()).accept().socket();
　　　　　　 　 　 SocketChannel sc = socket.getChannel();

　　　　　　 　 　 sc.configureBlocking(false);
　　　　　　 　 　 sc.register(selector, SelectionKey.OP_READ |SelectionKey.OP_WRITE);
　　　　　　 　 　 　　　　　　 　 　 System.out.println(++channels);
　　　　　　 　 }
　　　　　　 　 else
　　　　　　 　 {
　　　　　　 　 　 debug("NBTest: Channel not acceptable");
　　　　　　 　 }
　　　　　 }
　　　}
　　　else
　　　{
　　　　　　debug("NBTest: Select finished without any keys.");
　　　}

　 }

}

private static void debug(String s)
{
　 System.out.println(s);
}

private static void printKeyInfo(SelectionKey sk)
{
　 String s = new String();

　 s = "Att: " + (sk.attachment() == null ? "no" : "yes");
　 s += ", Read: " + sk.isReadable();
　 s += ", Acpt: " + sk.isAcceptable();
　 s += ", Cnct: " + sk.isConnectable();
　 s += ", Wrt: " + sk.isWritable();
　 s += ", Valid: " + sk.isValid();
　 s += ", Ops: " + sk.interestOps();
　 debug(s);
}

/**
* @param args the command line arguments
*/
public static void main (String args[])
{
　 NBTest nbTest = new NBTest();
　 try
　 {
　 　 nbTest.startServer();
　 }
　 　 catch(Exception e)
　 {
　 　 e.printStackTrace();
　 }
}

}

　　final Selector selector;
　　final ServerSocketChannel serverSocket;

　　Reactor(int port) throws IOException {
　　　　selector = Selector.open();
　　　　serverSocket = ServerSocketChannel.open();
　　　　InetSocketAddress address = new InetSocketAddress(InetAddress.getLocalHost(),port);
　　　　serverSocket.socket().bind(address);

　　　　serverSocket.configureBlocking(false);
　　　　//向selector注册该channel
　　　　 SelectionKey sk =serverSocket.register(selector,SelectionKey.OP_ACCEPT);

　　　　logger.debug("-->Start serverSocket.register!");

　　　　//利用sk的attache功能绑定Acceptor 如果有事情，触发Acceptor
　　　　sk.attach(new Acceptor());
　　　　logger.debug("-->attach(new Acceptor()!");
　　}

　　public void run() { // normally in a new Thread
　　　　try {
　　　　while (!Thread.interrupted())
　　　　{
　　　　　　selector.select();
　　　　　　Set selected = selector.selectedKeys();
　　　　　　Iterator it = selected.iterator();
　　　　　　//Selector如果发现channel有OP_ACCEPT或READ事件发生，下列遍历就会进行。
　　　　　　while (it.hasNext())
　　　　　　　　//来一个事件 第一次触发一个accepter线程
　　　　　　　　//以后触发SocketReadHandler
　　　　　　　　dispatch((SelectionKey)(it.next()));
　　　　　　　　selected.clear();
　　　　　　}
　　　　}catch (IOException ex) {
　　　　　　　　logger.debug("reactor stop!"+ex);
　　　　}
　　}

　　//运行Acceptor或SocketReadHandler
　　void dispatch(SelectionKey k) {
　　　　Runnable r = (Runnable)(k.attachment());
　　　　if (r != null){
　　　　　　// r.run();

　　　　}
　　}

　　class Acceptor implements Runnable { // inner
　　　　public void run() {
　　　　try {
　　　　　　logger.debug("-->ready for accept!");
　　　　　　SocketChannel c = serverSocket.accept();
　　　　　　if (c != null)
　　　　　　　　//调用Handler来处理channel
　　　　　　　　new SocketReadHandler(selector, c);
　　　　　　}
　　　　catch(IOException ex) {
　　　　　　logger.debug("accept stop!"+ex);
　　　　}
　　　　}
　　}
}

　　public static Logger logger = Logger.getLogger(SocketReadHandler.class);

　　private Test test=new Test();

　　final SocketChannel socket;
　　final SelectionKey sk;

　　 static final int READING = 0, SENDING = 1;
　　int state = READING;

　　public SocketReadHandler(Selector sel, SocketChannel c)
　　　　throws IOException {

　　　　socket = c;

　　　　socket.configureBlocking(false);
　　　　 sk = socket.register(sel, 0);

　　　　//将SelectionKey绑定为本Handler 下一步有事件触发时，将调用本类的run方法。
　　　　//参看dispatch(SelectionKey k)
　　　　sk.attach(this);

　　　　//同时将SelectionKey标记为可读，以便读取。
　　　　sk.interestOps(SelectionKey.OP_READ);
　　　　sel.wakeup();
　　}

　　public void run() {
　　　　try{
　　　　// test.read(socket,input);
　　　　　　readRequest() ;
　　　　}catch(Exception ex){
　　　　logger.debug("readRequest error"+ex);
　　　　}
　　}

/**
* 处理读取data
* @param key
* @throws Exception
*/
private void readRequest() throws Exception {

　　ByteBuffer input = ByteBuffer.allocate(1024);
　　input.clear();
　　try{

　　　　int bytesRead = socket.read(input);

　　　　......

　　　　//激活线程池 处理这些request
　　　　requestHandle(new Request(socket,btt));

　　　　.....

　　}catch(Exception e) {
　　}

}