Java, Netzwerk und Linux [0][11] Chris Hübsch

1. Java Geschichte und Idee
2. Die JDKs (1.02, 1.1, 1.2), Packages
3. Streams (1.02)
4. Sockets (1.02)
5. Serialization (1.1)
6. ObjectStream (1.1)
7. RMI (1.1)
8. Ausblick auf IDL=CORBA (1.2)
9. Servlets (javax)
10. Referenzen

Geschichte

• Anfang der Geschichte: 1990
• Ziel: Nie wieder hunderte verschiedener APIs für hunderte Plattformen
• Patric Naughton und 5 weitere Leute im Projekt Green
• Gosling nannte die resultierende Sprache Oak, Interpreter von ihm geschrieben
• Erste Anwendung eine keine Fernbedienung mit Display - darauf Duke Demos/Applet1.htm
• Aus Green-Tram wurde eine Eigene Firma: First Person
• 1993 kam NCSA Mosaic
• 1994 erster Web-Browser mit Oak-Unterstützung: WebRunner
• Allererstes Applet: Winkender Duke
• Umbennenung von Oak nach Java (Neon, Lyric, Pepper, Silk)
• Aus WebRunner wurde HotJava

Idee

1.02: Compiler, Interpreter, Appletviewer, Dokumentierer, Decompilierer, Header-Generator, Debugger
1.1: Jartools, Keygenerator, RMIRegistryServer
1.2: Neuer Javadoc, Servletrunner, ORB-Server

• Außerdem immer Classes.zip und einige Libs/DLLs
• Dazu Sources
• API-Doku und Tutorial extra erhältlich.

Packages

Jede Java Klasse gehört einem Package an. Packages sorgen für logische Ordnung der Klassen. Außerdem wird eine übersichtlichere Programmierung möglich.

• Folgen Decorator Pattern
• I/O-Streams (byte) und Reader/Writer (char)
• Können von verschiedenen Quellen/Zielen angefordert werden
  • File
  • Socket
  • URLConnection
  • Byte/Char-Array
  • ZipFile
  • Process
  • StringBuffer
  • Streams und Reader (<- Decorator)
• Abstrakte Oberklassen sind: InputStream, OutputStream, Reader, Writer
• 3 Stufen der Dekoration
  • Quellenorientiert
  • Übertragungsorientiert
  • Formatorientiert (Datentyp-Orientiert)

InputStream:

available()

Returns the number of bytes that can be read from this input stream without blocking.

close()

Closes this input stream and releases any system resources associated with the stream.

mark(int)

Marks the current position in this input stream.

markSupported()

Tests if this input stream supports the mark and reset methods.

read()

Reads the next byte of data from this input stream.

read(byte[])

Reads up to b.length bytes of data from this input stream into an array of bytes.

read(byte[], int, int)

Reads up to len bytes of data from this input stream into an array of bytes.

reset()

Repositions this stream to the position at the time the mark method was last called on this input stream.

skip(long)

Skips over and discards n bytes of data from this input stream.

Reader:

close()

Close the stream.

mark(int)

Mark the present position in the stream.

markSupported()

Tell whether this stream supports the mark() operation.

read()

Read a single character.

read(char[])

Read characters into an array.

read(char[], int, int)

Read characters into a portion of an array.

ready()

Tell whether this stream is ready to be read.

reset()

Reset the stream.

skip(long)

Skip characters.

OutputStream:

close()

Closes this output stream and releases any system resources associated with this stream.

flush()

Flushes this output stream and forces any buffered output bytes to be written out.

write(byte[])

Writes b.length bytes from the specified byte array to this output stream.

write(byte[], int, int) Writes len

bytes from the specified byte array starting at offset off to this output stream.

write(int)

Writes the specified byte to this output stream.

Writer:

close()

Close the stream, flushing it first.

flush()

Flush the stream.

write(char[])

Write an array of characters.

write(char[], int, int)

Write a portion of an array of characters.

write(int)

Write a single character.

write(String)

Write a string.

write(String, int, int)

Write a portion of a string.

