How to Handle Java SocketException

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

1. Introduction

In this quick tutorial, we’ll learn the causes of SocketException with an example.

We’ll also, of course, discuss how to handle the exception.

2. Causes of SocketException

The most common cause of SocketException is writing or reading data to or from a closed socket connection. Another cause of it is closing the connection before reading all data in the socket buffer.

Let’s take a closer look at some common underlying reasons.

2.1. Slow Network

A poor network connection might be the underlying problem. Setting a higher socket connection timeout can decrease the rate of SocketException for slow connections:

socket.setSoTimeout(30000); // timeout set to 30,000 ms

2.2. Firewall Intervention

A network firewall can close socket connections. If we have access to the firewall, we can turn it off and see if it solves the problem.

Otherwise, we can use a network monitoring tool such as Wireshark to check firewall activities.

2.3. Long Idle Connection

Idle connections might get forgotten by the other end (to save resources). If we have to use a connection for a long time, we can send heartbeat messages to prevent idle state.

2.4. Application Error

Last but not least, SocketException can occur because of mistakes or bugs in our code.

To demonstrate this, let’s start a server on port 6699:

SocketServer server = new SocketServer();
server.start(6699);

When the server is started, we’ll wait for a message from the client:

serverSocket = new ServerSocket(port);
clientSocket = serverSocket.accept();
out = new PrintWriter(clientSocket.getOutputStream(), true);
in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
String msg = in.readLine();

Once we get it, we’ll respond and close the connection:

out.println("hi");
in.close();
out.close();
clientSocket.close();
serverSocket.close();

So, let’s say a client connects to our server and sends “hi”:

SocketClient client = new SocketClient();
client.startConnection("127.0.0.1", 6699);
client.sendMessage("hi");

So far, so good.

But, if the client sends another message:

client.sendMessage("hi again");

Since the client sends “hi again” to the server after the connection is aborted, a SocketException occurs.

3. Handling of a SocketException

Handling SocketException is pretty easy and straightforward. Similar to any other checked exception, we must either throw it or surround it with a try-catch block.

Let’s handle the exception in our example:

try {
    client.sendMessage("hi");
    client.sendMessage("hi again");
} catch (SocketException e) {
    client.stopConnection();
}

Here, we’ve closed the client connection after the exception occurred. Retrying won’t work, because the connection is already closed. We should start a new connection instead:

client.startConnection("127.0.0.1", 6699);
client.sendMessage("hi again");

4. How to Solve SocketException Connection Reset

The java.net.SocketException: Connection reset exception usually occurs when one part of a TCP connection attempts to read/write data, but the other part abruptly closes the connection as if it had been blocked, stopped, or terminated.

Another reason for this exception is a protocol version mismatch between the server and the Java backend. For example, a Java backend running SSLv2 is trying to communicate with a server that only supports SSLv3.

The best way to handle this exception in case of protocol mismatch is to use setEnabledProtocols(). This method of Java’s SSLSocket class is used to set the list of SSL/TLS protocols that the socket should support:

// Enable multiple SSL/TLS protocols
String[] enabledProtocols = new String[] {"TLSv1.2", "TLSv1.3", "TLSv1.1", "TLSv1", "SSLv3", "SSLv3"};
socket.setEnabledProtocols(enabledProtocols);

In the above example, we defined a list of SSL/TLS versions that the socket should support. We should keep in mind that the protocol’s order determines its priority, which is recommended to ensure the use of the most secure protocols.