Java TCP/UDP socket programming process summary, udpsocket

Java TCP/UDP socket programming process summary, udpsocket

Recently I learned a little bit about java socket programming. Although the overall process is not very complicated, it is worth summing up.

Socket

A Socket is an abstraction for the network. An application can read and write data on the network. Just like using a file handler to write data to a storage device. Depending on the TCP protocol and UDP protocol, there are two different Sockets for the two protocols in terms of network programming. One is for byte streams and the other is for packets.

It is easier to understand the composition of the socket itself. Since the application communicates through socket, there must be a server and a client. Therefore, it must contain a corresponding IP address. In addition, the server must provide a series of services on this address, so a series of corresponding windows are required to provide services. So there is a corresponding Port ). The port number is a 16-bit binary number, and the range is from (0-65535 ). The IP address and port number constitute the socket. The following figure shows the relationship between the socket and the entire TCP/IP:

 

TCP

TCP is mainly a connection-oriented protocol. It includes functions such as establishing and removing connections and ensuring the sequence and correctness of data streams. Each data operation in the middle of TCP is equivalent to accessing a data stream. The most typical feature is the connection process of the three handshakes. The TCP connection establishment and revocation process is as follows:

 

Server

The main task of the Server side is to establish a communication endpoint and wait for the request sent by the client. The typical process is as follows:

1. Build a ServerSocket instance and specify the local port. This socket is used to listen to connection requests on the specified port.

2. Repeat the following steps:

A. Call the socket accept () method to obtain the connection request of the following client. The socket instance returned by the accept () method establishes a new connection with the client.

B. Use the returned socket instance to obtain InputStream and OutputStream. You can use these two streams to read and write data respectively.

C. Call the close () method of the socket instance to close the socket connection at the end.

 

The typical sample code for this process is as follows:

 

Java code

1. // 1. Construct a ServerSocket instance and specify the service port.
2. ServerSocket servSock = new ServerSocket (servPort );
5. While (true)
6. {
7. // 2. Call the accept method to establish a connection with the client
8. Socket clntSock = servSock. accept ();
9. SocketAddress clientAddress =
10. ClntSock. getRemoteSocketAddress ();
11. System. out. println ("Handling client at" + clientAddress );
13. // 3. Get the connected InputStream and OutputStream for data read/write
14. InputStream in = clntSock. getInputStream ();
15. OutputStream out = clntSock. getOutputStream ();
17. While (recvMsgSize = in. read (receiveBuf ))! =-1)
18. {
19. Out. write (receiveBuf, 0, recvMsgSize );
20. }
21. // 4. The operation is complete. Disable socket.
22. ClntSock. close ();
23. }

 

Client

The client request process is slightly different:

1. Build a Socket instance and establish a connection through the specified remote server address and port.

2. Read and Write data through the InputStream and OutputStream contained in the Socket instance.

3. After the operation is complete, call the close method of the socket instance to close it.

The sample code is as follows;

 

Java code

1. // 1. Establish a socket connection based on the specified server address and port.
2. Socket socket = new Socket (server, servPort );
4. // 2. Obtain InputStream and OutputStream Based on the socket instance for data read and write.
5. InputStream in = socket. getInputStream ();
6. OutputStream out = socket. getOutputStream ();
7. Out. write (data );
9. // 3. The operation is complete. Disable socket.
10. Socket. close ();

 

 

UDP

There are two typical differences between UDP and TCP. One is that it does not need to establish a connection, and the other is that it retains the message boundary in each message sent and received.

Server

Because UDP does not need to establish a connection, the process is as follows:

1. Construct an initramsocket instance and specify the local port.

2. Use the receive method of the initramsocket instance to receive the contents of the communication in the middle of DatagramPacket. DatagramPacket.

3. Use the send and receive methods of mongoramsocket to receive and send mongorampacket.

The typical Interaction Process Code is as follows:

 

 

Java code

