{"id":16,"date":"2020-11-25T16:14:09","date_gmt":"2020-11-25T21:14:09","guid":{"rendered":"https:\/\/www.alpharithms.com\/?p=16"},"modified":"2021-07-27T08:09:38","modified_gmt":"2021-07-27T12:09:38","slug":"detecting-client-disconnections-java-sockets","status":"publish","type":"post","link":"https:\/\/www.alpharithms.com\/detecting-client-disconnections-java-sockets-091416\/","title":{"rendered":"Detecting Client Disconnections Using Java Sockets"},"content":{"rendered":"

Java Sockets make networked programming a breeze. The java.net package offers developers a wide range of tools to create networked applications. The Socket class provides access to a TCP connection between hosts. Unfortunately, it doesn’t provide an API for detecting a dropped connection from the remote system.<\/p>\n

A Simple Client-Server Application Model<\/h2>\n

Java sockets can facilitate both TCP and UDP type protocols. While UDP connections are non-persistent, TCP connections often support a dynamic back-and-forth exchange of information between two network end systems. Let’s imagine this as a simple client:server<\/code> model that does the following:<\/p>\n

    \n
  1. The server opens a socket and begins listening for connections;<\/li>\n
  2. A client opens a socket and connects to the server;<\/li>\n
  3. The client sends a message to the server;<\/li>\n
  4. The server receives the client’s message and sends a response;<\/li>\n
  5. The client disconnects.<\/li>\n<\/ol>\n

    This exchange could represent the core interaction of a simple messaging application, a video game chat room, or perhaps a commenting system. The TCP protocol dictates that one member of a network communication session plays the role of the server (host) while multiple others can be a client. Typically, a server remains running such that many clients can connect, disconnect, reconnect, and perhaps even interact.<\/p>\n

    What happens when a client disconnects though?<\/p>\n

    Detecting Socket Connections<\/h2>\n

    Java’s Socket API does not provide an API for detecting a clientside disconnection. Let’s consider how a simple socket-based server is created using Java’s ServerSocket and Socket classes.<\/p>\n

    class TestServer {\r\n    \r\n    public static void main(String[] args) throws IOException {\r\n        \r\n        \/\/ Create server socket on port 1234\r\n        ServerSocket serverSocket = new ServerSocket(1234);\r\n        \r\n        \/\/ Listen for incoming connections\r\n        while(!serverSocket.isClosed()){\r\n            \r\n            \/\/ Listen\r\n            \r\n        }\r\n    }\r\n}<\/pre>\n
    In this example, a ServerSocket<\/code> is created and begins listening for connections on port 12345<\/code>. This means a remote host would attempt to connect to this server on that port and likely be refused if attempting to connect anywhere else. The key logic in this example is the while(!serverSocket.isClosed())<\/code> loop.<\/p>\n
    This is the equivalent of saying “listen for incoming connections as long as the server’s socket isn’t closed.” The loop isn’t doing anything, however, and the above code will likely run until there’s a keyboard interrupt or power outage\u2014it needs logic to handle incoming connections.<\/p>\n
    Accepting Socket Connections<\/h2>\n
    Once the ServerSocket has been established, effectively binding it to a port, the server can start listening for incoming client connections. Per the official JDK 11 docs<\/a>:<\/p>\n
    [The ServerSocket] Listens for a connection to be made to this socket and accepts it. The method blocks until a connection is made.<\/em><\/p>\n
    This is done by the following code:<\/p>\n
    Socket socket = serverSocket.accept();<\/code><\/p>\n
    Much like we ensured the Server would listen for incoming connections until its ServerSocket was closed, we also want to ensures that the server listens for incoming client data for as long as a client connection is established. This is accomplished by adding a while(!(socket.isClosed())<\/code> loop, within which we’ll analyze client messages and act accordingly:<\/p>\n
    \/\/ Open socket for incoming connections\r\nSocket socket = serverSocket.accept();\r\n\r\n\/\/ Continue to listen while client connected\r\nwhile(!(socket.isClosed())){\r\n\r\n    \/\/ Listen for and validate client incoming message\r\n    String input = inputStream.readLine();\r\n    if (input != null && !input.trim().equals(\"\")){\r\n         \r\n        \/\/ Stream to console\r\n        System.out.println(\"message received: \" + input);\r\n\r\n    }\r\n}<\/pre>\n
    Note<\/strong>: For a more complete tutorial, check out the Oracle KnockKnockServer series<\/a>.<\/p>\n
    The previous code is essentially saying “listen to what this client has to say as long as the socket is connected.” To accomplish this, it uses the socket.getInputStream()<\/code> method’s return value wrapped in the BufferedReader<\/code> object to extract a String representation of client data.<\/p>\n
    The line if (input != null && !input.trim().equals(\"\"))<\/code> is a minimalist check to ensure the server is responding only to valid client input, at which point it streams the received message to the console.<\/p>\n
    One problem that becomes apparent quickly is that the socket has no explicit way of detecting when a client disconnects<\/strong>.<\/p>\n
    Detecting Client Disconnections<\/h2>\n
    The call to socket.isClosed()<\/code> refers to the\u00a0server-side<\/em> socket\u2014which is still open. Essentially, the above code has created an infinite loop until we explicitly set conditions under which the socket will be closed. This is great for outputting client messages to the console, but what happens when that client disconnects?<\/p>\n
    Currently, the server-side socket<\/code> never detects a disconnect and remains open\u2014thus never satisfying the termination condition for the while<\/code> loop. To add this functionality, we need to manually check if the socket is connected in Java<\/strong>. This can be accomplished in several ways:<\/p>\n