package javacodebook.net.rmi.objectreference;

import java.rmi.*;
/**
 * Dieses Interface muss sowohl auf Client- als auch auf Serverseite
 * bekannt sein.
 * Klassen die Address implementieren kapseln sämtliche Addressdaten.
 */
public interface Address extends Remote {
    public String getStringRepresentation() throws RemoteException;
    public void setStreet(String street) throws RemoteException;
    public void setCity(String city) throws RemoteException;
}

--- Neue Klasse ---

package javacodebook.net.rmi.objectreference;

import java.rmi.*;
/**
 * Dieses Interface definiert alle AddressBook-Methoden die dem Client
 * zugänglich sein sollen.
 */
public interface AddressBook extends Remote{
    // Unter diesem String soll der Dienst gefunden werden
    public final static String NAMING = "addressbook";

    // Anzahl gespeicherter Adressen
    public int getSize() throws RemoteException;

    // Liefert Address-Objekt zuück
    public Address getAddressByName(String name) throws RemoteException;
}

--- Neue Klasse ---

package javacodebook.net.rmi.objectreference;

import java.rmi.*;
import java.rmi.registry.*;

/**
 * Dieser Client sucht ein entferntes Objekt im Netz, und ruft zwei seiner
 * Methoden auf.
 * Es können der Applikation beim Start zwei Strings übergeben werden, der
 * erste gibt den "Host" der zweite den "Port" des Namensdienstes an.
 */
public class AddressBookClient {

    public static String host = "localhost";
    public static int port = 1099;

    public static void main(String[] args) throws Exception {

        // Werden zwei Strings beim Program-Start übergeben, wird der erste
        // als URL und der zweite als Port des Namensdienstes interpretiert.
        // Wird nichts übergeben werden Default-Einstellungen verwendet.
        if(args.length==2) {
            host=args[0];
            port=Integer.parseInt(args[1]);
        }

        // Anhand der Namensdienst URL und des Ports wird der Lookup-String
        // zusammengebaut.
        String mLookup = "//"+host+":"+port+"/"+AddressBook.NAMING;

        // Remote-Objekt wird referenziert, und zum AddressBook Objekt
        // gecastet
        AddressBook book = (AddressBook)Naming.lookup(mLookup);

        // Aufruf der Methode getAddressByName("Arbeit") liefert ein Objekt
        // einer selbstgeschrieben Klasse
        Address a1=  book.getAddressByName("Arbeit");

        // Methoden des Remote-Objekts, sowie des übertragenen
        // Objects werden aufgerufen
        System.out.println("Das Adressbuch hat "+book.getSize()+" Eintraege.");
        System.out.println("Arbeit hat folgende Anschrift:\n"
                +a1.getStringRepresentation()+"\n");

        // Werte des Objektes werden geändert und ausgegeben
        a1.setCity("Muenchen");
        a1.setStreet("Landshuter Allee");
        System.out.println("Arbeit hat geaenderte Anschrift:\n"
                +a1.getStringRepresentation()+"\n");

        // Objekt wird neu abgefragt und ausgegeben
        System.out.println("Adresse von Arbeit wird neu abgefragt...");
        Address a2=  book.getAddressByName("Arbeit");
        System.out.println("Arbeit hat folgende Anschrift:\n"
                +a2.getStringRepresentation()+"\n");
    }
}

--- Neue Klasse ---

package javacodebook.net.rmi.objectreference;

import java.rmi.*;
import java.rmi.registry.*;
import java.rmi.server.UnicastRemoteObject;
import java.net.MalformedURLException;
import java.util.*;

/**
 * Dieser Server beinhaltet AddressDaten. Kennt der Client den Nachname,
 * kann er weitere Informationen über diese Person erlangen.
 * Zusätzlich hat er noch Zugriff auf die Anzahl gespeicherter Adressen
 * Achtung: Bevor der Server laufen kann müssen Stub und Skeleton generiert
 * werden:
 *        rmic javacodebook.net.rmi.reference.AddressBookServer
 *        rmic javacodebook.net.rmi.reference.AddressImpl
 */
public class AddressBookServer implements AddressBook {

    // Adressen werden in eine HashTable abgelegt
    private Hashtable content = new Hashtable();

    public int getSize() throws RemoteException {
        return content.size();
    }

    public Address getAddressByName(String name) throws RemoteException {
        return (Address)content.get(name);
    }

    public AddressBookServer(int port)throws Exception
    {
        // AdressBuch wird mit Daten gefüllt
        fillHashTable(port);
        // Die Registry wird vom Programm aus gestartet
        LocateRegistry.createRegistry(port);
        // Dieses Server-Object wird exportiert
        UnicastRemoteObject.exportObject(this,port);

        // Das exportierte Objekt wird an der registry mit defnierter
        // URL angemeldet
          Naming.rebind("//localhost:"+port+"/"+AddressBook.NAMING, this);
    }

    /**
     * Füllt Adressbuch mit Daten.
     */
    private void fillHashTable(int port) throws RemoteException{
        Address a1= new AddressImpl("Arbeit", "Andi", "Terlindenweg","Soest");
        Address a2= new AddressImpl("Einstellbar","Manuel","Kaiserallee",
                "Karlsruhe");
        Address a3= new AddressImpl("Sörwis","Sigrid","Winsstrasse","Berlin");
        Address a4= new AddressImpl("Mutig","Miss","Kungshamra","Stockholm");

        // Die AddressImpl-Objekte müssen exportiert, aber nicht am
        // Namensdienst angemeldet werden.
        // (Der Namensdienst wird nur für den ersten Kontakt zwischen Client
        // und Server benötigt. anschließend können die Referenzen wie gehabt
        // hin und her geschickt werden).
        UnicastRemoteObject.exportObject(a1,port);
        UnicastRemoteObject.exportObject(a2,port);
        UnicastRemoteObject.exportObject(a3,port);
        UnicastRemoteObject.exportObject(a4,port);

        content.put("Arbeit",a1);
        content.put("Einstellbar",a2);
        content.put("Sörwis",a3);
        content.put("Mutig",a4);
    }

    // Server wird gestartet.
    public static void main(String[] args) throws Exception{
            new AddressBookServer(1099);
    }
}

--- Neue Klasse ---

package javacodebook.net.rmi.objectreference;

import java.rmi.*;
/**
 * AddressImpl implementiert das Remote interface Address.
 * Addressdaten werden in ihr gekapselt. Veränderbar sollen nur
 * Strasse und Wohnort sein.
 */
public class AddressImpl implements Address {

    // Attribute der Klasse Address
    private String firstName;
    private String lastName;
    private String street;
    private String city;

    // Konstruktor der Klasse Address, sämtliche Attribute müssen
    // hier gesetzt werden
    public AddressImpl( String lastName, String firstName,
            String street, String city) {
        this.lastName=lastName;
        this.firstName=firstName;
        this.street=street;
        this.city=city;
    }

    public String getStringRepresentation() throws RemoteException{
        return firstName+" "+lastName+"\n"+street+"\n"+city;
    }

    public void setStreet(String street) throws RemoteException {
        this.street=street;
    }

    public void setCity(String city) throws RemoteException{
        this.city=city;
    }
}