Dans cette fiche...

<Retour Java Base>     <Retour Compléments>

Description de l'applet

Difficulté : Résultat
Dans les fiches précédentes, nous avons vu comment 2 applets pouvaient s'échanger des informations, via l'objet AppletContext et ses méthodes getApplet() ou getApplets().

Problème : si les 2 applets sont placées sur 2 frames HTML différentes, elles ne partagent plus le même "contexte", donc l'objet AppletContext devient inexploitable.

 Cliquez ici
pour afficher l'exemple

Une technique possible : nous allons recréer un AppletContext manuellement. Notre AppletContext s'appellera par exemple AppletManager, et servira uniquement à tenir à jour une liste des applets présentes à l'écran.
Pour que l'AppletManager soit partagé par toutes les applets, il faut en faire un objet static.

A partir de là, il est possible d'obtenir une liste de toutes les applets présentes, via l'AppletManager.

Listing de l'AppletManager

L'objet AppletManager gère les applets dans une Hashtable.
Il comporte donc des méthodes pour ajouter, supprimer, rechercher un objet (applet) stocké.
Les méthodes sont le plus simplifiées possibles; certains tests pourraient être ajoutés.

// --------------------------------------------------
// GESTIONNAIRE D'APPLETS
// --------------------------------------------------
import java.applet.Applet;
import java.util.*;
public class AppletManager extends Object
{
	// Liste des applets en cours
	static Hashtable hApplets = new Hashtable();
	// Ajouter une applet à la liste
	static void add(Applet a, String s)
	{
		hApplets.put(s, a);
	}
	// Supprimer une applet de la liste
	static void remove(String s)
	{
		hApplets.remove(s);
	}
	// Obtenir une applet par son nom
	static Applet getApplet(String s)
	{
		return (Applet)hApplets.get(s);
	}
	// Obtenir les noms des applets enregistrées
	static Enumeration getApplets()
	{
		return hApplets.keys();
	}
	// Compter le nombre d'applets
	static int count()
	{
		return hApplets.size();
	}
}

Le listing en détail...

L'objet AppletManager est un objet simple, pas une applet. Il fait référence aux objets suivants :

Toutes ces notions n'ont pas encore été abordées sur ce site. Les lignes qui suivent seront donc encore nébuleuses si vous débutez !

import java.applet.Applet;
L'objet AppletManager est un objet simple (il dérive directement de la classe Object).
L'importation du package java.applet n'a d'intérêt que parce nous souhaitons manipuler des objets Applet à l'intérieur de l'AppletManager.
  
static Hashtable hApplets = new Hashtable();
Cette hashtable (table de hash ?!) est initalisée pour l'instant à vide. Elle servira à contenir chaque applet présente à l'écran, en y faisant référence par un nom.
La hashtable est déclarée en static, de façon à pouvoir être mise à jour depuis n'importe quelle applet.
  
static void add(Applet a, String s)
{
	hApplets.put(s, a);
}
C'est cette fonction add() qui permet à une applet de s'inscrire auprès de l'AppletManager.
Notre fonction add() fait un applet à la méthode put() de la hashtable, qui stocke un objet a en lui associant un nom (une clef) s.
  • a désigne l'applet elle-même
  • s représente le nom de l'applet

L'appel de cette fonction se fera au moment de l'initialisation de l'applet, par exemple par :

public void init()
{
	AppletManager.add(this, "essai");
}
  
