Titel | Inhalt | Suchen | Index | DOC | Handbuch der Java-Programmierung, 3. Auflage
<< | < | > | >> | API | Kapitel 40 - Applets II

## 40.1 Verweise auf andere Seiten

- 40.1 Verweise auf andere Seiten
  - 40.1.1 Die Klasse URL
  - 40.1.2 Der Applet-Kontext
  - 40.1.3 Die Methode showDocument

### 40.1.1 Die Klasse URL

Das Konzept der URLs ist eines der wichtigsten im ganzen Web. Ein URL (Uniform Resource Locator) ist ein universelles Hilfsmittel zur Darstellung von Internet-Adressen. Hinter jedem Link, der sich auf einem HTML-Dokument verbirgt, steht ein URL, der beim Aufrufen des Links angesprungen wird.

Der Aufbau von URLs ist in seiner Vielfältigkeit recht komplex und ermöglicht es, sehr unterschiedliche Typen von Adressen zu verwalten. Ein URL-Link kann beispielsweise verwendet werden, um eine andere Web-Seite aufzurufen, eine Datei zu laden oder elektronische Post an einen anderen Anwender zu senden. Wir wollen hier nur auf die URLs eingehen, die man zur Darstellung von Web-Seiten-Adressen verwendet. Eine exakte Beschreibung des URL-Konzepts befindet sich in RFC 1630 (allgemeine Hinweise zu den RFCs finden sich in Abschnitt 45.1.5).

Ein Uniform Resource Locator besteht aus mehreren Teilen. Als erstes wird ein Dienst (auch Protokoll genannt) angegeben, der beschreibt, auf welche Art von Service die Adresse verweist. Typische Dienste sind html für Web-Seiten, ftp für einen File-Download oder mailto, um eine Mail zu versenden.

Bei einer HTML-Adresse besteht der URL aus drei weiteren Teilen:

- Dem Host-Namen (z.B. java.sun.com), der vom Dienst durch die Zeichenkette "://" getrennt wird.
- Einer optionalen Port-Nummer (z.B. 80 für einen http-Dämon), die vom Host-Namen durch einen ":" abgetrennt wird.
- Einem Dateinamen (z.B. bugsandfeatures.html), der vom Host-Namen bzw. der Port-Nummer durch "/" abgetrennt wird. Diesem Dateinamen kann auch die Rolle eines Kommandos oder Parameterstrings zukommen, beispielsweise, wenn ein CGI-Script aufgerufen wird.

Gültige URLs sind also http://java.sun.com/bugsandfeatures.html oder auch http://www.yahoo.com. Die meisten Browser und Server sind in der Lage, fehlende Bestandteile eines URLs weitgehend zu ergänzen. Fehlt beispielsweise die Dateierweiterung, wird .html angehängt. Bezeichnet der URL lediglich ein Verzeichnis, wird ein Standard-Dateiname wie beispielsweise index.html oder default.htm angehängt.

Java implementiert das Konzept eines Uniform Resource Locators durch eine eigene Klasse `URL`, die sich im Paket `java.net` befindet. Diese dient dazu, die Syntax von URLs zu kapseln und die einzelnen Bestandteile voneinander zu trennen. Die Klasse `URL` besitzt vier Konstruktoren, die es ermöglichen, eine Adresse auf verschiedene Art zusammenzubauen. Wir werden hier nur die Variante verwenden, die einen `String` als Argument akzeptiert:

    public URL(String url)
      throws MalformedURLException
| java.net.URL

Bei der Anwendung dieses Konstruktors muß ein syntaktisch einwandfreier URL als `String` übergeben werden. Enthält der String einen Syntaxfehler, löst der Konstruktor eine Ausnahme des Typs `MalformedURLException` aus.

An dieser Stelle wird natürlich noch nicht überprüft, ob die angegebene Adresse wirklich existiert. Dazu wäre eine funktionsfähige Netzwerkverbindung nötig, und es würde ein in der Regel nicht akzeptabler Aufwand bei der Konstruktion von URL-Objekten entstehen. Die im Konstruktor durchgeführten Überprüfungen sind lediglich syntaktischer Natur, um sicherzustellen, daß ein URL ein gültiges Adressenformat hat. Nachdem ein gültiges `URL`-Objekt erzeugt wurde, kann es zur Adressenübergabe verwendet werden.

