Java NIO (non-blocking I/O) cu Exemplu Server-Client – ​​java.nio.ByteBuffer și canale.Selector – Java NIO Vs. IO

Publicat: 2021-08-06
Java NIO (I:O fără blocare) cu exemplu server-client - CrunchifyNIOServer.java

Java NIO este subiectul meu preferat. Lucrez cu NIO din ultimii 2 ani și aș dori să partajez un Server-Client code pentru cititorii mei care sunt liberi să folosească acest cod în mediul lor de producție.

Începând cu JDK 1.4, NIO a fost creat pentru a permite tuturor programatorilor Java să implementeze intrare/ieșire de foarte mare viteză fără a fi nevoiți să se ocupe de cod nativ personalizat. NIO folosește biblioteca java.nio.buffer în comparație cu I/O simplă, care drenează și umple tamponul intern în orice sistem de operare.

În acest tutorial vom trece peste bibliotecile java.nio.channels și java.nio.channels.Selector .

  • channels reprezintă conexiuni la entități care sunt capabile să efectueze operațiuni I/O, cum ar fi fișiere și socket-uri; definește selectoare , pentru operațiuni I/O multiplexate, neblocante.
  • selector poate fi creat prin invocarea open method a acestei clase, care va folosi furnizorul de selector implicit al sistemului pentru a crea un nou selector.
explicația pachetului java.nio cu detalii API

Dacă aveți below questions atunci sunteți în locul potrivit:

  • Cum să începeți cu Java NIO
  • Ce este Java NIO și tutorialele Java NIO
  • NIO Java asincron
  • Care este utilizarea exactă a pachetului java nio
  • Tutorial Java NIO
  • Cum se implementează I/O de înaltă performanță cu Java NIO

Să începem:

Pasul 1

  • Creați CrunchifyNIOServer.java care deschide conexiunea pe port 1111
  • utilizați isAcceptable() pentru a verifica dacă canalul este gata să accepte o nouă conexiune socket
    • Dacă da, conectați-l
  • utilizați isReadable() pentru a verifica dacă canalul este gata pentru citire
    • dacă da – citiți din buffer și imprimați pe consola Eclipse
  • Odată ce obțineți numele companiei „crunchify”
    • legătură strânsă

Pasul 2

  • Creați CrunchifyNIOClient.java care încearcă să se conecteze la serverul de pe port 1111
  • Creați ArrayList cu 5 nume de companii
  • Iterați prin ArrayList și trimiteți fiecare nume companie la server
  • Închideți conexiunea după terminarea sarcinii

Aruncă o privire la acest cod Java:

Cod server – CrunchifyNIOServer.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
package crunchify . com . tutorials ;
 
import java . io . IOException ;
import java . net . InetSocketAddress ;
import java . nio . ByteBuffer ;
import java . nio . channels . SelectionKey ;
import java . nio . channels . Selector ;
import java . nio . channels . ServerSocketChannel ;
import java . nio . channels . SocketChannel ;
import java . util . Iterator ;
import java . util . Set ;
 
/**
* @author Crunchify.com
* Java NIO (Non-blocking I/O) with Server-Client Example - java.nio.ByteBuffer and channels.Selector
* This is CrunchifyNIOServer.java
*/
 