• Sockets dienen der Kommunikation übers Netz.
• Einige weitere Exceptions zur besseren Fehlererkennung in JDK 1.1
• Wichtige Klassen in java.net zu finden.
  • InetAddress:
    • Stellt eine IP-Adresse dar
    • getLocalhost()
    • getByName(String) (String ist "%s" oder "%d.%d.%d.&d")
  • DatagramSocket:
    • Für UDP Verbindungen
    • send(DatagramPacket)
    • receive(DatagramPacket)
  • DatagramPacket:
    • Transportiert ein Datenpaket über DatagramSockets
    • setData(byte[])
    • byte[] getData()
  • MulticastSocket (extends DatagramSocket):
    • Zum senden und empfangen von Multicast Packages
    • joinGroup(InetAddress)
    • leaveGroup(InetAddress)
  • ServerSocket:
    • Serverseite eienr TCP Verbindung
    • ServerSocket(int) (int ist Portnummer)
    • Socket accept()
  • Socket:
    • Ende einer TCP-Verbindung
    • Socket(InetAddress, int) (int ist Portnummer)
    • getInputStream()
    • getOutputStream()

Anwendung:

Clientseite:

//Achtung: Keinerlei Exception-Handling!!
//Socket erzeugen

  Socket sock = new Socket(hostName, port);
// oder
  InetAddress host = InetAddress.getByName(hostName);
  Socket sock = new Socket(host, port);

//Streams an Socket binden

  DataOutputStream dos = new DataOutputStream(sock.getOutputStream());
  DataInputSream dis = new DataInputStream(sock.getInputStream());

//lesen mit

  xxx = dis.readXXX();

//schreiben mit

  dos.writeXXX(xxx);

Serverseite:

//Achtung: Keinerlei Exception-Handling!!
//ServerSocket erzeugen

  ServerSocket serv = new ServerSocket(port);

//einmal auf Client warten -> Single-Client-Server

  Socket client = serv.accept();

//Streams an Socket binden

  DataInputSream dis = new DataInputStream(client.getInputStream());
  DataOutputStream dos = new DataOutputStream(client.getOutputStream());

//Alternative für Multiclient-Server

  while (true) {
    Socket client = serv.accept();
    new ClientHandlerThread(client).start(); //Sockets binden und Kommunikation im Thread
  }

Beispiele:

• EchoClient EchoServer
• Demos/Applet2.htm AppletSource ServerSource

• Serialisieren bedeutet ein Objekt in einen Strom von bytes zu zerlegen.
• Objekte, die in einen Stream geschrieben werden sollen, müssen das java.io.Serializable Interface implementieren.
• Java.io.Serializable hat keine Methoden und zeigt nur an, daß ein Objekt seiralisiert werden kann.
• Im Normalfall erfordert es keinerlei weiterer Arbeit durch den Programmierer.
• Ein Default-Construktor muß zugänglich sein, um Deserialisierung zu ermöglichen.
• Ganze Objektbäume können gespeichert und geladen werden.
• Mit transient gekennzeichnete Attribute werden nicht serialisiert.
• Bei Bedarf müssen implementiert werden:
  • private void writeObject(java.io.ObjectOutputStream out) throws IOException
  • private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException
• Serialisierung ist Angelegenheit des Systems und nicht des Programmierers (Gegenbeispiel: TStream in ObjectWindows von Borland, bei dem jede Klasse Store und Load implementieren muß.)
• Anwendung: Java Beans, ObjectStream, RMI

• 2 neue StreamKlassen ab JDK 1.1: ObjectInputStream und ObjectOutputStream
• Methoden: readObject(), writeObject(Object)
• Nur serialisierbare Objekte können gelesen und geschrieben werden.
• Object-I/O-Stream wird als Decorator um einen Input/Output-Stream gelegt
• ObjectStream kann - wie üblich -in Netzwerk, Pipe, Speicher oder File gehen.

Anwendung am Beispiel für Netzverbindung:

Clientseite:

//Achtung: Eingeschränkt vollständiges Exception-Handling!!
//Socket erzeugen

  Socket sock = new Socket(hostName, port);
// oder
  InetAddress host = InetAddress.getByName(hostName);
  Socket sock = new Socket(host, port);

//Streams an Socket binden

  ObjectOutputStream oos = new ObjectOutputStream(sock.getOutputStream());
  ObjectInputSream ois = new ObjectInputStream(sock.getInputStream());

//lesen mit

  try {
    Object o = ois.readObject();
  } catch (ClassNotFoundExceptin ex1) {
    //die übermittelte Klasse wurde nicht gefunden
  } catch (InvalidClassException ex2) {
    //etwas mit der Klasse stimmt nicht
  } catch (OptionalDataException ex3) {
    //Java-Primitive wurden gefunden, obwohl Objekt erwartet wurde
  } catch (IOExcpetion ex4) {
    //Irgendwas anderes ging schief
  }

