// 创建连接，如果域名解析不了会抛出UnknownHostException，当连接不上时会抛出IOException，
    如果希望控制建立连接的超时，可先调用new Socket()，然后调用socket.connect(SocketAddress
    类型的目标地址，以毫秒为单位的超时时间)
    Socket socket=new Socket(目标IP或域名，目标端口);
    // 创建读取服务器端返回流的BufferedReader
    BufferedReader in=new BufferedReader(new
    InputStreamReader(socket.getInputStream()));
    // 创建向服务器写入流的PrintWriter
    PrintWriter out=new PrintWriter(socket.getOutputStream(),true);
    // 向服务器发送字符串信息，要注意的是，此处即使写失败也不会抛出异常信息，并且一直会阻塞到写入
    操作系统或网络IO出现异常为止
    out.println(“hello”);
    // 阻塞读取服务端的返回信息，以下代码会阻塞到服务端返回信息或网络IO出现异常为止，如果希望在超
    过一段时间后就不阻塞了，那么要在创建Socket对象后调用socket.setSoTimeout(以毫秒为单位的超
    时时间)
    in.readLine();

    // 创建对本地指定端口的监听，如端口冲突则抛出SocketException，其他网络IO方面的异常则抛出
    IOException ServerSocket ss=new ServerSocket(监听的端口)
    // 接受客户端建立连接的请求，并返回Socket对象，以便和客户端进行交互，交互的方式和客户端相同，
    也是通过Socket.getInputStream和Socket.getOutputStream来进行读写操作，此方法会一直阻
    塞到有客户端发送建立连接的请求，如果希望此方法最多阻塞一定的时间，则要在创建ServerSocket后
    调用其setSoTimeout(以毫秒为单位的超时时间)
    Socket socket=ss.accept();

    SocketChannel channel=SocketChannel.open();
    // 设置为非阻塞模式
    channel.configureBlocking(false);
    //对于非阻塞模式，立刻返回false，表示连接正在建立中
    channel.connect(SocketAddress);
    Selector selector=Selector.open();
    // 向channel注册selector以及感兴趣的连接事件
    channel.register(selector,SelectionKey.OP_CONNECT);
    // 阻塞至有感兴趣的IO事件发生，或到达超时时间，如果希望一直等至有感兴趣的IO事件发生，可调用
    无参数的select方法，如果希望不阻塞直接返回目前是否有感兴趣的事件发生，可调用selectNow方法
    int nKeys=selector.select(以毫秒为单位的超时时间)
    // 如nKeys大于零，说明有感兴趣的IO事件发生
    SelectionKey sKey=null;
    if(nKeys>0){
      Set<SelectionKey> keys=selector.selectedKeys();
    for(SelectionKey key:keys){
        // 对于发生连接的事件
                if(key.isConnectable()){
                    SocketChannel sc=(SocketChannel) key.channel();
                    sc.configureBlocking(false);
                    // 注册感兴趣的IO读事件，通常不直接注册写事件，在发送缓冲区未满的情况下，一
    直是可写的，因此如注册了写事件，而又不用写数据，很容易造成CPU消耗100%的现象
    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返回的为成功复制到bytebuffer中的字
    节数，此步为阻塞操作，值可能为0；当已经是流的结尾时，返回-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();
                       // 此步为阻塞操作，直到写入操作系统发送缓冲区或网络IO出现异常，返回的为成功
    写入的字节数，当操作系统的发送缓冲区已满，此处会返回0
    int writtenedSize=sc.write(ByteBuffer);
    // 如未写入，则继续注册感兴趣的OP_WRITE事件
    if(writtenedSize==0){
       key.interestOps(key.interestOps() | SelectionKey.OP_WRITE);
    }
    }
          }
       selector.selectedKeys().clear();
    }
    // 对于要写入的流，可直接调用channel.write来完成，只有在写入未成功时才要注册OP_WRITE事件
    int wSize=channel.write(ByteBuffer);
    if(wSize==0){
       key.interestOps(key.interestOps() | SelectionKey.OP_WRITE);
    }

    ServerSocketChannel ssc=ServerSocketChannel.open();
      ServerSocket serverSocket=ssc.socket();
      // 绑定要监听的端口
    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是无连接的，如果希望双向通信，就必须启动一个监听端口，承担服务器的职责，如不能
    绑定到指定端口，则抛出SocketException
    DatagramSocket serverSocket=new DatagramSocket(监听的端口);
    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);
    // 阻塞发送packet到指定的服务器和端口，当出现网络IO异常时抛出IOException，当连不上目标地
    址和端口时，抛出PortUnreachableException
    socket.send(packet)
    // 阻塞并同步读取流信息，如接收到的流信息比packet长度长，则删除更长的信息，可通过调用
    DatagramSocket.setSoTimeout(以毫秒为单位的超时时间)来设置读取流的超时时间
    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);
    // 阻塞写入流，如发送缓冲区已满，则返回0，此时可通过注册SelectionKey.OP_WRITE事件，以便
    在可写入时再进行写操作，方式和TCP/IP+NIO基本一致
    sendChannel.write(ByteBuffer);

    // 组播地址
    InetAddress groupAddress=InetAddress.getByName("224.1.1.1");
    MulticastSocket server=new MulticastSocket(port);
      // 加入组播，如地址为非组播地址，则抛出IOException，当已经不希望再发送数据到组播地址，或
    不希望再读取数据时，可调用server.leaveGroup(组播地址)
    server.joinGroup(groupAddress);
      MulticastSocket client=new MulticastSocket();
    client.joinGroup(groupAddress);

    // 创建一个线程池大小为CPU核数+1的SocketConnector对象
    SocketConnector ioConnector = new
    SocketConnector(Runtime.getRuntime().availableProcessors() + 1,
    Executors.newCachedThreadPool());
    // 设置TCP NoDelay为true
    ioConnector.getDefaultConfig().getSessionConfig().setTcpNoDelay(true);
    // 增加一个将发送对象进行序列化以及接收字节流进行反序列化的类至filter Chain
    ioConnector.getFilterChain().addLast("stringserialize", new
    ProtocolCodecFilter(new ObjectSerializationCodecFactory()));
    // IoHandler的实现，以便当mina建立连接、接收到消息后通知应用
    IoHandler handler=new IoHandlerAdapter(){
                public void messageReceived(IoSession session, Object message)
                        throws Exception {
                    System.out.println(message);
                }
      };
            // 异步建立连接
    ConnectFuture connectFuture = ioConnector.connect(socketAddress,handler);
            // 阻塞等待连接建立完毕，如须设置连接创建的超时时间，可调用
    SocketConnectorConfig.setConnectTimeout(以秒为单位的超时时间)
      connectFuture.join();
    IoSession session=connectFuture.getSession();
    // 发送对象
    session.write(Object);

    // 创建一个线程池大小为CPU核数+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 {
                    // 接收到客户端发送的对象
                }
            };
    // 绑定监听的端口以及当有连接建立、接收到对象等事件发送时需要通知的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;
          }
              // 写入失败，自行进行处理
      }
    });