static void remove(String s)
{
	hApplets.remove(s);
}
Une fonction pour supprimer une applet de la liste (d'après son nom s).
L'applet est simplement supprimée de la hashtable, grâce à la méthode remove() de l'objet Hashtable.

L'appel de cette fonction se fera au moment de la destruction de l'applet, par exemple par :

public void destroy()
{
	AppletManager.remove("essai");
}
  
static Applet getApplet(String s)
{
	return (Applet)hApplets.get(s);
}
Notre fonction getApplet() renvoie l'objet Applet correspondant au nom s.
Rappel sur les hashtables : la méthode get() renvoie un objet générique. Il faut donc en faire une conversion (cast), pour obtenir un objet Applet. D'où le (Applet) en début de ligne.
  
static Enumeration getApplets()
{
	return hApplets.keys();
}
Cette méthode fournit une énumération de tous les noms d'applets stockés dans l'AppletManager.
Attention : contrairement à AppletContext (qui renvoie des objets Applet), cette méthode renvoie uniquement les noms des applets (sous forme d'objets String).
  
static int count()
{
	return hApplets.size();
}
Cette méthode donne le nombre d'applets présentes à l'écran, en lisant simplement la taille de la hashtable.

Listing de l'applet AppletLister

Cette applet se référence elle-même auprès de l'AppletManager, et liste toutes les applets présentes à l'écran. En plaçant plusieurs AppletListers sur la page HTML, on voit comment évolue l'AppletManager en fonction du chargements des frames HTML.

// --------------------------------------------------
// APPLETLISTER : LISTE DES APPLETS TROUVEES,
//                AVEC OU SANS FRAMES
// --------------------------------------------------
import java.applet.*;
import java.awt.*;
import java.util.*;
public class AppletLister extends Applet
{
	// Le nom de cette applet
	String NomApplet;
	// --------------------------------------------------
	// GESTION DE L'APPLET
	// --------------------------------------------------
	public void init()
	{
		NomApplet = getParameter("NAME");
		AppletManager.add(this, NomApplet);
	}
	public void destroy()
	{
		AppletManager.remove(NomApplet);
	}
	// --------------------------------------------------
	// AFFICHAGE
	// --------------------------------------------------
	public void paint(Graphics g)
	{
		g.setColor(Color.black);
		g.fillRect(0, 0, size().width, size().height);
		// Afficher le nom de cette applet
		g.setColor(Color.yellow);
		g.drawString("Applet " + NomApplet, 10, 15);
		// Afficher le nombre d'applets stockées dans AppletManager
		g.setColor(Color.white);
		g.drawString("Applets=" + AppletManager.count(), 10, 30);	
		// Lister les noms des applets
		Enumeration e = AppletManager.getApplets();
		int i = 45;
		while (e.hasMoreElements())
		{
			g.drawString((String)e.nextElement(), 10, i);
			i += 15;
		}
		// Réafficher dans 200 millisecondes
		repaint(200);
	}
}

Le listing en détail...

Seules les nouveautés sont traitées ci-dessous, comme d'habitude !
La notion d'énumération (plus bas) est détaillée sur la fiche Enumérations.

String NomApplet;
Cette variable NomApplet servira simplement à stocker le nom de l'applet.
Pour plus de souplesse, on suppose que ce nom est passé en paramètre par la page HTML.
  
public void init()
{
	NomApplet = getParameter("NAME");
	AppletManager.add(this, NomApplet);
}
Au démarrage de l'applet, celle-ci commence par lire son nom, défini par la page HTML.
Ensuite, elle se référence auprès d% l'AppletManager.
  
public void destroy()
{
	AppletManager.remove(NomApplet);
}
Inversement, au moment de sa destruction, l'applet met à jour l'AppletManager en s'enlevant de la liste des applets présentes.
Rappel : la méthode destroy() est appelée automatiquement quand l'applet disparaît (ce qui signifie qu'on quitte le navigateur, ou qu'on passe à une autre page, une autre frame).
  
g.drawString("Applets=" + AppletManager.count(), 10, 30);
On affiche le nombre d'applets actuellement référencées, grâce à la méthode count() de l'AppletManager.
  
Enumeration e = AppletManager.getApplets();
On récupère ici, dans l'énumération e, les noms de toutes les applets présentes actuellement dans l'AppletManager.
La boucle plus bas sert à afficher la liste de ces noms (en parcourant l'énumération).
  
repaint(200);
On demande ici de redessiner l'applet dans 200 millisecondes, de façon à interroger à nouveau l'AppletManager, pour vérifier si d'autres applet s'y sont référencées..

Il serait plus judicieux d'utiliser des threads et du double buffering pour améliorer ce traitement.
Le but ici est de garder l'essentiel du listing.

Intégration des applets dans la page

Voici le code qui a été utilisé dans cette page HTML pour faire apparaître l'applet :

<applet code="AppletLister.class" width=250 height=100>
<param name="NAME" value="ALPHA">
Votre navigateur n'est pas compatible Java !
</applet>

Pour l'exemple, l'applet a été placée plusieurs fois sur la page, avec un paramètre NAME différent à chaque fois.

Pour plus de précisions sur l'intégration d'une applet, cliquez ici.