# RMI wie kann ich objekte übergeben?



## Anselmus (19. Apr 2005)

hi folks,

wie kann ich denn mit RMI objekte der implementierenden klasse übergeben?

also mal ein beispiel um das problem zu verdeutlichen:

interface:

```
package examples.car;


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

public interface carIFace extends Remote {
	int setCar() throws RemoteException;
	int showCar() throws RemoteException;		
}
```

implementierende klasse:

```
package examples.car;


import java.rmi.Naming;
import java.rmi.RemoteException;
import java.rmi.RMISecurityManager;
//import java.rmi.MarshalledObject;
import java.rmi.server.UnicastRemoteObject;
import java.io.*;

public class carImpl extends UnicastRemoteObject implements carIFace{
	
	String carName;
	String topV;
	
	public carImpl() throws RemoteException
	{
		super();
	}
	
	public int setCar()
	{
		System.out.println("Name:");
		try
		{
			BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
			carName = input.readLine();
			System.out.println("Top Speed:");
			topV = input.readLine();
			return 0;
		}
		catch (Exception e)
		{
			System.out.println("Input Error");
			return -1;
		}
	}
	
	public int showCar()
	{
		System.out.println("Name: " + carName);
		System.out.println("Top V: " + topV);
		return 0;
		
	}
	
	public static void main(String[]args)
	{
		if(System.getSecurityManager() == null)
		{
			System.setSecurityManager(new RMISecurityManager());
		}
		try
		{
			carImpl a_object = new carImpl();
			Naming.rebind("//localhost/CarServer", a_object);
			System.out.println("CarServer is now registered");
		}
		catch (Exception e)
		{
				System.out.println("Unable to register CarServer");
		}
	}
}
```


jetzt will ich aber nicht nur eine methode mit rückgabewert benutzen, sondern will ein ganzes car-objekt zurückhaben, so daß ich auch zb setCar  und showCar ausführen kann (die ja eigentlich keinen rückgabewert haben... ich hab denen mal int gegeben, weils halt das iface verlangt hat)...

wie kann ich das machen? habs mal mit marshalledobject probiert aber ich weiß nicht ob das der richtige weg ist...

viele grüße
stephan


----------



## Guest (20. Apr 2005)

Mach' das Ding serialisierbar und gut ist. Es muss sowohl clientseitig wie auch serverseitig bekannt sein (in classpath).
z.B.

```
public class Car implements Serializable {
  private static final long serialVersionUID = .....; 
  ...
  public Car() {
    ...
  }
  ...
}
```
Das Interface aus deinem Code würde ich noch überdenken.
Was soll man damit?
	
	
	
	





```
int setCar() throws RemoteException;
```
Es müsste schon irgendein Car übergeben werden. Bedenke, dass das ganze auf dem Server läuft und nicht auf dem Client.
Es sei dann, da sitzt einer und gibt ständig was über die Console ein. :lol:


----------



## zubi (25. Mai 2005)

> Mach' das Ding serialisierbar und gut ist. Es muss sowohl clientseitig wie auch serverseitig bekannt sein (in classpath).



Dazu hab' ich eine Frage: Wenn ich eine abstrakte Klasse Test im Client definiere (welche Serializable implementiert), daraus die Klasse TestA ableite und von dieser eine Instanz an ein Remote-Objekt übergeben will, muss dem Server wie du schreibst die Klasse bekannt sein. Wieso genügt es nun nicht, dass ich ihm die abstrakte Klasse in den classpath lege? Die Methodenaufrufe auf dem Server sollen polymorph stattfinden, d.h. er erwartet ein Objekt vom Typ Test.

Ich erhalte folgende Exception: 
Exception: error unmarshalling arguments; nested exception is: java.lang.ClassNotFoundException


Muss ich mit einem Interface arbeiten, da somit sichergestellt wird, dass alle Schnittstellen implementiert werden oder sollte das mit meinem Ansatz funktionieren?

gruss
zubi


----------



## Bleiglanz (26. Mai 2005)

zubi hat gesagt.:
			
		

> > Mach' das Ding serialisierbar und gut ist. Es muss sowohl clientseitig wie auch serverseitig bekannt sein (in classpath).
> 
> 
> 
> Wieso genügt es nun nicht, dass ich ihm die abstrakte Klasse in den classpath lege? Die Methodenaufrufe auf dem Server sollen polymorph stattfinden, d.h. er erwartet ein Objekt vom Typ Test.



Weil Serialisierung auf Instanzebene arbeitet!

du kannst nicht eine Klasseninstanz x von X, die von der Klasse Y erbt in ein byte[] verwandeln,  und dieses byte[] dann in ein Y deserialisieren...

Wenn Y abstrakt ist, dann erst recht -> denn von abstrakten Klassen gibts keine Instanzen


----------



## Anselmus (30. Mai 2005)

hatte das problem schon gelöst. wollt ih rnoch weiterdiskutieren, sonst mach ich ein häkchen dran...?


----------



## stev.glasow (30. Mai 2005)

Wenn das Problem gelöst wurde mach ruhig schon ein Häkchen ran, man kann ja auch mit Hälchen noch weiter posten.
So ist es zumndest gedacht.


----------

