Ik heb een voorbeeld gebakken

.
Allereerst moet je natuurlijk een interface voor een server hebben. Deze is heel simpel:
code:
1
2
3
4
5
6
7
| import java.rmi.Remote;
import java.rmi.RemoteException;
public interface Server extends Remote
{
public void addListener(Listener listener) throws RemoteException;
} |
Je kunt dus alleen maar Listeners aanmelden.
Deze listeners zien er als volgt uit:
code:
1
2
3
4
5
6
7
| import java.rmi.Remote;
import java.rmi.RemoteException;
public interface Listener extends Remote
{
public void sendMessage(String message) throws RemoteException;
} |
.
Ook simpel dus

.
Nu maken we een implementatie van de server. Deze is ietsje groter.
code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
| import java.rmi.Remote;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
import java.util.ArrayList;
import java.util.List;
import java.util.Iterator;
public class ServerImpl extends UnicastRemoteObject implements Server
{
private List listeners;
public ServerImpl() throws RemoteException
{
super();
listeners = new ArrayList();
}
public void addListener(Listener listener) throws RemoteException
{
synchronized(listeners)
{
listeners.add(listener);
}
}
public void sendMessage(String message)
{
synchronized(listeners)
{
Iterator iterator = listeners.iterator();
while(iterator.hasNext())
{
Listener listener = (Listener) iterator.next();
try
{
listener.sendMessage(message);
}
catch(Exception exc)
{
}
}
}
}
} |
De code spreekt voor zich denk ik. Super makkelijk

.
Nu maken we een simpele ListenerImpl:
code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| import java.rmi.Remote;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
public class ListenerImpl extends UnicastRemoteObject implements Listener
{
public ListenerImpl() throws RemoteException
{
super();
}
public void sendMessage(String message) throws RemoteException
{
System.out.println("Incoming message: " + message);
}
} |
Je moet de ListenerImpl en de ServerImpl even door rmic heenhalen:
rmic ListenerImpl
rmic ServerImpl
Dan worden er stubs gegeneerd voor deze remote objecten.
Nu nog even een simpele client applicatie die je kan starten:
code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
| import java.rmi.Naming;
import java.rmi.registry.Registry;
public class ClientApplication
{
public static void main(String[] ps)
{
try
{
Server server = (Server) Naming.lookup(getNamingURL());
server.addListener(new ListenerImpl());
}
catch(Exception exc)
{
exc.printStackTrace();
}
}
private static String getNamingURL()
{
return "//localhost:" + Registry.REGISTRY_PORT +"/pandoramix/rmi-server";
}
} |
Uiteraard moet de server ook gestart kunnen worden en moet er nog iets verzonden worden

. De server moet je starten voor de clients.
code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
| import java.rmi.Naming;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
public class ServerApplication
{
public static void main(String[] ps)
{
try
{
LocateRegistry.createRegistry(Registry.REGISTRY_PORT);
ServerImpl server = new ServerImpl();
Naming.rebind(getNamingURL(), server);
while(true)
{
Thread.currentThread().sleep(5000);
server.sendMessage("Hey, the time is: " + System.currentTimeMillis());
}
}
catch(Exception exc)
{
exc.printStackTrace();
}
}
private static String getNamingURL()
{
return "//localhost:" + Registry.REGISTRY_PORT +"/pandoramix/rmi-server";
}
} |
Ok. Je kunt het zaakje dus draaien door even te compileren, rmic eroverheen te halen en een ServerApplication te starten. Daarna kan je meerdere ClientApplications starten en de communicatie werkt perfect
Viel best mee he?

.
Je kind in de Listener zelf methoden opnemen voor verschillende meldingen die je wilt doen. Uiteraard moet je in een echte applicatie ook even netter rekening houden met het afmelden van listeners op de server

.