Java TCP programming

Objectives

• Program your own TCP client/server applications in Java with the Socket API
• Understand how to process data from streams
• Make usage of a REPL

Your applications will be able to communicate over the network!

Explore the code examples

Individually, or in pair/group, take 10 minutes to explore and discuss the code examples.

Answer the questions available in the course material:

• How do the code examples work?
• What are the main takeaways of the code examples?
• What are the main differences between the code examples?

If needed, use the theoretical content to help you.

TCP

TCP is a transport protocol that is similar to a phone call:

1. A connection is established between two parties (unicast)
2. Data sent is guaranteed to arrive in the same order
3. Data can be sent again if needed (retransmission)

The Socket API

• Originally developed by Berkeley University
• Ported to Java and many other languages
• Provides a simple API to use TCP and UDP
• A socket is a connection between two parties using a protocol and a port

Client/server common functions

Client structure and functions

1. Create a Socket
2. Connect the socket to an IP address and a port number
3. Read and write data from/to the socket
4. Flush and close the socket

Server structure and functions

1. Create a ServerSocket
2. Bind the socket to an IP address and a port number
3. Listen for incoming connections
4. Loop
   1. Accept an incoming connection - creates a new Socket on a port
   2. Read and write data from/to the socket
   3. Flush and close the socket
5. Close the ServerSocket

To make it simple, a socket is just like a file that you can open, read from, write to and close. To exchange data, sockets on both sides must be connected.

Processing data from streams

• Sockets use data streams to send and receive data, just like files
• Get an input stream to read data from a socket
• Get an output stream to write data to a socket

Get the streams from a socket:

// Get input stream
input = socket.getInputStream();

// Get output stream
output = socket.getOutputStream();

Read and write data from/to the streams as text:

// Get input stream as text
input = new InputStreamReader(socket.getInputStream(), StandardCharsets.UTF_8);

// Get output stream as text
output = new OutputStreamWriter(socket.getOutputStream(), StandardCharsets.UTF_8);

Improve performance with a buffer (with a binary stream):

// Get input stream as binary with buffer
input = new BufferedReader(new InputStreamReader(socket.getInputStream());

// Get output stream as binary with buffer
output = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream());

Variable length data

Data sent can have a variable length. Manage this using one of the two methods:

• Use a delimiter
• Communicate a fixed length

This must be defined by your application protocol!

Using a delimiter:

// End of transmission character
String EOT = "\u0004";

// Read data until the delimiter is found
String line;
while ((line = in.readLine()) != null && !line.equals(EOT)) {
  System.out.println(
    "[Server " + SERVER_ID + "] received data from client: " + line
  );
}

Communicating a fixed length:

// Send the length of the data
out.write("DATA_LENGTH " + data.length() + "\n");

// Send the data
out.write(data);

// Read the length of the data
String[] parts = in.readLine().split(" ");
int dataLength = Integer.parseInt(parts[1]);

// Read the data
for (int i = 0; i < dataLength; i++) {
  System.out.print((char) in.read());
}

Read-Eval-Print Loop (REPL)

A REPL is a concept that allows you to interact with a program by sending commands to it without restarting it.

In networking, it is used to send commands to a server that will read the commands, evaluate them, and send back the result.

All of this is done in a loop until the client or the server decides to close the connection.

Useful to keep a connection open and send multiple commands!

What will you do?

• Update your application protocol with the new knowledge you gained
• Execute the code examples and run multiple clients at the same time
• Explore the Java TCP programming template
• Implement and Dockerize the "Guess the number" game (optional)

Finished? Was it easy? Was it hard?

Can you let us know what was easy and what was difficult for you during this chapter?

This will help us to improve the course and adapt the content to your needs. If we notice some difficulties, we will come back to you to help you.

GitHub Discussions

You can use reactions to express your opinion on a comment!

What will you do next?

In the next chapter, you will learn the following topics:

• Java UDP programming
  • How does it compare to TCP?
  • How to create efficient UDP network applications
  • Implement the "Temperature monitoring" application using UDP (optional)

Sources

• Main illustration by Carl Nenzen Loven on Unsplash
• Illustration by Aline de Nadai on Unsplash
• Illustration by Alexander Andrews on Unsplash
• Illustration by Oleksandra Bardash on Unsplash
• Illustration by patricia serna on Unsplash