//schreiben mit

  try {
    oos.writeObject(o);
  } catch (InvalidClassException ex1) {
    //etwas mit der Klasse stimmt nicht
  } catch (NoSerializableException ex2) {
    //Objekt kann nicht serialisiert werden
  } catch (IOExcpetion ex3) {
    //Irgendwas anders ist nicht in Ordnung
  }

Serverseite:

//Achtung: Keinerlei Exception-Handling!!
//ServerSocket erzeugen

  ServerSocket serv = new ServerSocket(port);

//einmal auf Client warten -> Single-Client-Server

  Socket client = serv.accept();

//Streams an Socket binden

  ObjectInputSream ois = new ObjectInputStream(client.getInputStream());
  ObjectOutputStream oos = new ObjectOutputStream(client.getOutputStream());

//Alternative für Multiclient-Server

  while (true) {
     Socket client = serv.accept();
     new ClientHandlerThread(client).start(); //Sockets binden und Kommunikation im Thread
   }

Beispiel für Arbeit mit Datei:

  FileOutputStream ostream = new FileOutputStream("t.tmp");
  ObjectOutputStream p = new ObjectOutputStream(ostream);
  p.writeInt(12345);
  p.writeObject("Today");
  p.writeObject(new Date());
  p.flush();
  ostream.close(); 

  FileInputStream istream = new FileInputStream("t.tmp"); 
  ObjectInputStream p = new ObjectInputStream(istream); 
  int i = p.readInt(); 
  String today = (String)p.readObject(); 
  Date date = (Date)p.readObject(); 
  istream.close();

Beispiel:

• Demos/Applet3.htm AppletSource ServerSource

• Erlaubt die Ausführung von Code auf entfernten Rechnern.
• Finden des Remote-Objektes mittels "rmiURL" der Form: "rmi://host:port/name"
  • host: der Name des Rechners (default: aktueller Host)
  • port: Portnummer der Registry (default: default Port)
  • name: Name des Remote Objektes
• Zentrale Arbeit wird in der Klasse Naming erledigt:
  • bind(String rmiURL, Object)
  • unbind(String rmiURL, Object)
  • rebind(String rmiURL, Object)
  • Remote lookup(String rmiURL)
  • String [] list (String rmiURL)
• Exportierbares Objekt wird durch das methodenlose Interface java.rmi.Remote gekennzeichnet
• Prozedurorientiert

Implementation:

Interface der remote aufrufbaren Klasse beschreiben. Muß java.rmi.Remote erweitern.

public interface Manager extends java.rmi.Remote {
  String getName() throws java.rmi.RemoteException;
  Date getDate() throws java.rmi.RemoteException;
  int calculate(int a, double b, Long c) throws java.rmi.RemoteException;
}

Implementation für das Interface schreiben.

public ManagerImpl extends java.rmi.server.UnicastRemoteObject implements Manager {

  String name = null;

  public ManagerImpl (String aName) throws java.rmi.RemoteException {
    name = aName;
  }

  public String getName () throws java.rmi.RemoteException {
    return name;
  }

  //....

}

Einen Server schreiben.

public class RMIServer {

