Chatting dengan menggunakan Java RMI

Jika anda berminat membuat sebuah aplikasi chatting sederhana dengan menerapkan sistem terdistribusi, anda dapat membangunnya dengan menggunakan tools Java yaitu Java RMI. RMI(Remote Method Invocation) adalah sebuah layanan yang diberikan oleh Java bagi para developernya untuk mngembangkan sebuah aplikasi Network dengan konsep Sistem terdistribusi.
Maksud dari sistem terdistribusi adalah :

• Client mengakases method/operation yang ada diserver seolah-olah method tersebut berada disisi client.
• Method-method yang boleh diakses oleh client sudah didefinisikan didalam sebuah Interface.
• Jika anda menerapkan chatting dengan Multi Server maka setiap server akan saling berbagi objek-objek yang ada padanya(mendistribusiannya dengan server lainnya).

Hal yang perlu diperhatikan dalam percobaan RMI adalah:

• Membuat sebuah interface yang digunakan untuk membatasi method-method yang boleh diakses oleh client.
• membuat sebuah class Implement dari interface tersebut.
• Membuat sebuah class Server sebagai penerima koneksi.
• Membuat sebuah class Clinet.

Setala hal ini anda lakukan maka anda telah dapat mengcompilenya dengan command sebagai berikut di Command Prompt anda :
javac *.java
rmic CLASS_IMPLEMENTASI

Setelah command tersebut anda lakukan kemudian anda mengatur path dari direktori kerja anda pada CLASSPATH yang berada “Environment Variables”.
Setelah anda selesai melakukan step diatas kemudian anda dapat mengeksekusi Server dan kemudian mengeksekusi Client.
java CLASS_SERVER
java CLASS_CLIENT


Contoh:
Interface

/* File: Chatting.java */
import java.rmi.*;
import java.util.*;
public interface Chatting extends Remote
{
public void sendMessageToAll(String keyword, String username, String messageClient) throws RemoteException;
public void sendMessageToAllClient(String keyword, String username, String messageClient) throws RemoteException;
public void sendMessageToPrivateRoom(String username, String nameOfRoom, String messageClient) throws RemoteException;
public void sendMessageToClient(String keyword, String destination, String username, String messageClient) throws RemoteException;
}

Implementasi

/* File: ChattingServant.java */

