Networking infrastructure

The first assignment simplified the home networking situation in many ways

• All "devices" were running in the same virtual machine instead of distributed processes
• The "mobile phone" constructed objects representing each device instead of having to find them
• The mobile phone called methods on each local device instead of communicating across the network

Events

• An event is generated by an object to signal that some change has occurred
• Events occur in Java in many places
  • Low-level key and mouse events are generated by the AWT in response to user actions
  • Semantic events are generated by objects such as java.awt.Button when the combination MousePressed/MouseReleased occurs, to signal an ActionEvent
  • When a Java Bean changes state, it generates a PropertyChangeEvent
  • A Jini object can generate a RemoteEvent
• Events have a source and a target
• The target registers itself as a listener with the source and continues asynchronously
• The source calls a method on the target either synchronously or asynchronously

Listeners

• The target of an event must implement a listener interface
• The general format of a listener interface is

  
        interface Listener {
            public void invoke(Event e);
        }
        

• Examples of actual listener interfaces in Java include

  • 
    	    java.awt.ActionListener {
    	        void actionPerformed(ActionEvent evt);
    	    }
    	    

  • 
    	    java.beans.PropertyChangeListener {
    	        void propertyChange(PropertyChangeEvent evt);
    	    }
    	    

  • 
    	    public interface RemoteEventListener {
    	         public void notify(RemoteEvent evt);
    	    }
    	    

• When the event is generated, the source calls the appropriate method of the listener

  
        Event evt = new Event(...);
        listener.invoke(evt);
        

Listener list

• A source may only allow a single listener, or may keep a list of listeners
• A single listener source would have methods such as

  
        public class EventSource {
            public void setListener(Listener l);
            public void removeListener();
            public void callListener(Event evt);
        }
        

• A multiple listener source would have methods such as

  
        public class EventSource {
            public void addListener(Listener l);
            public void removeListener();
            public void callListeners(Event evt);
        }
        

Single listener

The source may have an implementation such as

      public class EventSource {
          Listener listener = null;

          public void setListener(Listener l) {
              if (l == null) {
                  listener = l;
              } else {
                  throw new java.util.TooManyListenersException();
              }
          }

          public void removeListener() {
              listener = null;
          }

          public void callListener(Event evt) {
              if (listener != null) {
                  listener.invoke(evt);
              }
          }
      }

Multiple listeners

The multiple listener source might be implemented by

public class EventSource {

    Vector listeners = new Vector();

    public void addListener(Listener l) {
        listeners.add(l);
    }

    public void removeListener(Listener l) {
        if ( ! listeners.remove(l)) {
            throw new NoSuchListenerException();
        }
    }

    public void callListeners(Event evt) {
        Enumeration enum = listeners.elements();

        while (enum.hasMoreElements()) {
            Listener listener = (Listener) enum.nextElement();
            listener.invoke(evt);
        }
    }
}

EventListenerList

• Support in Java for event management is not good
• The EventListenerList is intended to support a list that can be made up of different types of listener

  
   EventListenerList listenerList = new EventListenerList();
   FooEvent fooEvent = null;
  
   public void addFooListener(FooListener l) {
       listenerList.add(FooListener.class, l);
   }
  
   public void removeFooListener(FooListener l) {
       listenerList.remove(FooListener.class, l);
   }
  
  
   // Notify all listeners that have registered interest for
   // notification on this event type.  The event instance 
   // is lazily created using the parameters passed into 
   // the fire method.
  
   protected void fireFooXXX() {
       // Guaranteed to return a non-null array
       Object[] listeners = listenerList.getListenerList();
       // Process the listeners last to first, notifying
       // those that are interested in this event
       for (int i = listeners.length-2; i>=0; i-=2) {
           if (listeners[i]==FooListener.class) {
               // Lazily create the event:
               if (fooEvent == null)
                   fooEvent = new FooEvent(this);
               ((FooListener)listeners[i+1]).fooXXX(fooEvent);
           }
       }
   }
        

EventHandler

• Another class that could be used is EventHandler
• This is intended for uses where the target just executes a single command in invoke(), and has no other methods
• If there are lots of listeners that just implement a single command, the EventHandler can reduce space requirements of lots of class code
• e.g replace a Button listener

  
  myButton.addActionListener(new ActionListener {
       public void actionPerformed(ActionEvent e) {
           frame.toFront();
       }
  });
        

  by

  
  myButton.addActionListener(
       (ActionListener)EventHandler.create(ActionListener.class,
                                           frame, "toFront"));
   
        

