By click on the above link you will get the webpage like as follows
In the above webpage click on the DOWNLOAD button so that you can download the chat.zip file.Extract the zip file into specific folder.In that folder you will find the several .java and .class files and two files Server.bat and Client.bat then you click on Server.bat as well as Client.bat then you will get login window logon that as a one user and open another Client.bat then logon as a different User so that you can chat as a two different clients from two different client windows.
Chat server is a standlone application that is made up the combination of two-application, server application (which runs on server side) and client application (which runs on client side). This application is using for chatting in LAN. To start chatting you must be connected with the server after that your message can broadcast to each and every client.
For making this application we are using some core java features like swing, collection, networking, I/O Streams and threading also. In this application we have one server and any number of clients (which are to be communicated with each other). For making a server we have to run the
MyServer.java file at any system on the network that we want to make server and for client we have to run
MyClient.java file on the system that we want to make client. For running whole client operation we can run the
Login.java.
Understand and get the chat server application by following steps :
Some features of the application are as follows :
This application is used for sending messages from one client to all clients. In this, server takes a message from the sender client and sends it to all clients. If any client wants to join the chatting then he runs the client application on client side, enters the login name and hits the login button and starts the chatting with every client. If any client joins the chatting system then the message ?User_Name has Logged in? comes on the message list box of every client window. Same like this, if any client exit from the chatting then the message ?User_Name has Logged Out? comes on the message list box of every client window.
In this we are maintaining the list of user names (client name) also. After creating the connection with server, client sends the user name to server and server store it in the arraylist and sends this arraylist to all clients. Same like this when any client has logged out then server remove this name from the arraylist and send this updated arraylist to every client.
Limitations of the application are as follows :
ServerSide Application:
Server side application is used to get the message from any client and broadcast to each and every client. And this application is also used to maintain the list of users and broadcast this list to everyone.
The Server side application follows these steps
- Firstly creates a new server socket by the ServerSocket ss = new ServerSocket(1004);
- After creating the ServerSocket it accepts the client socket and add this socket into arraylist.
Socket s = ss.accept();
ArrayList al2 = new ArrayList();
Al2.add(s);
- After getting the client socket it creates a thread and make DataInputStream for this socket. After creating the input stream its read the user name and add it to arraylist and this arraylist object write in ObjectOutputStream of each client by using iterator.
DataInputStream din1=new DataInputStream(s.getInputStream)
ArrayList alname=new ArrayList();
alname.add(din1.readUTF());
Iterator i1=al2.iterator();
Socket st1;
while(i1.hasNext()){
st1=(Socket)i1.next();
dout1=new DataOutputStream(st1.getOutputStream());
ObjectOutputStream obj=new ObjectOutputStream(dout1);
obj.writeObject(alname);
}
- After this it makes a new thread and makes one DataInputStream for reading the messages which sends by the client and after reading the message its creates the DataOutputStream for each socket and writes this message in each client output stream through iterator.
String str=din.readUTF();
Iterator i=al.iterator();
Socket st;
while(i.hasNext()){
st=(Socket)i.next();
dout=new DataOutputStream(st.getOutputStream());
dout.writeUTF(str);
dout.flush();
}
- If any client Logged out then server received the client name and server remove it from the arraylist. And sends this updated arraylist to all client.
sname=ddin.readUTF();
alname.remove(sname);
Here is the code of the Server side application :
/****************************************************************
*
* Description
* This is a Server Side application of Chat System.
* This application is used for receiving the messages from any client
* and send to each and every client and in this we can maintain the
* list of all online users.
*
******************************************************************/
import java.io.*;
import java.net.*;
import java.util.*;
public class MyServer{
ServerSocket ss;
Socket s;
ArrayList al=new ArrayList();
ArrayList al1=new ArrayList();
ArrayList al2=new ArrayList();
ArrayList alname=new ArrayList();
Socket s1,s2;
MyServer()throws IOException{
ss=new ServerSocket(1004); // create server socket
while(true){
s=ss.accept(); //accept the client socket
s1=ss.accept();
s2=ss.accept();
al.add(s); // add the client socket in arraylist
al1.add(s1);
al2.add(s2);
System.out.println("Client is Connected");//new thread for maintaning the list of user name
MyThread2 m=new MyThread2(s2,al2,alname);
Thread t2=new Thread(m);
t2.start();
//new thread for receive and sending the messages
MyThread r=new MyThread(s,al);
Thread t=new Thread(r);
t.start();
// new thread for update the list of user name
MyThread1 my=new MyThread1(s1,al1,s,s2); Thread t1=new Thread(my);
t1.start();
}
}
public static void main(String[] args){
try{
new MyServer();
}catch (IOException e){}
}
}
//class is used to update the list of user name
class MyThread1 implements Runnable{
Socket s1,s,s2;
static ArrayList al1;
DataInputStream ddin;
String sname;
MyThread1(Socket s1,ArrayList al1,Socket s,Socket s2){
this.s1=s1;
this.al1=al1;
this.s=s;
this.s2=s2;
}
public void run(){
try{
ddin=new DataInputStream(s1.getInputStream());
while(true){
sname=ddin.readUTF();
System.out.println("Exit :"+sname);//remove the logout user name from arraylist
MyThread2.alname.remove(sname); MyThread2.every();
al1.remove(s1);
MyThread.al.remove(s);
MyThread2.al2.remove(s2);
if(al1.isEmpty())
System.exit(0); //all client has been logout
}
}catch(Exception ie){}
}
}
// class is used to maintain the list of all online users
class MyThread2 implements Runnable{
Socket s2;
static ArrayList al2;
static ArrayList alname;
static DataInputStream din1;
static DataOutputStream dout1;
MyThread2(Socket s2,ArrayList al2,ArrayList alname){
this.s2=s2;
this.al2=al2;
this.alname=alname;
}
public void run(){
try{
din1= new DataInputStream(s2.getInputStream());// store the user name in arraylist
alname.add(din1.readUTF());
every();
}catch(Exception oe){}
}
// send the list of user name to all client
static void every()throws Exception{
Iterator i1=al2.iterator();
Socket st1;
while(i1.hasNext()){
st1=(Socket)i1.next();
dout1=new DataOutputStream(st1.getOutputStream());
ObjectOutputStream obj=new ObjectOutputStream(dout1);
//write the list of users in stream of all clients obj.writeObject(alname);
dout1.flush();
obj.flush();
}
}
}
//class is used to receive the message and //send it to all clients
class MyThread implements Runnable{
Socket s;
static ArrayList al;
DataInputStream din;
DataOutputStream dout;
MyThread(Socket s, ArrayList al){
this.s=s;
this.al=al;
}
public void run(){
String str;
int i=1;
try{
din=new DataInputStream(s.getInputStream());
}catch(Exception e){}
while(i==1){
try{
str=din.readUTF(); //read the message
distribute(str);
}catch (IOException e){}
}
}
// send it to all clients
public void distribute(String str)throws IOException{
Iterator i=al.iterator();
Socket st;
while(i.hasNext()){
st=(Socket)i.next();
dout=new DataOutputStream(st.getOutputStream());
dout.writeUTF(str);
dout.flush();
}
}
}
Clientside Application:
|
For creating the Client side application firstly creates the login frame it consist one textfield and the login button. After hitting the login button it shows the next frame that Client Frame and it consist one textfield for writing the message and one send button for sending it. And two list boxes, one is for showing the all messages and another list box is use to show the all user names. This frame has one more button that is Logout button for terminating the chat.
For running the whole Client operation we can run the Login file Login.java. It can directly call Client file MyClient.java.
Here is the code of Login.java file :
/****************************************************************
*
*
* Description
* This is a Login frame of client side application in chat System.
* It is used to just take the user name
*
* Remarks
* Before running the Login application make sure the server is
* running.
* If server is running then only you can execute your application.
******************************************************************/
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.util.*;
// Login class which takes a user name and passed it to client class
public class Login implements ActionListener{
JFrame frame1;
JTextField tf;
JButton button;
JLabel heading;
JLabel label;
public static void main(String[] args){
new Login();
}
public Login(){
frame1 = new JFrame("Login Page");
tf=new JTextField();
button=new JButton("Login");
heading=new JLabel("Chat Server");
heading.setFont(new Font("Impact", Font.BOLD,40));
label=new JLabel("Enter you Login Name");
label.setFont(new Font("Serif", Font.PLAIN, 24));
JPanel panel = new JPanel();
button.addActionListener(this);
panel.add(heading);panel.add(tf);panel.add(label);
panel.add(button);
heading.setBounds(30,20,280,80);
label.setBounds(20,100,250,60);
tf.setBounds(50,150,150,30);
button.setBounds(70,200,90,30);
frame1.add(panel);
panel.setLayout(null);
frame1.setSize(300, 300);
frame1.setVisible(true);
frame1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
// pass the user name to MyClient class
public void actionPerformed(ActionEvent e){
String name="";
try{
name=tf.getText();
frame1.dispose();
MyClient mc=new MyClient(name);
}catch (IOException te){}
}
} |
The Client side application follows these steps :
- In the client sides firstly creates a new socket and specifies the address and port of the server and establish the connection with the Server.
Socket s=new Socket("localhost",1004);
Note - Instead of "localhost" you have to write the server IP address or computer name.
- After that client makes a new thread and DataInputStream, ObjectInputStream and DataOutputStream for sending the user name and retrieving the list of all users and add the all user name in its list box through iterator.
DataOutputStream dout=new DataOutputStream(s.getOutputStream());
dout.writeUTF(name);
DataInputStream din1=new DataInputStream(s.getInputStream());
ObjectInputStream obj=new ObjectInputStream(din1);
ArrayList alname=new ArrayList();
Alname=(ArrayList)obj.readObject();
String lname;
Iterator i1=alname.iterator();
while(i1.hasNext()){
lname=(String)i1.next();
model1.addElement(lname);
}
Note ? model1 is the object of DefaultListModel that is used to add the element in JList Box.
- Now we make one new thread for sending and receiving the messages from the server. It does this task by using DataInputStream and DataOutputStream.
dout.writeUTF(str); // for sending the messages
str1=din.readUTF(); // receiving the messages
model.addElement(str1) // add these messages to JList Box
- When the client is logged out it sends its name and message ?User_Name has Logged out? and terminate the chatting
dout.writeUTF(name+" has Logged out");
dlout.writeUTF(name);
Here is the code of Client Side application :
/****************************************************************
*
* Description
* This is a client side of chat application.
* This application is used to sending and receiving the messages
* and in this we can maintain the list of all online users
*
* Remarks
*
******************************************************************/
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.net.*;
import java.util.ArrayList;
import java.util.Iterator;
//create the GUI of the client side
public class MyClient extends WindowAdapter implements ActionListener{
JFrame frame;
JList list;
JList list1;
JTextField tf;
DefaultListModel model;
DefaultListModel model1;
JButton button;
JButton lout;
JScrollPane scrollpane;
JScrollPane scrollpane1;
JLabel label;
Socket s,s1,s2;
DataInputStream din;
DataOutputStream dout;
DataOutputStream dlout;
DataOutputStream dout1;
DataInputStream din1;
String name;
MyClient(String name)throws IOException{
frame = new JFrame("Client Side");
tf=new JTextField();
model=new DefaultListModel();
model1=new DefaultListModel();
label=new JLabel("Message");
list=new JList(model);
list1=new JList(model1);
button=new JButton("Send");
lout=new JButton("Logout");
scrollpane=new JScrollPane(list);
scrollpane1=new JScrollPane(list1);
JPanel panel = new JPanel();
button.addActionListener(this);
lout.addActionListener(this);
panel.add(tf);panel.add(button);panel.add(scrollpane);
panel.add(label);panel.add(lout);
panel.add(scrollpane1);
scrollpane.setBounds(10,20,180,150);
scrollpane1.setBounds(250,20,100,150);
label.setBounds(20,180,80,30);
tf.setBounds(100,180,140,30);
button.setBounds(260,180,90,30);
lout.setBounds(260,230,90,30);
frame.add(panel);
panel.setLayout(null);
frame.setSize(400, 400);
frame.setVisible(true);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.name=name;
frame.addWindowListener(this);
s=new Socket("localhost",1004); //creates a socket object
s1=new Socket("localhost",1004);
s2=new Socket("localhost",1004);
//create inputstream for a particular socket
din=new DataInputStream(s.getInputStream());
//create outputstream
dout=new DataOutputStream(s.getOutputStream());
//sending a message for login
dout.writeUTF(name+" has Logged in");
dlout=new DataOutputStream(s1.getOutputStream());
dout1=new DataOutputStream(s2.getOutputStream());
din1=new DataInputStream(s2.getInputStream());
// creating a thread for maintaning the list of user name
My1 m1=new My1(dout1,model1,name,din1);
Thread t1=new Thread(m1);
t1.start();
//creating a thread for receiving a messages
My m=new My(din,model);
Thread t=new Thread(m);
t.start();
}
public void actionPerformed(ActionEvent e){
// sending the messages
if(e.getSource()==button){
String str="";
str=tf.getText();
tf.setText("");
str=name+": > "+str;
try{
dout.writeUTF(str);
System.out.println(str);
dout.flush();
}catch(IOException ae){System.out.println(ae);}
}
// client logout
if (e.getSource()==lout){
frame.dispose();
try{
//sending the message for logout
dout.writeUTF(name+" has Logged out");
dlout.writeUTF(name);
dlout.flush();
Thread.currentThread().sleep(1000);
System.exit(1);
}catch(Exception oe){}
}
}
public void windowClosing(WindowEvent w){
try{
dlout.writeUTF(name);
dlout.flush();
Thread.currentThread().sleep(1000);
System.exit(1);
}catch(Exception oe){}
}
}
// class is used to maintaning the list of user name
class My1 implements Runnable{
DataOutputStream dout1;
DefaultListModel model1;
DataInputStream din1;
String name,lname;
ArrayList alname=new ArrayList(); //stores the list of user names
ObjectInputStream obj; // read the list of user names
int i=0;
My1(DataOutputStream dout1,DefaultListModel model1,
String name,DataInputStream din1){
this.dout1=dout1;
this.model1=model1;
this.name=name;
this.din1=din1;
}
public void run(){
try{
dout1.writeUTF(name); // write the user name in output stream
while(true){
obj=new ObjectInputStream(din1);
//read the list of user names
alname=(ArrayList)obj.readObject();
if(i>0)
model1.clear();
Iterator i1=alname.iterator();
System.out.println(alname);
while(i1.hasNext()){
lname=(String)i1.next();
i++;
//add the user names in list box
model1.addElement(lname);
}
}
}catch(Exception oe){}
}
}
//class is used to received the messages
class My implements Runnable{
DataInputStream din;
DefaultListModel model;
My(DataInputStream din, DefaultListModel model){
this.din=din;
this.model=model;
}
public void run(){
String str1="";
while(true){
try{
str1=din.readUTF(); // receive the message
// add the message in list box
model.addElement(str1);
}catch(Exception e){}
}
}
} |
Download this application
Output of the Client Side Application is
