|
|
|
JSP meets Middleware (RMI)
|
| von shark, 14.07.2001 15:31:08 |
  (9 votes) [vote] |
Neben CORBA ist RMI (Remote Method Invocation) eine gute Alternative für die Realisierung von verteilten Anwendungen. RMI hat eine sehr enge Bindung an die Programmiersprache Java und kann nicht wie CORBA mit anderen Programmier-sprachen verwendet werden. CORBA und RMI basieren auf dem Prinzip der entfernten Prozeduraufrufe (Remote Procedure Calls). Das Prinzip der entfernten Prozeduraufrufe (Kommunikation von Client zu Server über Stubs) wurde im CORBA Teil der Artikelserie bereits beschrieben und trifft auch für RMI zu.
Damit zwei Programme über das Netzwerk miteinander kommunizieren können benötigt, man wie bei CORBA Systemen einen ORB. Im Falle von RMI ist es der Service "rmiregistry", der Teil des JDKs ist. Ein RMI-Server meldet sich bei der RMI-Registry an und veröffentlicht seine Methoden, die er als Services bereitstellt, damit ein RMI-Client auf die Services zugreifen kann.
Ein RMI Programm schreibt man folgendermaßen:
------------------------------------------------------------------------
- Definition der Schnittstelle zwischen dem Client und dem Server
- Entwicklung des Servers und Implementierung des Dienstes, der Server meldet den Dienst an und verwaltet den Dienst
- Realisierung des Clients, welcher den Dienst des Servers benutzt
Schnittstelle zwischen dem Client und dem Server:
-------------------------------------------------------------------------
package RemoteHelloWorld;
import java.rmi.*;
public interface RemoteHello extends Remote
{
public String getHello() throws RemoteException;
}
Server der den Dienst "getHello()" anbietet:
--------------------------------------------------------------
package RemoteHelloWorld;
import java.rmi.*;
import java.rmi.server.*;
public class HelloServer extends UnicastRemoteObject implements RemoteHello
{
// Standard Konstruktor
public HelloServer() throws RemoteException
{
super();
}
// Hello World Service
public String getHello()
{
return("Hello World!");
}
// Server Hauptroutine
public static void main(String args[])
{
try
{
// Security Manager erzeugen und setzen
RMISecurityManager oSecManager = new RMISecurityManager();
System.setSecurityManager(oSecManager);
// Server Instanz erzeugen
HelloServer oHelloServer = new HelloServer();
// Server bei der Registry anmelden
Naming.rebind("GetHello", oHelloServer);
System.out.println("Hello Server wartet auf Anfragen");
}
catch(Exception ex)
{
ex.printStackTrace();
}
}
}
Der Server stellt den Dienst "getHello()", den ein Client aufrufen kann, zur Verfügung. In der Hauptroutine des Servers wird ein SecurityManager erzeugt. Der SecurityManager unterstützt das Laden der dynamischen Objekte und die Anmeldung an der RMI-Registry (Socket Access). Die Zugriffsrechte werden über eine Policy-Datei definiert, die beim Start des Servers angegeben werden muss.
Policy-Datei (rmi.policy):
-----------------------------------
grant
{
permission java.net.SocketPermission "*", "accept,listen,connect,resolve";
};
Der Client ist eine Java Klasse, die in eine JSP Seite eingebunden werden kann. Der Client setzt sich aus zwei Methoden zusammen: "connectServer()" und "getHello()".
Client der in einer JSP-Seite aufgerufen werden kann:
----------------------------------------------------------------------------
package RemoteHelloWorld;
import java.rmi.*;
import java.rmi.server.*;
public class HelloClient
{
// Remote Interface
private RemoteHello oHello;
// Verbindung zum RMI Server aufbauen
public void connectServer()
{
try
{
// Service ermitteln
oHello = (RemoteHello) Naming.lookup("//localhost/GetHello");
}
catch(Exception ex)
{
ex.printStackTrace();
}
}
// Methode des Clients zum Aufrufen der Service Methode
public String getHello()
{
String strHelloWorld = null;
try
{
// Service aufrufen
strHelloWorld = oHello.getHello();
}
catch(Exception ex)
{
ex.printStackTrace();
}
// Rueckgabe des Ergebnisses
return(strHelloWorld);
}
}
Im Client wird kein SecurityManager benötigt. Das Lookup wird über die Methode "Naming.lookup(..)" durchgeführt. Wenn der Server nicht auf der gleichen Maschine wie der Client läuft, muss der String "localhost" durch den Namen der Maschine auf dem der Server läuft ersetzt werden. Der Service "getHello" wird im Server unter dem Namen "GetHello" bei der RMI-Registry registriert.
JSP-Seite:
---------------
<%@ page language= "java" contentType="text/html"%>
<%@ page import = "RemoteHelloWorld.HelloClient"%>
<%
try
{
// Client Objekt erzeugen
HelloClient oHelloClient = new HelloClient();
// Verbindung zum Server aufbauen
oHelloClient.connectServer();
// Aufruf der Service Methode und Ausgabe des Eregbnisses
out.println(oHelloClient.getHello());
}
catch(Exception ex)
{
ex.printStackTrace();
}
%>
Nachdem man die Java Klassen realisiert hat (Interface, Server und Client), übersetzt man die Dateien in Java Klassendateien (javac *.java). Nach dem Übersetzungsvorgang erzeugt man mit dem Werkzeug "rmic" die entsprechenden Stubs für die Kommunikation über das Netzwerk.
Aufruf:
----------
rmic -d . RemoteHelloWorld.RemoteServer
Nach dem Aufruf werden die zwei Klassendateien (Stub und Skeleton) für die Kommunikation über das Netzwerk erzeugt ("HelloServer_Stub.class" und "HelloServer_Skel.class").
Die Klassendateien (Interface, Server, Client, Stub, Skeleton) müssen im Classpath unter dem Packageverzeichnis liegen, in unserem Fall ist es das Verzeichnis "RemoteHelloWorld".
Nach dem Übersetzen startet man das RMI-System in einer DOS-Box:
------------------------------------------------------------------------------------------------------
(1) start rmiregistry
(2) start java -Djava.security.policy=rmi.policy RemoteHelloWorld.HelloServer
(3) Nach dem Starten des Servers kann die JSP-Seite im Browser ausgeführt werden. Das Ergebnis im Browser sollte die Ausgabe "Hello World!" sein.
Die JSP-Seite muss, um ausgeführt zu werden, im virtuellen Verzeichnis des WEB-Servers liegen.
Dieses Beispiel zeigt, wie über RMI mit entfernten Servern kommuniziert werden kann. RMI öffnet auch den Weg in die CORBA Welt, weil Sun Microsystems (TM) eine "RMI over IIOP" Bridge realisiert hat. Die "RMI over IIOP" Bridge ermöglicht es auch, dass von einer nicht Browser Anwendung auf CORBA-Services zugegriffen werden kann. Weitere Informationen hierzu findet man über die Links: http://java.sun.com/rmi und http://java.sun.com/rmi-iiop |
|
|
Hinweis: Auf dieser Seite liegen Links zu anderen Seiten im Internet. Für alle diese Links gilt: Wir
betonen ausdrücklich, daß wir keinerlei Einfluß auf die Gestaltung und die Inhalte der gelinkten Seiten
haben. Deshalb distanzieren wir uns hiermit ausdrücklich von allen Inhalten aller gelinkten Seiten auf
dieser Homepage und machen uns ihre Inhalte nicht zueigen. Diese Erklärung gilt für alle auf unserer
Homepage angebrachten Links
Redaktion/Betreiber von JSP-Develop übernehmen keinerlei Gewährleistung und Verantwortung für die Richtig-
und/oder Vollständigkeit von den auf den Webseiten JSP-Develop veröffentlichten Source Codes.
Die Verantwortung der Verwendung/Anwendung sowie etwaige Modifikation der hier veröffentlichten Sourcen
obliegt einzig dem Benutzer der Webseite, welche die veröffentlichten Sourcen in einer Applikation/Anwendung
einsetzt. Durch das Kopieren und/oder Benutzen der Sourcen in einer Applikation/Anwendung
bzw. etwaigen Abschriften wird dieser Rechtshinweis anerkannt.
Java, JSP, JavaServer Pages, J2EE, EJB, JDBC, JNDI, JTA, Sun, Sun Microsystems are trademarks or registered trademarks of Sun Microsystems, Inc. in the United States and in other countries.
IBM, WebSphere are trademarks or registered trademarks of International Business Machines Corporation.
Other trademarks and registered trademarks are the property of their respective owners.
|
|
|
|