|  | Weitere Hinweise zur Anwendung der Klasse `URL` finden sich in Abschnitt 45.4. |  |
Hinweis

### 40.1.2 Der Applet-Kontext

Ein anderes Konzept, das bei der Programmierung von Links eine Rolle spielt, ist das des Applet-Kontexts. Hierunter versteht Java das Programm, das das aktuelle Applet ausführt. Dies ist in der Regel der Browser, der das Applet geladen hat; während der Entwicklung und Testphase des Programms kann es natürlich auch der Appletviewer sein.

Mit Hilfe der Methode `getAppletContext` kann ein Objekt des Typs `AppletContext` beschafft werden:

    public AppletContext getAppletContext()
| java.applet.Applet

In der Klasse `AppletContext` gibt es eine Reihe von Methoden, die dem Applet Funktionalitäten des Browsers zur Verfügung stellen:

- `getApplets` liefert eine Liste aller laufenden Applets
- `getApplet` liefert ein einzelnes Applet, wenn sein Name bekannt ist
- `showDocument` erlaubt das Laden eines anderen HTML-Dokuments

Wir wollen auf die ersten beiden Methoden nicht weiter eingehen, sondern uns hier lediglich mit `showDocument` beschäftigen.

### 40.1.3 Die Methode showDocument

Die Methode `showDocument` kann dazu verwendet werden, eine andere Web-Seite zu laden. Dies führt dazu, daß das aktive Applet angehalten wird und die Kontrolle über die Web-Seite verliert. Befindet sich auf der neuen Web-Seite ein anderes Applet, so wird dieses geladen bzw. - falls es bereits geladen war - reaktiviert.

Die Methode `showDocument` steht in zwei unterschiedlichen Varianten zur Verfügung:

    public void showDocument(URL url)

    public void showDocument(URL url, String name)
| java.applet.AppletContext

In seiner einfachsten Form erwartet `showDocument` lediglich einen einzigen Parameter, nämlich die Adresse der Zielseite. Hier muß ein gültiges `URL`-Objekt angegeben werden, also eine komplette Adresse mit Dienst, Host-Name, Verzeichnis und Datei. In der zweiten Variante kann zusätzlich ein target angegeben werden, also das Sprungziel innerhalb der ausgewählten Datei. Hier können die Standard-HTML-Targets `_self`, `_parent`, `_top` und `_blank` sowie alle benutzerdefinierten Sprungmarken verwendet werden.

|  |  |  | Soll statt einer absoluten eine relative Adresse angegeben werden , also beispielsweise eine andere Web-Seite aus demselben Verzeichnis oder aus einem seiner Unterverzeichnisse, muß das `URL`-Objekt mit einem erweiterten Konstruktor instanziiert werden. Zusätzlich zur Angabe des relativen URL-Strings ist als erstes Argument ein Kontext-URL anzugeben, der das Basisverzeichnis für das zweite Argument vorgibt. Mit Hilfe der Methoden `getCodeBase` und `getDocumentBase` der Klasse `Applet` kann beispielsweise das Stammverzeichnis des Applets bzw. der HTML-Seite ermittelt werden. Als zweites Argument muß dann lediglich der Dateiname relativ zu diesem Verzeichnis angegeben werden. |  |
Tip

Das folgende Applet demonstriert die Anwendung von `showDocument`. Es erstellt eine Reihe von Buttons und zeigt sie auf dem Bildschirm an. Wird einer der Buttons gedrückt, verzweigt das Programm auf die durch den Button spezifizierte Seite. Während der Initialisierung sucht das Applet nach Parametern mit den Namen `button1`, `button2` usw. Jeder dieser Parameter sollte den Namen des Buttons und die Zieladresse enthalten. Die beiden Teile müssen durch ein Komma getrennt sein. Eine Besonderheit besteht darin, daß auch Adressen angegeben werden können, die mit `=` anfangen. In diesem Fall wird das `=` entfernt und der interne URL nicht absolut, sondern unter Verwendung des erweiterten Konstruktors relativ zur aktuellen Web-Seite angelegt.

Um die Buttons sowohl auf dem Bildschirm anzeigen zu können als auch den zugehörigen URL zu speichern, wurde eine neue Klasse `URLButton` definiert. `URLButton` erweitert die Klasse `Button` um die Fähigkeit, einen URL mitzuspeichern und bei Bedarf abzufragen.