public class CrunchifyNIOServer {
 
@ SuppressWarnings ( "unused" )
public static void main ( String [ ] args ) throws IOException {
 
// Selector: A multiplexor of SelectableChannel objects.
// A selector may be created by invoking the open method of this class, which will use the system's default selector provider to create a new selector.
// A selector may also be created by invoking the openSelector method of a custom selector provider. A selector remains open until it is closed via its close method.
Selector selector = Selector . open ( ) ; // selector is open here
 
// ServerSocketChannel: A selectable channel for stream-oriented listening sockets.
// A server-socket channel is created by invoking the open method of this class.
// It is not possible to create a channel for an arbitrary, pre-existing ServerSocket.
ServerSocketChannel crunchifySocket = ServerSocketChannel . open ( ) ;
// InetSocketAddress: This class implements an IP Socket Address (IP address + port number) It can also be a pair (hostname + port number),
// in which case an attempt will be made to resolve the hostname.
// If resolution fails then the address is said to be unresolved but can still be used on some circumstances like connecting through a proxy.
InetSocketAddress crunchifyAddr = new InetSocketAddress ( "localhost" , 1111 ) ;
 
// Binds the channel's socket to a local address and configures the socket to listen for connections
crunchifySocket . bind ( crunchifyAddr ) ;
 
// Adjusts this channel's blocking mode.
crunchifySocket . configureBlocking ( false ) ;
 
int ops = crunchifySocket . validOps ( ) ;
// SelectionKey: A token representing the registration of a SelectableChannel with a Selector.
// A selection key is created each time a channel is registered with a selector.
// A key remains valid until it is cancelled by invoking its cancel method, by closing its channel, or by closing its selector.
SelectionKey selectKy = crunchifySocket . register ( selector , ops , null ) ;
 
// Infinite loop..
// Keep server running
while ( true ) {
 
log ( "I'm a server and I'm waiting for new connection and buffer select..." ) ;
// Selects a set of keys whose corresponding channels are ready for I/O operations
selector . select ( ) ;
 
// token representing the registration of a SelectableChannel with a Selector
Set < SelectionKey > crunchifyKeys = selector . selectedKeys ( ) ;
Iterator < SelectionKey > crunchifyIterator = crunchifyKeys . iterator ( ) ;
 
while ( crunchifyIterator . hasNext ( ) ) {
SelectionKey myKey = crunchifyIterator . next ( ) ;
 
// Tests whether this key's channel is ready to accept a new socket connection
if ( myKey . isAcceptable ( ) ) {
SocketChannel crunchifyClient = crunchifySocket . accept ( ) ;
 
// Adjusts this channel's blocking mode to false
crunchifyClient . configureBlocking ( false ) ;
 
// Operation-set bit for read operations
crunchifyClient . register ( selector , SelectionKey . OP_READ ) ;
log ( "Connection Accepted: " + crunchifyClient . getLocalAddress ( ) + "\n" ) ;
 
// Tests whether this key's channel is ready for reading
} else if ( myKey . isReadable ( ) ) {
SocketChannel crunchifyClient = ( SocketChannel ) myKey . channel ( ) ;
// ByteBuffer: A byte buffer.
// This class defines six categories of operations upon byte buffers:
// Absolute and relative get and put methods that read and write single bytes;
// Absolute and relative bulk get methods that transfer contiguous sequences of bytes from this buffer into an array;
ByteBuffer crunchifyBuffer = ByteBuffer . allocate ( 256 ) ;
crunchifyClient . read ( crunchifyBuffer ) ;
String result = new String ( crunchifyBuffer . array ( ) ) . trim ( ) ;
 
log ( "Message received: " + result ) ;
 
if ( result . equals ( "Crunchify.com" ) ) {
crunchifyClient . close ( ) ;
log ( "\nIt's time to close connection as we got last company name 'Crunchify'" ) ;
log ( "\nServer will keep running. Try running client again to establish new connection" ) ;
}
}
crunchifyIterator . remove ( ) ;
}
}
}
 
private static void log ( String str ) {
System . out . println ( str ) ;
}
}
 

Cod client – ​​CrunchifyNIOClient.java

Java NIO (I:O fără blocare) cu exemplu server-client - CrunchifyNIOClient.java
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
package crunchify . com . tutorials ;
 
import java . io . IOException ;
import java . net . InetSocketAddress ;
import java . nio . ByteBuffer ;
import java . nio . channels . SocketChannel ;
import java . util . ArrayList ;
 
/**
* @author Crunchify.com
* Java NIO (Non-blocking I/O) with Server-Client Example - java.nio.ByteBuffer and channels.Selector
* This is CrunchifyNIOClient.java
*/
 