1. // 1. Create an initramsocket instance and specify the local port.
2. DatagramSocket socket = new DatagramSocket (servPort );
4. // 2. Construct the initrampacket packet to be sent and received
5. DatagramPacket packet = new DatagramPacket (new byte [ECHOMAX], ECHOMAX );
7. While (true)
8. {
9. // 3. receive the message
10. Socket. receive (packet );
11. System. out. println ("Handling client at" + packet. getAddress (). getHostAddress ()
12. + "On port" + packet. getPort ());
13. // 4. Send messages
14. Socket. send (packet );
15. Packet. setLength (ECHOMAX );
16. }

 

 

Client

The steps of the UDP client are also relatively simple, mainly including the following three steps:

1. Construct an initramsocket instance.

2. send the mongorampacket packet through the send and receive methods of the mongoramsocket instance.

3. Call the close method of DatagramSocket to close the interface.

Different from TCP, UDP can send packets to different servers at Will on the same local port. Generally, you do not need to specify the address of the target server in the UDP DatagramSocket constructor.

In addition, another important difference between the UDP client is that after the TCP client sends an echo connection message, it will be blocked when the read method is called, But UDP does not. Because UDP allows packet loss in the middle. If the packet is lost and the process is blocked or suspended, the process will never be able to go down. Therefore, a setSoTimeout method is usually set to specify how long the message will be discarded if it is not received. You can also specify a number and the number of times specified by the loop to read the message. If the number is read, the message is returned. Otherwise, the message is discarded.

 

A typical UDP Client code example is as follows:

 

Java code

1. // 1. Construct a UDP DatagramSocket object
2. DatagramSocket socket = new DatagramSocket ();
4. // 2. Specifies the timeout time to prevent infinite wait
5. Socket. setSoTimeout (TIMEOUT );
7. // 3. Construct the packet object for sending and receiving
8. DatagramPacket sendPacket = new DatagramPacket (bytesToSend,
9. BytesToSend. length, serverAddress, servPort );
10. DatagramPacket extends epacket =
11. New DatagramPacket (new byte [bytesToSend. length], bytesToSend. length );
13. // 4. specify the number of attempts
14. Int tries = 0;
15. Boolean receivedResponse = false;
16. Do
17. {
18. Socket. send (sendPacket );
19. Try
20. {
21. Socket. receive (paiepacket );
23. If (! ReceivePacket. getAddress (). equals (serverAddress ))
24. {
25. Throw new IOException ("Received packet from an unknown source ");
26. }
27. ReceivedResponse = true;
28. }
29. Catch (InterruptedIOException e)
30. {
31. Tries + = 1;
32. System. out. println ("Timed out," + (MAXTRIES-tries) + "");
33. }
34. } While ((! ReceivedResponse) & (tries <MAXTRIES ));
36. // Provide feedback based on whether packets are received
37. If (receivedResponse)
38. {
39. System. out. println ("Received:" + new String (paiepacket. getData ()));
40. }
41. Else
42. {
43. System. out. println ("No response -- giving up .");
44. }
46. // 5. Disable socket
47. Socket. close ();

Summary

The Communication Between TCP server and client is like two people making calls. They need to know each other's phone number and start the conversation. Therefore, you must specify the port and address during the connection process.

The communication between UDP server and client is like two people sending messages to each other. I only need to know the address of the other party, and then send the mail. I don't know if the other party has received it, nor do I need to establish a connection with a password.

These examples are actually the simplest. A single thread can only process a single request at a time. In practical applications, it is generally applied to multithreading and some highly concurrent processing policies, such as event-driven reactor mode. You can discuss it in detail in subsequent articles.

References

1. TCP/IP Sockets in Java

2. TCP/IP encrypted strated, Volume 1: The Protocols (2nd Edition)
What is the relationship between SOCKET and TCP and UDP?

SOCKET is an API for Java to implement data communication.
This term originated from BSD-related UNIX and is the name of the API used for communication between processes in program development.

TCP/UDP is the two communication modes defined in Layer 4 of the OSI model.

That is to say, SOCKET is an API, and TCP/UPD is a communication protocol. The two are fundamentally different.

Example of language expression:
Use SOCKET to implement TCP (or UDP) communication. (On the contrary, TCP or UDP communication can also be implemented without SOCKET)

How does java reflect the difference in tcp programming udp programming?

The current computer configuration is high, so you don't have to worry too much about memory and resources. I recommend using tcp to transmit data. Although udp is fast, data loss is a big defect and tcp stability is still possible.