Java Socket:Java-NIO-ServerSocketChannel

ServerSocketChannel

让我们从最简单的ServerSocketChannel来开始对socket通道类的讨论

ServerSocketChannel是一个基于通道的socket监听器。它同我们所熟悉的java.net.ServerSocket执行相同的基本任务，不过它增加了通道语义，因此能够在非阻塞模式下运行。

用静态的open( )工厂方法创建一个新的ServerSocketChannel对象，将会返回同一个未绑定的java.net.ServerSocket关联的通道。该对等ServerSocket可以通过在返回的ServerSocketChannel上调用socket( )方法来获取。作为ServerSocketChannel的对等体被创建的ServerSocket对象依赖通道实现。这些socket关联的SocketImpl能识别通道。通道不能被封装在随意的socket对象外面。

由于ServerSocketChannel没有bind( )方法，因此有必要取出对等的socket并使用它来绑定到一个端口以开始监听连接。我们也是使用对等ServerSocket的API来根据需要设置其他的socket选项

[java] view plaincopy
  1. ServerSocketChannel ssc = ServerSocketChannel.open();  
  2.     ServerSocket serverSocket = ssc.socket(); // Listen on port 1234  
  3.     serverSocket.bind(new InetSocketAddress(1234));  

同它的对等体java.net.ServerSocket一样，ServerSocketChannel也有accept( )方法。

一旦您创建了一个ServerSocketChannel并用对等socket绑定了它，然后您就可以在其中一个上调用accept( )。

如果您选择在ServerSocket上调用accept( )方法，那么它会同任何其他的ServerSocket表现一样的行为：总是阻塞并返回一个java.net.Socket对象(阻塞的！！！！)

。如果您选择在ServerSocketChannel上调用accept( )方法则会返回SocketChannel类型的对象，返回的对象能够在非阻塞模式下运行。假设系统已经有一个安全管理器（security manager），两种形式的方法调用都执行相同的安全检查。


如果以非阻塞模式被调用，当没有传入连接在等待时，ServerSocketChannel.accept( )会立即返回null (因为他是非阻塞的所以要有返回，)。

正是这种检查连接而不阻塞的能力实现了可伸缩性并降低了复杂性。可选择性也因此得到实现。我们可以使用一个选择器实例来注册一个ServerSocketChannel对象以实现新连接到达时自动通知的功能。

演示如何使用一个非阻塞的accept( )方法：

[java] view plaincopy
  1. package com.anders.selector2;  
  2.   
  3. import java.net.InetSocketAddress;  
  4. import java.net.ServerSocket;  
  5. import java.nio.ByteBuffer;  
  6. import java.nio.channels.ServerSocketChannel;  
  7. import java.nio.channels.SocketChannel;  
  8.   
  9. public class ServerSocketChannelApp {  
  10.     private static final String MSG = "hello, I must be going  ";  
  11.   
  12.     public static void main(String[] args) throws Exception {  
  13.   
  14.         int port = 8989;  
  15.         ServerSocketChannel ssc = ServerSocketChannel.open();  
  16.         ServerSocket ss = ssc.socket();  
  17.         ss.bind(new InetSocketAddress(port));  
  18.         // set no blocking  
  19.         ssc.configureBlocking(false);  
  20.   
  21.         ByteBuffer buffer = ByteBuffer.wrap(MSG.getBytes());  
  22.   
  23.         while (true) {  
  24.             System.out.println("wait for connection ……");  
  25.             SocketChannel sc = ssc.accept();  
  26.               
  27.             if (sc == null) {  
  28.                 // no connections, snooze a while ...  
  29.                 Thread.sleep(1000);  
  30.             } else {  
  31.                 System.out.println("Incoming connection from " + sc.socket().getRemoteSocketAddress());  
  32.                 buffer.rewind();  
  33.                 //write msg to client  
  34.                 sc.write(buffer);  
  35.                 sc.close();  
  36.             }  
  37.         }  
  38.     }  
  39. }  

ps  阻塞和非阻塞

传统的serversocket阻塞模式：

[java] view plaincopy
  1. public class ServerSocketApp {  
  2.     public static void main(String[] args) throws Exception {  
  3.         ServerSocket ss = new ServerSocket(8989);  
  4.         ss.accept();  
  5.           
  6.         System.out.println(1);  
  7.     }  
  8. }     


运行这个程序 为什么没有输出1 ？？？ 

 因为ServerSocket  是阻塞模式的 ，什么是阻塞，就是在没有任何连接之前，accept方法一直在那里阻塞着，直到有connection来继续往下执行，所以在运行程序的时候，并没输出1，若要输出  telnet一下就可以了

nio中的 非阻塞：