public class CrunchifyNIOClient {
 
public static void main ( String [ ] args ) throws IOException , InterruptedException {
 
InetSocketAddress crunchifyAddr = new InetSocketAddress ( "localhost" , 1111 ) ;
//  selectable channel for stream-oriented connecting sockets
SocketChannel crunchifyClient = SocketChannel . open ( crunchifyAddr ) ;
 
log ( "Connecting to Server on port 1111..." ) ;
 
ArrayList <String> companyDetails = new ArrayList <String> ( ) ;
 
// create a ArrayList with companyName list
companyDetails . add ( "Facebook" ) ;
companyDetails . add ( "Twitter" ) ;
companyDetails . add ( "IBM" ) ;
companyDetails . add ( "Google" ) ;
companyDetails . add ( "Crunchify" ) ;
 
for ( String companyName : companyDetails ) {
 
byte [ ] message = new String ( companyName ) . getBytes ( ) ;
ByteBuffer buffer = ByteBuffer . wrap ( message ) ;
crunchifyClient . write ( buffer ) ;
 
log ( "sending: " + companyName ) ;
buffer . clear ( ) ;
 
// wait for 2 seconds before sending next message
Thread . sleep ( 2000 ) ;
}
// close(): Closes this channel.
// If the channel has already been closed then this method returns immediately.
// Otherwise it marks the channel as closed and then invokes the implCloseChannel method in order to complete the close operation.
crunchifyClient . close ( ) ;
}
 
private static void log ( String str ) {
System . out . println ( str ) ;
}
}

Rezultat pe partea serverului:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
I 'm a server and I' m waiting for new connection and buffer select . . .
Connection Accepted : / 127.0.0.1 : 1111
 
I 'm a server and <meta charset="utf-8"/>I' m waiting for new connection and buffer select . . .
Message received : Facebook
< meta charset = "utf-8" / > I 'm a server and <meta charset="utf-8"/>I' m waiting for new connection and buffer select . . .
Message received : Twitter
< meta charset = "utf-8" / > I 'm a server and <meta charset="utf-8"/>I' m waiting for new connection and buffer select . . .
Message received : IBM
< meta charset = "utf-8" / > I 'm a server and <meta charset="utf-8"/>I' m waiting for new connection and < a href = "https://crunchify.com/how-to-remove-duplicate-elements-from-csv-or-any-other-file-in-java/" target = "_blank" rel = "noreferrer noopener" > buffer < / a > select . . .
Message received : Google
< meta charset = "utf-8" / > I 'm a server and <meta charset="utf-8"/>I' m waiting for new connection and buffer select . . .
Message received : Crunchify
 
It 's time to <a href="https://crunchify.com/json-manipulation-in-java-examples/" target="_blank" rel="noreferrer noopener">close connection</a> as we got last company name ' Crunchify '
 
Server will keep running. Try running client again to establish new connection
<meta charset="utf-8"/>I' m a server and < meta charset = "utf-8" / > I ' m waiting for new connection and buffer select . . .

Rezultat la partea clientului:

1
2
3
4
5
6
Connecting to Server on port 1111...
sending : Facebook
sending : Twitter
sending : IBM
sending : Google
sending : Crunchify

Câteva întrebări frecvente:

  1. De la client, cum mențin o conexiune persistentă?
    • Ai putea folosi socket.setKeepAlive(true); pentru a avea conexiuni vii din partea clientului.
  2. Cum citesc un răspuns la mesajul pe care îl trimit serverului. Serverul continuă să genereze mesaje la fiecare 10 secunde. Trebuie doar să citesc răspunsul la cererea mea. Din câte am înțeles, TCP „transmite” date în loc de sfârșitul înregistrării etc.
    • Pentru comunicarea client-server, un protocol trebuie să fie bine definit. readLine() va fi blocat până când toate datele vor fi returnate, așa că nu-l utilizați. Try reading bytes from the stream until -1 is returned.

Anunță-mă dacă funcționează.