Asynchronous event queue

• Some situations may generate large numbers of events in a very short time e.g. mouse motion events
• If the time to process an event is longer than the time between new events, then they will have to be "buffered" by puting them in an event queue
• The event queue is handled by two threads: one to put events in the queue, the other to remove and dispatch them
• The java.awt.EventQueue does this, but only for AWT events

• 
        public class EventQueue {
            public synchronised void addEvent(Event evt);
            public synchronised Event getEvent();
            public void dispatchEvents();
        }
        

EventQueue with one listener

public class EventQueue {
    protected Queue queue;
    protected Listener listener;

    public synchronised void addEvent(Event evt) {
        queue.add(evt);
        notifyAll();
    }

    public synchronised Event getEvent() {
        if (queue.isEmpty()) {
            wait();
        }
        return (Event) queue.removeElement():
    }

    public void dispatchEvents() {
        while (true) {
            Event evt = getEvent();
            if (listener != null) {
                listener.invoke(evt);
            }
        }
    }
}

Remote events

• The source and target for events need not be on the machine
• The target needs to know the remote source and call a remote method to add itself as a listener
• The source needs to call the invoke() method on a remote object
• This needs techniques such as remote procedure call, Java RMI (remote method invocation) or messaging

Procedure call

• A procedure call or method call acts within the same virtual machine, using common memory and common adressing
• The calling code knows the address of the called procedure - the compiler/linker generates these addresses
• Parameters and return values are passed on the local stack in a "stack frame"

Remote procedure call

• An RPC is like a procedure call but acts between different virtual machines, usually running on different computers
• The caller must establish a connection to the remote machine and send a message representing the procedure call
• The parameters must be encoded in some way (marshalling) and sent as well
• The remote machine must be running a server that waits for RPC messages. When a message arrives it must work out which procedure is called and then execute it
• The results of the procedure call must be marshalled and returned to the caller
• The caller is waiting for the message return. It unmarshalls it and returns it

Example: World RPC

