// 創(chuàng)建連接，如果域名解析不了會拋出UnknownHostException，當(dāng)連接不上時會拋出IOException，
    如果希望控制建立連接的超時，可先調(diào)用new Socket()，然后調(diào)用socket.connect(SocketAddress
    類型的目標(biāo)地址，以毫秒為單位的超時時間)
    Socket socket=new Socket(目標(biāo)IP或域名，目標(biāo)端口);
    // 創(chuàng)建讀取服務(wù)器端返回流的BufferedReader
    BufferedReader in=new BufferedReader(new
    InputStreamReader(socket.getInputStream()));
    // 創(chuàng)建向服務(wù)器寫入流的PrintWriter
    PrintWriter out=new PrintWriter(socket.getOutputStream(),true);
    // 向服務(wù)器發(fā)送字符串信息，要注意的是，此處即使寫失敗也不會拋出異常信息，并且一直會阻塞到寫入
    操作系統(tǒng)或網(wǎng)絡(luò)IO出現(xiàn)異常為止
    out.println(“hello”);
    // 阻塞讀取服務(wù)端的返回信息，以下代碼會阻塞到服務(wù)端返回信息或網(wǎng)絡(luò)IO出現(xiàn)異常為止，如果希望在超
    過一段時間后就不阻塞了，那么要在創(chuàng)建Socket對象后調(diào)用socket.setSoTimeout(以毫秒為單位的超
    時時間)
    in.readLine();

    // 創(chuàng)建對本地指定端口的監(jiān)聽，如端口沖突則拋出SocketException，其他網(wǎng)絡(luò)IO方面的異常則拋出
    IOException ServerSocket ss=new ServerSocket(監(jiān)聽的端口)
    // 接受客戶端建立連接的請求，并返回Socket對象，以便和客戶端進行交互，交互的方式和客戶端相同，
    也是通過Socket.getInputStream和Socket.getOutputStream來進行讀寫操作，此方法會一直阻
    塞到有客戶端發(fā)送建立連接的請求，如果希望此方法最多阻塞一定的時間，則要在創(chuàng)建ServerSocket后
    調(diào)用其setSoTimeout(以毫秒為單位的超時時間)
    Socket socket=ss.accept();

    SocketChannel channel=SocketChannel.open();
    // 設(shè)置為非阻塞模式
    channel.configureBlocking(false);
    //對于非阻塞模式，立刻返回false，表示連接正在建立中
    channel.connect(SocketAddress);
    Selector selector=Selector.open();
    // 向channel注冊selector以及感興趣的連接事件
    channel.register(selector,SelectionKey.OP_CONNECT);
    // 阻塞至有感興趣的IO事件發(fā)生，或到達超時時間，如果希望一直等至有感興趣的IO事件發(fā)生，可調(diào)用
    無參數(shù)的select方法，如果希望不阻塞直接返回目前是否有感興趣的事件發(fā)生，可調(diào)用selectNow方法
    int nKeys=selector.select(以毫秒為單位的超時時間)
    // 如nKeys大于零，說明有感興趣的IO事件發(fā)生
    SelectionKey sKey=null;
    if(nKeys>0){
      Set<SelectionKey> keys=selector.selectedKeys();
    for(SelectionKey key:keys){
        // 對于發(fā)生連接的事件
                if(key.isConnectable()){
                    SocketChannel sc=(SocketChannel) key.channel();
                    sc.configureBlocking(false);
                    // 注冊感興趣的IO讀事件，通常不直接注冊寫事件，在發(fā)送緩沖區(qū)未滿的情況下，一
    直是可寫的，因此如注冊了寫事件，而又不用寫數(shù)據(jù)，很容易造成CPU消耗100%的現(xiàn)象
    sKey = sc.register(selector, SelectionKey.OP_READ);
    // 完成連接的建立
                    sc.finishConnect();
            }
            // 有流可讀取
                else if(key.isReadable()){
                    ByteBuffer buffer=ByteBuffer.allocate(1024);
                    SocketChannel sc=(SocketChannel) key.channel();
                    int readBytes=0;
                    try{
                        int ret=0;
                        try{
                            // 讀取目前可讀的流，sc.read返回的為成功復(fù)制到bytebuffer中的字
    節(jié)數(shù)，此步為阻塞操作，值可能為0；當(dāng)已經(jīng)是流的結(jié)尾時，返回-1
    while((ret=sc.read(buffer))>0){
                              readBytes+=ret;
                            }
                         }
                         finally{
                             buffer.flip();
                         }
                      }
                      finally{
                         if(buffer!=null){
                             buffer.clear();
                         }
                      }
                   }
                   // 可寫入流
                   else if(key.isWritable()){
                       // 取消對OP_WRITE事件的注冊
                       key.interestOps(key.interestOps() & (～SelectionKey.OP_WRITE));
                       SocketChannel sc=(SocketChannel) key.channel();
                       // 此步為阻塞操作，直到寫入操作系統(tǒng)發(fā)送緩沖區(qū)或網(wǎng)絡(luò)IO出現(xiàn)異常，返回的為成功
    寫入的字節(jié)數(shù)，當(dāng)操作系統(tǒng)的發(fā)送緩沖區(qū)已滿，此處會返回0
    int writtenedSize=sc.write(ByteBuffer);
    // 如未寫入，則繼續(xù)注冊感興趣的OP_WRITE事件
    if(writtenedSize==0){
       key.interestOps(key.interestOps() | SelectionKey.OP_WRITE);
    }
    }
          }
       selector.selectedKeys().clear();
    }
    // 對于要寫入的流，可直接調(diào)用channel.write來完成，只有在寫入未成功時才要注冊O(shè)P_WRITE事件
    int wSize=channel.write(ByteBuffer);
    if(wSize==0){
       key.interestOps(key.interestOps() | SelectionKey.OP_WRITE);
    }

    ServerSocketChannel ssc=ServerSocketChannel.open();
      ServerSocket serverSocket=ssc.socket();
      // 綁定要監(jiān)聽的端口
    serverSocket.bind(new InetSocketAddress(port));
      ssc.configureBlocking(false);
    // 注冊感興趣的連接建立事件
    ssc.register(selector, SelectionKey.OP_ACCEPT);

    if(key.isAcceptable()){
      ServerSocketChannel server=(ServerSocketChannel)key.channel();
      SocketChannel sc=server.accept();
      if(sc==null){
            continue;
    }
    sc.configureBlocking(false);
    sc.register(selector,SelectionKey.OP_READ);
    }

    // 由于UDP/IP是無連接的，如果希望雙向通信，就必須啟動一個監(jiān)聽端口，承擔(dān)服務(wù)器的職責(zé)，如不能
    綁定到指定端口，則拋出SocketException
    DatagramSocket serverSocket=new DatagramSocket(監(jiān)聽的端口);
    byte[] buffer=new byte[65507];
    DatagramPacket receivePacket=new DatagramPacket(buffer,buffer.length);
    DatagramSocket socket=new DatagramSocket();
    DatagramPacket packet=new DatagramPacket(datas,datas.length,server,port);
    // 阻塞發(fā)送packet到指定的服務(wù)器和端口，當(dāng)出現(xiàn)網(wǎng)絡(luò)IO異常時拋出IOException，當(dāng)連不上目標(biāo)地
    址和端口時，拋出PortUnreachableException
    socket.send(packet)
    // 阻塞并同步讀取流信息，如接收到的流信息比packet長度長，則刪除更長的信息，可通過調(diào)用
    DatagramSocket.setSoTimeout(以毫秒為單位的超時時間)來設(shè)置讀取流的超時時間
    serverSocket.receive(receivePacket)

    DatagramChannel receiveChannel=DatagramChannel.open();
      receiveChannel.configureBlocking(false);
      DatagramSocket socket=receiveChannel.socket();
      socket.bind(new InetSocketAddress(rport));
      Selector selector=Selector.open();
      receiveChannel.register(selector, SelectionKey.OP_READ);
      之后即可采取和TCP/IP+NIO中對selector遍歷一樣的方式進行流信息的讀取。
      DatagramChannel sendChannel=DatagramChannel.open();
      sendChannel.configureBlocking(false);
      SocketAddress target=new InetSocketAddress("127.0.0.1",sport);
    sendChannel.connect(target);
    // 阻塞寫入流，如發(fā)送緩沖區(qū)已滿，則返回0，此時可通過注冊SelectionKey.OP_WRITE事件，以便
    在可寫入時再進行寫操作，方式和TCP/IP+NIO基本一致
    sendChannel.write(ByteBuffer);

    // 組播地址
    InetAddress groupAddress=InetAddress.getByName("224.1.1.1");
    MulticastSocket server=new MulticastSocket(port);
      // 加入組播，如地址為非組播地址，則拋出IOException，當(dāng)已經(jīng)不希望再發(fā)送數(shù)據(jù)到組播地址，或
    不希望再讀取數(shù)據(jù)時，可調(diào)用server.leaveGroup(組播地址)
    server.joinGroup(groupAddress);
      MulticastSocket client=new MulticastSocket();
    client.joinGroup(groupAddress);

    // 創(chuàng)建一個線程池大小為CPU核數(shù)+1的SocketConnector對象
    SocketConnector ioConnector = new
    SocketConnector(Runtime.getRuntime().availableProcessors() + 1,
    Executors.newCachedThreadPool());
    // 設(shè)置TCP NoDelay為true
    ioConnector.getDefaultConfig().getSessionConfig().setTcpNoDelay(true);
    // 增加一個將發(fā)送對象進行序列化以及接收字節(jié)流進行反序列化的類至filter Chain
    ioConnector.getFilterChain().addLast("stringserialize", new
    ProtocolCodecFilter(new ObjectSerializationCodecFactory()));
    // IoHandler的實現(xiàn)，以便當(dāng)mina建立連接、接收到消息后通知應(yīng)用
    IoHandler handler=new IoHandlerAdapter(){
                public void messageReceived(IoSession session, Object message)
                        throws Exception {
                    System.out.println(message);
                }
      };
            // 異步建立連接
    ConnectFuture connectFuture = ioConnector.connect(socketAddress,handler);
            // 阻塞等待連接建立完畢，如須設(shè)置連接創(chuàng)建的超時時間，可調(diào)用
    SocketConnectorConfig.setConnectTimeout(以秒為單位的超時時間)
      connectFuture.join();
    IoSession session=connectFuture.getSession();
    // 發(fā)送對象
    session.write(Object);

    // 創(chuàng)建一個線程池大小為CPU核數(shù)+1的IoAcceptor對象
    final IoAcceptor acceptor=new
    SocketAcceptor(Runtime.getRuntime().availableProcessors() + 1,
                                  Executors.newCachedThreadPool());
    acceptor.getFilterChain().addLast("stringserialize", new
    ProtocolCodecFilter(new ObjectSerializationCodecFactory()));
    IoHandler handler=new IoHandlerAdapter(){
                public void messageReceived(IoSession session, Object message)
                        throws Exception {
                    // 接收到客戶端發(fā)送的對象
                }
            };
    // 綁定監(jiān)聽的端口以及當(dāng)有連接建立、接收到對象等事件發(fā)送時需要通知的IoHandler對象
    acceptor.bind(new InetSocketAddress(port), handler);

    WriteFuture writeResult=session.write(data);
    writeResult.addListener(new IoFutureListener() {
      public void operationComplete(IoFuture future){
          WriteFuture wfuture=(WriteFuture)future;
          // 寫入成功
          if(wfuture.isWritten()){
              return;
          }
              // 寫入失敗，自行進行處理
      }
    });