Java Socket Programming

Java Socket Programming

Socket programming is used for the communication between the applications, i.e., client and server running on different JRE may be connection-oriented or connectionless. The client program can be designed using the Socket class. The server program can be created using the ServerSocket class. Both Socket and ServerSocket classes are the inbuilt classes in the java.net package. A client program instantiates a Socket object on its end in the communication and attempts to connect the Socket to a server. When the connection is made, the server can communicate by writing to and reading from the Socket.

The following steps occur when establishing a connection between two computers using sockets:

• The server creates a ServerSocket object that denotes on which port number communication is going to occur.
• The server calls the accept() method of the ServerSocket class. The accept() method waits until a client connects to the server on the given port.
• A client creates a Socket object, indicating the server name and the port number to which it connects on the internet.
• The accept() method gives a reference to a Socket on the server that is connected to the client’s Socket.
• After the connection is established, communication can occur using I/O streams. Every Socket has both an OutputStream and InputStream. The OutputStream of the client is connected to the server’s InputStream, and the client’s InputStream is connected to the server’s OutputStream. In two-way communication, the data can be sent across both streams at the same time.

The Socket class

Socket class indicates the socket that both the client and the server used to communicate with each other. The client has a Socket object by instantiating its class, rather than the server gets the object of Socket by the return value of the accept() method. Socket class designs a client program.

The constructor of the Socket class:

Syntax:

Socket s=new Socket(“localhost”,8080); //localhost—port name and 8080—port number

Method of Socket class

public OutputStream getOuputStream() :

The above method writes on the data from the client program to the server program and from the server program to the client program, which returns the OutputStream class object. A syntax is given below that tells how we can use it in the Socket class:

Syntax:

Socket s=new Socket(“localhost”,8080);
OutputStream os=new s.getOutputStream();
DataOutputStream dis=new DataOutputStream(os);

public InputStream  getInputStream()

It is used by the server to read the data from the client system or by the client from the server system that returns an InputStream class object.

A syntax is given below that tells how we can use it in the Socket class:

Syntax:

Socket s=new Socket(“localhost”,10);
InputStream input=new s.getInputStream();
DataInputStream datainput=new DataInputStream(is);

 public synchronized void close()

To close an object of Socket class or it is used to close client requests. A syntax is given below that tells how we can incorporate it in the Socket class:

Syntax:

Socket s=new Socket(“localhost”,8080);
s.close(); 

The ServerSocket class

This class can be used to create a ServerSocket instance that is used by server applications to listen to client’s requests. If the application has successfully bound to the specified port, the ServerSocket constructor does not throw an exception and is ready for client requests.

The ServerSocket class has four constructors:

Methods of the ServerSocket class

When the ServerSocket calls accept(), the method does not return until a client connects. After a client connects, the ServerSocket creates a new Socket on an unspecified port and returns a reference to this new socket. A connection now exists between the client and the server, and communication can begin. ServerSocket object is used to communicate with clients. ServerSocket class is used to design a server program. It has some constructors and methods that are used in designing the server program. ServerSocket class contains a constructor that is used to create a separate port number to run the server program.

Syntax:

ServerSocket ss=new ServerSocket(8080);

public Socket accept()

It is used to accept the client's request on the internet. The following syntax is given below, which tells how we can use it in the ServerSocket class.

Syntax:

Socket s=new Socket(“localhost”,8080);
ServerSocket ss=new ServerSocket(8080);
Socket s=ss.accept(); 

The following are some examples of TCP protocol:

Example 1: One-way communication from the client to the server.

 Client-side programming:

import java.net.*;
import java.io.*;
class Client
{
public static void main(String s1[])
{
try
{
Socket s=new Socket("localhost",20); //creates the socket instance
System.out.println(s);
//DataOutputStream class is to create an output stream to send response to the server.
DataOutputStream d1=new DataOutputStream(s.getOutputStream());
d1.writeUTF("hello server");
d1.close();
}
catch(Exception e)
{
System.out.println(e);
}
}
} 

Server side programming