• A simple class is

  
        public class World {
            public String sayHello() {
                return "Hello world";
            }
  
            public String sayGoodbye() {
                return "Goodbye cruel world";
            }
  
            public static void main(String[] args) {
                World w = new World();
                System.out.println(w.sayHello());
                System.out.println(w.sayGoodbye());
        }
        

• Making this into a remote object with remote methods means
  • having a server side object WorldServer which reads messages from the network and calls local server-side methods
  • having a client stub WorldStub that send messages to the server and reads replies
  • having a client object (say WorldClient) that calls the stub

World pseudocode

• WorldClient

  
  public class WorldClient {
  
      main() {
          create new WorldStub object
          call local methods on stub
      }
  }// WorldClient
  

• WorldStub

  
  public class WorldStub {
  
      public WorldStub() {
          create socket to World server
      }
   
      public String sayHello() {
          write method name "sayHello" to server
          read response
          return response
      }
  
      public String sayGoodbye() {
          write method name "sayGoodbye" to server
          read response
          return response
      }
  }// WorldStub
  

• World Server

  
  public class WorldServer {
  
      main() {
  	create new WorldServer
      }
  
      public WorldServer () {
          create server socket
          while true
              accept client connection socket
              handle client socket
      }
      
      handleClient() {
          while true
              read command from client socket
              if command is "sayHello"
                  result = sayHello()
              if command is "sayGoodbye"
                  result = sayGoodbye()
              write result to client socket
      }
  
      sayHello() {
  	return "Hello world";
      }
  
      sayGoodbye() {
  	return "Goodbye cruel world";
      }
  }// WorldServer
  

WorldClient

public class WorldClient {

    public static void main(String[] args) {
	WorldStub w = new WorldStub();
	System.out.println(w.sayHello());
	System.out.println(w.sayGoodbye());
    }
}// WorldClient

WorldStub

import java.net.*;
import java.io.*;

public class WorldStub {

    private final String SERVER_IP = "127.0.0.1";
    private final int PORT = 7890;
    private static String SAY_HELLO = "sayHello";
    private static String SAY_GOODBYE = "sayGoodbye";

    private Socket s;
    private BufferedReader in;
    private PrintStream out;

    public WorldStub() {
	try {
	    InetAddress address = InetAddress.getByName(SERVER_IP);
	    s = new Socket(address, PORT);
	    in = new BufferedReader(new InputStreamReader(s.getInputStream()));
	    out = new PrintStream(s.getOutputStream());
	} catch(Exception e) {
	    System.err.println(e);
	    System.exit(1);
	}
    }

    public String sayHello() {
	try {
	    out.println(SAY_HELLO);
	    out.flush();
	    String response = in.readLine();
	    return response;
	} catch(IOException e) {
	    return "";
	}
    }

    public String sayGoodbye() {
	try {
	    out.println(SAY_GOODBYE);
	    out.flush();
	    String response = in.readLine();
	    return response;
	} catch(IOException e) {
	    return "";
	}
    }
}// WorldStub

WorldServer

import java.net.*;
import java.io.*;

public class WorldServer {

    private static int PORT = 7890;
    private static String SAY_HELLO = "sayHello";
    private static String SAY_GOODBYE = "sayGoodbye";

    public static void main(String[] args) {
	new WorldServer();
    }

    public WorldServer (){
	ServerSocket server = null;
	try {
	    server = new ServerSocket(PORT);
	} catch(IOException e) {
	    e.printStackTrace();
	    System.exit(1);
	}

	while (true) {
	    try {
		Socket client = server.accept();
		handleClient(client);
	    } catch(IOException e) {
		// ignore errors from a client
	    }
	}
    }
    
    private void handleClient(Socket client) {
	BufferedReader in = null;
	PrintStream out = null;
	String result = null;

	try {
	    in = new BufferedReader(new InputStreamReader(client.getInputStream()));
	    out = new PrintStream(client.getOutputStream());
	    String command = null;
	    while (true) {
		command = in.readLine();
		if (command.equals("")) {
		    break;
		}
		if (command.equals(SAY_HELLO)) {
		    result = sayHello();
		} else if (command.equals(SAY_GOODBYE)) {
		    result = sayGoodbye();
		}
		out.println(result);
	    }
	} catch(Exception e) {
	} finally {
	    try {
		if (in != null) {
		    in.close();
		}
		if (out != null) {
		    out.close();
		}
	    } catch(IOException e) {
		// nothing we can do
	    }
	}
    }

    private String sayHello() {
	System.err.println("hello");
	return "Hello world";
    }

    private String sayGoodbye() {
	System.err.println("bye");
	return "Goodbye cruel world";
    }
}// WorldServer

Comments on RPC

• Much of the RPC code can be automatically generated from a specification such as

  
        public class World {
            public String sayHello();
            public String sayGoodbye();
        }

• All the programmer should supply is the server implementation of the two methods
• RPC systems such as Sun RPC standardise wire formats for procedure parameters and results, and have tools to generate the client stub and server
• The client needs access to the client stub class files, and the server needs access to the server side implementatio class files
• RPC uses the half object plus protocol design pattern

Half object plus protocol

• This design pattern uses a "half" object on the client side and a "half" object on the server side
• the two halves communicate using an arbitrary protocol
• The protocol could be e.g. HTTP

Messaging systems

• Messages are less structured than events, and do not require knowledge of the senders or recipients methods
• Typically, the receiver need not be online when the message is sent, but must be online to receive it
• Messages can be point-to-point or publish/subscribe
• Point-to-point messages have a sender and targeted receiver
• Published messages are sent to a "topic list"
• Subscribers register for particular topics and only receive messages for those topics

Message architectures

Mobile objects

• If the airconditioner wants to run a user interface on the TV, it must be able to move a UI object from itself to the TV
• Most languages do not support object migration, since they need to represent object state in a processor independent form
• Java has classes ObjectOutputStream and ObjectInputStream which allow an object and all the objects that it refers to, to be serialised (written as a byte stream) and deserialised
• The serialisation captures the state of the object's instance variables
• It does not move class files: either the class files must already exist in the destination classpath or be loaded by a special class loader

Example migrating objects

• The Integer class has a single field, an int
• The example creates 10 Integer objects and writes them to an ObjectOutputStream
• A client reads 10 objects from an ObjectInputStream and instantiates them locally
• The code follows the same structure as the World example

IntegerClient

public class IntegerClient {

    public static void main(String[] args) {
	IntegerStub w = new IntegerStub();
    }
}// IntegerClient

IntegerStub

import java.net.*;
import java.io.*;

public class IntegerStub {

    private final String SERVER_IP = "127.0.0.1";
    private final int PORT = 7891;

    private Socket s;
    private ObjectInputStream in;

    public IntegerStub() {
	try {
	    InetAddress address = InetAddress.getByName(SERVER_IP);
	    s = new Socket(address, PORT);
	    in = new ObjectInputStream(s.getInputStream());
	    
	    for (int n = 0; n < 10; n++) {
		Integer nObj = (Integer) in.readObject();
		System.out.println(nObj.toString());
	    }
	} catch(Exception e) {
	    System.err.println(e);
	    System.exit(1);
	}
    }
}// IntegerStub

IntegerServer

import java.net.*;
import java.io.*;

public class IntegerServer {

    private static int PORT = 7891;

    public static void main(String[] args) {
	new IntegerServer();
    }

    public IntegerServer (){
	ServerSocket server = null;
	try {
	    server = new ServerSocket(PORT);
	} catch(IOException e) {
	    e.printStackTrace();
	    System.exit(1);
	}

	while (true) {
	    try {
		Socket client = server.accept();
		handleClient(client);
	    } catch(IOException e) {
		// ignore errors from a client
	    }
	}
    }
    
    private void handleClient(Socket client) {
	ObjectOutputStream out = null;

	try {
	    out = new ObjectOutputStream(client.getOutputStream());
	    for (int n = 0; n < 10; n++) {
		out.writeObject(new Integer(10-n));
	    }
	} catch(Exception e) {
	} finally {
	    try {
		if (out != null) {
		    out.close();
		}
	    } catch(IOException e) {
		// nothing we can do
	    }
	}
    }
}// IntegerServer

Dynamic class loading

• It is possible to build special class loaders that will load class files from places other than CLASSPATH
• The RMICLassLoader will load class files from any valid URL using e.g.

  
        Class RMIClassLoader(String url, String className)
        

• Instances of these classes can be constructed using the zero-args constructor

  
        Object Class.newInstance()
        

• The object can then be cast to the right class, and methods called

Using interfaces for dynamic classes

• If you know a class definition, then you don't need to dynamically download it
• If you know the class name, but don't know the class definition then it is hard to find the methods (but not impossible)
• If you don't know the methods, you can't invoke them
• Solution: the dynamic class is an implementation of a known interface with known methods
• Cast the object to the interface, and call interface methods

Dynamic Foo loading

• Foo interface

  
  interface Foo {
  }
  

• Foo1 (etc)

  
  public class Foo1 implements Foo {
  
      public String toString() {
  	return "I'm a Foo 1 object";
      }
  }
  

• Foo loader

  
  import java.rmi.server.RMIClassLoader;
  
  public class LoadFoo {
  
      public static void main(String[] args) {
  	try {
  	    Class cls =
                    RMIClassLoader.loadClass(
                        "file://home/httpd/html/internetdevices/infrastructure/",
                        "Foo1");
  	    Foo foo = (Foo) cls.newInstance();
  	    System.out.println(foo.toString());
  	    
  	    cls = RMIClassLoader.loadClass(
                        "file://home/httpd/html/internetdevices/infrastructure/",
                        "Foo2");
  	    foo = (Foo) cls.newInstance();
  	    System.out.println(foo.toString());
  	    
  	    cls = RMIClassLoader.loadClass(
                        "file://home/httpd/html/internetdevices/infrastructure/",
                        "Foo3");
  	    foo = (Foo) cls.newInstance();
  	    System.out.println(foo.toString());
  	} catch(Exception e) {
  	    e.printStackTrace();
  	}
      }
  }
  

MarshalledObject

• The MarshalledObject combines both serialisation of an object's instance data and information about the location of the class files
• A MarshalledObject can be unmarshalled, and will load the class files and restore object state
• It has a constructor MarshalledObject(Object obj)
• It has a retrieval method Object get()
• The constructor uses the property java.rmi.server.codebase to set the location of the class file
  • java -Djava.rmi.server.codebase=...
  • System.setProperty("java.rmi.server.codebase", ...)
• The server creates an object, marshalls it, and writes it to an ObjectOutputStream
• The client reads the object from an ObjectInputStream, casts it to MarshalledObject and calls get
• The resultant object is then cast to a known interface and methods are called

Conclusion

There are a variety if ways that one object can call methods on another, even if they are remote

• Events
• Remote events
• Procedure/method call
• RPC
• Messaging
• Mobile objects
• Downloadable class files
• Marshalled objects