Java Socket Programming – Upgrade your programming skills in Java

In our last Java tutorial, we discussed the Java URL class. In this tutorial, we will discuss the networking concept of Java programming, that is, Socket programming in Java along with its implementation. We will earn to establish a Java Socket Connection. We will discuss both client-side and server-side socket programming in Java.

But before starting with our tutorial, it is recommended for you all to take a quick sneak peak on Java URL Class to clear your basics with Techvidvan.

Keeping you updated with latest technology trends, Join TechVidvan on Telegram

Socket Programming in Java

Socket programming refers to communication between two nodes or applications running on different JRE (Java Runtime Environment). We use the socket programming in Java to connect the client program with the server program, or simply, connect a client and a server. Socket programming in Java can be either connection-oriented or connectionless. The package java.net is used for socket programming in Java. There are two classes in this package which are Socket class and ServerSocket class.

Every server is a software program running on a specific system that listens to a specific port and waits for the requests from the client-side. For example, the Tomcat server running on the port number 8080 responds to the requests coming on this port number.

The Java Socket Programming has two sections.

  • Java Server Socket Program
  • Java Client Socket Program

The following diagram shows the Socket Programming process:

What is a Socket in Java?

A socket in Java is one of the nodes of a two-way communication link between the client and server programs running on the network. An endpoint or a node is a combination of an IP address and a port number. There is a port number for each socket so that the TCP layer can identify the application where to send the data.

Now, let’s discuss the two classes of java.net package in brief.

The java.net.Socket Class in Java

We use the Socket class to create the sockets for the client and server. The java.net.Socket class represents the socket. Both the client and the server programs use this socket to communicate with each other. There are some methods in the Socket class.

Methods of Socket Class

S.N Method  Description
1 public void connect(SocketAddress host, int timeout) throws IOException This method connects the socket to the given input host. 
2 public int getPort() This method returns the port through which the socket is bound on the remote machine.
3 public int getLocalPort() This method returns the port through which the socket is bound on the local machine.
4 public SocketAddress getRemoteSocketAddress() This method gives the address of the remote socket.
5 public InputStream getInputStream() throws IOException This method returns the input stream of the socket. 
7 public void close() throws IOException This method closes the socket. Closing the socket makes it no longer available to connect it to any server.

The java.net.ServerSocket Class in Java

The java.net.ServerSocket creates a server socket to obtain a port of the server and to listen to the client requests. The object of the ServerSocket class object helps to establish communication with the clients.

Methods of ServerSocket Class

S.N. Method Description
1 public int getLocalPort() This method returns the port on which the server socket is listening to.
2 public Socket accept() throws IOException It returns the socket and establishes a connection between the server and the client.
3 public void setSoTimeout(int timeout) This method sets the time-out value for how long the server socket has to wait for a client during the accept() method.
4 public void bind(SocketAddress host, int backlog) This method binds the socket to the specified server and port in the SocketAddress object. 
5 public synchronized void close() This method closes the object of the ServerSocket class.

Client-Side Socket Programming

For implementing client-side programming, we need to follow the below steps:

  1. Create a Socket
  2. Connect it to ServerSocket by specifying the IP address and the port number
  3. Get the reference of the OutputStream
  4. Attach this reference to OutputStreamWriter
  5. Write and close
  6. Get the reference of InputStream
  7. Attach this reference to InputStreamWriter
  8. Read and Buffer
  9. Parse, interpret and process it
  10. Close Connection

1. Creating a Socket

To create a Socket, we use the Socket class and create its object. We pass the IP address and port number of the Server inside the Socket.

Here, we are using “localhost” because our server and the client applications are present on the same machine. For example:

Socket s=new Socket("localhost",6666);

2. Connecting socket to ServerSocket

After creating a socket, we connect it to the ServerSocket by passing the IP address and the port number.

3. Get the reference of the OutputStream

Now, we get the reference of the OutputStream for writing the request.

DataOutputStream out = null;

4. Attach this reference to OutputStreamWriter

Attach the reference of OutputStream to the OutputStreamWriter.

5. Write and close

With the reference of OutputStream, write the request and then close it:

out.write();
out.close();

6. Get the reference of the InputStream

Now, we get the reference of the InputStream for reading the request.

DataInputStream input = null;

7. Attach this reference to InputStreamWriter

Attach the reference of InputStream to the InputStreamReader.

8. Read and close

With the reference of InputStream, read the request a then close it:

input.readLine();
input.close();

9. Close the connection

After interpreting and parsing, close the connection

socket .close();

Server-Side Socket Programming

For implementing server-side programming, we need to follow the below steps:

  1. Create ServerSocket
  2. Bind it to a port number
  3. Put it into the listening mode
  4. Get the reference of InputStream
  5. Attach the reference to InputStreamReader
  6. Read and buffer
  7. Parse the request
  8. Prepare response
  9. Get the reference of OutputStream
  10. Attach the reference to OutputStreamReader
  11. Write the response
  12. Close Connection