Hier ist das Listing:

    001 /* URLLaden.java */
    002
    003 import java.applet.*;
    004 import java.awt.*;
    005 import java.awt.event.*;
    006 import java.util.*;
    007 import java.net.*;
    008
    009 class URLButton
    010 extends Button
    011 {
    012   private URL url;
    013
    014   public URLButton(String label, URL url)
    015   {
    016     super(label);
    017     this.url = url;
    018   }
    019
    020   public URL getURL()
    021   {
    022     return url;
    023   }
    024 }
    025
    026 public class URLLaden
    027 extends Applet
    028 implements ActionListener
    029 {
    030   Vector buttons;
    031
    032   public void init()
    033   {
    034     super.init();
    035     setLayout(new FlowLayout());
    036     addNotify();
    037     buttons = new Vector();
    038     for (int i=1; ; ++i) {
    039       String s = getParameter("button"+i);
    040       if (s == null) {
    041         break;
    042       }
    043       try {
    044         StringTokenizer st = new StringTokenizer(s,",");
    045         String label = st.nextToken();
    046         String urlstring = st.nextToken();
    047         URL url;
    048         if (urlstring.charAt(0) == '=') {
    049           urlstring = urlstring.substring(1);
    050           url = new URL(getDocumentBase(),urlstring);
    051         } else {
    052           url = new URL(urlstring);
    053         }
    054         URLButton button = new URLButton(label,url);
    055         button.addActionListener(this);
    056         add(button);
    057         buttons.addElement(button);
    058       } catch (NoSuchElementException e) {
    059         System.out.println("Button"+i+": "+e.toString());
    060         break;
    061       } catch (MalformedURLException e) {
    062         System.out.println("Button"+i+": "+e.toString());
    063         break;
    064       }
    065     }
    066   }
    067
    068   public void actionPerformed(ActionEvent event)
    069   {
    070     URLButton source = (URLButton)event.getSource();
    071     Enumeration en = buttons.elements();
    072     while (en.hasMoreElements()) {
    073       URLButton button = (URLButton)en.nextElement();
    074       if (button == source) {
    075         System.out.println(
    076           "showDocument("+button.getURL().toString()+")"
    077         );
    078         getAppletContext().showDocument(button.getURL());
    079       }
    080     }
    081   }
    082 }
| URLLaden.java

Listing 40.1: Laden von Web-Seiten aus einem Applet

Um die wichtigsten Fälle zu demonstrieren, wurde das Applet mit der folgenden HTML-Datei gestartet:

    001 <html>
    002 <head>
    003 <title>URLLaden</title>
    004 </head>
    005 <body>
    006 <h1>URLLaden</h1>
    007 <applet code=URLLaden.class width=400 height=200>
    008 <param
    009    name="button1"
    010    value="JAVA-Home,http://java.sun.com/">
    011 <param
    012    name="button2"
    013    value="Guido-Home,http://www.gkrueger.com">
    014 <param
    015    name="button3"
    016    value="Schranke,=Schranke.html">
    017 <param
    018    name="button4"
    019    value="Jana30,=images/jana30.gif">
    020 Hier steht das Applet URLLaden.class
    021 </applet>
    022 </body>
    023 </html>
| URLLaden.html

Listing 40.2: Die HTML-Datei zum Laden der Webseiten

|  | Hier werden vier verschiedene Buttons definiert: Der Button JAVA-Home verzweigt auf die Java-Seite von SUN. Der Button Guido-Home verzweigt auf die Homepage des Autors. Der Button Schranke lädt das Beispiel `Schranke`, das sich in demselben Verzeichnis wie die aktuelle HTML-Seite befindet. Der Button Jana30 schließlich demonstriert zwei weitere Features. Erstens, daß es bei den meisten Browsern auch möglich ist, Grafikdateien (beispielsweise im GIF-Format) zu laden. Zweitens, wie man mit Unterverzeichnissen umgeht (Pfadtrennzeichen in UNIX-Manier). |  |
Hinweis

Die Ausgabe des Programms im Netscape Navigator sieht folgendermaßen aus:

Abbildung 40.1: Darstellung von URLLaden im Netscape Navigator

Titel | Inhalt | Suchen | Index | DOC | Handbuch der Java-Programmierung, 3. Auflage, Addison Wesley, Version 3.0
<< | < | > | >> | API | © 1998-2002 Guido Krüger, http://www.javabuch.de