Desenvolvimento distribuído Java TCP / IP NIO Socket sem bloqueio ((com base no modo de mensagem para obter comunicação entre sistemas))

De: https://www.iteye.com/blog/mars914-1238353

Em java, a comunicação entre sistemas TCP / IP + NIO pode ser realizada com base nas classes relacionadas de Canal e Seletor em java.nio.channels.

 

Utilizado para comunicação entre sistemas, SocketChannel e ServerSocketChannel são usados. SocketChannel é usado para estabelecer conexões, monitorar eventos e operações de leitura e gravação.ServidorSocketChannel é usado para monitorar portas e monitorar eventos de conexão.Você pode usar o Seletor para obter se há eventos a serem processados.

 

Código java do servidor:

Código Java  

1. pacote com.java.distributed.message.tcpip;  
2.   
3. importar java.io.IOException;  
4. importar java.net.InetSocketAddress;  
5. importar java.net.ServerSocket;  
6. importar java.nio.ByteBuffer;  
7. importar java.nio.channels.SelectionKey;  
8. importar java.nio.channels.Selector;  
9. importar java.nio.channels.ServerSocketChannel;  
10. importar java.nio.channels.SocketChannel;  
11. importar java.nio.charset.Charset;  
12.   
13. classe pública  NIOServer {  
14.   
15.     / ** 
16.      * @param args 
17.      * @throws IOException  
18.      * /  
19.     public  static  void main (String [] args)  lança IOException {  
20.         porta int = 7889;  
21.         // Abra o seletor  
22.         Seletor seletor = Selector.open ();  
23.         // Abra o canal do soquete do servidor  
24.         ServerSocketChannel ssc = ServerSocketChannel.open ();  
25.         // Recupera o soquete do servidor associado a este canal  
26.         ServerSocket serverSocket = ssc.socket ();  
27.         // Vincula ServerSocket a um endereço específico (endereço IP e número da porta)  
28.         serverSocket.bind ( novo InetSocketAddress (porta));  
29.         System.out.println ( "servidor escuta na porta:" + porta);  
30.           
31.         // Ajusta o modo de bloqueio do canal  
32.         ssc.configureBlocking ( false);  
33.         // Registre este canal com o seletor fornecido e retorne uma tecla de seleção. SelectionKey.OP_ACCEPT - Bit de conjunto de operações para operação de aceitação de soquete     
34.         ssc.register (seletor, SelectionKey.OP_ACCEPT);  
35.           
36.         while ( true) {  
37.             // timeout: positivo, em seguida, bloqueie no máximo o tempo limite ms enquanto aguarda que um canal esteja pronto; se zero, bloqueie indefinidamente; deve ser não negativo  
38.             int nKeys = selector.select ( 1000);  
39.             if (nKeys> 0) {  
40.                   
41.                 for (chave SelectionKey: selector.selectedKeys ()) {  
42.                     / * Teste se o canal desta chave está pronto para aceitar novas conexões de soquete - 
43.                      * Se o canal desta chave não suportar operação de aceitação de soquete, esse método sempre retornará false 
44.                      * * /  
45.                     if (key.isAcceptable ()) {  
46.                         ServerSocketChannel server = (ServerSocketChannel) key.channel ();  
47.                         SocketChannel sc = server.accept ();  
48.                           
49.                         if (sc == null) {  
50.                             continuar;  
51.                         }  
52.                         sc.configureBlocking ( false);  
53.                         sc.register (seletor, SelectionKey.OP_READ);  
54.                     } else  if (key.isReadable ()) {  
55.                         // Aloca um novo buffer de bytes  
56.                         Buffer ByteBuffer = ByteBuffer.allocate ( 1024);  
57.                         SocketChannel sc = (SocketChannel) key.channel ();  
58.                         int readBytes = 0;  
59.                         Mensagem da string = null;  
60.                         experimentar{  
61.                             int ret;  
62.                             experimentar{  
63.                                 while ((ret = sc.read (buffer))> 0) {  
64.                                     readBytes + = ret;  
65.                                 }  
66.                                   
67.                             } captura (exceção e) {  
68.                                 readBytes = 0;  
69.                                 //ignorar  
70.                             } finalmente {  
71.                                 // Inverta esse buffer. Primeiro defina um limite na posição atual e depois defina a posição como zero  
72.                                 buffer.flip ();  
73.                             }  
74.                               
75.                             if (readBytes> 0) {  
76.                                 message = Charset.forName ( "UTF-8"). decode (buffer) .toString ();  
77.                                 buffer = nulo;  
78.                             }  
79.                         } finalmente {  
80.                             if (buffer! = nulo)  
81.                                 buffer.clear ();  
82.                         }  
83.                           
84.                         if (readBytes> 0) {  
85.                             System.out.println ( "mensagem do cliente:" + mensagem);  
86.                             if ( "quit" .equalsIgnoreCase (message.trim ())) {  
87.                                 sc.close ();  
88.                                 selector.close ();  
89.                                 System.out.println ( "O servidor foi encerrado!");  
90.                                 System.exit ( 0);  
91.                             }  
92.                             String outMessage = "resposta do servidor:" + mensagem;  
93.                             sc.write (Charset.forName ( "UTF-8"). encode (outMessage));  
94.                         }  
95.                           
96.                     }  
97.                 }  
98.                 selector.selectedKeys (). clear ();  
99.             }  
100.           
101.         }  
102.     }  
103. }  

 

 