Note: The 4th point only happens when there is a request from the client. Otherwise, the server ends at the 3rd stage only.

1. Creating a ServerSocket

To create a ServerSocket, we use the ServerSocket class and create its object.

ServerSocket server;

2. Binding it to a port number

After creating the object, we bind it to a port number through which the client can request it.

server = new ServerSocket(port);

3. Put it to the listening mode

Put the server into the listening mode so that it can listen to the requests coming from the client-side at the port number that we binded in the last step.

server.accept();

4. Get the reference of the OutputStream

Now, we get the reference of the OutputStream for writing the request.

DataOutputStream out = null;

5. Attach this reference to OutputStreamWriter

Attach the reference of OutputStream to the OutputStreamWriter.

6. Write the response

With the reference of OutputSteam, write the response:

7. Close the connection

After writing the response, close the connection

socket .close();

Now as we know the process of both client and server-side, we will implement them with the help of Java code.

Implementing Socket Programming in Java

Code for Server-side:

package com.techvidvan.socketprogramming;
//A Java program for a Server Side
import java.net.*;
import java.io.*;
public class ServerSide
{
  //initialize socket and input stream
  private Socket socket = null;
  private ServerSocket server = null;
  private DataInputStream in = null;
  //constructor with port
  public ServerSide(int port)
  {
    //starts server and waits for a connection
    try
    {
      System.out.println("Server started at port 5100");
      System.out.println("Waiting for a client ...");
      socket = server.accept();
      System.out.println("Client accepted");
      //takes input from the client socket
      in = new DataInputStream(new BufferedInputStream(socket.getInputStream()));
      String line = " ";
      //reads message from client until "Over" is sent
      while (!line.equals("Over"))
      {
        try
        {
          line = in.readUTF();
          System.out.println(line);
        }
        catch(IOException i)
        {
          System.out.println(i);
        }
      }
      System.out.println("Closing connection");
      //close connection
      socket.close();
      in.close();
    }
    catch(IOException i)
    {
      System.out.println(i);
    }
  }
  public static void main(String args[]){
    ServerSide server = new ServerSide(5100);
  }
}

Output:

Server started at port 5230
Waiting for a client …

Code for Client-side:

package com.techvidvan.socketprogramming;
//A Java program for a ClientSide
import java.net.*;
import java.io.*;
public class ClientSide
{
  //initialize socket and input output streams
  private Socket socket = null;
  private DataInputStream input = null;
  private DataOutputStream out = null;
  //constructor to put ip address and port
  @SuppressWarnings("deprecation")
  public ClientSide(String address, int port)
  {
    //establish a connection
    try
    {
      socket = new Socket(address, port);
      System.out.println("Connected");
      //takes input from terminal
      input = new DataInputStream(System.in);
      //sends output to the socket
      out = new DataOutputStream(socket.getOutputStream());
    }
    catch(UnknownHostException u)
    {
      System.out.println(u);
    }
    catch(IOException i)
    {
      System.out.println(i);
    }
    // string to read message from input
    String line = " ";
    //keep reading until "Over" is input
    while (!line.equals("Over"))
    {
      try
      {
        line = input.readLine();
        out.writeUTF(line);
      }
      catch(IOException i)
      {
        System.out.println(i);
      }
    }
    //close the connection
    try
    {
      input.close();
      out.close();
      socket.close();
    }
    catch(IOException i)
    {
      System.out.println(i);
    }
  }
  public static void main(String args[])
  {
    ClientSide client = new ClientSide("localhost", 5230);
  }
}

Output:

Connected

Important Points

  • The server application makes the object of ServerSocket on port number 5230. Then, the server starts listening for client requests for port 5230.
  • After that, the Server makes a Socket object to communicate with the client.
  • The accept() method does not run unless the client program connects to the server.
  • The getInputStream() method takes the input from the socket.
  • The Server keeps receiving messages until the Client sends “Over”.
  • In the end, we close the connection with the close() method. We close both the socket and the input stream.
  • Compile both the Client and Server programs on your machine, and then, first, run the Server and then run the Client.

Summary

Socket Programming in Java is used to set the communication between the two nodes on the network. There are two important classes for Socket Programming in Java which is Socket and ServerSocket class. We covered various important methods of both the classes.

At last, we implemented the socket programming by connecting the client code with the server code. This article will surely help you to build and sharpen your concepts in Java Socket Programming.

Thank you for reading our article. Do share your feedback through the comment section below.

Happy Learning 🙂

Leave a Reply

Your email address will not be published. Required fields are marked *

This site is protected by reCAPTCHA and the Google Privacy Policy and Terms of Service apply.