  public static void main (String args[]) {

    //neuen Security Manager einstellen
    System.setSecurityManager(new java.rmi.RMISecurityManager());

    try {

      //RMI-Objekt erzeugen
      ManagerImpl obj = new ManagerImpl("Manager");

      //an Registry binden
      Naming.rebind("/ManagerServer", obj);

      System.out.println("ManagerServerbound in registry");
    } catch (Exception e) {
      System.out.println("ManagerServer err: " + e.getMessage());
      e.printStackTrace();
    }

}

Verwendung des RMI-Servers im Client (Applet oder Application).

Manager remoteManager = null;

public void initRMI() {
  try {
    String hostName = (isApplet)?getCodeBase().getHost():"anyHost":
    remoteManager = (Manager)Naming.lookup("//" + hostName + "/ManagerServer");
  } catch (Exception e) {
    System.out.println("ManagerClient exception: " + e.getMessage());
    e.printStackTrace();
  }
}

public void useRMI() {
  try {
    System.out.println(remoteManager.getName());
    System.out.println(remoteManager.getDate());
    System.out.println(remoteManager.calculate(2, 3.4, new Long(4352342342)));
  } catch (RemoteException e) {
    System.err.println(e);
  }
}

Compilierung

• java Manager.java ManagerImpl.java RMIServer.java Client.java
• rmic ManagerImpl

Beispiele:

• Demos/Applet4.htm CLUGJob CLUGImpl RMIServer AppletSource

• IDL=Interface Definition Language
• C++ ähnliche Sprache zum Beschreiben von Klassen
• "Compiler", die IDL nach C++, Java, Ada, SmallTalk, ... umwandeln
• Über ORBs (Object Request Broker) wird während der Laufzeit das entsprechende Objekt lokalisiert
• Sprachübergreifende Netzkommunikation mit Objekten

Beispiel (aus der API-Doku)

OMG-IDL Beschreibung (hello.idl) des Objektes schreiben:

module HelloApp {
  interface Hello {
    string sayHello();
  };
};

Hello.idl mit idltojava compilieren -> Java-Files zur Weiterbearbeitung

Server schreiben:

import HelloApp.*;
import org.omg.CosNaming.*;
import org.omg.CosNaming.NamingContextPackage.*;
import org.omg.CORBA.*;
 
class HelloServant extends _HelloImplBase 
{
    public String sayHello()
    {
        return "\nHello world !!\n";
    }
}

 
public class HelloServer {
 