import java.io.*;
import java.rmi.*;
import java.net.*;
import java.util.*;
import java.rmi.server.*;
public class ChattingServant extends UnicastRemoteObject implements Chatting
{
private ChattingServer cs;
private ManageClientServant mcs;
private ManageRoomServant mrs;
private ManageServerServant mss;
private ManageClient mc;
private Chatting c;
private HashMap serverList = new HashMap();
private HashMap connectedUser = new HashMap();
private HashMap userRoom = new HashMap();
private PrintWriter output;
private Socket ClientSocket = null;
private ServerSocket serverSocket;
private ArrayList removedServer;
private final String SERVER = "SERVER";
private final String PUBLICMESSAGE = "PUBLICMESSAGE";
private final String PRIVATEROOM = "PRIVATEROOM";
private final String PRIVATEMESSAGE = "PRIVATEMESSAGE";
public ChattingServant(ChattingServer CS, ManageClientServant MCS, ManageRoomServant MRS, ManageServerServant MSS) throws RemoteException
{
super();
cs = CS;
mcs = MCS;
mss = MSS;
}
private void sendMessage(String message) throws RemoteException
{
connectedUser = mcs.getConnectedUser();
Iterator i = connectedUser.keySet().iterator();
String user = null;
while(i.hasNext())
{
try
{
user = i.next().toString();
ClientSocket = connectedUser.get(user);
output = new PrintWriter(ClientSocket.getOutputStream(), true);;
output.println(message);
output.flush();
}
catch(IOException ioe)
{
System.out.println("An Error has occured, please check it");
}
}
}
public void sendMessage(String keyword, String roomName, String username, String message) throws RemoteException
{
connectedUser = mcs.getConnectedUser();
message = keyword + "***" + roomName + "***" + username + "***" + message;
try
{
ClientSocket = connectedUser.get(username);
output = new PrintWriter(ClientSocket.getOutputStream(), true);
output.println(message);
output.flush();
}
catch(IOException ioe)
{
System.out.println("An Error has occured, please check it");
}
}
public void sendMessageToAll(String keyword, String username, String message) throws RemoteException
{
serverList = mss.getServerList();
String serverAddress = null;
Iterator serverIterator = mss.getServerList().keySet().iterator();
removedServer = new ArrayList();
while(serverIterator.hasNext())
{
serverAddress = (String) serverIterator.next();
try
{
c = (Chatting) Naming.lookup("rmi://" + serverAddress + "/ChattingService");
c.sendMessageToAllClient(keyword, username, message);
}
catch (MalformedURLException murle)
{
removedServer.add(serverAddress);
System.out.println("REMOVING A SERVER : " + "Server " + serverAddress + " has been removed from your list");
}
catch (RemoteException re)
{
removedServer.add(serverAddress);
System.out.println("REMOVING A SERVER : " + "Server " + serverAddress + " has been removed from your list");
}
catch (NotBoundException nbe)
{
removedServer.add(serverAddress);
System.out.println("REMOVING A SERVER : " + "Server " + serverAddress + " has been removed from your list");
}
catch (Exception e)
{
removedServer.add(serverAddress);
System.out.println("REMOVING A SERVER : " + "Server " + serverAddress + " has been removed from your list");
}
}
if (!removedServer.isEmpty())
{
mss.removeServer(removedServer);
removedServer.clear();
}
}
public void sendMessageToClient(String keyword, String destination, String username, String message) throws RemoteException
{
message = keyword + "***" + destination + "***" + username + "***" + message;
try
{
ClientSocket = mcs.getSocket(username);
output = new PrintWriter(ClientSocket.getOutputStream(), true);
output.println(message);
output.flush();
}
catch(IOException ioe)
{
System.out.println("An Error has occured, please check it");
}
}
public void sendMessageToAllClient(String keyword, String username, String message) throws RemoteException
{
message = keyword + "***" + username + "***" + message;
sendMessage(message);
}
public void sendMessageToAllClient(String keyword, String message) throws RemoteException
{
message = keyword + "***" + message;
sendMessage(message);
}
public void sendMessageToPrivateRoom(String username, String nameOfRoom, String messageClient) throws RemoteException
{
userRoom = cs.getUserRoom();
int i = 0;
ArrayList client = userRoom.get(nameOfRoom);
for (i=0; i
{
String serverAddress = null;
Iterator serverIterator = serverList.keySet().iterator();
removedServer = new ArrayList();
while(serverIterator.hasNext())
{
serverAddress = (String) serverIterator.next();
try
{
c = (Chatting) Naming.lookup("rmi://" + serverAddress + ":1099/ChattingService");
mc = (ManageClient) Naming.lookup("rmi://" + serverAddress + ":1099/ManageClientService");
if (mc.getUser(client.get(i).toString()))
{
c.sendMessageToClient(PRIVATEROOM, nameOfRoom, client.get(i).toString(), messageClient);
break;
}
}
catch (MalformedURLException murle)
{
System.out.println();
System.out.println("MalformedURLException");
System.out.println(murle);
}
catch (RemoteException re)
{
removedServer.add(serverAddress);
System.out.println("REMOVING A SERVER : " + "Server " + serverAddress + " has been removed from your list");
}
catch (NotBoundException nbe)
{
System.out.println();
System.out.println("NotBoundException");
System.out.println(nbe);
}
catch (Exception e)
{
System.out.println(e);
}
}
if (!removedServer.isEmpty())
{
mss.removeServer(removedServer);
removedServer.clear();
}
}
}
}

Server

/* File: ChattingServer.java */

import java.rmi.*;
import java.net.*;
import java.io.*;
import java.util.*;
import javax.swing.JOptionPane;
public class ChattingServer
{
private HashMap serverList = new HashMap();
private HashMap allClientList = new HashMap();
private HashMap userRoom = new HashMap();
private PrintWriter output;
private Socket ClientSocket = null;
private ServerSocket serverSocket;
private String username;
private String message;
private static String myAddress = null;
private static int myPort;
private static String myName = null;
private static InetAddress serverAddress = null;
private String ipServer = null;
private ManageServer ms = null;
private ManageRoomServant mrs;
private ManageServerServant mss;
private ChattingServant cs;
private ManageAccountServant mas;
private ManageClientServant mcs;
private final String SERVER = "SERVER";
private final String PUBLICMESSAGE = "PUBLICMESSAGE";
public ChattingServer(String myName, String ipAddress, int port)
{
try
{
mss = new ManageServerServant(this, ipAddress, port);
Naming.rebind("rmi://localhost:1099/ManageServerService", mss);
mrs = new ManageRoomServant(this, mss);
Naming.rebind("rmi://localhost:1099/ManageRoomService", mrs);
mcs = new ManageClientServant(this, mss);
Naming.rebind("rmi://localhost:1099/ManageClientService", mcs);
cs = new ChattingServant(this, mcs, mrs, mss);
Naming.rebind("rmi://localhost:1099/ChattingService", cs);
mas = new ManageAccountServant(this, mcs, cs, myName);
Naming.rebind("rmi://localhost:1099/ManageAccountService", mas);
cs.sendMessageToAllClient(SERVER, "NEW_SERVER_CONNECTED");
}
catch(java.rmi.ConnectException ce)
{
System.out.println("Trouble : " + ce);
}
catch (Exception e)
{
System.out.println("Trouble : " + e);
}
}
private void processConnection(String myAddress, String ipAddress, int myPort)
{
try
{
serverSocket = null;
try
{
ms = (ManageServer) Naming.lookup("rmi://" + ipAddress + "/ManageServerService");
serverList = ms.getServerList();
if (!serverList.isEmpty())
mss.updateAnotherServer("ADD_NEW_SERVER");
mss.addNewServer(myAddress, myPort);
userRoom = mrs.getUserRoom();
}
catch (MalformedURLException murle)
{
System.out.println();
System.out.println("MalformedURLException");
System.out.println(murle);
}
catch (RemoteException re)
{
System.out.println();
System.out.println("RemoteException");
System.out.println(re);
}
catch (NotBoundException nbe)
{
System.out.println();
System.out.println("NotBoundException");
System.out.println(nbe);
}
catch (Exception e) {
System.out.println(e);
}
serverSocket = new ServerSocket(myPort);
System.out.println("Server is running on port " + myPort + " .... ");
}
catch (IOException ioe)
{
JOptionPane.showMessageDialog(null, "Could not listen port " + myPort, "ERROR", JOptionPane.ERROR_MESSAGE);
System.exit(-1);
}
try
{
while (true)
{
mcs.addNewClient(serverSocket.accept());
username = mcs.getUsername();
mcs.setMyClient();
cs.sendMessageToAll(PUBLICMESSAGE, myName, "[" + username + "] is now online");
}
}
catch (IOException ioe)
{
JOptionPane.showMessageDialog(null, "Could not accept connection.", "ERROR", JOptionPane.ERROR_MESSAGE);
System.exit(-1);
}
}
public static void main(String args[]) throws IOException
{
try
{
int myPort = Integer.parseInt(args[0]);
String ipServer = args[1];
serverAddress = InetAddress.getLocalHost();
myAddress = serverAddress.getHostAddress();
myName = serverAddress.getHostName().toUpperCase();
ChattingServer cs = new ChattingServer(myName, myAddress, myPort);
cs.processConnection(myAddress, ipServer, myPort);
}
catch (ArrayIndexOutOfBoundsException ae)
{
JOptionPane.showMessageDialog(null, "Please insert the port and the server address.", "ATTENTION", JOptionPane.INFORMATION_MESSAGE);
System.exit(-1);
}
}
public void sendMessageToAllClient(String keyword, String message) throws RemoteException
{
cs.sendMessageToAllClient(keyword, message);
}
public void sendMessageToAll(String keyword, String username, String message) throws RemoteException
{
cs.sendMessageToAll(keyword, username, message);
}
public HashMap getUserRoom()
{
return mrs.getUserRoom();
}
}

Client

/* File: ClientService.java */

import java.rmi.*;
import java.io.*;
import java.net.*;
import java.util.*;
import javax.swing.*;
public class ClientService implements Runnable
{
private Chatting c;
private ManageAccount ma;
private ManageServer ms;
private ManageClient mc;
private ManageRoom mr;
private Socket socket=null;
private BufferedReader in = null;
private ArrayList allClientList = new ArrayList();
private HashMap serverList = new HashMap();
private HashMap myRoomList = new HashMap();
private HashMap privateRoom = new HashMap();
private String removedServer[];
private frmPublicRoom fpr;
private String username = null;
private String ipAddress = null;
private String message = null;
private Thread thread = null;
private int port;
private final String SEPARATOR = "\\*\\*\\*";
private final String SERVER = "SERVER";
private final String PUBLICMESSAGE = "PUBLICMESSAGE";
private final String PRIVATEROOM = "PRIVATEROOM";
private final String PRIVATEMESSAGE = "PRIVATEMESSAGE";
private final String ONLINE = "ONLINE";
private final String OFFLINE = "OFFLINE";
public ClientService(String Username, String IPAddress, int Port)
{
username = Username;
ipAddress = IPAddress;
port = Port;
thread = new Thread(this);
try
{
c = (Chatting) Naming.lookup("rmi://" + IPAddress + "/ChattingService");
ms = (ManageServer) Naming.lookup("rmi://" + IPAddress + "/ManageServerService");
mc = (ManageClient) Naming.lookup("rmi://" + IPAddress + "/ManageClientService");
mr = (ManageRoom) Naming.lookup("rmi://" + IPAddress + "/ManageRoomService");
ma = (ManageAccount) Naming.lookup("rmi://" + IPAddress + "/ManageAccountService");
}
catch (MalformedURLException murle)
{
System.out.println();
System.out.println("MalformedURLException");
System.out.println(murle);
}
catch (RemoteException re)
{
System.out.println();
System.out.println("RemoteException");
System.out.println(re);
}
catch (NotBoundException nbe)
{
System.out.println();
System.out.println("NotBoundException");
System.out.println(nbe);
}
catch (Exception e)
{
System.out.println(e);
}
thread.start();
}
public void setClientList(ArrayList allClientList)
{
this.allClientList = allClientList;
}
public void run()
{
try
{
mc.setUsername(username);
System.out.println(username);
socket = new Socket(ipAddress, port);
}
catch(java.net.UnknownHostException e)
{
JOptionPane.showMessageDialog(null, "Can not connect to server " + ipAddress ,"WARNING", JOptionPane.WARNING_MESSAGE);
}
catch(IOException e)
{
JOptionPane.showMessageDialog(null, "The server " + ipAddress + " on port " + port + " is not found!", "ERROR",JOptionPane.ERROR_MESSAGE);
}
try
{
myRoomList = mr.getMyRoom(username);
allClientList = mc.getAllClient();
fpr = new frmPublicRoom(username, ipAddress, this);
fpr.updateRoom(myRoomList);
fpr.updateClient(allClientList);
readMessage();
}
catch (RemoteException re)
{
JOptionPane.showMessageDialog(null, "The server is not available!", "Remote Exception",JOptionPane.WARNING_MESSAGE);
}
catch (Exception e)
{
JOptionPane.showMessageDialog(null, "The server is not available!", "Exception",JOptionPane.WARNING_MESSAGE);
}
}
public void readMessage()
{
try
{
in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
while((message = in.readLine()) != null)
{
System.out.println(message);
String[] fromServer = message.split(SEPARATOR);
if (fromServer[0].equals(SERVER))
{
serverList = ms.getServerList();
}
else if (fromServer[0].equals(ONLINE) || fromServer[0].equals(OFFLINE))
{
setClientList(mc.getAllClient());
fpr.updateClient(allClientList);
}
else if (fromServer[0].equals(PUBLICMESSAGE))
{
String Message = splitPublicMessage(message);
fpr.updateMessage(Message);
}
else if (fromServer[0].equals(PRIVATEROOM))
{
String roomName = fromServer[1];
String username = fromServer[2];
String message = fromServer[3];
String Message = splitPublicMessage(message);
processPrivateMessage(roomName, username, message);
}
}
in.close();
socket.close();
}
catch(java.net.UnknownHostException e)
{
setServer();
}
catch(IOException e)
{
setServer();
}
}
public void removeServer(int counter)
{
int i = 0;
for (i=0; i<=counter; i++)
{
serverList.remove(removedServer[i]);
}
}
private void setServer()
{
Iterator serverIterator = serverList.keySet().iterator();
String serverAddress = null;
int port;
int i = -1;
removedServer = new String[serverList.size()];
while(serverIterator.hasNext())
{
serverAddress = serverIterator.next().toString();
port = serverList.get(serverAddress);
try
{
ipAddress = serverAddress;
c = (Chatting) Naming.lookup("rmi://" + ipAddress + ":1099/ChattingService");
ms = (ManageServer) Naming.lookup("rmi://" + ipAddress + ":1099/ManageServerService");
mc = (ManageClient) Naming.lookup("rmi://" + ipAddress + ":1099/ManageClientService");
mc.setUsername(username);
serverList = ms.getServerList();
socket = new Socket(serverAddress, port);
break;
}
catch (MalformedURLException murle)
{
i++;
removedServer[i] = serverAddress;
}
catch (RemoteException re)
{
i++;
removedServer[i] = serverAddress;
}
catch (NotBoundException nbe)
{
i++;
removedServer[i] = serverAddress;
}
catch (Exception e)
{
i++;
removedServer[i] = serverAddress;
JOptionPane.showMessageDialog(null, "There are no server in your network. Please contact your Administrator.", "Warning", JOptionPane.WARNING_MESSAGE);
System.exit(0);
}
}
if (i>=0)
removeServer(i);
if (serverList.isEmpty())
{
JOptionPane.showMessageDialog(null, "There is no server in your network. Please contact your Administrator.", "Warning", JOptionPane.WARNING_MESSAGE);
System.exit(0);
}
readMessage();
}
public String splitPublicMessage(String Message)
{
String[] fromServer = message.split(SEPARATOR);
return fromServer[1] + " >> " + fromServer[2];
}
public void sendMessage(String username, String message)
{
try
{
c.sendMessageToAll(PUBLICMESSAGE, username, message);
}
catch (RemoteException re)
{
JOptionPane.showMessageDialog(null, "Error : " + re, "ERROR", JOptionPane.ERROR_MESSAGE);
}
}
public void sendMessageToPrivateRoom(String username, String nameOfRoom, String messageClient)
{
try
{
c.sendMessageToPrivateRoom(username, nameOfRoom, messageClient);
}
catch (RemoteException re)
{
JOptionPane.showMessageDialog(null, "Error : " + re, "ERROR", JOptionPane.ERROR_MESSAGE);
}
}
public boolean signOut(String username) throws RemoteException
{
if (ma.signOut(username))
return true;
else
return false;
}
private void processPrivateMessage(String roomName, String username, String message)
{
if (!privateRoom.containsKey(roomName))
{
String admin = getAdmin(roomName);
openPrivateRoomWindow(roomName, username, admin);
}
privateRoom.get(roomName).updateMessage(username, message);
}
public boolean isWindowOpen(String keyword, String roomName)
{
boolean status = false;
if (keyword.equals(PRIVATEROOM))
status = privateRoom.containsKey(roomName);
return status;
}
public void openPrivateRoomWindow(String roomName, String username, String admin)
{
privateRoom.put(roomName, new frmPrivateRoom(roomName, username, admin, this));
}
public void removeOpenedWindow(String keyword, String roomName)
{
if (keyword.equals(PRIVATEROOM))
privateRoom.remove(roomName);
}
public String getAdmin(String roomName)
{
System.out.println(roomName + myRoomList);
return myRoomList.get(roomName).toString();
}
}

Mudah-mudahan RMI dapat membantu anda ……………….
ALin

Blogged with the Flock Browser

Tags: JavaRMI

Filed under: Java, Pemograman , Java