- Internetprogrammering 98/99 -

CORBA: Meddelandesystem baserat på CORBA

Meddelandesystemet implementerat i CORBA. Lite mer funktionalitet än i dom tidigare versionerna (dvs den socket- respektive RMIbaserade versionen). Men det blir inte direkt mer kod för det!

IDL-beskrivning

module MessageBoard  {

 // Följande gränssnitt implementeras av en klient som skall kunna få meddelanden skickade till sig från en "meddelandecentral".
 interface MessageClientInterface {

  // Meddelande till klienten, utan avsändarnamn.
  void message (in string aMessageString);

  // Meddelande till klienten, med avsändarnamn.
  void messageFrom (in string aMessageString, in string aSender);

 };

 // Vi definierar en typ clientlist som en vektor av strängar
 typedef sequence<string> clientlist;
 // I Javakoden blir clientlist ersatt med String[]

 //Meddelandecentralens gränssnitt.
 interface MessageBoardInterface {

  // Lägg till klient med namn och callbackobjekt.
  void addClientNamedCallbackObject (
      in string aName,
      in MessageClientInterface aCallbackObject);

  // Alla anslutna klienters namn.
  clientlist getClientNames ();

  // Skicka aMessageString till alla anslutna klienter, utan avsändarnamn.
  void broadcast (in string aMessageString);

  // Skicka aMessageString till alla anslutna klienter, med avsändarnamn.
  void broadcastFrom (in string aMessageString, in string aSender);

  // Är en klient med namnet aName ansluten till aktuell server?
  boolean includesClientNamed (in string aName);

  // Skicka aMessageString till (den anslutna) klienten clientNamed, utan avsändarnamn.
  void passMessageTo (in string aMessageString, in string clientNamed);

  // Skicka aMessageString till (den anslutna) klienten clientNamed, med avsändarnamn.
  void passMessageToFrom (
      in string aMessageString,
      in string clientNamed,
      in string aSender);

  // Ta bort klienten aName:s callbackrutin.
  void removeClientNamed (in string aName);

 };
};

Server

import MessageBoard.*;
import org.omg.CosNaming.*;
import org.omg.CosNaming.NamingContextPackage.*;
import org.omg.CORBA.*;
import java.util.*;

class MessageBoardServant extends _MessageBoardInterfaceImplBase {
 Hashtable clientsCatalogue = new Hashtable();

 public void addClientNamedCallbackObject (String aName, MessageClientInterface aCallbackObject) {
  clientsCatalogue.put(aName, aCallbackObject);
 }

    //Observera att clientlist blir String[] i Javakoden
 public String[] getClientNames (){
  String[] s;
  s = new String[clientsCatalogue.size()];
  int i = 0;
  for(Enumeration e = clientsCatalogue.keys(); e.hasMoreElements(); i++)
   s[i] = (String) e.nextElement();
  return s;
 }

 public void broadcast (String aMessageString){
  for(Enumeration e = clientsCatalogue.elements(); e.hasMoreElements(); )
   ((MessageClientInterface) e.nextElement()).message(aMessageString);
 }

 public void broadcastFrom (String aMessageString, String aSender){
  for(Enumeration e = clientsCatalogue.elements(); e.hasMoreElements(); )
   ((MessageClientInterface) e.nextElement()).messageFrom(aMessageString, aSender);
 }

 public boolean includesClientNamed (String aName){
  return clientsCatalogue.containsKey(aName);
 }

 public void passMessageTo (String aMessageString, String clientNamed){
  ((MessageClientInterface) clientsCatalogue.get(clientNamed)).message(aMessageString);
 }

 public void passMessageToFrom (String aMessageString, String clientNamed, String aSender) {
  ((MessageClientInterface) clientsCatalogue.get(clientNamed)).messageFrom(aMessageString, aSender);
 }

 public void removeClientNamed (String aName){
  clientsCatalogue.remove(aName);
 }
}

public class MessageBoardServer {

    public static void main(String args[])
    {
 try{
     // skapa och initiera ORB
     ORB orb = ORB.init(args, null);

     // skapa serverobjekt och registrera det i ORBen
     MessageBoardServant messageBoard = new MessageBoardServant();
     orb.connect(messageBoard);

     // skapa referens till namnserver
     org.omg.CORBA.Object objRef =
  orb.resolve_initial_references("NameService");
     NamingContext ncRef = NamingContextHelper.narrow(objRef);

     // bind objektet till namnet "messageBoard"
     NameComponent nc = new NameComponent("messageBoard", "");
     NameComponent path[] = {nc};
     ncRef.rebind(path, messageBoard);

     // vänta på klienter
     java.lang.Object sync = new java.lang.Object();
     synchronized (sync) {
         sync.wait();
     }

 } catch (Exception e) {
     System.err.println("ERROR: " + e);
     e.printStackTrace(System.out);
 }
}
}

Klient

import MessageBoard.*;
import org.omg.CosNaming.*;
import org.omg.CORBA.*;
import java.io.*;

class MessageClientListener extends _MessageClientInterfaceImplBase {
 protected String name;
 public MessageClientListener(String aName){
  name = aName;
 }

 public void message (String aMessageString){
  messageFrom (aMessageString, "");
 }

 public void messageFrom (String aMessageString, String aSender) {
  System.out.println(name + ":" + aMessageString + "|" + aSender);
 }
}

public class MessageBoardClient {

 public static void main(String args[])
 {
 try{
  // skapa och initiera ORB
  ORB orb = ORB.init(args, null);

  // skapa referens till namnserver
  org.omg.CORBA.Object objRef =
   orb.resolve_initial_references("NameService");
  NamingContext ncRef = NamingContextHelper.narrow(objRef);

  // bind objektet till namnet "messageBoard"
  NameComponent messageBoardName = new NameComponent("messageBoard", "");
  NameComponent path[] = {messageBoardName};

  MessageBoardInterface messageBoard = MessageBoardInterfaceHelper.narrow(ncRef.resolve(path));

  // skapa och registrera callbackobjekt
  String name = args[0]; //namnet ges vid start av klienten
  MessageClientListener clientListener = new MessageClientListener(name);
  orb.connect(clientListener);

  messageBoard.addClientNamedCallbackObject(name, clientListener);

  BufferedReader in = new BufferedReader(new
                                         InputStreamReader(System.in));
  for(;;) {
   System.out.print(">");
   String line = in.readLine();
   if((line == null) || line.equalsIgnoreCase("quit")) break;
   try {
    messageBoard.broadcastFrom(name, line);
   }
   catch(Exception e) {System.out.println("Fel!");}
  }
  messageBoard.removeClientNamed(name);
 } catch (Exception e) {
  System.err.println("ERROR: " + e);
  e.printStackTrace(System.out);
 }
 }
}


^ Upp till kursens hemsida.


Sidansvarig: <bjorne@nada.kth.se>
Senast ändrad 21 april 1999