Throughout this Learn to Code series, we’ve been slowly cranking up the complexity of the Java code we’ve created, looking at concepts from assigning values to variables, right through to how to create multi-threaded apps.
But in everything we’ve done so far, we’ve only been running code on just the one computer.
Here, we’re taking our first simple steps into Java networking and learning how to send and receive data between two computers.
The end goal will be to create a multi-user chat system, coding both the server and client sides and running it on your local network.
TCP/IP basics
Network data is commonly transmitted using the Internet Protocol Suite.
Networking in general can scare the daylights out of even seasoned professionals, but just understanding the basics can really help you in your coding.
All networking is about sending and receiving data between locations in such a way that the data arrives as quickly as possible (routing) and reliably handles transmission failure (error recovery).
Put simply, data transmission typically involves four network layers:
Application layer
This is the layer where HyperText Transfer Protocol (HTTP), File Transfer Protocol (FTP) and other protocols are often used. It’s essentially your app’s data level.
Transport layer
This layer encapsulates your data with a Transmission Control Protocol (TCP) transport header, adding connection continuity, error recovery and flow control parameters.
Network layer
This layer further encapsulates the data and TCP header with an Internet Protocol (IP) header providing addressing or ‘routing’ parameters.
Network Access or Link layer
At this layer, the data is encapsulated yet again, this time with communications protocols, depending on the relative location.
For local routing, a MAC (Medium Access Control) header is added. If sending the data across the Internet, the MAC header is replaced by Wide Area Network (WAN) header.
The fully encapsulated data packet then hits the cables in what’s called the ‘physical layer’, converted into electrical voltages as its whizzes around your network or around the world.
Together, these layers form the Internet Protocol Suite, and if you combine the transport and network layers, you get the TCP/IP protocol pairing that makes the Internet work.
At the destination end, the router pulls off the WAN header and replaces it with the appropriate MAC header for that local area network.
The data block or ‘packet’ is then progressively stripped of each header encapsulation as it goes back up the layers at the destination end, until the last thing remaining by the time it reaches the application layer is just the original data.
Now, there are big thick books written about TCP/IP, so I’m on a hiding-to-nothing trying to cover it in a couple of paragraphs. But just be aware it’s a series of network communication layers that controls how data is reliably transmitted.
Java networking
The client socket is a one-line network dialer to the server on localhost.
Thankfully, that’s about as much theory as you need to start playing around with Java network coding.
In simple terms, transferring data over a network relies on two computers negotiating roles between them — one acting as a ‘server’, the other as ‘client’.
Now, we throw these terms around like lollies, but it’s important to understand them and what they actually represent.
A client is a computer that makes a request for data from a server and the server’s role is to be ever ready to supply the data requested.
The process begins with the server awaiting a data request from a client on the network. The client then requests a connection to the server and the server says yes or no.
If ‘no’, the client should ideally wait for a time period and try again. If it’s ‘yes’, the two connect, the client makes its data request and, if the server has the data, sends it back to the client.
A client can only make one server connection at a time, whereas a server can typically handle many clients at once. However, the key is that the connection between a client and server in Java occurs through ‘sockets’.
Java has two socket classes — ‘ServerSocket’ for creating a server and ‘Socket’ for creating a client.
Server listens
Every time we’ve created a JButton in an app so far, we’ve attached a Listener object to it that continually monitors for when that button is pressed. Servers are similar, but in a more complex way.
A server is normally seen as a heavy-duty computer with buckets of storage, but at a software level, it’s just an app continually listening out for connection requests from clients.
That means the server application needs to be running first, otherwise the clients will just be whistling in the wind.
Yet, just as there’s not much point waiting for a phone call if no-one knows your phone number, the same goes for running a server. So when creating a server app, we have to create a phone number, which consists of the server computer’s network connection (IP address) and a TCP ‘port’ number.
Just briefly, the IP address is the common 32-bit dotted address you’re no doubt familiar with, for example 192.168.0.1, while the TCP port address is a 16-bit number between 1025 and 65535.
A TCP data packet is encoded with source and destination port numbers, but in both cases, the bottom 1024 port numbers are usually reserved.
So putting this altogether in Java, we can create a simple server with just the single line:
ServerSocket server = new ServerSocket(3801);
The IP address is set by the computer’s network connection, but the port number you can choose from the above range, and here, we’ve chosen ‘3801’.
But to now set that server to begin listening for a client connection request, we need to activate it and we do that with:
Socket socket = server.accept();
We create a Socket class object called ‘socket’, but what’s unusual about this code line is that, once Java sees it, it doesn’t proceed beyond this point until it receives that connection request, so it’s a bit like a ‘wait’ or ‘delay’ statement.
Input/Output Streaming
With the server initialised and waiting, what happens when it receive a connection request?
Thankfully, Java, your OS and your networking gear handle all the really tough stuff, but we still need to create two data connections — one coming into the server, the other going out back to the client, both through the connecting socket.
The way Java does this is very similar to handling file I/O — by data streams.
‘DataInputStream’ is the stream class used to accept data from the client and ‘DataOutputStream’ does the job going back the other way. We create the two stream objects with:
DataInputStream dataIn = new DataInputStream(socket.getInputStream());
DataOutputStream dataOut = new DataOutputStream(socket.getOutputStream());
From here, we read the input from the client through ‘dataIn’ and write data back out to the client through ‘dataOut’.
Clients talk
Okay, the server is up and running, now we turn our attention to the client. Thankfully, they’re quite similar.
We start by creating a Socket object with the parameters that are essentially the phone number of the server we want to dial up.
We do that with:
Socket client = new Socket(“localhost”, 3801);
The parameter “localhost” is cheat-code for when you’re running the client and the server on the same box.
If the server is on another computer, you replace ‘localhost’ with the IP address, such as:
Socket client = new Socket(“192.168.0.4”, 3801);
Again, we use the DataInputStream and DataOutputStream classes to create objects that talk to the server.
Making your first server
The simple user interface is created in NetBeans 8.o.2 IDE.
So let’s try all this out and see how it works in practice.
Grab the ‘apc_clientserver.zip’ source code from the our website, unzip it, open up NetBeans, import the inner ‘TablesServer.zip’ project file (File, Import Project, From Zip) and run it.
Next, import the ‘TablesClient.zip’ project file and run that.
This simple client/server project allows the client app to send a times tables maths question to the server app, something like ‘8 x 7’.
The server accepts input from the client, calculates the problem result and sends it back to the client.
It’s scintillating stuff, for sure, but it shows the basic techniques required for getting two apps talking to each other — and that’s still pretty cool!
TablesServer project
The server UI just consists of a scrollpane housing a jTextArea.
Let’s start with the server side code, since we need this running first.
The user interface consists of a single jTextArea inside a jScrollPane — that enables the vertical scroll bars when text flows beyond the visible JFrame window area. And that’s it.
The actual server code itself is as simple as you can get and sits inside the ‘try’ statement block.
It begins with initialising the ‘serverStatus’ text area with time, date and server IP address, followed by setting up the ServerSocket with its port (3801) and starting the socket using statements we looked at previously.
The whole Times Table Server code in a few lines.
The code waits until it receives a connection request from a client, at which point, we initialise the input and output stream objects, so the server can read and write data to the connecting client.
With the sockets and input and output streams now set up, we run the server inside an infinite while() loop.
It starts with initialising the string called ‘problem’ that waits for input on the input stream, reading it as a UTF string of characters.
We then split that string (which should be something like ‘7 x 6’) into separate integers using the String.split() function, splitting on the ‘x’ character and storing the arguments in two integer variables, arg1 and arg2.
Next, we send the…
