Mécanisme de gestion de protocole en Java

Les classes URL, URLConnection, URLStreamHandler, et URLStreamHandlerFactory nous permettent d'intecepter et de gérer les protocoles en Java. La manière dont ces classes interagissent peut sembler confuse, et un moyen de comprendre comment cela fonctionne est de résumer la séquence d'évènements :

1. Le programme construit un objet URL qui représente un pointeur sur une ressource réseau.

   URL u = new URL("https://www.gaudry.be/infobrol.php");

2. Le constructeur de l'objet URL détache la partie protocole de l'argument passé.
   Dans le cas de notre exemple : http

3. Le constructeur de l'objet URL tente de trouver un URLStreamHandler en passant la partie protocole, de manière statique, à la méthode URLStreamHandler getURLStreamHandler(String protocol)¹ de la classe URL.

   Code Java (Méthode getURLStreamHandler) (96 lignes)

   /**
   * Returns the Stream Handler.
   * @param protocol the protocol to use
   */
   static URLStreamHandler getURLStreamHandler(String protocol) {
    
   	URLStreamHandler handler = (URLStreamHandler)handlers.get(protocol);
   	if (handler == null) {
    
   		 boolean checkedWithFactory = false;
    
   		// Use the factory (if any)
   		if (factory != null) {
   			handler = factory.createURLStreamHandler(protocol);
   			checkedWithFactory = true;
   		}
    
   		// Try java protocol handler
   		if (handler == null) {
   			String packagePrefixList = null;
    
   			packagePrefixList
   			= (String) java.security.AccessController.doPrivileged(
   			new sun.security.action.GetPropertyAction(
   			protocolPathProp,""));
   			if (packagePrefixList != "") {
   				packagePrefixList += "|";
   			}
    
   			// REMIND: decide whether to allow the "null" class prefix
   			// or not.
   			packagePrefixList += "sun.net.www.protocol";
    
   			StringTokenizer packagePrefixIter =
   			new StringTokenizer(packagePrefixList, "|");
    
   			while (handler == null && packagePrefixIter.hasMoreTokens()) {
    
   				String packagePrefix =
   				packagePrefixIter.nextToken().trim();
   				try {
   					String clsName = packagePrefix + "." + protocol + ".Handler";
   					Class cls = null;
   					try {
   						cls = Class.forName(clsName);
   					} catch (ClassNotFoundException e) {
   						ClassLoader cl = ClassLoader.getSystemClassLoader();
   						if (cl != null) {
   							cls = cl.loadClass(clsName);
   						}
   					}
   					if (cls != null) {
   						handler  = (URLStreamHandler)cls.newInstance();
   					}
   				} catch (Exception e) {
   					// any number of exceptions can get thrown here
   				}
   			}
   		}
    
   		synchronized (streamHandlerLock) {
    
   			URLStreamHandler handler2 = null;
    
   			// Check again with hashtable just in case another
   			// thread created a handler since we last checked
   			handler2 = (URLStreamHandler)handlers.get(protocol);
    
   			if (handler2 != null) {
   				return handler2;
   			}
    
   			// Check with factory if another thread set a
   			// factory since our last check
   			if (!checkedWithFactory && factory != null) {
   				handler2 = factory.createURLStreamHandler(protocol);
   			}
    
   			if (handler2 != null) {
   				// The handler from the factory must be given more
   				// importance. Discard the default handler that
   				// this thread created.
   				handler = handler2;
   			}
    
   			// Insert this handler into the hashtable
   			if (handler != null) {
   				handlers.put(protocol, handler);
   			}
    
   		}
   	}
    
   	return handler;
    
   }

   Retourner au début du code

   Explications  :

   1. Si le protocole a déjà été utilisé auparavant, il est présent dans la HashTable statique nommée handlers.
   2. Autrement, si une URLStreamHandlerFactory a été mise en place, le protocole est passé à la méthode createURLStreamHandler() de l'URLStreamHandlerFactory.
      Un objet URLStreamHandler est installé en utilisant la méthode statique setURLStreamHandlerFactory() de URL.
   3. Si le protocole n'a encore jamais été rencontré et qu'aucune URLStreamHandlerFactory n'est présente, une tentative est faite pour instancier un objet URLStreamHandler nommé <nom-du-protocole>.Handler dans un des packages listés dans la propriété système java.protocol.handler.pkgs
      • Si la valeur de cette propriété système n'est pas vide (null), elle est interprétée comme une liste de packages séparés par un trait vertical (|).
      • Le constructeur tente de charger la classe nommée : <nom-du-package>.<nom-du-protocole>.Handler
        Si cette classe n'existe pas, ou n'est pas une sous-classe de URLStreamHandler, le package suivant de la liste est essayé.
   4. Si il est impossible de trouver un URLStreamHandler dans la liste, le constructeur tente d'instancier un objet URLStreamHandler nommé : <nom-du-protocole>.Handler dans le package sun.net.www.protocol.
   5. Si cette classe n'existe pas ou si elle n'est pas une sous-classe de URLStreamHandler, une exception de type MalformedURLException est lancée.
4. A présent que l'objet URL possède son « gestionnaire de flux » (en anglais, “Stream handler”), il demande à ce dernier de terminer l'« analyse » (en anglais, “parsing”) de la chaîne de caractères de l'URL, pour en extraire les valeurs qui lui permettront de constituer les propriétés de l'objet URL. C'est parce que le format d'une URL dépend du protocole utilisé qu'une grande part du travail de découpe de l'URL est réservé à un URLStreamHandler, qui connait les particularités du protocole, et non l'objet URL qui est plus générique et n'a pas de connaissance particulière des protocoles.
5. Le programme appelle la méthode openConnection() sur l'objet URL. Cette méthode appelle elle-même la méthode openConnection(URL u) de URLStreamHandler, pour enfin retourner l'objet URLConnection approprié pour cet objet URL. Si un problème survient, une exception de type IOException est lancée.

   Fortgeschrittenes Konzept

   Au lieu d'appeller openConnection(), le programme peut appeller getContent() ou getInputStream(). Dans ce cas, l'objet URLStreamHandler instanciera un objet URLConnection de la classe appropriée. Quoi qu'il en soit, au lieu de retourner l'objet URLConnection lui-même, l'URLStreamHandler retourne le résultatde getContent() de URLConnection ou la méthode getInputStream().

6. Le programme utilise les méthodes de la classe URLConnection pour interagir avec la ressource distante.

You are on the German version of the site, but your system indicates that you prefer to use the English language.
The entire site is not translated yet, but the menus and buttons on the interface are largely translated.

Would you like to reach the page in English?
Click here to continue in English: Consult the English version of this page

U bevindt zich op de Duits versie van de site, maar uw systeem geeft aan dat u liever de Nederlandse taal gebruikt.
De hele site is nog niet vertaald, maar de menu's en knoppen op de interface zijn grotendeels vertaald.

Wilt u de pagina in het Nederlands bereiken?
Klik hier om door te gaan in het Nederlands: Raadpleeg de Nederlandse versie van deze pagina

Vous vous trouvez sur la version allemande du site, mais votre système indique que vous préférez utiliser la langue française.

Souhaitez-vous atteindre la page en français?
Cliquez ici pour continuer en français: Consulter la page en français