In this article, we’re going to talk about Java in its relation to WebSocket, which is a type of Application Program Interface (or API for short). Understanding how WebSocket and other APIs work is important to learning Java as a whole because, to a large extent, WebSocket and extensions like it are the reason that modern web development can be done the way that it’s done. This article is an overview of what WebSocket is, how it works, and how Java supports it throughout its lifecycle.
What is WebSocket?
WebSocket is a tool that makes online development easier. In simple terms, it’s a protocol that opens up a full duplex (two way) connection using a TCP internet connection. Before the invention of WebSocket, programs running over the internet had to circumvent to the connection, often including a client-side and server-side portion of each program, making it a difficult and time consuming process. It’s important to note that WebSocket doesn’t overwrite the standard HTTP protocols, it merely compliments them with the ability to forge a direct two-way connection between user and server.
How WebSocket communication works
The process that WebSocket uses to create a two-way communication is a little involved, but we’ll walk through it step by step.
- First, the user sends a handshake request by opening up a connection to the server. This is done by formatting an HTTP upgraded header (HTTP version 1.1+). There are other optional header fields here, too, which can provide other particulars.
- When that’s done, the user waits for a response. When the server receives the request, it parses the data from the header and gathers the information it needs from it.
- The information gathered is formatted into the handshake response, which is another HTTP header. If it’s successful, the server opens up the connection and accepts the data which is now coming from the client.
- Next, the user receives notification that the handshake is successful, which is a message that they receive from the server.
- After that, regular data transfer occurs. This is done in a series of frames, which are masked by the user before they are sent in order to preserve security throughout the process. The server checks that the mask is intact when it receives the data, and isolates and provides an error message whenever it detects a frame that is unmasked.
- The reverse is also possible, and in both cases, an unmasked frame results in either the user or the server shutting down the connection. Otherwise, the connection remains open until it is closed by a command from either side.
Comet vs. HTML5 WebSockets
Before the creation of WebSocket APIs, communications between servers and users were very difficult and convoluted. They relied on a system called Comet, which essentially keeps an HTTP response from resolving in order to deliver a message to a user. Comet and systems like it were pretty archaic and hard to establish for users on a wide basis. This is because most of them had to use multiple steps in order to bounce signals from the user, to a third location like a secondary server, and then finally to the server they were trying to reach. They were formatted this way because of the difficulty of creating a secure two-way connection. With the invention of WebSockets with HTML 5, however, fully duplex (twoway) connections were then possible, and it became much easier to support user connections between the user and the server.
WebSocket supported by Java
Currently, the most recent version of Java Enterprise, Java Enterprise Edition 7, has native support for WebSocket, and runs an API that integrates WebSocket into its software development kit. This means that businesses who are creating large servers that users will connect to regularly – such as online stores, websites, social media sites, and so on – can do so with the much faster WebSocket two-way connection. This rather than being forced to use an indirect connection like a Comet system. What’s exciting is that, because WebSocket is a new and evolving protocol, we can expect to see a lot of improvement in connectivity and how developers will be able to write programs in a more connective environment. All of this is the result of Java taking WebSocket on as a native process, which will ensure that it is used in the next wave of web development.
Much like Ted Stevens once declared, WebSocket does turn the internet into something a little like his famous ‘series of tubes.’ In particular, it creates a sort of pipeline between the user and the server, and allows data to flow two ways between them. In general, the lifecycle of this connection is that the user sends a handshake request, the server sends back its own handshake response, the two way connection is established, the two sides send and receive messages back and forth, and then either side can close the connection.
This concludes our discussion on WebSocket and Java. Hopefully it’s given you a better understanding of WebSocket and how it relates to Java and web development in general. In the next article, we’ll be discussing some legal issues over copyrights between Java and Android.