[java] view plaincopy
  1. public static void main(String[] args) throws Exception {  
  2.   
  3.         ServerSocketChannel ssc = ServerSocketChannel.open();  
  4.         ServerSocket ss = ssc.socket();  
  5.         ss.bind(new InetSocketAddress(8989));  
  6.         // set no blocking  
  7.         ssc.configureBlocking(false);  
  8.   
  9.         ssc.accept();  
  10.           
  11.         System.out.println(1);  
  12.           
  13.     }  

运行这个程序  有1  输出！！

这就是因为  它是非阻塞模式的。


SocketChannel

[java] view plaincopy
  1. public abstract class SocketChannel extends AbstractSelectableChannel implements ByteChannel, ScatteringByteChannel, GatheringByteChannel {  
  2.     // This is a partial API listing  
  3.     public static SocketChannel open() throws IOException;  
  4.   
  5.     public static SocketChannel open(InetSocketAddress remote) throws IOException;  
  6.   
  7.     public abstract Socket socket();  
  8.   
  9.     public abstract boolean connect(SocketAddress remote) throws IOException;  
  10.   
  11.     public abstract boolean isConnectionPending();  
  12.   
  13.     public abstract boolean finishConnect() throws IOException;  
  14.   
  15.     public abstract boolean isConnected();  
  16.   
  17.     public final int validOps();  
  18. }  


Socket和SocketChannel类封装点对点、有序的网络连接，类似于我们所熟知并喜爱的TCP/IP网络连接。SocketChannel扮演客户端发起同一个监听服务器的连接。直到连接成功，它才能收到数据并且只会从连接到的地址接收

每个SocketChannel对象创建时都是同一个对等的java.net.Socket对象串联的。静态的open( )方法可以创建一个新的SocketChannel对象，而在新创建的SocketChannel上调用socket( )方法能返回它对等的Socket对象；在该Socket上调用getChannel( )方法则能返回最初的那个SocketChannel。

新创建的SocketChannel虽已打开却是未连接的。在一个未连接的SocketChannel对象上尝试一个I/O操作会导致NotYetConnectedException异常。

我们可以通过在通道上直接调用connect( )方法或在通道关联的Socket对象上调用connect( )来将该socket通道连接。

一旦一个socket通道被连接，它将保持连接状态直到被关闭。

您可以通过调用布尔型的isConnected( )方法来测试某个SocketChannel当前是否已连接。

[java] view plaincopy
  1. 第二种带InetSocketAddress参数形式的open( )是在返回之前进行连接的便捷方法。这段代码：   
  2. SocketChannel socketChannel = SocketChannel.open (new InetSocketAddress ("somehost", somePort));   
  3. 等价于下面这段代码：  
  4.  SocketChannel socketChannel = SocketChannel.open( );   
  5. socketChannel.connect (new InetSocketAddress ("somehost", somePort));  

1 如果您选择使用传统方式进行连接——通过在对等Socket对象上调用connect( )方法，那么传统的连接语义将适用于此。线程在连接建立好或超时过期之前都将保持阻塞。

2 如果您选择通过在通道上直接调用connect( )方法来建立连接并且通道处于阻塞模式（默认模式），那么连接过程实际上是一样的。在SocketChannel上并没有一种connect( )方法可以让您指定超时（timeout）值，当connect( )方法在非阻塞模式下被调用时SocketChannel提供并发连接：它发起对请求地址的连接并且立即返回值。

如果返回值是true，说明连接立即建立了（这可能是本地环回连接）；

如果连接不能立即建立，connect( )方法会返回false且并发地继续连接建立过程。



面向流的的socket建立连接状态需要一定的时间，因为两个待连接系统之间必须进行包对话以建立维护流socket所需的状态信息。

跨越开放互联网连接到远程系统会特别耗时。假如某个SocketChannel上当前正由一个并发连接，isConnectPending( )方法就会返回true值。调用finishConnect( )方法来完成连接过程，该方法任何时候都可以安全地进行调用。假如在一个非阻塞模式的SocketChannel对象上调用finishConnect( )方法，将可能出现下列情形之一：

 connect( )方法尚未被调用。那么将产生NoConnectionPendingException异常。
 连接建立过程正在进行，尚未完成。那么什么都不会发生，finishConnect( )方法会立即返回false值。
 在非阻塞模式下调用connect( )方法之后，SocketChannel又被切换回了阻塞模式。那么如果有必要的话，调用线程会阻塞直到连接建立完成，finishConnect( )方法接着就会返回true值。
 在初次调用connect( )或最后一次调用finishConnect( )之后，连接建立过程已经完成。那么SocketChannel对象的内部状态将被更新到已连接状态，finishConnect( )方法会返回true值，然后SocketChannel对象就可以被用来传输数据了。
 连接已经建立。那么什么都不会发生，finishConnect( )方法会返回true值。
