# Mit RMI Server: Methodenaufruf Client zuordnen



## tuxedo (4. Okt 2007)

Servus,

ich stehe gerade vor dem Problem dass ich mit meinem RMI Server nicht weiß welcher Client die jeweilige Servermethode aufruft...

Folgendes Szenario:

Der Client holt sich das RMI Serverobjekt und ruft damit eine Login-Methode am Server auf. Als Argument übergibt der Client der Methode ein Callback-Objekt gemäß folgendem Interface:


```
public interface ClientCallback extends Remote {....}
```

Das funktioniert prima. Der Server kann dann mit diesem Objekt Methoden beim Client aufrufen. Soweit so gut.
Wenn sich der Client nun ausloggen möchte ruft er eine Logout-Methode im Serverobjekt auf. 

Aber woher weiß jetzt der Server welcher Client die Methode aufgerufen hat? Kann mir irgendwie nicht vorstellen, dass der Client immer seine ID als Argument übergeben muss damit der Server weiß woher der Aufruf kommt.

Was mich auch gerade etwas verwirrt: Hab ich mit RMI multiple Serverobjekt-Instanzen (jeder Client erhält eine eigene Instanz) oder greifen alle verbundenen Clients auf ein und dasselbe Objekt zu? 

*verwirrt bin*

Kann mir da jemand helfen?


Gruß
Alex

[update]

okay, scheinbar gibt es nur eine einzige Serverobjekt-Instanz die alle Clients erhalten (hab die String-Repräsentation des Rmi-Serverobjekts bei mehreren verbundenen Clients verglichen).


----------



## Niki (4. Okt 2007)

Wenn du das Remote Objekt in der Registry registrierst bekommt jeder Client das SELBE Objekt. Damit jeder Client sein eigenes Objekt hat brauchst du ein weiteres Remote Objekt. Dieses wird jedoch nicht in der Registry hinterlegt, sondern vom Remote Objekt, welches in der Registry liegt, zurück gegeben. Das heißt das Objekt in der Registry ist nur ein Session-Objekt erzeuger. Java ist so klug und erkennt dass die Methode vom Remote-Objekt der Registry von einer anderen VM aufgerufen worden ist und liefert dir daher den Stub des eigentlichen Session-Objekts zurück.
Damit der Ablauf ein wenig verständlicher ist:

RemoteObjekt1 hat Methode: Session getNewSession();
Session ist RemoteObjekt2
Server registriert RemoteObjekt1 in Registry
Client holt RemoteObjekt1 vom Server und ruft getNewSession auf, der Server erkennt, dass er den Stub zurück geben muss und liefert dem Client ein neues Session Objekt (also den Stub).
Der Client hat jetzt sein eigenes Session Objekt mit dem er am Server arbeiten kann. Falls du Code Beispiele brauchst sag bescheid, dann werd ich schnell mal eins runter klopfen!


----------



## tuxedo (4. Okt 2007)

Ja, Codebeispiele wären nett....

Ein einfaches Gerüst würde ja reichen.

thx,

Alex


----------



## Niki (4. Okt 2007)

Bitte sehr:

```
package server;

import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;

public class Server {
	public static void main(String[] args) throws Exception {
		SessionFactory factory = new SessionFactoryImpl();
		Registry reg = null;
		try {
			reg = LocateRegistry.getRegistry(1099);
			reg.rebind(SessionFactory.SERVICE_NAME, factory);
		} catch (Exception ex) {
			reg = LocateRegistry.createRegistry(1099);
			reg.bind(SessionFactory.SERVICE_NAME, factory);
		}
		while(true){
			System.gc();
			Thread.sleep(10000);
		}
	}
}


package server;

import java.rmi.Remote;

public interface Session extends Remote {
	
}


package server;

import java.rmi.Remote;
import java.rmi.RemoteException;

public interface SessionFactory extends Remote{
	public Session getNewSession() throws RemoteException;
	
	public static final String SERVICE_NAME = "SessionFactory";
}


package server;

import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;

public class SessionFactoryImpl extends UnicastRemoteObject implements SessionFactory {
	public SessionFactoryImpl() throws RemoteException{
		
	}
	
	public Session getNewSession() throws RemoteException {
		return new SessionImpl();
	}
}


package server;

import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;

public class SessionImpl extends UnicastRemoteObject implements Session {
	public SessionImpl() throws RemoteException{

	}	
}


package client;

import server.Session;

public class Client {

	/**
	 * @param args
	 */
	public static void main(String[] args) throws Exception{
		Session session = ServerSessionFactory.getSession();
		System.out.println(session);

	}

}


package client;

import java.rmi.Naming;

import server.Session;
import server.SessionFactory;

public class ServerSessionFactory {
	
	
	private static SessionFactory factory = null;
	
	public static String host = "localhost";
	
	public static int port = 1099;
	
	private static synchronized SessionFactory getSessionFactory() throws Exception{
		if(factory == null)
			factory = (SessionFactory)Naming.lookup("//" + host + ":" + port + "/" + SessionFactory.SERVICE_NAME);
		return factory;
	}
	
	public static Session getSession() throws Exception{
		return getSessionFactory().getNewSession();		
	}
}
```


----------



## tuxedo (4. Okt 2007)

Vielen Dank. Ich werd's mir jetzt mal zu Gemüte führen...

thx,
Alex


----------



## tuxedo (4. Okt 2007)

So, angesehen und verstanden.. Ist ja eigentlich recht easy. Einfach im äußeren RMI-Server-Objekt ein weiteres Remote-Objekt zurückgegen lassen. Jo, vielen dank nochmal für das Codebeispiel.



- Alex


----------

