Java Networking – Sockets, URL, and HTTP Communication

Learn how Java facilitates communication over networks using Sockets, ServerSockets, HttpURLConnection, and Java HTTP Client (Java 11+), and how to build server-client applications.

Java provides a robust Networking API that allows Java programs to communicate with other programs over a network. This can be done using sockets, URLs, and HTTP communication. Let's go through these concepts in detail.

1. Introduction to Sockets

A socket is an endpoint for communication between two machines over a network. It allows sending and receiving data through network protocols such as TCP (Transmission Control Protocol) or UDP (User Datagram Protocol).

  1. TCP Socket: Provides reliable, connection-oriented communication.
  2. UDP Socket: Provides connectionless communication, typically used for real-time data like video and voice.

Key Concepts:

  1. A socket consists of an IP address and a port number.
  2. Ports are used to distinguish between multiple services on the same machine.

2. ServerSocket and Client Socket

In Java, we use ServerSocket to create a server that listens for incoming connections, and Socket to create the client-side connection.

Server-Side Code Using ServerSocket


import java.io.*;
import java.net.*;

public class Server {
public static void main(String[] args) {
try {
// Create a server socket on port 12345
ServerSocket serverSocket = new ServerSocket(12345);
System.out.println("Server started. Waiting for connections...");
// Accept a client connection
Socket clientSocket = serverSocket.accept();
System.out.println("Client connected: " + clientSocket.getInetAddress());
// Set up input and output streams
BufferedReader input = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
PrintWriter output = new PrintWriter(clientSocket.getOutputStream(), true);
// Read data from the client and respond
String message = input.readLine();
System.out.println("Received from client: " + message);
output.println("Hello from server!");
// Close the connection
clientSocket.close();
serverSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}

Client-Side Code Using Socket


import java.io.*;
import java.net.*;

public class Client {
public static void main(String[] args) {
try {
// Connect to the server on localhost and port 12345
Socket socket = new Socket("localhost", 12345);
// Set up input and output streams
PrintWriter output = new PrintWriter(socket.getOutputStream(), true);
BufferedReader input = new BufferedReader(new InputStreamReader(socket.getInputStream()));
// Send data to the server
output.println("Hello from client!");
// Read the server's response
String serverResponse = input.readLine();
System.out.println("Server response: " + serverResponse);
// Close the connection
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}

Key Points:

  1. ServerSocket listens for incoming connections from clients.
  2. Socket establishes a connection to the server.
  3. Data can be exchanged using InputStream and OutputStream.

3. URL and HttpURLConnection

In Java, you can make HTTP requests using HttpURLConnection to interact with web resources. URL is used to represent the address of the resource on the internet.

Example – Fetching Data from a URL


import java.io.*;
import java.net.*;

public class URLExample {
public static void main(String[] args) {
try {
// Create a URL object with the desired URL
URL url = new URL("https://www.example.com");
// Open a connection to the URL
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
// Set request method
connection.setRequestMethod("GET");
// Read the response from the input stream
BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
// Print the response from the URL
System.out.println(response.toString());
} catch (IOException e) {
e.printStackTrace();
}
}
}

Key Points:

  1. Use HttpURLConnection to make HTTP requests and handle responses.
  2. You can specify the HTTP request method (e.g., GET, POST) using setRequestMethod().
  3. BufferedReader is used to read the response.

4. Java HTTP Client (Java 11+)

Java 11 introduced a new HTTP Client API (java.net.http), which provides a more modern and flexible way of making HTTP requests. It supports both synchronous and asynchronous communication.

Example – Sending a GET Request Using HTTP Client (Java 11+)


import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.concurrent.CompletableFuture;

public class HttpClientExample {
public static void main(String[] args) {
// Create a HttpClient instance
HttpClient client = HttpClient.newHttpClient();
// Create a request for the desired URL
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://www.example.com"))
.build();
// Send the GET request synchronously
try {
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println("Response: " + response.body());
} catch (Exception e) {
e.printStackTrace();
}

// Send the GET request asynchronously
CompletableFuture<HttpResponse<String>> futureResponse = client.sendAsync(request, HttpResponse.BodyHandlers.ofString());
futureResponse.thenAccept(response -> {
System.out.println("Async Response: " + response.body());
});
}
}

Key Points:

  1. HttpClient simplifies HTTP communication and supports modern HTTP features.
  2. The new sendAsync() method allows for asynchronous HTTP requests.
  3. BodyHandlers provide different methods for handling responses, such as ofString() and ofByteArray().

Key Benefits of Java HTTP Client (Java 11+)

  1. Simplified API: Java 11’s HTTP Client API is easier to use than HttpURLConnection.
  2. Asynchronous Requests: Easily handle requests asynchronously using CompletableFuture.
  3. HTTP/2 Support: Java 11’s HttpClient supports HTTP/2 by default.
  4. Secure and Flexible: Automatically handles redirects, cookies, and authentication.