CORBA mit Java: Server, Client und Name Service im Überblick

CORBA mit Java: Server, Client und Name Service

Server-Paket und Imports

SERVER: Server-Paket; Import

java.util.Scanner;

import org.omg.CORBA.ORB;
import org.omg.CosNaming.NameComponent;
import org.omg.CosNaming.NamingContextExt;
import org.omg.CosNaming.NamingContextExtHelper;
import org.omg.PortableServer.POA;
import org.omg.PortableServer.POAHelper;

Main-Methode und Initialisierung des ORB

public static void main(String[] args) {
  Server manager = new Server(args);
  manager.publicarEnNS();
  manager.start();
}

Klasse Server

public class Server extends Thread {
  DispensadorCorba dispasc;
  ORB orb;
  POA rootpoa;

public static Server(String[] args) throws Exception {
  // Initialisieren des ORB
  orb = ORB.init(args, null);
  try {
    // Objekt-Referenz holen und auf RootPOA narrowen
    rootpoa = POAHelper.narrow(orb.resolve_initial_references("RootPOA"));
    // Aktivieren des POA-Managers zur Behandlung von Aufrufen
    rootpoa.the_POAManager().activate();
  } catch (Exception e) {
    e.printStackTrace();
  }
  // Objekt instanziieren
  dispasc = new DispensadorCorba(5);
}

Klasse DispensadorCorba und Aufzug

Package Server; import interfaz.*;

public class Elevator extends DispensadorPOA {
  Aufzug[] aufzuege;
  int numAscensores;

public DispensadorCorba(int numasc) {
  aufzuege = new Aufzug[numasc];
}

Klasse AscensorCorba:
public class AscensorPOA extends AscensorCorba {
  public AscensorCorba(int num) {
    tuer = new Tuer();
  }
}

Klasse Puerta (Door):
public class Tuer implements Serializable {
  public void open() {}
  public void close() {}
}

public int getPiso() {}
public synchronized void ir(int pisodest) {}
private void down(int pisodest) {}
private void raise(int pisodest) {}

for (int i = 0; i < numAscensores; i++) {
  try {
    // Objekt instanziieren
    AscensorCorba aufzug = new AscensorCorba(i);
    // Verweis auf den Diener holen
    org.omg.CORBA.Object ref = Servidor.rootpoa.servant_to_reference(aufzug);
    aufzuege[i] = AscensorHelper.narrow(ref);
  }
}

public Aufzug(int id) {
  return aufzuege[id];
}

Methode publicarEnNS

public void publicarEnNS() {
  try {
    // Zugriff auf den Root-Kontext des Name Service
    NamingContextExt root = NamingContextExtHelper.narrow(orb.resolve_initial_references("NameService"));
    // Referenz des Dieners holen
    org.omg.CORBA.Object ref = rootpoa.servant_to_reference(dispasc);
    NameComponent path[] = root.to_name("Spender");
    // dispasc unter dem Namen "Spender" im NameService binden
    root.rebind(path, ref);
  } catch (Exception e) {
    e.printStackTrace();
  }
}

Methode run

public void run() {
  // Wir bleiben bis zu Zugriffen aktiv
  orb.run();
}

CLIENT

CLIENT: Client-Paket; Import

Client Alter; import org.omg.CORBA.*; import interfaz.*; import org.omg.CosNaming.*; import java.util.Scanner; import interfaz.Ascensor;

public static void main(String[] args) {
  ControlRemoto manager = new ControlRemoto(args);
  manager.controlar();
}

public class Fernwartung {
  Dispenser disp;
  Fahrstuhl asc;

public Fernwartung(String[] args) throws Exception {
  ORB orb = ORB.init(args, null);
  try {
    org.omg.CORBA.Object objRef = orb.resolve_initial_references("NameService");
    NamingContextExt ncRef = NamingContextExtHelper.narrow(objRef);
    String name = "Spender";
    disp = DispensadorHelper.narrow(ncRef.resolve_str(name));
  }
}

public void controlar() throws Exception {
  asc = getAscensorControlar();
  option = menu();
  asc.ir(pisodest);
}

private Ascensor getAscensorControlar() {
  System.out.println("Geben Sie die Steuerungsfunktion des Aufzugs ein: ");
  return disp.getAscensor(id);
}

Schnittstellen und Grundbegriffe

Schnittstellen

Beweis: Java-Schnittstelle, die die Remote-Objekte beschreibt. Sie wird verwendet, um Verweise zu enthalten, die CORBA.Implementa Test und die CORBA-Objektklasse erweitern, die vom Client verwendet werden.

PruebaHolder: Hilft, die Parameterübergabe für Argumente vom Typ in, out und inout umzusetzen, die nur durch Wert übergeben werden können.

PruebaHelper: Enthält nur statische Methoden für eine Reihe spezifischer Operationen.

Im Naming Service erhält man die Referenz eines CORBA-Objekts. Dabei wird die Typumwandlung, die sogenannte Verengung (Narrowing), benötigt.

narrow(): Eine Art Casting, das Referenzen an die passenden Objekte anpasst.

PruebaOperations: Java-Schnittstelle, die die Definitionen der Methoden gemäß dem IDL-Typ-Mapping für Java enthält, einschließlich Operationen und Ausnahmen.

PruebaPOA (Skeleton) und PruebaPOATie.java: Implementieren PruebaOperations und sind die Klassen, die den Diener umhüllen. Sie erweitern diesen, um eine Referenz von einem Objekt zu einem Diener zu bringen.

_PruebaStub: Vermittler auf Client-Seite, der Remote-Objekte zugänglich macht und die Methoden in Byte-Arrays umwandelt.

Sprache IDL: Die IDL-Sprache ist eine neutrale Sprache zur Definition von CORBA-Objekten. Die IDL-Definitionen werden von einem Compiler in die verwendete Programmiersprache umgewandelt. Diese Umwandlungen sind ebenfalls in CORBA spezifiziert, jedoch ist es Sache jedes ORB, welche Dateien erstellt werden.

Name Service: Wie in jedem verteilten System bietet CORBA mit dem Name Service die Möglichkeit, Referenzen auf Objekte über CORBA-basierte Namen zu finden. Ein Name besteht aus mehreren Komponenten, wobei jede Komponente einen Bezeichner (Kennzeichen) und einen Schlüssel besitzt. Die Namen sind in einem Graphen organisiert. Jeder Knoten ist ein Objekt, der Namenskontext genannt wird und eine Tabelle speichert, welche die Beziehung zwischen Namen und Referenzen festhält.

Servant: Eine Einheit in einer Programmiersprache, die den Code der IDL-Schnittstellenoperationen implementiert.

CORBA Object Reference: Enthält die Identität eines CORBA-Objekts, die ein Client für Anfragen an Operationen verwendet.

CORBA-Objekt:

• Virtuelle Entitäten, mit denen wir über einen ORB kommunizieren können. Sie werden durch eine Implementierung verkörpert.
• Diese Implementierung kann ein Objekt einer Programmiersprache oder eine andere Konstruktion sein, die ein Diener aufruft.
• Die Anwendung, die ein oder mehrere Objekte besitzt, nennen wir Server.

POA (Portable Object Adapter):

• 1. Erhält der ORB eine Nachricht, leitet er diese an den POA weiter, der das Objekt verwaltet, an das die Nachricht gerichtet ist (die Objektreferenz verbindet ein Objekt mit einem Diener).
• 2. Der POA muss wissen, welcher Diener jedes CORBA-Objekt verkörpert. Bei jeder eintreffenden Nachricht muss sie an das Skelett des passenden Dieners weitergeleitet werden.

Der POA erzeugt die "Illusion" von CORBA-Objekten für Clients; das gesendete Objekt ist nur eine virtuelle Entität, die in einem Diener verkörpert ist. Um das tatsächliche Ziel, also den verkörpernden Diener, zu bestimmen, besitzt der POA eine Tabelle namens Active Object Map, in der diese Informationen gespeichert werden.