Java Java Network Programming rookie advanced: Getting Started with TCP and sockets

Java Network Programming Rookie advanced: Getting Started with TCP and sockets

The JDK provides support for two data transfer protocols, TCP (transmission Control Protocol, transmission Protocol), and UDP (user Datagram Protocol, Subscriber Datagram Protocol). This article begins with the discussion of TCP.

TCP Basic Knowledge

In the server-client architecture, the server and the client each maintain an endpoint, and two endpoints need to exchange data over the network. TCP provides a reliable streaming connection for this requirement, which means that both outgoing and received data are contiguous bytes, and there is no size limit on the amount of data. An endpoint is comprised of an IP address and a port (the professional term is "tuple {IP address, port}"). In this way, a connection can be represented by a tuple {local address, local port, remote address, remote port}.

Connection process

In the TCP programming interface, the endpoint is represented as a TCP socket. There are two types of TCP sockets: Active and passive, and the "passive" state is often referred to as the "listening" state. The process by which servers and clients connect using sockets is as follows:

1. The server creates a passive socket and begins looping the connection of the client listening.

2. The client creates an active socket to connect to the server.

3. The server accepts the client connection and creates an active socket that represents the connection.

4. The server and client transmit data via two active sockets created in steps 2 and 3.

Here is a diagram of the connection process:

A simple TCP server

The JDK provides a passive socket for the ServerSocket class to represent the TCP server. The following code demonstrates a simple TCP server (multi-threaded blocking mode) that constantly listens for and accepts connections from clients, then reads the text sent by the client in rows and returns it to the client after the full-text is converted to uppercase until the client sends a text line bye:

2. Public class TCPServer implements Runnable {
4. private ServerSocket ServerSocket;
8. Public tcpserver (int port) throws IOException {
10. //Create a passive socket for a TCP server bound to a port.
12. ServerSocket = New ServerSocket (port);
14. }
18. @Override
20. public Void Run () {
22. While (true) {
24. try {
26. //Accept a client connection in a blocking manner, returning an active socket that represents the connection.
28. Socket socket = serversocket.accept ();
30. //Handle client connections in a new thread.
32. New Thread (new ClientHandler (socket)). Start ();
34. } catch (IOException ex) {
36. Ex.printstacktrace ();
38. }
40. }
42. }
44. }
48. Public class ClientHandler implements Runnable {
50. private socket socket;
54. Public ClientHandler (socket socket) {
56. This.socket = objects.requirenonnull (socket);
58. }
62. @Override
64. public Void Run () {
66. try (socket s = socket) { ///Reduce the amount of code tricks ...
68. //wraps the input stream of the socket to read the lines of text sent by the client.
70. BufferedReader in = new BufferedReader (new InputStreamReader (
72. S.getinputstream (), standardcharsets.utf_8));
74. //wraps the output stream of the socket to send the conversion result to the client.
76. PrintWriter out = new PrintWriter (new OutputStreamWriter (
78. S.getoutputstream (), standardcharsets.utf_8), true);
82. String line = null;
84. While (line = In.readline ()) = null) {
86. if (line.equals ("Bye")) {
88. Break ;
90. }
94. //outputs the conversion result to the client.
96. Out.println (Line.touppercase (locale.english));
98. }
100. } catch (IOException ex) {
102. Ex.printstacktrace ();
104. }
106. }
108. }

Blocking mode is simple to program, but has performance problems because the server thread is stuck on the Accept () method of the receiving client and cannot effectively utilize the resource. Sockets support nonblocking mode, which is now temporarily skipped.

A simple TCP client

The JDK provides the socket class to represent the active socket of the TCP client. The following code shows the client for the above server:

2. Public class TcpClient implements Runnable {
4. private socket socket;
8. Public TcpClient (String host, int port) throws IOException {
10. //Create a socket attached to the server.
12. Socket = new socket (host, port);
14. }
18. @Override
20. public Void Run () {
22. try (socket s = socket) { //reduce the amount of code again ...
24. //wraps the output stream of the socket to send a line of text to the server.
26. PrintWriter out = new PrintWriter (new OutputStreamWriter (
28. S.getoutputstream (), standardcharsets.utf_8), true);
30. //wraps the input stream of the socket to read the text rows returned by the server.
32. BufferedReader in = new BufferedReader (new InputStreamReader (
34. S.getinputstream (), standardcharsets.utf_8));
38. Console console = System.Console ();
40. String line = null;
42. While (line = Console.ReadLine ()) = null) {
44. if (line.equals ("Bye")) {
46. Break ;
48. }
52. //Send text lines to the server.
54. Out.println (line);
56. the text line returned by the//print server.
58. Console.writer (). println (In.readline ());
60. }
64. //Notifies the server to close the connection.
66. Out.println ("Bye");
68. } catch (IOException ex) {
70. Ex.printstacktrace ();
72. }
74. }
76. }

As you can see from the JDK documentation, ServerSocket and sockets can be initialized with some parameters, and delay binding is also supported. These things have an impact on performance and behavior. The next two articles will explain the initialization of these two classes separately.

Original link: http://www.blogjava.net/shinzey/archive/2012/01/04/367846.html