当通道处于中间的连接等待（connection-pending）状态时，您只可以调用finishConnect( )、isConnectPending( )或isConnected( )方法。

一旦连接建立过程成功完成，isConnected( )将返回true值。

[java] view plaincopy
  1. InetSocketAddress addr = new InetSocketAddress (host, port);  
  2.  SocketChannel sc = SocketChannel.open( );   
  3. sc.configureBlocking (false);  
  4.  sc.connect (addr);   
  5.   
  6. while ( ! sc.finishConnect( )) {   
  7. doSomethingElse( );   
  8. }  
  9.   
  10. doSomethingWithChannel (sc);  
  11.  sc.close( );  


一段用来管理异步连接的可用代码。

[java] view plaincopy
  1. public class SocketChannelApp {  
  2.     public static void main(String[] args) throws Exception {  
  3.         InetSocketAddress addr = new InetSocketAddress("127.0.0.1", 8989);  
  4.         SocketChannel sc = SocketChannel.open();  
  5.         sc.connect(addr);  
  6.         sc.configureBlocking(false);  
  7.           
  8.         while (!sc.finishConnect()) {  
  9.             doSomethings();  
  10.         }  
  11.           
  12.         //Do something with the connected socket  
  13.         ByteBuffer buffer = ByteBuffer.wrap(new String("Hello server!").getBytes());  
  14.         sc.write(buffer);  
  15.         sc.close();  
  16.           
  17.     }  
  18.   
  19.     private static void doSomethings() {  
  20.         System.out.println("do something useless!");  
  21.     }  
  22. }  

server还是采用上篇的 ，我把它简单的改了改

[java] view plaincopy
  1. public class ServerSocketChannelApp {  
  2.     private static final String MSG = "hello, I must be going  ";  
  3.   
  4.     public static void main(String[] args) throws Exception {  
  5.   
  6.         int port = 8989;  
  7.         ServerSocketChannel ssc = ServerSocketChannel.open();  
  8.         ServerSocket ss = ssc.socket();  
  9.         ss.bind(new InetSocketAddress(port));  
  10.         // set no blocking  
  11.         ssc.configureBlocking(false);  
  12.   
  13.         ByteBuffer buffer = ByteBuffer.wrap(MSG.getBytes());  
  14.   
  15.         while (true) {  
  16. //          System.out.println("wait for connection ……");  
  17.             SocketChannel sc = ssc.accept();  
  18.               
  19.             if (sc == null) {  
  20.                 // no connections, snooze a while ...  
  21.                 Thread.sleep(1000);  
  22.             } else {  
  23.                 System.out.println("Incoming connection from " + sc.socket().getRemoteSocketAddress());  
  24.                 ByteBuffer readerBuffer = ByteBuffer.allocate(1024);  
  25.                 sc.read(readerBuffer);  
  26.                 readerBuffer.flip();  
  27.                 //output get   
  28.                 out(readerBuffer);  
  29.                   
  30.                 buffer.rewind();  
  31.                 sc.write(buffer);  
  32.                 sc.close();  
  33.             }  
  34.         }  
  35.     }  
  36.   
  37.     private static void out(ByteBuffer readerBuffer) {  
  38.         StringBuffer sb = new StringBuffer();  
  39.         for (int i = 0; i < readerBuffer.limit(); i++) {  
  40.             char c = (char) readerBuffer.get();  
  41.             sb.append(new String(new char[]{c}));  
  42.         }  
  43.           
  44.         System.out.println(sb.toString());  
  45.     }  
  46. }  


ps:

如果尝试异步连接失败，那么下次调用finishConnect( )方法会产生一个适当的经检查的异常以指出问题的性质。通道然后就会被关闭并将不能被连接或再次使用。与连接相关的方法使得我们可以对一个通道进行轮询并在连接进行过程中判断通道所处的状态。第四章中，我们将了解到如何使用选择器来避免进行轮询并在异步连接建立之后收到通知。Socket通道是线程安全的。并发访问时无需特别措施来保护发起访问的多个线程，不过任何时候都只有一个读操作和一个写操作在进行中。请记住，sockets是面向流的而非包导向的。它们可以保证发送的字节会按照顺序到达但无法承诺维持字节分组。某个发送器可能给一个socket写入了20个字节而接收器调用read( )方法时却只收到了其中的3个字节。剩下的17个字节还是传输中。由于这个原因，让多个不配合的线程共享某个流socket的同一侧绝非一个好的设计选择。

connect( )和finishConnect( )方法是互相同步的，并且只要其中一个操作正在进行，任何读或写的方法调用都会阻塞，即使是在非阻塞模式下。如果此情形下您有疑问或不能承受一个读或写操作在某个通道上阻塞，请用isConnected( )方法测试一下连接状态。


【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/wuyida/p/6300966.html