Unterlagen zu Kap. 6 (pdf

HOCHSCHULE MUENCHEN
FAKULTÄT FÜR ELEKTROTECHNIK UND INFORMATIONSTECHNIK
BEREICH DATENTECHNIK
V – JV – 600 – 00 – TH – 02
-----------------------------------------------------------------------------------
Programmieren in Java
Kapitel 6
6. Applets
6.1.
Aufbau und Funktionsweise
6.2.
Applet-Tag im HTML-Code
6.3.
Java-Applet-API
6.4.
Sicherheitsbeschränkungen
FACHHOCHSCHULE MUENCHEN
FACHBEREICH ELEKTROTECHNIK UND INFORMATIONSTECHNIK
FG TECHNISCHE INFORMATIK
V – JV – 611 – 00 – TH – 02
-----------------------------------------------------------------------------------
Aufbau und Funktionsweise von Java-Applets (1)
• Prinzip eines Applets
◇ Ein Applet ist ein – i.a. kleineres – Java-Programm, das nicht eigenständig durch eine JVM ausgeführt wird sondern
innerhalb eines Java-fähigen Web-Browsers bzw eines Applet-Viewers abläuft.
◇ Als Applet-Viewer steht z.B. das im JDK enthaltene Programm appletviewer zur Verfügung.
◇ Ein Applet besitzt immer eine graphische Benutzeroberfläche.
Das diese Oberfläche bereitstellende Top-Level-Fenster ist aber nicht eigenständig, sondern befindet sich innerhalb
des Browser-Fensters.
◇ Üblicherweise befindet sich der Applet-Code auf einem Server. Er kann nur aus einer HTML-Seite heraus gestartet
werden. Hierfür muß die Start-Klasse des Applets durch ein <APPLET>-Tag in der HTML-Seite referiert werden..
◇ Stößt der Browser (bzw. der Applet-Viewer) bei der Interpretation der HTML-Seite auf ein <APPLET>-Tag, so
startet er seine – direkt integrierte oder als Plug-In eingebundene – eine JVM enthaltene Java-Laufzeit-Umgebung
(JRE – Java Runtime Environment). Diese lädt die Start-Klasse vom Server, instanziert sie und beginnt die Abarbeitung ihres Codes durch den Aufruf spezieller Methoden.
◇ Die Funktionalität eines als Applet realisierten Java-Programms ist nicht auf die Start-Klasse begrenzt. Ausgehend
von der Start-Klasse können – wie bei einem Java-Applikations-Programm – weitere Klassen geladen und instanziert
werden.
Trotzdem bezieht man den Begriff Applet häufig nur auf die Start-Klasse bzw auf das von ihr im Browser instanzierte Objekt.
• Die Klassen Applet und JApplet
◇ Die Start-Klasse eines Applets muß von der Klasse Applet (Package java.applet) abgeleitet sein.
Diese Klasse ist ihrerseits über die Klasse Panel von der Klasse Container abgeleitet. Sie verfügt daher über
die allen AWT-Komponenten- und Container-Klassen gemeinsamen Fähigkeiten zum Aufbau graphischer Oberflächen (einschliesslich des Event-Handling-Mechanismus für Benutzereingaben). Die Klasse Applet selbst ergänzt
diese durch die besonderen Fähigkeiten und Funktionalitäten, die für Applets benötigt werden.
Das von der Browser-JVM instanzierte Objekt der Applet-Start-Klasse bildet einen Container, in den AWT-GUIKomponenten eingefügt werden können. Defaultmässig besitzt dieser Container ein BorderLayout.
◇ Wenn die vom Applet dargebotene Benutzeroberfläche aus Swing-GUI-Komponenten bestehen soll, muß seine StartKlasse von der Klasse JApplet (Package javax.swing) abgeleitet sein.
Diese ist selbst direkt von der Klasse Applet abgeleitet und ergänzt diese um die besonderen Fähigkeiten und
Eigenschaften des Swing-Frameworks.
Das von der Browser-JVM instanzierte Objekt einer von JApplet abgeleiteten Start-Klasse bildet somit einen
Container für Swing-GUI-Komponenten. Dieser besitzt – wie ein JFrame-Container – eine Content Pane, in die
Komponenten einzufügen sind. Defaultmässig besitzt die Content Pane ein BorderLayout.
• Wesentliche Unterschiede zwischen Applets und Applikationsprogrammen
Applet
Applikationsprogramm
Start-Klasse
von Applet bzw JApplet abgeleitet
keine main()-Methode
beliebige Klasse,
statische main()-Methode
Programmstart
Laden Start-Klasse in Browser-JVM,
Instanzierung, Aufruf spezieller API-Methoden
Laden Start-Klasse in JVM,
Aufruf von deren main()-Methode
Benutzerschnittstelle
graphisch
Konsole oder graphisch
Zugriff zum lokalen
Dateisystem
durch Security-Manager in Browser-JVM
i.a. verhindert (Lesen, Schreiben, Ausführen)
Lesen, Schreiben, Ausführen von
Dateien i.a. zulässig
FACHHOCHSCHULE MUENCHEN
FACHBEREICH ELEKTROTECHNIK UND INFORMATIONSTECHNIK
FG TECHNISCHE INFORMATIK
V – JV – 612 – 00 – TH – 02
-----------------------------------------------------------------------------------
Aufbau und Funktionsweise von Java-Applets (2)
• Demonstrationsbeispiel eines sehr einfachen Applets
◇ Applet-Code (Datei HelloWorldApplet.java)
import java.applet.Applet;
import java.awt.Graphics;
public class HelloWorldApplet extends Applet
{
public void paint(Graphics g)
{ super.paint(g);
g.drawString("This Applet just says : \"Hello world !\"", 70, 25);
}
}
◇ Einbettende HTML-Datei (HelloWorldApplet.html)
<HTML>
<HEAD>
<TITLE> A Simple Applet </TITLE>
</HEAD>
<BODY>
<H3>
Ein sehr einfaches Applet :
</H3>
<APPLET CODE="HelloWorldApplet.class" WIDTH=340 HEIGHT=40>
</APPLET>
</BODY>
</HTML>
◇ Darstellung des Applets im Browser
◇
Darstellung des Applets durch :
appletviewer
HelloWorldApplet.html
FACHHOCHSCHULE MUENCHEN
FACHBEREICH ELEKTROTECHNIK UND INFORMATIONSTECHNIK
BEREICH DATENTECHNIK
V – JV – 613 – 00 – TH – 03
-----------------------------------------------------------------------------------
Aufbau und Funktionsweise von Java-Applets (3)
• Der Lebenszyklus eines Applets
◇ Ein Applet durchläuft während seiner Lebensdauer mehrere Zustände :
init()
no-arg-Konstruktor
instanziert
start()
initialisiert
paint()
gestartet
stop()
start()
angehalten
destroy()
zerstört
◇ Zur Instanzierung eines Applets (genauer : eines Objekts der Applet-Start-Klasse) wird von der JRE des Browsers/
Applet-Viewers der no-arg-Konstruktor der Applet-Start-Klasse aufgerufen.
Normalerweise wird für diese ein derartiger Konstruktor nicht explizit definiert, stattdessen wird der Default-nor-argKonstruktor verwendet. Dieser ruft lediglich den no-arg-Konstruktor der Basisklasse (Applet oder JApplet)
auf. Applets werden also üblicherweise durch ihren Konstruktor nicht initialisiert.
◇ Der Übergang zwischen den verschiedenen Applet-Zuständen wird durch spezielle Memberfunktionen der Klasse
Applet, die in der Applet-Start-Klasse gegebenenfalls geeignet überschrieben werden müssen, begleitet.
Diese Memberfunktionen werden durch die JRE des Browsers/Applet-Viewers automatisch in verschiedenen Situationen aufgerufen. Nach ihrer Ausführung befindet sich das Applet im jeweils neuen Zustand.
◇ Unmittelbar nach der erfolgreichen Instanzierung eines Objekts der Applet-Start-Klasse wird dessen Methode init()
aufgerufen. Diese dient zur Initialisierung des Applets und überführt es somit in den Zustand "initialisiert"
In ihr werden Anweisungen ausgeführt, die normalerweise in Konstruktoren enthalten sind, also nur einmal während
der Lebensdauer eines Applets ausgeführt werden sollen. Typischerweise werden durch diese Methode Datenkomponenten initialisiert, die vom Applet dargestellte graphische Oberfläche aufgebaut sowie sonstige dauernd benötigte
Resourcen alloziert.
◇ Nach seiner erfolgreichen Initialisierung gelangt das Applet durch Aufruf der Methode start() in den Zustand
"gestartet" (aktiv).
Diese Methode wird auch immer dann aufgerufen, wenn das im Zustand "angehalten" befindliche Applet erneut
aktiviert wird. Dies kann z.B. dann der Fall sein, wenn die HTML-Seite, in die das Applet eingebettet ist, nach dem
kurzzeitigen Laden einer anderen Seite erneut angezeigt wird oder das Browser/Applet-Viewer-Fenster nach vorübergehender Ikonifizierung wieder voll dargestellt wird.
Grundsätzlich kann ein Applet also während seiner Lebensdauer mehrmals zwischen den Zuständen "gestartet" und
angehalten" wechseln.
Allerdings verhalten sich viele Browser in derartigen Situation anders : Im ersten Fall vernichten sie das Applet und
instanzieren es erneut. Im zweiten Fall verbleibt das Applet auch während der Ikonifizierung im Zustand "gestartet".
In der Methode start() sollten alle Aktionen gestartet werden, die zur Ausführung des Applets notwendig sind
(z.B. Erzeugung und Start von Animations-Threads, Allokation von nur temporär benötigten Resourcen usw)
◇ Die Methode stop() überführt das Applet in den Zustand "angehalten" (inaktiv). Sie wird unmittelbar vor der Zerstörung eines Applets aufgerufen. Ausserdem kann sie immer dann aufgerufen werden, wenn das Applet vorübergehend
nicht dargestellt wird (Laden einer anderen HTML-Seite, Ikonifizierung des Browser-Fensters, s. oben).
Die in der Methode start() begonnenen Aktionen und vorgenommenen Allokationen sollen in der Methode
stop() wieder angehalten bzw freigegeben werden ( Verhinderung unnötigen Resourcenverbrauchs)
◇ Die Methode destroy() wird aufgerufen, wenn das Applet mit Sicherheit nicht mehr benötigt wird. Es gelangt in
den Zustand "zerstört". Danach wird es endgültig beseitigt (aus dem Browser und dem Speicher entfernt).
In dieser Methode sollten die in der init()-Methode durchgeführten Allokationen – soweit notwendig – wieder
aufgehoben werden ( Funktionalität eines Destruktors !).
◇ Die Standard-Implementierung der vier Lebenszyklus-Methoden (methods for milestones) in der Klasse Applet
enthält einen leeren Funktionsrumpf.
Bei Bedarf müssen sie in einer Applet-Start-Klasse geeignet überschrieben werden.
FACHHOCHSCHULE MUENCHEN
FACHBEREICH ELEKTROTECHNIK UND INFORMATIONSTECHNIK
FG TECHNISCHE INFORMATIK
V – JV – 614 – 00 – TH – 02
-----------------------------------------------------------------------------------
Aufbau und Funktionsweise von Java-Applets (4)
• Die Methode paint()
◇ Die Klasse Applet erbt von der Klasse Container (Package java.awt) u.a. die Methode
public void paint(Graphics g)
◇ Diese Methode wird vom JRE des Browsers/Applet-Viewers immer dann aufgerufen, wenn das Applet-Fenster neu
gezeichnet werden muß.
Dies ist z.B. immer dann der Fall,
- wenn das Browser/Applet-Viewer-Fenster und damit das eingebettete Applet-Fenster zum ersten Mal dargestellt
wird (Aufruf von paint() nach start())
- wenn das Browser/Applet-Viewer-Fenster wegen einer Größenänderung neu gezeichnet wird
- wenn das Applet-Fenster durch andere Fenster überdeckt war und wieder sichtbar wird
- wenn im Applet-Code durch den Aufruf von repaint() ein Neuzeichnen veranlasst wird.
◇ Die Methode wird häufig in Applet-Start-Klassen überschrieben, um gezielt bestimmte Graphik-Ausgaben(einschliesslich Text) direkt in das Applet-Fenster vorzunehmen.
(z.B. g.drawString("Hallo") statt Einfügen einer Label-(bzw JLabel-)Komponente mit dem Text
"Hallo" in das Applet-Objekt)
Um eine einwandfreie Funktion sicherzustellen sollte die überschreibende paint()-Funktion als erstes die von
Container geerbte paint()-Funktion aufrufen ( erste Anweisung : super.paint(g))
• Anmerkungen zum Erstellen / Testen von Applets
◇ Während ihrer Entwicklung sollten Applets grundsätzlich mit dem JDK-Programm appletviewer getestet
werden.
Bei diesem Programm ist sichergestellt, dass die HTML-Seite und damit das auszuführende Applet bei jedem Aufruf
neu geladen wird. Damit wird immer die neueste Version des Applets ausgeführt.
◇ Browser dagegen speichern den einmal geladenen Code eines Applets im Arbeitsspeicher und besitzen darüberhinaus
einen Seiten-Cache.
Dadurch wird nach Änderung des Quellcodes eines Applets und seiner Neu-Übersetzung gegebenenfalls nicht die dadurch neu entstandene Version des Applets sondern die im Arbeitsspeicher bzw Cache vorhandene alte Version ausgeführt.
Selbst das Neuladen der HTML-Seite aktualisiert nicht das im Arbeitssspeicher vorhandene Applet.
◇ Das Programm appletviewer stellt allerdings nur das Applet und nicht die übrigen Elemente der HTML-Seite dar.
• Vereinigung von Applet und Applikations-Programm
◇ Es ist möglich, Java-Programme zu erstellen, die sowohl als Applet als auch als Applikations-Programm gestartet
werden können.
◇ Um dies zu realisieren, muß die Start-Klasse
▻ sowohl von der Klasse Applet abgeleitet sein und gegebenenfalls die Lebenszyklus-Methoden implementieren
▻ als auch eine geeignete main()-Methode definieren
◇ Damit das Applet und das Applikations-Programm die gleiche GUI besitzen, sollte der Aufbau derselben in einer
eigenen Memberfunktion implementiert sein, die sowohl von der init()-funktion als auch der main()-Funktion
(bzw gegebenenfalls auch von einem geeigneten Konstruktor) aufgerufen werden kann.
FACHHOCHSCHULE MUENCHEN
FACHBEREICH ELEKTROTECHNIK UND INFORMATIONSTECHNIK
BEREICH DATENTECHNIK
V – JV – 615 – 01 – TH – 01
-----------------------------------------------------------------------------------
Aufbau und Funktionsweise von Java-Applets (5-1)
• Demonstrationsbeispiel zum Lebenszyklus eines Applets
◇ Applet-Code (Datei LifeCycleDemo.java)
// LifeCycleDemo.java
import java.applet.Applet;
import java.awt.*;
import javax.swing.*;
public class LifeCycleDemo extends JApplet
{ JLabel info;
public LifeCycleDemo()
// i.a. nicht ueblich, nur fuer Demo-Zwecke
{ super();
System.out.println("constructing ... ");
}
public void init()
{ info = new JLabel("Demo des Applet Lifecycles", SwingConstants.CENTER);
info.setBackground(Color.YELLOW);
info.setOpaque(true);
getContentPane().add(info);
System.out.println("initializing... ");
}
public void start()
{ System.out.println("starting... ");
}
public void stop()
{ System.out.println("stopping... ");
}
public void destroy()
{ System.out.println("destroying...");
}
public void paint(Graphics g)
{ super.paint(g);
System.out.println("painting ...");
//Zeichnen eines Rechtecks um Fensterflaeche des Applets.
g.drawRect(0, 0, getSize().width - 1, getSize().height - 1);
}
}
◇ Einbettende HTML-Datei (LifeCycleDemo.html)
<HTML>
<HEAD>
<TITLE> A Simple Aplet </TITLE>
</HEAD>
<BODY>
<APPLET code="LifeCycleDemo"
width="300" height = "100" >
</APPLET>
</BODY>
</HTML>
FACHHOCHSCHULE MUENCHEN
FACHBEREICH ELEKTROTECHNIK UND INFORMATIONSTECHNIK
BEREICH DATENTECHNIK
V – JV – 615 – 02 – TH – 01
-----------------------------------------------------------------------------------
Aufbau und Funktionsweise von Java-Applets (5-2)
• Demonstrationsbeispiel zum Lebenszyklus eines Applets, Forts.
◇ Darstellung des Applets durch : appletviewer LifeCycleDemo.html
◇ Beispiel zur Konsolenausgabe
Ausführung folgender Aktionen
- Start des Applets im Appletviewer
- Vergrösserung des Applet-Viewer-Fensters in der Breite
- Vergrösserung des Applet-Viewer-Fensters in der Höhe
- Ikonifizierung des Applet-Viewer-Fensters
- Herstellung der Normalgroesse des Applet-Viewer-Fensters
- Verkleinerung des Applet-Viewer-Fensters in der Breite
- Schliessen des Applet-Viewer-Fensters
( einmaliger Aufruf von paint())
( einmaliger Aufruf von paint())
( zweimaliger Aufruf von paint())
E:\Java\fhm\ee\vorl\applets>appletviewer LifeCycleDemo.html
constructing ...
initializing...
starting...
painting ...
painting ...
painting ...
stopping...
starting...
painting ...
painting ...
painting ...
stopping...
destroying...
E:\Java\fhm\ee\vorl\applets>
FACHHOCHSCHULE MUENCHEN
FACHBEREICH ELEKTROTECHNIK UND INFORMATIONSTECHNIK
BEREICH DATENTECHNIK
V – JV – 616 – 01 – TH – 01
-----------------------------------------------------------------------------------
Aufbau und Funktionsweise von Java-Applets (6-1)
• Demonstrationsbeispiel zur Vereinigung von Applet und Applikations-Programm
◇ Applet-Code (Datei AppletAndAppliDemo.java)
// AppletAndAppliDemo.java
import java.applet.*;
import java.awt.*;
import javax.swing.*;
public class AppletAndAppliDemo extends JApplet
{
String progType="Application";
JLabel lab;
public void init()
{
progType="Applet";
setContentPane(buildGUI());
}
private Container buildGUI()
{
JPanel pan=new JPanel();
lab=new JLabel("gestartet als " + progType, SwingConstants.CENTER);
lab.setBackground(Color.YELLOW);
lab.setBorder(BorderFactory.createEmptyBorder(10,10,10,10));
lab.setOpaque(true);
pan.add(lab);
return pan;
}
public static void main(String[] args)
{
AppletAndAppliDemo app = new AppletAndAppliDemo();
JFrame frame = new JFrame("AppletAndAppliDemo");
frame.setContentPane(app.buildGUI());
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(330, 150);
frame.setVisible(true);
}
}
◇ Einbettende HTML-Datei (AppletAndAppliDemo.html)
<HTML>
<HEAD>
<TITLE> AppletAndAppliDemo</TITLE>
</HEAD>
<BODY>
<APPLET code="AppletAndAppliDemo"
width="330" height = "150" >
</APPLET>
</BODY>
</HTML>
FACHHOCHSCHULE MUENCHEN
FACHBEREICH ELEKTROTECHNIK UND INFORMATIONSTECHNIK
BEREICH DATENTECHNIK
V – JV – 616 – 02 – TH – 01
-----------------------------------------------------------------------------------
Aufbau und Funktionsweise von Java-Applets (6-2)
• Demonstrationsbeispiel zur Vereinigung von Applet und Applikations-Programm, Forts.
◇ Start als Applet mittels : appletviewer AppletAndAppliDemo.html
◇ Start als Applikations-Programm mittels : java AppletAndAppliDemo
FACHHOCHSCHULE MUENCHEN
FACHBEREICH ELEKTROTECHNIK UND INFORMATIONSTECHNIK
FG TECHNISCHE INFORMATIK
V – JV – 621 – 00 – TH – 03
-----------------------------------------------------------------------------------
HTML-<APPLET>-Tag (1)
• Minimalform des <APPLET>-Tags
◇ Vorbemerkung :
In der HTML-Syntax wird nicht zwischen Groß- und Klein-Buchstaben unterscheiden.
◇ Das zur Referenzierung eines Applets (genauer : der Applet-Start-Klasse) in einer HTML-Seite benötigte <APPLET>Tag besitzt Attribute. Diese dienen zur Festlegung bestimmter Eigenschaften des Applets.
◇ In seiner Minimalform muß das <APPLET>- Tag den Namen der Applet-Start-Klasse sowie die Größe (Breite und
Höhe) des Applet-Fensters festlegen.
Damit muß es wenigstens die folgenden drei Attribute definieren :
▻ code :
Dateiname der Bytecode-Datei der Applet-Start-Klasse. Die Extension .class kann weggelassen
werden. Die Angabe eines auch Directory-Angaben enthaltenen Dateipfades ist nicht zulässig.
Der Dateiname wird relativ zur Codebase-URL der Applet-Start-Klasse ausgewertet.
Ohne explizite Festlegung (Attribut codebase) ist diese Codebase-URL gleich der Directory-URL
der HTML-Datei, d.h. Applet-Bytecode-Datei und HTML-Datei müssen sich im gleichen Verzeichnis
befinden.
▻ width : Breite des Applet-Fensters in Pixel
▻ height : Höhe des Applet-Fensters in Pixel
◇ Beispiel :
<APPLET code
= "LifeCycleDemo"
width = "300"
height = "100" >
</APPLET>
• Allgemeine Form des <APPLET>-Tags
◇ Die Werte der Attribute des <APPLET>-Tags werden als Strings interpretiert.
Sie können mit oder ohne String-Quotes (doppelte Hochkommata) angegeben werden.
◇ Die Minimalform des <APPLET>-Tags kann optional ergänzt werden um
▻ weitere Attribute
▻ Parameter, die an das Applet übergeben werden
▻ alternativen HTML-Code, der von Browsern, die das <APPLET>-Tag nicht verstehen, interpretiert wird
◇ Allgemeine Form des <APPLET>-Tags (Die eckigen Klammern [...] kennzeichnen optionale Angaben) :
<APPLET
[codebase = codebaseURL]
code = appletFile
[archive = archivFile]
[alt = alternateText]
[name = appletInstanceName]
width = wpixels
heigt = hpixels
[align = alignment]
[vspace = vpixels]
[hspace = hpixels]
>
[<PARAM name = appletParameter1 value = parval1 >]
[<PARAM name = appletParameter2 value = parval2 >]
. . .
[alternateHTML]
</APPLET>
FACHHOCHSCHULE MUENCHEN
FACHBEREICH ELEKTROTECHNIK UND INFORMATIONSTECHNIK
BEREICH DATENTECHNIK
V – JV – 622 – 00 – TH – 02
-----------------------------------------------------------------------------------
HTML-<APPLET>-Tag (2)
• Optionale Attribute des <APPLET>-Tags
◇ Die folgenden <APPLET>-Tag-Attribute sind optional :
▻ codebase : URL des Verzeichnisses, in dem sich die Bytecode-Datei der Applet-Start-Klasse bzw die JavaArchiv-Datei (s. unten) befindet.
Die Angabe kann absolut oder relativ zur Directory-URL der HTML-Datei erfolgen
Diese Angabe ist notwendig, wenn die Codebase-URL von der Directory-URL der HTML-Datei
abweicht, also Applet-Bytecode-Datei und HTML-Datei sich in verschiedenen Verzeichnissen
befinden.
▻ archive : Dateiname einer Java-Archiv-Datei (Extension .jar), in der die Applet-Start-Klasse sowie
weitere von dieser verwendete Klassen zusammengefasst sind.
Der Dateiname wird relativ zur Codebase-URL ausgewertet.
▻ alt :
Alternativer Text, der dargestellt wird, wenn der Browser zwar das <APPLET>-Tag versteht,
aber keine Java-Applets ausführen kann
▻ name :
Name der Applet-Instanz (genauer : Instanz der Applet-Start-Klasse).
Dieser Name ermöglicht es, dass sich mehrere Applets auf der gleichen HTML-Seite gegenseitig
lokalisieren und miteinander kommunizieren können.
▻ align :
Ausrichtung des Applets gegenüber dem umgebenden Text (Wirkung wie beim <IMG>-Tag)
Zulässige Werte : midddle, top, bottom, left, right, texttop, absmiddle,
baseline, absbottom
▻ hspace :
▻ vspace :
Horizontaler Abstand (links und rechts) des Applet-Fensters zu den umgebenden Elementen auf der
HTML-Seite in Pixel
Vertikaler Abstand (oben und unten) des Applet-Fensters zu den umgebenden Elementen auf der
HTML-Seite in Pixel
• Parameter in <APPLET>-Tags
◇ Zwischen den Tag-Begrenzungen <APPLET> und </APPLET> können auch Parameter angegeben werden, die
von der HTML-Seite an das Applet (genauer : die Instanz der Applet-Start-Klasse) übergeben werden.
◇ Name und Wert eines Parameters sind als Attribut-Werte eines <PARAM>-Tags festzulegen.
Sowohl der Name als auch der Wert des Parameters sind jeweils als String anzugeben :
<PARAM name = appletParameter value = parval >
◇ Es können beliebig viele Parameter angegeben werden.
◇ In der Klasse Applet existieren Memberfunktionen, mit denen Applets zu diesen Parametern zugreifen können.
• Alternativer HTML-Code
◇ alternateHTML
Steht für alternativen HTML-Code, der für Browser, die das <APPLET>-Tag nicht verstehen, vorgesehen ist.
Er ist zwischen den Tag-Begrenzungen <APPLET> und </APPLET> anzugeben.
Typischerweise kann hier alternativ auszugebender Text oder ein Link zu einer alternativ anzuzeigenden Seite angegeben werden.
◇ Von Browsern, die das <APPLET>-Tag verstehen, wird dieser Code ignoriert.
FACHHOCHSCHULE MUENCHEN
FAKULTÄT ELEKTROTECHNIK UND INFORMATIONSTECHNIK
FG TECHNISCHE INFORMATIK
V – JV – 631 – 00 – TH – 03
-----------------------------------------------------------------------------------
Java-Applet-API (1)
• Allgemeines
◇ Das Java-Applet-API wird im wesentlichen durch die Klasse Applet und das Interface AppletContext
implementiert (beide sind im Package java.applet enthalten).
Auf der Basis der engen Beziehung, die zwischen Applets und den sie ausführenden Web-Browsern besteht, stellen
sie die folgenden Applet-Fähigkeiten zur Verfügung :
∙ Annahme verschiedener Lebenszyklus-Zustände ("milestones")
∙ Zugriff zu im <APPLET>-Tag enthaltenen Parametern
∙ Einbinden von Graphiken, die in Dateien abgelegt sind
∙ Abspielen von Audio- (Sound-)Dateien
∙ Ausgabe von Informationen in der Statuszeile des Browsers
∙ Darstellung eines neuen HTML-Dokuments im Browser
∙ Kommunikation mit anderen Applets auf derselben HTML-Seite
• Das Interface AppletContext
◇ Das Interface AppletContext stellt dem Applet einen Zugang zu seiner Umgebung (der das Applet enthaltenen
HTML-Seite und den anderen Applets auf dieser Seite) zur Verfügung. Es wird durch die JRE des Browsers/AppletViewers implementiert.
◇ Mittels der Methode getAppletContext() kann ein Applet sein AppletContext-"Objekt" ermitteln.
Über dieses kann das Applet mit seiner Umgebung kommunizieren.
◇ Methoden des Interfaces (Auszug)
public Image getImage(URL url)
Erzeugung eines Image-Objekts, das die durch die
absolute URL url referierte Bild-Datei repräsentiert
public AudioClip getAudioClip(URL url)
Erzeugung eines AudioClip-Objekts, das die durch die
absolute URL url referierte Audio-Datei repräsentiert
public void showStatus(String msg)
Ausgabe des Strings msg in die Statuszeile des Browsers
public void showDocument(URL url)
Ersatz der aktuell dargestellten HTML-Seite durch den Inhalt
der durch die absolute URL url referierten HTML-Datei
(darf von einem Applet-Viewer ignoriert werden)
public void showDocument(URL url,
String tgt)
Darstellung des Inhalts der durch die absolute URL url rereferierten HTML-Datei in dem durch tgt bezeichneten
Browser-Frame
(darf von einem Browser / Applet-Viewer ignoriert werden)
public Applet getApplet(String name)
Ermittlung der Instanz des Applets mit dem Namen name
Dabei ist name der Wert des name-Attributs im
<APPLET>-Tag
public Enumeration<Applet> getApplets()
Ermittlung aller Applet-Instanzen in der aktuellen HTMLSeite, einschliesslich des Applets, das diese Methode für
seinen AppletContext aufruft
◇ Für einige dieser Methoden stehen gleichnamige Methoden in der Klasse Applet zur Verfügung, die jeweils mittels
getAppletContext() das zugehörige AppletContext-"Objekt" ermitteln und dann für dieses die entsprechende AppletContext-Methode aufrufen.
In einem derartigen Fall kann der Applet-Programmierer also auf den expliziten Aufruf von getAppletContext()
verzichten und direkt die jeweilige Applet-Methode aufrufen
FACHHOCHSCHULE MUENCHEN
FAKULTÄT ELEKTROTECHNIK UND INFORMATIONSTECHNIK
FG TECHNISCHE INFORMATIK
V – JV – 632 – 00 – TH – 03
-----------------------------------------------------------------------------------
Java-Applet-API (2)
• Memberfunktionen der Klasse Applet (auszugsweiser Überblick)
◇ Lebenszyklus-Methoden : Aufruf durch JRE des Browsers, Implementierung in der Klasse Applet tut nichts,
Bei Bedarf müssen sie in abgeleiteten Klassen geeignet überschrieben werden
public void init()
Aufruf beim erstmaligen Laden des Applets, dient zur Initialisierung des Applets
public void start()
Aufruf beim (Wieder-)Beginn der Applet-Abarbeitung
public void stop()
Aufruf beim (vorübergehenden) Anhalten der Applet-Abarbeitung
public void destroy() Aufruf, wenn das Applet zerstört wird, dient zur Freigabe allozierter Resourcen
◇ einige weitere Methoden :
public String getAppletInfo()
Rückgabe von Informationen über das Applet
Die Implementierung in Applet liefert null.
Die Methode sollte in abgeleiteten Klassen geeignet überschrieben werden (Autor, Version, Copyright)
public AppletContext getAppletContext()
Ermittlung des AppletContext-"Objekts"
public URL getCodeBase()
Ermittlung der URL des Directories, das die Datei mit
dem Applet-Code enthält
public URL getDocumentBase()
Ermittlung der URL der HTML-Datei, in die das Applet
eingebettet ist.
public String[][] getParameterInfo()
Rückgabe von Informationen über die Parameter, die das
Applet "verstehen" kann
Die Implementierung in Applet liefert null.
Die Methode sollte in abgeleiteten Klassen geeignet überschrieben werden (s. Java-API-Dokumentation)
public String getParameter(String name)
Ermittlung des Werts des Parameters bzw <APPLET>-TagAttributs mit dem Namen name
public Image getImage(URL url)
Rückgabe eines Image-Objekts, das die durch die
absolute URL url referierte Bild-Datei repräsentiert
public Image getImage(URL base,
String rel)
Rückgabe eines Image-Objekts, das die Bild-Datei
repräsentiert, die durch die absolute Basis-URL base und
den hierzu relativen Pfad rel referiert wird
public AudioClip getAudioClip(URL url)
Rückgabe eines AudioClip-Objekts, das die durch die
absolute URL url referierte Audio-Datei repräsentiert
public AudioClip getAudioClip(URL base,
String rel)
Rückgabe eines AudioClip-Objekts, das die Audio-Datei
repräsentiert, die durch die absolute Basis-URL base und
den hierzu relativen Pfad rel referiert wird
public void play(URL url)
Abspielen der durch url referierten Audio-Datei
public void play(URL base, String rel)
Abspielen der durch die Basis-URL url und den hierzu
relativen Pfad rel referierten Audio-Datei
public void showStatus(String msg)
Ausgabe des Strings msg in die Statuszeile des Browsers
public static final AudioClip newAudioClip(URL url) (ermöglicht Sound in Applikations-Progr.)
Rückgabe eines AudioClip-Objekts, das die durch die absolute URL url referierte Audio-Datei repräsentiert
FACHHOCHSCHULE MUENCHEN
FACHBEREICH ELEKTROTECHNIK UND INFORMATIONSTECHNIK
BEREICH DATENTECHNIK
V – JV – 633 – 00 – TH – 01
-----------------------------------------------------------------------------------
Java-Applet-API (3)
• Zugriff zu Applet- Parametern
◇ Von der HTML-Seite, in die ein Applet eingebettet ist, lassen sich Parameter an das Applet übergeben, die – analog zu
Kommandozeilen-Parametern von Applikations-Programmen – die Konfigurierung und Steuerung der Arbeitsweise des
Applets ermöglichen ( Applet-Parameter).
◇ Applet-Parameter sind im <APPLET>-Tag mit ihrem Namen und Wert anzugeben :
<PARAM name = appletParameter value = parval >
Sowohl der Name (name) als auch der Wert (value) werden – unabhängig davon, ob sie in doppelte Hochkommata
gesetzt werden oder nicht – als Strings interpretiert
Dabei werden beim Namen Groß- und Klein-Buchstaben als gleich betrachtet (case-insensitive), während der Wert
dagegen case-sensitive ist.
Werden durch die Strings Werte anderer Datentypen dargestellt (z.B. numerische Werte), müssen sie vor ihrer Verwendung erst entsprechend konvertiert werden.
◇ Innerhalb des Applet-Codes kann (typischerweise in der init()-Methode) der Wert eines durch seinen Namen
name spezifizierten Parameters ermittelt werden mittels der Methode
public String getParameter(String name)
Für einen im <APPLET>-Tag nicht gesetzten Parameter liefert die Methode den Wert null.
Mit dieser Methode lassen sich auch die Werte der <APPLET>-Tag-Attribute ermitteln (name == Attribut-Name)
◇ Beispiele typischer Kandidaten für Applet-Parameter sind
- Name und Ort von zu verwendenden Resource-Dateien (z.B. Bild- oder Ton-Dateien)
- Werte, die die Erscheinung des Applets beeinflussen (darzustellender Text, Schrift-Stil und -Größe, Anzahl der Bildwechsel pro sec bei annimierten Applets usw)
- Größe darzustellender Fenster usw
◇ Defaultwerte für Applet-Parameter
Für alle von einem Applet verwendeten Parameter sollten im Applet-Code sinnvolle Defaultwerte vorgesehen werden.
Damit kann eine einwandfreie Funktion des Applets auch dann sichergestellt werden, wenn bestimmte Parameter nicht
durch das <APPLET>-Tag bereitgestellt werden.
◇ Beispiel :
...
<APPLET code="AppletAPIDemo1"
width="250" height = "225" >
...
<PARAM name = "SoundPath" value = "sounds/bgsound.mid" >
...
</APPLET>
...
public class AppletAPIDemo1 extends JApplet
{
// ...
static final String DEF_SOUNDPATH = "sounds/bark.au";
// ...
public void init()
{
String relSoundPath=getParameter("SoundPath");
if (relSoundPath==null)
relSoundPath=DEF_SOUNDPATH;
// ...
}
// ...
}
FACHHOCHSCHULE MUENCHEN
FACHBEREICH ELEKTROTECHNIK UND INFORMATIONSTECHNIK
FG TECHNISCHE INFORMATIK
V – JV – 634 – 00 – TH – 03
-----------------------------------------------------------------------------------
Java-Applet-API (4)
• Zugriff zu Resource-Dateien
◇ Mit einigen Applet-API-Funktionen kann zu Resource-Dateien (i.a. Bild- und Audio-Dateien) zugegriffen werden.
◇ Die entsprechenden Methoden benötigen i.a. ein Objekt der Klasse URL als Parameter.
Objekte der Klasse URL (Package java.net) repräsentieren in Java die als Uniform Resource Locator (URL)
bezeichnete spezielle Darstellung von Resourcen-Adressen im Internet.
◇ Eine URL setzt sich im allgemeinen aus mehreren Komponenten zusammen, im wesentlichen aus :
- Protokoll
- Rechneradresse
- Port-Nummer
- Dateipfad (auf dem Rechner)
Einige der Komponenten können gegebenenfalls auch fehlen. Sie werden dann durch Default-Werte ersetzt
(z.B. Default-Port-Nr des jeweiligen Protokolls).
Eine URL kann auch als relative URL angegeben werden. Sie dient dann zur Spezifikation einer Resource relativ zu
einer anderen URL. Meist handelt es sich hierbei um einen relativen Dateipfad. Derartige relative URLs werden z.B.
häufig innerhalb von HTML-Seiten verwendet. Sie beziehen sich dann auf die Directory-URL der HTML-Seite.
◇ URLs werden üblicherweise als Strings angegeben, z.B.
http://archive.ncsa.uiuc.edu:80/SDG/Software/Mosaic/Demo/url-primer.html
◇ Erzeugung eines URL-Objektes aus einem URL-String :
Hierzu dient der folgende Konstruktor der Klasse URL :
public URL(String spec) throws MalformedURLException
Wenn der als Parameter übergebene String spec formal keine URL bezeichnen kann (z.B. unbekanntes Protokoll),
wird eine MalformedURLException geworfen.
Es existieren noch weitere Konstruktoren mit mehr als einem Parameter.
Einige dieser Konstruktoren erlauben es, einzelne Komponenten einer URL getrennt durch Strings anzugeben.
◇ Applets dürfen i.a. nur zu Dateien zugreifen, die sich auf demselben Rechner befinden, von dem sie selbst (d.h. der
Byte-Code ihrer Start-Klasse) geladen worden sind.
Sinnvollerweise werden derartige Dateien durch eine relative Pfadangabe referiert, die sich entweder auf die CodeBase-URL (Directory-URL der Applet-Start-Klasse) oder auf die Directory-URL der HTML-Seite, in der das Applet
eingebettet ist, bezieht.
◇ Die Klasse Applet stellt Memberfunktionen sowohl zum relativen Dateizugriff als auch zur Ermittlung der i.a.
hierfür benötigen Basis-URLs zur Verfügung.
• Einbinden von Graphiken
◇ Mittels den Applet-Memberfunktionen
public Image getImage(URL url)
public Image getImage(URL base, String rel)
wird ein Objekt der Klasse Image aus dem Inhalt der Bild-Datei erzeugt, die durch die absolute URL url bzw
die Basis-URL base und den relativen Pfad rel referiert wird.
◇ Mittels des Konstruktors
public ImageIcon(Image img)
lässt sich aus dem Image-Objekt img ein Objekt der Klasse ImageIcon erzeugen.
Die Klasse ImageIcon implementiert das Interface Icon.
Die durch Objekte dieser Klasse repräsentierten Bilder können in diversen Swing-Komponten (z.B. JButton,
JLabel, JCheckBox) dargestellt werden (Übergabe durch entsprechende Konstruktoren bzw Memberfunktionen.
Beispiel :
Image img = getImage(getCodeBase(), relPictPath);
JButton pictbut=new JButton(new ImageIcon(img));
◇ Alternativ kann ein Image-Objekt auch innerhalb der Methode public void paint(Graphics g) mittels
der Graphics-Memberfunktion public boolean drawImage(Image img, ...) dargestellt werden.
FACHHOCHSCHULE MUENCHEN
FACHBEREICH ELEKTROTECHNIK UND INFORMATIONSTECHNIK
BEREICH DATENTECHNIK
V – JV – 635 – 00 – TH – 01
-----------------------------------------------------------------------------------
Java-Applet-API (5)
• Abspielen von Audio-Dateien
◇ Java-Applets können Audio-Dateien abspielen.
Ab dem JDK 1.2 steht diese Möglichkeit auch für Applikations-Programme zur Verfügung.
◇ Zum einmaligen Abspielen einer Audio-Datei dienen die Applet-Memberfunktionen
public void play(URL url)
public void play(URL base, String rel)
Die abzuspielende Audio-Datei wird entweder durch eine absolute URL url oder eine Basis-URL base und einen
relativen Pfad rel referiert.
Sie wird bei jedem Aufruf von play() erneut geladen.
◇ Zum beliebig mehrmaligen und auch ständig wiederholten Abspielen ohne erneutes Laden der Audio-Datei ist es
sinnvoll, zunächst ein die Audio-Datei repräsentierendes AudioClip-Objekt zu erzeugen.
Dies ermöglichen die Applet-Memberfunktionen
public AudioClip getAudioClip(URL url)
public AudioClip getAudioClip (URL base, String rel)
Auch hier wird die abzuspielende Audio-Datei entweder durch eine absolute URL url oder eine Basis-URL base
und einen relativen Pfad rel referiert.
◇ Das Interface AudioClip stellt drei Methoden zur Verfügung :
public void play()
einmaliges Abspielen der durch das AudioClip-Objekt repräsentierten Audio-Datei
public void loop()
ständiges wiederholtes Abspielen der repräsentierten Audio-Datei
public void stop()
Beenden des Abspielens der repräsentierten Audio-Datei
Mit ihnen lässt sich das Abspielen der repräsentierten Audio-Datei ohne erneutes Laden beliebig steuern.
Dies kann zum Beispiel in der Methode actionPerformed() eines ActionListener-Objekts als Reaktion
auf das Betätigen eines Schaltknopfes (JButton) erfolgen.
◇ Beispiel :
public class AppletAPIDemo1 extends JApplet
{
// ...
AudioClip sound;
public void init()
{
// ...
sound=getAudioClip(getCodeBase(), relSoundPath);
// ...
}
class ButtonListener implements ActionListener
{
public void actionPerformed(ActionEvent e)
{ Object src=e.getSource();
if (src==startbut)
sound.loop();
else if (src==stopbut)
sound.stop();
}
}
}
FACHHOCHSCHULE MUENCHEN
FACHBEREICH ELEKTROTECHNIK UND INFORMATIONSTECHNIK
BEREICH DATENTECHNIK
V – JV – 636 – 01 – TH – 01
-----------------------------------------------------------------------------------
Java-Applet-API (6-1)
• Demonstrationsbeispiel 1 zum Java-Applet-API
◇ Applet-Code (Datei AppletAPIDemo1.java), 1.Teil
import
import
import
import
java.applet.*;
java.awt.*;
java.awt.event.*;
javax.swing.*;
public class AppletAPIDemo1 extends
{
static final String DEF_LABTEXT
static final String DEF_PICTPATH
static final String DEF_SOUNDPATH
static final int DEF_RAND = 10;
Container c;
JLabel lab;
JButton pictbut;
JButton startbut;
JButton stopbut;
JPanel playpan;
AudioClip sound;
JApplet
= "Demo";
= "images/dukeWaveRed.gif";
= "sounds/bark.au";
public void init()
{ String relSoundPath=getParameter("SoundPath");
if (relSoundPath==null)
relSoundPath=DEF_SOUNDPATH;
sound=getAudioClip(getCodeBase(), relSoundPath);
String labText=getParameter("LabelText");
if (labText==null)
labText=DEF_LABTEXT;
int rand;
try
{ rand = Integer.parseInt(getParameter("RandBreite")); }
catch (NumberFormatException e)
{ rand=DEF_RAND; }
lab=new JLabel(labText, SwingConstants.CENTER);
lab.setAlignmentX(Component.CENTER_ALIGNMENT);
lab.setBackground(Color.YELLOW);
lab.setBorder(BorderFactory.createEmptyBorder(rand, rand, rand, rand));
lab.setOpaque(true);
String relPictPath=getParameter("PictPath");
if (relPictPath==null)
relPictPath=DEF_PICTPATH;
Image img = getImage(getCodeBase(), relPictPath);
pictbut=new JButton(new ImageIcon(img));
pictbut.setAlignmentX(Component.CENTER_ALIGNMENT);
pictbut.setBorder(BorderFactory.createCompoundBorder(
BorderFactory.createEmptyBorder(5, 0, 10, 0),
pictbut.getBorder()));
startbut = new JButton("start play");
startbut.setBackground(Color.GREEN);
stopbut = new JButton("stop play");
stopbut.setBackground(Color.RED);
playpan = new JPanel();
playpan.add(startbut);
playpan.add(stopbut);
ActionListener butlis = new ButtonListener();
startbut.addActionListener(butlis);
stopbut.addActionListener(butlis);
FACHHOCHSCHULE MUENCHEN
FACHBEREICH ELEKTROTECHNIK UND INFORMATIONSTECHNIK
BEREICH DATENTECHNIK
V – JV – 636 – 02 – TH – 01
-----------------------------------------------------------------------------------
Java-Applet-API (6-2)
• Demonstrationsbeispiel 1 zum Java-Applet-API, Forts.
◇ Applet-Code (Datei AppletAPIDemo1.java), 2.Teil
c=getContentPane();
c.setLayout(new BoxLayout(c, BoxLayout.Y_AXIS));
c.add(lab);
c.add(pictbut);
c.add(playpan);
}
// Ende init()
class ButtonListener implements ActionListener
{ public void actionPerformed(ActionEvent e)
{ Object src=e.getSource();
if (src==startbut)
sound.loop();
else if (src==stopbut)
sound.stop();
}
}
}
◇ Einbettende HTML-Datei (AppletAPIDemo1.html)
<HTML>
<HEAD>
<TITLE> AppletAPIDemo1</TITLE>
</HEAD>
<BODY>
<APPLET code="AppletAPIDemo1" width="300" height = "225" >
<PARAM name = "LabelText" value = "Demo zum Applet-API" >
<PARAM name = "RandBreite" value = 8 >
<PARAM name = "PictPath"
value = "images/animals/Bird.gif" >
<PARAM name = "SoundPath" value = "sounds/bgsound.mid" >
</APPLET>
</BODY>
</HTML>
◇ Darstellung des Applets durch : appletviewer AppletAPIDemo1.html
FACHHOCHSCHULE MUENCHEN
FACHBEREICH ELEKTROTECHNIK UND INFORMATIONSTECHNIK
BEREICH DATENTECHNIK
V – JV – 637 – 01 – TH – 01
-----------------------------------------------------------------------------------
Java-Applet-API (7-1)
• Demonstrationsbeispiel 2 zum Java-Applet-API (Demo zu showStatus())
◇ Applet-Code (Datei AppletAPIDemo2.java)
// AppletAPIDemo2.java
// Demo zu showStatus()
import
import
import
import
java.applet.*;
java.awt.*;
java.awt.event.*;
javax.swing.*;
public class AppletAPIDemo2 extends JApplet
{
static final String DEF_PICTPATH = "images/javalogo52x88.gif";
Container c;
JLabel textlab;
JLabel pictlab;
public void init()
{
textlab=new JLabel("Demo zu showStatus()", SwingConstants.CENTER);
textlab.setAlignmentX(Component.CENTER_ALIGNMENT);
textlab.setBorder(BorderFactory.createEmptyBorder(8, 8, 8, 8));
String relPictPath=getParameter("PictPath");
if (relPictPath==null)
relPictPath=DEF_PICTPATH;
Image img = getImage(getCodeBase(), relPictPath);
pictlab=new JLabel(new ImageIcon(img));
pictlab.setAlignmentX(Component.CENTER_ALIGNMENT);
pictlab.setBorder(BorderFactory.createLineBorder(Color.BLACK));
c=getContentPane();
c.setLayout(new BoxLayout(c, BoxLayout.Y_AXIS));
c.add(textlab);
c.add(pictlab);
MouseListener mouselis = new AppletMouseListener();
addMouseListener(mouselis);
}
class AppletMouseListener extends MouseAdapter
{
public void mouseEntered(MouseEvent e)
{
showStatus("Gruess Gott Mouse !");
}
public void mouseExited(MouseEvent e)
{
showStatus("Auf Wiedersehen Mouse !");
}
}
}
FACHHOCHSCHULE MUENCHEN
FACHBEREICH ELEKTROTECHNIK UND INFORMATIONSTECHNIK
BEREICH DATENTECHNIK
V – JV – 637 – 02 – TH – 01
-----------------------------------------------------------------------------------
Java-Applet-API (7-2)
• Demonstrationsbeispiel 2 zum Java-Applet-API (Demo zu showStatus()), Forts.
◇ Einbettende HTML-Datei (AppletAPIDemo2.html)
<HTML>
<HEAD>
<TITLE> AppletAPIDemo2</TITLE>
</HEAD>
<BODY>
<APPLET code="AppletAPIDemo2"
width="300" height = "150" >
<PARAM name = "PictPath"
value = "images/dukeWaveRed.gif" >
</APPLET>
</BODY>
</HTML>
◇ Darstellung des Applets durch : appletviewer AppletAPIDemo2.html
Mouse-Zeiger
über dem Applet
Mouse-Zeiger wieder
ausserhalb desApplets
FACHHOCHSCHULE MUENCHEN
FACHBEREICH ELEKTROTECHNIK UND INFORMATIONSTECHNIK
BEREICH DATENTECHNIK
V – JV – 641 – 00 – TH – 02
-----------------------------------------------------------------------------------
Sicherheitsbeschränkungen bei Java-Applets (1)
• Allgemeines
◇ Ein über das Netz geladenes lokal ablaufendes Programm stellt für den lokalen Rechner prinzipiell ein Sicherheitsrisiko dar.
◇ Um dieses Sicherheitsrisiko aufzuheben, muß sichergestellt werden, dass ein derartiges Programm keine unbefugten
Aktionen (wie z.B. Zugriff zum lokalen Dateisystem, Start lokaler Programme usw) durchführen kann.
◇ Als Mechanismus zum Schutz vor der unbefugten Ausführung sicherheitsrelevanter Operationen ist in Java ein sogenannter Security-Manager vorgesehen.
Ein Security-Manager ist ein Objekt der Klasse SecurityManager oder einer davon abgeleiteten Klasse, das in
jedem Java-Programm installiert sein kann.
Ein SecurityManager-Objekt stellt Methoden zur Verfügung, die die Zulässigkeit diverser sicherheitsrelevanter
Operationen überprüfen.
Falls im Programm ein SecurityManager-Objekt installiert ist, wird von den Java-Bibliotheks-Klassen vor der
Ausführung einer entsprechenden sicherheitsrelevanten Operation die zugehörige SecurityManager-ÜberprüfungsMethode aufgerufen.
Falls die Ausführung der überprüften Operation unzulässig ist, wird eine SecurityException geworfen.
◇ Defaultmässig besitzt ein Applikations-Programm keinen Security-Manager.
Soll die Ausführung bestimmter sicherheitsrelevanter Operationen für ein Applikations-Programm beschränkt werden,
muß es selbst ein geeignetes SecurityManager-Objekt erzeugen und installieren.
◇ Die existierenden java-fähigen Browser und Applet-Viewer dagegen installieren beim Start einen Security-Manager.
Damit unterliegt die Ausführung von Applets den durch diesen zur Verfügung gestellten Sicherheits-Überprüfungen.
Für die Ausführung von Applets gelten also bestimmte Sicherheitsbeschränkungen, die verhindern, dass unbefugte
Aktionen ausgeführt werden können.
• Prinzipielle Sicherbeschränkungen bei Applets
◇ Der Umfang der für Applets geltenden Sicherheitsbeschränkungen hängt von dem jeweiligen Browser / Applet-Viewer
und dem installierten Security-Manager sowie von der Vertrauenswürdigkeit des Applets ab.
◇ Standardmässig werden alle von einem anderen Rechner geladen Applets als nicht-vertrauenswürdig betrachtet.
Sie unterliegen damit i.a. allen nachfolgend aufgelisteten Sicherheitsbeschränkungen.
◇ Vom lokalen Dateisystem geladene Applets werden dagegen als vertrauenswürdig betrachtet.
Für sie gelten die meisten der Sicherheitsbeschränkungen nicht.
Analoges gilt für signierte Applets, auch wenn sie von einem entfernten Rechner geladen werden.
Sie werden ebenfalls als vertrauenswürdig betrachtet.
◇ Typischerweise gelten für nicht-vertrauenswürdige Applets die folgenden Sicherheitsbeschränkungen :
∙ kein Zugriff (weder lesend noch schreibend) zum lokalen Dateisystem (Client-Datei-System)
∙ kein Aufbau von Netzwerkverbindungen, außer zu dem Rechner von dem das Applet jeweils stammt (Host-Rechner)
∙ kein Start von Programmen auf dem ausführenden (lokalen) Rechner (Client-Rechner)
∙ kein zusätzliches Laden von Bibliotheken (über die vom Browser geladene Standard-Bibliothek hinaus)
∙ keine Definition von native-Methoden
∙ kein Top-Level-Fenster ohne Warnhinweis erzeugen
∙ keine Beendigung des Browsers (mittels System.exit(i))
∙ eingeschränkter Zugriff zur System-Umgebung (System Properties)
◇ Für vom Applet-Viewer des JDK ausgeführte Applets gelten viele der o.a. Beschränkungen nicht
FACHHOCHSCHULE MUENCHEN
FACHBEREICH ELEKTROTECHNIK UND INFORMATIONSTECHNIK
BEREICH DATENTECHNIK
V – JV – 642 – 00 – TH – 01
-----------------------------------------------------------------------------------
Sicherheitsbeschränkungen bei Java-Applets (2)
• Beschränkungen beim Zugriff zur System-Umgebung (System-Properties)
◇ Applets können zu einigen, aber nicht allen System Properties zugreifen.
◇ Der Zugriff zu folgenden System Properties ist gemäß der Java-Dokumentation für Applets nicht möglich :
∙ java.home
Java-Installations-Directory
∙ java.class.path
Wert der CLASSPATH-Environment-Variablen
∙ user.name
Benutzer-Name des aktuellen Benutzers
∙ user.home
Heimat-Verzeichnis des aktuellen Benutzers
∙ user.dir
aktuelles Arbeitsverzeichnis des aktuellen Benutzers
◇ Zu den folgenden System Properties sollte dagegen von Applets aus jedem Browser bzw Applet-Viewer zugegriffen
werden können :
∙ java.version
Nummer der Java-Version
∙ java.vendor
Kennzeichnung des Java-Lieferanten
∙ java.vendor.url
URL des Java-Lieferanten
∙ java.class.version
Java-Klassen-Versions-Nummer
∙ os.name
Name des Betriebssystems
∙ os.arch
Prozessor-Architektur auf der das Betriebssystem läuft
∙ os.version
Versions-Nummer des Betriebssystems
∙ file.separator
Trennzeichen in Pfadangaben
∙ path.separator
Trennzeichen zwischen Pfaden
∙ line.separator
Zeilenende-Zeichen