7. Entwicklungsablauf einer RMI-Umgebung

1. Definition des Remote Interface

Jedes Remote Interface erweitert, direkt oder indirekt, das Interface java.rmi.Remote, welches selbst keine Methoden definiert. Das Interface und seine Methoden müssen public sein. Jede Methode eines Remote Interface muß (neben anwendungsspezifischen Exceptions) die Basisklasse java.rmi.RemoteException im Exception-Teil des Methodenkopfes enthalten, um die Robustheit gegenüber jeglichen Kommunikationsproblemen sicherzustellen.

Der Quellcode für Hello.java:

	package examples.hello;
	
	public interface Hello extends java.rmi.Remote {
		String sayHello() throws java.rmi.RemoteException;
	}

2. Implementierung des Remote Interface (Server)

Um ein entferntes Objekt zu schreiben, muß man nun eine Klasse schreiben, die ein oder mehrere Remote Interfaces implementiert, dazu muß man:

1. Alle Remote Interfaces spezifizieren, welche sie implementiert
2. Die Klasse UnicastRemoteObject direkt oder indirekt erweitern. Sie erbt somit die Methoden der Klassen RemoteObject und RemoteServer.
3. Den Konstruktor der Klasse UnicastRemoteObject aufrufen (default). (Da auch bei der Instanzierung eines neuen Objekts Kommunikationsfehler auftreten können, muß auch der Konstruktor die Klasse java.rmi.RemoteException erweitern).
4. Alle im Remote Interface spezifizierten Methoden implementieren. Darüber hinaus kann sie Methoden implementieren, die nicht im Remote Interface angegeben sind, diese sind dann jedoch nur lokal verfügbar.
5. Entweder den RMI- oder einen benutzerdefinierten SecurityManager installieren.
6. Zumindest eine Instanz des entfernten Objekts erzeugen und an die RMI Registry binden, um auf Methodenaufrufe zu warten und diese entgegenzunehmen.

Code für das Beispiel:

	package examples.hello;

	import java.rmi.*;
	import java.rmi.server.UnicastRemoteObject;

Das erben von der Klasse UnicastRemoteObject gibt an, daß HelloImpl eine Klasse ist, deren Instanzen die standard-socketbasierte RMI Kommunikation benutzen. Um ein entferntes Objekt aus einer Klasse, die nicht dafür gedacht wurde, zu erzeugen, muß durch Aufruf der Methode UnicastRemoteObject.exportObject dieses explizit als entferntes Objekt kennzeichnen.

	public class HelloImpl 
		implements Hello						// 1.)
		extends UnicastRemoteObject					// 2.)
	{
		private String name;

Der Konstruktor einer Klasse für entfernte Objekte unterscheidet sich nicht von dem einer lokalen Klasse.

		public HelloImpl(String s) throws RemoteException {
			super();						// 3.)
			name = s;
		}

Argumente und Rückgabewerte von entfernten Methoden können alle Datentypen oder Objekte sein, solange sie das Interface java.io.Serializable implementieren. Es können hier auch Methoden definiert werden die nicht im Remote Interface deklariert wurden, diese können jedoch nur lokal aufgerufen werden.

		public String sayHello() throws RemoteException {		// 4.)
			return  "Hello World!";
		}

Die Installation eines SecurityManagers ist notwendig, damit entfernte Klassen geladen werden können.

		public static void main(String args[]) {
			// Erzeugen und installieren des SecurityManagers	// 5.)
			System.setSecurityManager(new RMISecurityManager());

Das RMI System benutzt zum laden von Klassen eine URL-basierte Registry, d.h. eine URL der Form //host/Objektname wird an das entfernte Objekt gebunden. Aufrufe können jetzt das Objekt an ihrem Namen identifizieren und bekommen eine Referenz auf dieses entfernte Objekt, und können nun dessen Methoden aufrufen.

			try {
				HelloImpl obj = new HelloImpl("HelloServer");	//6.)
				Naming.rebind("//192.168.1.1/HelloServer", obj);
				System.out.println("HelloServer bound in registry");
			} catch (Exception e) {
				System.out.println("HelloImpl err: " + e.getMessage());
				e.printStackTrace();
			}
		}
	}

3. Entwicklung des Client-Programms

Das Client Programm kann jede Art von Java-Programm (Applet oder Applikation) sein, solange es die entfernten Objekte aufruft.

In diesem Beispiel ist es ein Applet:

	package examples.hello;

	import java.awt.*;
	import java.rmi.*;

	public class HelloApplet extends java.applet.Applet {
		String message = "";
		public void init() {
			try {

Das Applet holt sich zuerst eine Referenz auf das entfernte Objekt, indem es in der Registry nachschaut. Dann kann es auf die entfernte Methode zugreifen.

				Hello obj = (Hello)Naming.lookup("//" +
					getCodeBase().getHost() + "/HelloServer");
				message = obj.sayHello();
			} catch (Exception e) {
				System.out.println("HelloApplet exception: " +
					e.getMessage());
				e.printStackTrace();
			}
		}
		public void paint(Graphics g) {
			g.drawString(message, 25, 50);
		}
	}

4. Kompilierung der Quelltexte: Remote Interface, Server, Client

Die Quellcode-Dateien sollten sich nun im Basisverzeichnis des Projekts befinden. Jetzt geht es an das kompilieren, dies geschieht durch den Aufruf:

javac -d c:\rmi\examples *.java

Dadurch werden die Unterverzeichnisse examples\hello im Basisverzeichnis c:\rmi\examples erzeugt, und die Klassendateien dorthin kompiliert.

5. Generierung von Stub und Skeleton

Der rmic-Compiler wird aufgerufen mit der Implementationsklasse (Server) des entfernten Objekts. Dadurch werden die Stub- und die Skeletondateien erzeugt. Der erzeugte Stub implementiert exakt den gleichen Satz von Interfaces wie das Remote Object und sind typidentisch.

Aufruf:

rmic –d c:\rmi\examples examples.hello.HelloImpl

Der d-Parameter gibt hier wieder das Basisverzeichnis an, von dem ausgehend die Stub- und die Skeletondatei in das Verzeichnis examples\hello erzeugt werden.