1 Jini Tutorial, Part 3 Jini Programming. 2 Tutorial outline Part 1 Introduction Distributed systems...
-
Upload
felipe-vineyard -
Category
Documents
-
view
217 -
download
0
Transcript of 1 Jini Tutorial, Part 3 Jini Programming. 2 Tutorial outline Part 1 Introduction Distributed systems...
1
Jini Tutorial, Part 3
Jini Programming
2
Tutorial outline Part 1 Introduction
Distributed systems Java basics Remote Method Invocation (RMI)
Part 2 Overview of Jini Goals Architecture Basic concepts, protocols
Part 3 Jini Programming
Part 4 Advanced topics Mobile Jini access Adaptive user interfaces Security
3
Contents
Software overview – architecture, packages
Programming the basic steps discovery, join (service registration) and lookup (finding services)
Deployment – where to put what
4
The key steps of operation
Every service and client will have to discover one or more lookup services
Every service will have to register with (join) the discovered lookup service(s)
Every client will have to search for (look up) services in the lookup service(s)
First we look at the programming of these fundamental steps of operation
5
Jini package structure
The naming of Jini packages follow the inverted domain name naming convention jini.net.xxx
The core classes are in packages jini.net.core.*, stored in jini-core.jar
Classes building on core classes are in jini.net.*, stored in file jini-ext.jar
Non-standard utility, helper classes are in com.sun.jini.*, stored in file sun-util.jar
6
The programmer’s view of Jini
The essential steps of creating a system of Jini services and clients
1. Create well-known interfaces (if required)
2. Create services that implement the interfaces
3. Provide discovery in services and clients
4. Services: Program service registration5. Clients: Program service lookup
7
How we should proceed
Simple service example to show these steps
1. Defining service interface2. Creating the service3. Programming the Unicast Discovery4. Service registration5. Service lookup6. Multicast discovery7. The interesting parts
8
Creating the interface
First we define the well-known interface for our sample service
public interface GreetingInterface {
public void hello();
}
9
Creating the Service Proxy Then we create the proxy class the client will
see
public class GreetingServiceProxy implements Serializable, GreetingInterface {
public GreetingServiceProxy (){};
public void hello(){ System.out.println(“Welcome to Jini
World!”);}
}
10
What we want to achieve
Service AService A
Lookup ServiceLookup Service
Service Proxy
registrarregistrar
registrationregistration
register( )
11
Unicast discovery
LookupLocator lookup = null;
ServiceRegistrar registrar = null;
lookup = new LookupLocator(“jini://hostname”);
registrar = lookup.getRegistrar();
12
Service registration
Once we have a proxy to the lookup service, we can register the service ServiceRegistration registration = null;
//create serviceItem (no ID, no attributes)
try{ // register for 100 seconds
registration = registrar.register(serviceItem,
100000L); } catch (java.rmi.RemoteException e){
}
ServiceItem serviceItem = new ServiceItem(null, new GreetingServiceProxy(), null);
13
Putting the service together
import net.jini.core.discovery.*;import net.jini.core.lookup.*; public class GreetingService { static public void main(String argv[]) {
LookupLocator lookup = null; //object for discoveryServiceRegistrar registrar = null; //lookup serv. proxy
try { lookup = new LookupLocator("jini://hostname");} catch(java.net.MalformedURLException e) {...}// perform unicast discoverytry { registrar = lookup.getRegistrar(100000);}catch ...}
14
Putting the service together
...
ServiceRegistration registration = null;
//create serviceItem (no ID, no attributes)
ServiceItem serviceItem = new ServiceItem(null, new GreetingServiceProxy(), null);
try{ // register for 100 seconds
registration = registrar.register(serviceItem,
100000L); }catch (java.rmi.RemoteException e){
}} // GreetingService
15
The client side
Lookup ServiceLookup ServiceClient 1Client 1
Found proxy
registrarregistrar lookup( )
Interface
Template
Template
Unicastdiscovery
16
Programming the service lookup
System.setSecurityManager( new RMISecurityManager() );
// create template for service search...GreetingServiceInterface returnedService = null;try{ returnedService = (GreetingServiceInterface)
registrar.lookup(template);}catch (java.rmi.RemoteException e){ ...}returnedService.hello();
}
17
Creating the template
Class[] serviceTypes = new Class[1];
try {
serviceTypes[0] = Class.forName( "GreetingServiceInterface");
}catch (ClassNotFoundException e){
...
}
ServiceTemplate template = new ServiceTemplate(null, serviceTypes, null);
18
Using Attibutes
Why use attributes The type (interface) of a service will only
say ‘what’ we can do with a service. We also need information on the properties
of the service (eg type and speed of a printer, supercomputer
specialising in climate modelling, storage capacity, location of service)
You can use standard Jini attributes Address, Comment, Location, Name,
ServiceInfo, ServiceType, Status And/or create your own particular ones
19
Attributes
Entry[] attribSet = new Entry[3];
attribSet[0] = new Location(“G", “002", “South Building");
attribSet[1] = new Location(“1st", “107", "North Building");
attribSet[2] = new Name(“Greeting Service for Euro-Par participants");
ServiceTemplate newTemplate = new ServiceTemplate(null, serviceTypes, attribSet);
Since attributes are Java objects and downloaded with the service, they can be used for transferring any type of static or dynamic information from the service to the client
20
Is that all? What’s missing?
We know how to discover a lookup service, register and lookup services
BUT, we can only discover a known lookup service, which is not discovery at all, only connecting to it Multicast discovery to deal with unknown
lookup services
21
Programming the multicast discovery – Step 1
LookupDiscovery discover = null;
try{
discover = new LookupDiscovery(LookupDiscovery.ALL_GROUPS);
}catch ...
This implements the process shown in the next figure.
Lookup Service NLookup Service N
Discovering entityDiscovering entity Lookup Service …Lookup Service …
Lookup Service 2Lookup Service 2
Lookup Service 1Lookup Service 1
multicast request
22
Programming the multicast discovery – Step 2
Asynchronous responses are handled by a listener object (implementing the DiscoveryListener interface)
discover.addDiscoveryListener(listener);
try{
Thread.currentThread().sleep(10000L);
}
catch ...
}
23
Handling responses in the listener
Two methods for joining and leaving
public void discovered(DiscoveryEvent e){
//Lookup service discovered
}
public void discarded(DiscoveryEvent e){
//Clean up after lookup service discarded");
}
24
Step 3 -- Handling registration Multicast version of the registration process
Note the use of event and the number of lookup services
public void discovered(DiscoveryEvent event){
ServiceRegistrar[] registrars = event.getRegistrars();ServiceRegistration[] registration = null;ServiceItem serviceItem = new ServiceItem(null, new GreetingServiceProxy(), null); for (int i = 0; i < registrars.length; i++){ try {
registration[i] = registrars[i].register(serviceItem, 100000L);
} catch ... }}
}
25
Creating a ‘real’ service proxy
Creating a new proxy that talks to the backend service
public class GreetingServiceProxy implements Serializable, GreetingInterface {
protected GreetingBackEnd be;
public GreetingServiceProxy ( be ){
this.be = be;
};
public void hello(){
String str = be.getString();
System.out.println(str);
}
}
26
Modifying the service
The interface for the remote proxypublic interface GreetingBackEnd extends Remote{
public String getString();}
We also need to create the Backend Remote object that will receive RMI calls from the proxypublic class BackEnd extends UnicastRemoteObject implements GreetingBackEnd{
public String getString(){ return “Welcome to Euro-Par”;
}}
27
Modifying registration
The service will publish a proxy initialised with a reference to the back end service (the remote object)
BackEnd be = new BackEnd();
GreetingServiceProxy proxy = new GreetingServiceProxy(be);
...
ServiceItem serviceItem = new ServiceItem(null, proxy, null);
28
Where are we now?
We have seen the programming of the discovery, join, lookup protocols
Shortcomings: We have no leasing for our service Only up and running services will be
located – latecomers (both lookup and other services) are missed. We need notification (events) when this happen
29
Service computerService computer
Client deviceClient device
Lookup service computerLookup service computer
Deployment
RMI DaemonRMI Daemon
HTTP Server for exporting LS
classes
HTTP Server for exporting LS
classes
Lookup ServiceLookup Service
ClientClientServiceService
HTTP Server for exporting
service classes
HTTP Server for exporting
service classes
RMI DaemonRMI Daemon
HTTP Server for exporting client classes
HTTP Server for exporting client classes
30
Summary
Overviewed the programming steps of the Discovery, Join and Lookup protocols
Have used a simple and real proxy to a Jini service
Looked at the use of attributes Overviewed deployment issues We look at the more advanced
issues in the next part