Mécanisme de gestion de protocole en Java

Sommaire du document

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("http://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)^[1] de la classe URL.

   /**
   * 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;
    
   }

   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.

   Notion avancée

   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.

Notes

1. ↑ getURLStreamHandler : La méthode URLStreamHandler getURLStreamHandler(String protocol) ne figure pas dans la JavaDoc, mais existe bien dans la source de la classe URL.
   
   
2. ↑ gestionnaire de flux : correspond à “Stream handler » en anglais
   
   
3. ↑ analyse : correspond à “parsing » en anglais
   
   
4. ↑^a,b,c Uniform Resource Locator : correspond à « localisateur uniforme de ressource” en français
   
   
5. ↑^a,b,c URL : “Uniform Resource Locator” (en français, « localisateur uniforme de ressource »)
   
   

Structure du document