Código java do cliente:

Código Java  

1. pacote com.java.distributed.message.tcpip;  
2.   
3. importar java.io.BufferedReader;  
4. importar java.io.IOException;  
5. importar java.io.InputStreamReader;  
6. importar java.net.InetSocketAddress;  
7. importar java.net.SocketAddress;  
8. importar java.nio.ByteBuffer;  
9. importar java.nio.channels.SelectionKey;  
10. importar java.nio.channels.Selector;  
11. importar java.nio.channels.SocketChannel;  
12. importar java.nio.charset.Charset;  
13.   
14.   
15. classe pública  NIOClient {  
16.   
17.     / ** 
18.      * @param args 
19.      * @throws IOException  
20.      * /  
21.     public  static  void main (String [] args)  lança IOException {  
22.         porta int = 7889;  
23.         Canal SocketChannel = SocketChannel.open ();  
24.         channel.configureBlocking ( false);  
25.           
26.         SocketAddress target = new InetSocketAddress ( "127.0.0.1", porta);  
27.         channel.connect (target);  
28.         Seletor seletor = Selector.open ();  
29.         // Bit de conjunto de operações para operação de conexão de soquete  
30.         channel.register (seletor, SelectionKey.OP_CONNECT);  
31.         BufferedReader systemIn = novo BufferedReader ( novo InputStreamReader (System.in));  
32.           
33.         while ( true) {  
34.             if (channel.isConnected ()) {  
35.                 Comando string = systemIn.readLine ();  
36.                 channel.write (Charset.forName ( "UTF-8"). encode (comando));  
37.                   
38.                 if (command == null || "quit" .equalsIgnoreCase (command.trim ())) {  
39.                     systemIn.close ();  
40.                     channel.close ();  
41.                     selector.close ();  
42.                     System.out.println ( "Cliente encerrado!");  
43.                     System.exit ( 0);  
44.                 }  
45.             }  
46.             int nKeys = selector.select ( 1000);  
47.             if (nKeys> 0) {  
48.                 for (chave SelectionKey: selector.selectedKeys ()) {  
49.                     if (key.isConnectable ()) {  
50.                         SocketChannel sc = (SocketChannel) key.channel ();  
51.                         sc.configureBlocking ( false);  
52.                         sc.register (seletor, SelectionKey.OP_READ);  
53.                         sc.finishConnect ();  
54.                     } else  if (key.isReadable ()) {  
55.                         Buffer ByteBuffer = ByteBuffer.allocate ( 1024);  
56.                         SocketChannel sc = (SocketChannel) key.channel ();  
57.                         int readBytes = 0;  
58.                         experimentar{  
59.                             int ret = 0;  
60.                             experimentar{  
61.                                 while ((ret = sc.read (buffer))> 0) {  
62.                                     ler bytes = K +;  
63.                                 }  
64.                             } finalmente {  
65.                                 buffer.flip ();  
66.                             }  
67.                             if (readBytes>  0) {     
68.                                 System.out.println (Charset.forName ( "UTF-8")     
69.                                         .decode (buffer) .toString ());     
70.                                 buffer =  nulo;     
71.                             }     
72.   
73.                         } finalmente {     
74.                             if (buffer! =  null) {     
75.                                 buffer.clear ();     
76.                             }  
77.                         }  
78.                     }  
79.                 }  
80.                     selector.selectedKeys (). clear ();     
81.             }  
82.         }  
83.     }  
84.   
85. }