    public static void main(String args[])
    {
        try{
            // create and initialize the ORB
            ORB orb = ORB.init(args, null);
 
            // create servant and register it with the ORB
            HelloServant HelloRef = new HelloServant();
            orb.connect(HelloRef);
 
            // get the root naming context
            org.omg.CORBA.Object objRef = 
                orb.resolve_initial_references("NameService");
            NamingContext ncRef = NamingContextHelper.narrow(objRef);
 
            // bind the Object Reference in Naming
            NameComponent nc = new NameComponent("Hello", "");
            NameComponent path[] = {nc};
            ncRef.rebind(path, HelloRef);
 
            // wait for invocations from clients
            java.lang.Object sync = new java.lang.Object();
            synchronized (sync) {
                sync.wait();
            }
 
        } catch (Exception e) {
            System.err.println("ERROR: " + e);
            e.printStackTrace(System.out);
        }
    }
}

Client als Applet oder Application schreiben:

import HelloApp.*;
import org.omg.CosNaming.*;
import org.omg.CORBA.*;
 
public class HelloClient 
{
    public static void main(String args[])
    {
        try{
            // create and initialize the ORB
            ORB orb = ORB.init(args, null);
 
            // get the root naming context
            org.omg.CORBA.Object objRef = orb.resolve_initial_references("NameService");
            NamingContext ncRef = NamingContextHelper.narrow(objRef);

            // resolve the Object Reference in Naming
            NameComponent nc = new NameComponent("Hello", "");
            NameComponent path[] = {nc};
            Hello HelloRef = HelloHelper.narrow(ncRef.resolve(path));
 
            // call the Hello server object and print results
            String hello = HelloRef.sayHello();
            System.out.println(hello);
 
        } catch (Exception e) {
            System.out.println("ERROR : " + e) ;
            e.printStackTrace(System.out);
        }
    }
}

• Servlets sind Klassen, die von einem Server geladen werden
• Können die Aufgaben von Pearl oder anderen CGI-Programmen erledigen
• Sind als Java-Klassen systemunabhänig und teilweise schneller
• Werden nicht ständig neu geladen, sondern verbleiben im Speicher des Servers -> schneller
• Methoden des allgemeinen Servlets:
  • init(ServletConfig): initialisiert das Servlet und reserviert Ressourcen (z.B. Sockets, Datenbank)
  • destroy(): gibt alles reservierten Ressourcen frei (so sie nicht automatisch freigegeben werden)
  • service(ServletRequest, ServletResponse): behandelt alle Requests, die an das Servlet gestellt werden
• Methoden des Http-Servlets:
  • service(ServletRequest, ServletResponse) wurde überschrieben, um eine der folgenden Methoden aufzurufen
  • doGet(HttpServletRequest, HttpServletResponse)
  • doPut(HttpServletRequest, HttpServletResponse)
  • doPost(HttpServletRequest, HttpServletResponse)
  • doTrace(HttpServletRequest, HttpServletResponse)
  • doOptions(HttpServletRequest, HttpServletResponse)
• HttpServletRequest (extends ServletRequest) kapselt alle Daten der Eingabe an das Servlet
• HttpServletResponse (extends ServletResponse) ist für die Ausgabe verantwortlich (u.A. auch ein IOStream anforderbar)

Beispiel (aus der API-Doku):

import java.io.*;
import java.util.*;

import javax.servlet.*;
import javax.servlet.http.*;

/**
 * A sample single-threaded servlet that takes input from a form
 * and writes it out to a file.  It is single threaded to serialize
 * access to the file.  After the results are written to the file,
 * the servlet returns a "thank you" to the user.
 *
 * <p>You can run the servlet as provided, and only one thread will run
 * a service method at a time.  There are no thread synchronization
 * issues with this type of servlet, even though the service method
 * writes to a file.  (Writing to a file within a service method
 * requires synchronization in a typical servlet.)
 *
 * <p>You can also run the servlet without using the single thread
 * model by removing the <tt>implements</tt> statement.  Because the
 * service method does not synchronize access to the file, multiple
 * threads can write to it at the same time.  When multiple threads try
 * to write to the file concurrently, the data from one survey does not
 * follow the data from another survey in an orderly fashion.
 *
 * <p>To see interaction (or lack of interaction) between threads, use
 * at least two browser windows and have them access the servlet as
 * close to simultaneously as possible.  Expect correct results (that
 * is, expect no interference between threads) only when the servlet
 * implements the <code>SingleThreadedModel</code> interface.
 */

public class SurveyServlet extends HttpServlet 
    implements SingleThreadModel
{
    String resultsDir;
    
    public void init(ServletConfig config)
        throws ServletException
    {
        super.init(config);
        resultsDir = getInitParameter("resultsDir");
        if (resultsDir == null) {
            Enumeration initParams = getInitParameterNames();
            System.err.println("The init parameters were: ");
            while (initParams.hasMoreElements()) {
                System.err.println(initParams.nextElement());
            }
            System.err.println("Should have seen one parameter name");
            throw new UnavailableException (this,
                "Not given a directory to write survey results!");
        }
    }

    /**
     * Write survey results to output file in response to the POSTed
     * form.  Write a "thank you" to the client.     
     */
    public void doPost(HttpServletRequest req, HttpServletResponse res)
        throws ServletException, IOException
    {
        // first, set the "content type" header of the response
        res.setContentType("text/html");

        //Get the response's PrintWriter to return text to the client.
        PrintWriter toClient = res.getWriter();

        try {
            //Open the file for writing the survey results.
            String surveyName = req.getParameterValues("survey")[0];
            FileWriter resultsFile = new FileWriter(resultsDir
                + System.getProperty("file.separator")
                + surveyName + ".txt", true);
            PrintWriter toFile = new PrintWriter(resultsFile);

            // Get client's form data & store it in the file
            toFile.println("<BEGIN>");
            Enumeration values = req.getParameterNames();
            while(values.hasMoreElements()) {
                String name = (String)values.nextElement();
                String value = req.getParameterValues(name)[0];
                if(name.compareTo("submit") != 0) {
                    toFile.println(name + ": " + value);
                }
            }
            toFile.println("<END>");

            //Close the file.
            resultsFile.close();

            // Respond to client with a thank you
            toClient.println("<html>");
            toClient.println("<title>Thank you!</title>");
            toClient.println("Thank you for participating");
            toClient.println("</html>");

        } catch(IOException e) {
            e.printStackTrace();
            toClient.println(
                "A problem occured while recording your answers.  "
                + "Please try again.");
        }

        // Close the writer; the response is done.
        toClient.close();
    }
}

[0] Java-Homepage bei Sun
[1] Java Geschichte 1
[2] Java Geschichte 2
[3] JDK 1.02 Docs bei SUN, JDK 1.02 Docs an der TU-Chemnitz
[4] JDK 1.1 Docs bei SUN, JDK 1.1 Docs an der TU-Chemnitz
[5] JDK 1.2 Beta Docs bei SUN
[6] Java Tutorial bei SUN, Java Tutorial an der TU-Chemnitz
[7] Design Patterns, Gamma, Erich, u.a. - ISBN 0-201-63361-2
[8] A system of patterns, Buschmann, Frank, u.a. - ISBN 0-471-95869-7
[9] OMG - Object Management Group
[10] Servlet Homepage bei SUN
[11] JDK für LINUX bei Blackdown.ORG, JDK für LINUX von Sergey Nikitin