import java.net.*;
import java.io.*;
class Server
{
public static void main(String s1[])
{
try
{
ServerSocket ss=new ServerSocket(20);
System.out.println("server is started......");
Socket s=ss.accept();  //establishing connection  and waits for the client.
System.out.println(s);
//DataInputStream class is to create an input stream to receive a response from the client.
DataInputStream ds=new DataInputStream(s.getInputStream());
String msg=(String)ds.readUTF();
System.out.println(msg);
}
catch(Exception e)
{
e.printStackTrace();
}
}
} 

The output of the client:

The output of the server:

Example 2: Peer to peer chatting, i.e., (Read-Write from both side) Two-way communication:

The client first writes to the server, then the server receives and prints the text. Then the server writes to the client, and the client receives and prints the text.

Client side programming:

import java.net.*; 
import java.io.*; 
class MyClient1{ 
public static void main(String s1[])throws Exception{ 
Socket s=new Socket("localhost",10); 
//DataInputStream class is to create an input stream to receive response from the server.
DataInputStream din=new DataInputStream(s.getInputStream()); 
//DataOutputStream class is to create output stream to send information to the server socket.
DataOutputStream dout=new DataOutputStream(s.getOutputStream());
BufferedReader br3=new BufferedReader(new InputStreamReader(System.in));   
String str="",str2=""; 
while(!str.equals("stop")){ 
str=br3.readLine(); 
dout.writeUTF(str); 
dout.flush(); 
str2=din.readUTF(); 
System.out.println("Server says: "+str2); 
}   
dout.close(); 
s.close(); 
}}  

Server side programming:

import java.net.*; 
import java.io.*; 
class MyServer1{ 
public static void main(String s2[])throws Exception{ 
ServerSocket ss=new ServerSocket(10); 
Socket s=ss.accept(); 
// DataInputStream creates  an input stream to receive input from the client.
DataInputStream din=new
DataInputStream(s.getInputStream()); 
//DataOutputStream creates an output stream to send information to the client.
DataOutputStream dout=new
DataOutputStream(s.getOutputStream()); 
BufferedReader br=new BufferedReader
(new InputStreamReader(System.in)); 
String str="",str2=""; 
while(!str.equals("stop")){ 
str=din.readUTF(); 
System.out.println("client says: "+str); 
str2=br.readLine(); 
dout.writeUTF(str2); 
dout.flush(); 
} 
din.close(); 
s.close(); 
ss.close(); 
}}  

The output of the client:

 The output of the server:

Example 3: Echo Server for communication:  Whatever message the client writes, it reflects towards the client as it is, from the server

The client side:

import java.io.*;
import java.net.*;
public class MyClient2
{            
Socket s;
DataInputStream din;
DataOutputStream dout;
public MyClient2()
{
try
{
s=new Socket("localhost",10);
System.out.println(s);
din=new DataInputStream(s.getInputStream());
dout=new DataOutputStream(s.getOutputStream());
clientChat();
}
catch(Exception e)
{
System.out.println(e);
}
}
public void clientChat() throws IOException
{
BufferedReader br3=new BufferedReader(new InputStreamReader(System.in));
String s1;
do
{
s1=br3.readLine();
dout.writeUTF(s1);
dout.flush();
System.out.println("server message:"+din.readUTF());
}
while(!s1.equals("stop"));
}
public static void main(String s[])
{
new  MyClient2();
}
} 

The server side:

import java.io.*;
import java.net.*;
public class MyServer2
{
ServerSocket ss;
Socket s;
DataInputStream dis;
DataOutputStream dos;
public MyServer2()
{
try
{
System.out.println("server started");
ss=new ServerSocket(10);
s=ss.accept();
System.out.println("client connected");
dis=new DataInputStream(s.getInputStream());
dos=new DataOutputStream(s.getOutputStream());
serverChat();
}
catch(Exception e)
{
System.out.println(e);
}
}
public static void main(String s[])
{
new MyServer2();
}
public void serverChat() throws IOException{
String str;
do
{
str=dis.readUTF();
System.out.println("client message"+str);
dos.writeUTF(str);
dos.flush();
}
while(!str.equals("stop"));
}
} 

The output of the client:

The output of the server:

Limitations of Socket programming

1. You can share the resources locally but not globally.
2. You cannot develop internet-based applications.
3. You can develop only half-duplex applications.
4. You cannot get services from universal protocols like http, ftp, etc.
5. You cannot get services from universal server software like Tomcat, WebLogic, etc.

Note: Servlet and JSP technology has overcome these limitations.