Mécanisme de chargement des classes de Tomcat

package com.developpez.rpouiller.partagelibrairiesversionnees.caspratique;

public class [CategorieClasse]Classe[NumeroClasse] {

    public static final String VERSION = "[NumeroVersion]";  // Si la classe est versionnée
    public static final java.util.Calendar CALENDAR = java.util.Calendar.getInstance();
    public static final Throwable THROWABLE = new Throwable();

    public void methode() {
        new [ClasseDeDependance]().methode();   // Si la classe a une dépendance
    }
}

package com.developpez.rpouiller.partagelibrairiesversionnees.caspratique;

public class CommonClasse2 {

    public static final java.util.Calendar CALENDAR = java.util.Calendar.getInstance();
    public static final Throwable THROWABLE = new Throwable();

    public void methode() {
    }
}

package com.developpez.rpouiller.partagelibrairiesversionnees.caspratique;

public class VersionneeClasse8 {

    public static final String VERSION = "1.0";
    public static final java.util.Calendar CALENDAR = java.util.Calendar.getInstance();
    public static final Throwable THROWABLE = new Throwable();

    public void methode() {
        new CommonClasse1().methode();
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<web-app id="WebApp_ID" version="2.4"
    xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
    <display-name>application[numeroApplication]</display-name>

    <servlet>
        <servlet-name>racine</servlet-name>
        <servlet-class>com.developpez.rpouiller.partagelibrairiesversionnees.caspratique.ApplicationServlet[numeroApplication]</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>racine</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

package com.developpez.rpouiller.partagelibrairiesversionnees.caspratique;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.URLClassLoader;
import java.text.SimpleDateFormat;
import java.util.Calendar;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class ApplicationServlet[numeroApplication] extends HttpServlet {

    private static final SimpleDateFormat DATE_FORMAT = new SimpleDateFormat("HH:mm:ss.SSS");

    private ClassLoader classLoader;

    /**
     * Retourne les informations d'element de Stack correspondant à une classe ApplicationServletX.
     */
    private String getApplicationServlet(final Throwable pThrowable) {
        if(pThrowable == null) {
            return " ";
        }

        final StringBuffer lStringBuffer = new StringBuffer();
        final StackTraceElement[] StackTracesElement = pThrowable.getStackTrace();
        for(int i=0;i<StackTracesElement.length;i++) {
            final String lClassName = StackTracesElement[i].getClassName();
            final int lPosDernierPoint = lClassName.lastIndexOf('.');
            final String lNomClasse = (lPosDernierPoint >= 0)?lClassName.substring(lPosDernierPoint + 1):lClassName;
            if(lNomClasse.startsWith("ApplicationServlet")) {
                lStringBuffer.append(lNomClasse + "." + StackTracesElement[i].getMethodName() + 
                        "(" + StackTracesElement[i].getLineNumber() + ")");
            }
        }
        return lStringBuffer.toString();
    }

    /**
     * Retourne la partie "intéressante" d'une URL d'un ClassLoader.
     */
    private String getFinChemin(final URL pURL) {
        try {
            String lChemin = pURL.toString();
            final int lPosTomcat = lChemin.indexOf("Tomcat");
            if(lPosTomcat != -1) {
                lChemin = "...." + lChemin.substring(lPosTomcat);
            }
            
            return lChemin.replaceAll("%20", "&nbsp;");
        } catch (ex.ception e) {
            return e.getMessage();
        }
    }

    /**
     * Retourne une ligne d'informations pour une classe donnée.
     */
    private String getInformations(final Class<? extends Object> pClasse, final String pVersion, 
            final Calendar pDateInit, final Throwable pOrigineInit) {

        final StringBuffer lStringBuffer = new StringBuffer();

        final ClassLoader lClassLoader = pClasse.getClassLoader();
        lStringBuffer.append("<TR><TD>");
        lStringBuffer.append(pClasse.getSimpleName());
        lStringBuffer.append("</TD><TD>");
        lStringBuffer.append(pVersion==null?"&nbsp;":pVersion);
        lStringBuffer.append("</TD><TD>");
        lStringBuffer.append(DATE_FORMAT.format(pDateInit.getTime()));
        lStringBuffer.append("</TD><TD>");
        lStringBuffer.append(getApplicationServlet(pOrigineInit));
        lStringBuffer.append("</TD><TD>");
        if(lClassLoader == classLoader) {
            lStringBuffer.append("idem</TD><TD>idem");
        }
        else {
            lStringBuffer.append(lClassLoader.getClass().getSimpleName());
            lStringBuffer.append("</TD><TD>");
            if(lClassLoader instanceof URLClassLoader) {
                final URLClassLoader lURLClassLoader = (URLClassLoader)lClassLoader;
                final URL[] lURLs = lURLClassLoader.getURLs();
                for(int i=0;i<lURLs.length;i++) {
                    lStringBuffer.append(getFinChemin(lURLs[i]) + "<BR/>");
                }
            }
            else {
                lStringBuffer.append("&nbsp;");
            }
        }
        lStringBuffer.append("</TD></TR>");

        classLoader = lClassLoader;

        return lStringBuffer.toString();
    }

    /**
     * Retourne une ligne d'informations pour une ressource donnée.
     * @throws IOException 
     */
    private String getInformationsRessource(final String pNomRessource) throws IOException {

        final StringBuffer lStringBuffer = new StringBuffer();
        lStringBuffer.append("<TR><TD>");
        lStringBuffer.append(pNomRessource);
        lStringBuffer.append("</TD><TD>");
        lStringBuffer.append(getFinChemin(Thread.currentThread().getContextClassLoader().getResource(pNomRessource)));
        lStringBuffer.append("</TD><TD>");
        final InputStream lInputStream = Thread.currentThread().getContextClassLoader().getResourceAsStream(pNomRessource);
        if(lInputStream == null) {
            lStringBuffer.append("<I>null</I>");
        }
        else {
            final BufferedReader lBufferedReader = new BufferedReader(new InputStreamReader(lInputStream));
            lStringBuffer.append(lBufferedReader.readLine());
        }
        lStringBuffer.append("</TD></TR>");

        return lStringBuffer.toString();
    }

    /**
     * Affiche les informations sur les classes.
     */
    @Override
    protected synchronized void doGet(final HttpServletRequest pRequete, final HttpServletResponse pReponse) 
            throws ServletException, IOException {

        new ApplicationClasse3().methode();
        new VersionneeClasse5().methode();

        final StringBuffer lStringBuffer = new StringBuffer();

        lStringBuffer.append("<HTML><BODY>");
        lStringBuffer.append("<TABLE BORDER=\"1\" CELLSPACING=\"0\">");
        lStringBuffer.append("<TR>");
        lStringBuffer.append("<TH>Classe</TH><TH>Version</TH><TH>Heure d'init</TH><TH>Origine de l'init</TH>");
        lStringBuffer.append("<TH>ClassLoader</TH><TH>URLs du ClassLoader</TH>");
        lStringBuffer.append("</TR>");

        classLoader = null;
        lStringBuffer.append(getInformations(CommonClasse1.class, null, CommonClasse1.CALENDAR, CommonClasse1.THROWABLE));
        lStringBuffer.append(getInformations(CommonClasse2.class, null, CommonClasse2.CALENDAR, CommonClasse2.THROWABLE));
        lStringBuffer.append(getInformations(CommonClasse3.class, null, CommonClasse3.CALENDAR, CommonClasse3.THROWABLE));
        lStringBuffer.append(getInformations(CommonClasse4.class, null, CommonClasse4.CALENDAR, CommonClasse4.THROWABLE));
        lStringBuffer.append(getInformations(ApplicationClasse3.class, null, ApplicationClasse3.CALENDAR, ApplicationClasse3.THROWABLE));
        lStringBuffer.append(getInformations(ApplicationClasse4.class, null, ApplicationClasse4.CALENDAR, ApplicationClasse4.THROWABLE));
        lStringBuffer.append(getInformations(ApplicationClasse3.class, null, ApplicationClasse3.CALENDAR, ApplicationClasse3.THROWABLE));
        lStringBuffer.append(getInformations(ApplicationClasse4.class, null, ApplicationClasse4.CALENDAR, ApplicationClasse4.THROWABLE));
        lStringBuffer.append(getInformations(VersionneeClasse1.class, VersionneeClasse1.VERSION, VersionneeClasse1.CALENDAR, 
                VersionneeClasse1.THROWABLE));
        lStringBuffer.append(getInformations(VersionneeClasse2.class, VersionneeClasse2.VERSION, VersionneeClasse2.CALENDAR, 
                VersionneeClasse2.THROWABLE));
        lStringBuffer.append(getInformations(VersionneeClasse3.class, VersionneeClasse3.VERSION, VersionneeClasse3.CALENDAR, 
                VersionneeClasse3.THROWABLE));
        lStringBuffer.append(getInformations(VersionneeClasse4.class, VersionneeClasse4.VERSION, VersionneeClasse4.CALENDAR, 
                VersionneeClasse4.THROWABLE));
        lStringBuffer.append(getInformations(VersionneeClasse5.class, VersionneeClasse5.VERSION, VersionneeClasse5.CALENDAR, 
                VersionneeClasse5.THROWABLE));
        lStringBuffer.append(getInformations(VersionneeClasse6.class, VersionneeClasse6.VERSION, VersionneeClasse6.CALENDAR, 
                VersionneeClasse6.THROWABLE));
        lStringBuffer.append(getInformations(VersionneeClasse7.class, VersionneeClasse7.VERSION, VersionneeClasse7.CALENDAR, 
                VersionneeClasse7.THROWABLE));
        lStringBuffer.append(getInformations(VersionneeClasse8.class, VersionneeClasse8.VERSION, VersionneeClasse8.CALENDAR, 
                VersionneeClasse8.THROWABLE));

        lStringBuffer.append("</TABLE>");

        lStringBuffer.append("<TABLE BORDER=\"1\" CELLSPACING=\"0\">");
        lStringBuffer.append("<TR><TH>Ressource recherchée</TH><TH>URL de la ressource</TH><TH>Contenu de la ressource</TH></TR>");
        lStringBuffer.append(getInformationsRessource("com/developpez/rpouiller/partagelibrairiesversionnees/caspratique/commonA.txt"));
        lStringBuffer.append(getInformationsRessource("com/developpez/rpouiller/partagelibrairiesversionnees/caspratique/commonB.txt"));
        lStringBuffer.append(getInformationsRessource("com/developpez/rpouiller/partagelibrairiesversionnees/caspratique/application.txt"));
        lStringBuffer.append(getInformationsRessource("com/developpez/rpouiller/partagelibrairiesversionnees/caspratique/versionneeA.txt"));
        lStringBuffer.append(getInformationsRessource("com/developpez/rpouiller/partagelibrairiesversionnees/caspratique/versionneeB.txt"));
        lStringBuffer.append(getInformationsRessource("com/developpez/rpouiller/partagelibrairiesversionnees/caspratique/versionneeC.txt"));
        lStringBuffer.append("</TABLE>");

        lStringBuffer.append("</BODY></HTML>");

        pReponse.getWriter().print(lStringBuffer.toString());
    }
}

package com.developpez.rpouiller.partagelibrairiesversionnees.loader.config;

/** Classe contenant les informations d'un partage pour une application. */
public class Partage {

    private String nom;

    /** Constructeur sans paramètres */
    public Partage() {
    }

    /** Constructeur avec paramètres */
    public Partage(final String pNom) {
        nom = pNom;
    }

    /** Retourne le nom d'un dossier de partage. */
    public String getNom() {
        return nom;
    }

    /** Fixe le nom d'un dossier de partage. */
    public void setNom(final String pNom) {
        nom = pNom;
    }
}

package com.developpez.rpouiller.partagelibrairiesversionnees.loader.config;

import java.util.LinkedList;
import java.util.List;

/** Classe contenant les informations d'une application. */
public class Application {

    private String contexte;
    private List<Partage> listePartages = new LinkedList<Partage>();

    /** Constructeur sans paramètres */
    public Application() {
    }

    /** Constructeur avec paramètres */
    public Application(final String contexte, final List<Partage> listePartages) {
        this.contexte = contexte;
        this.listePartages = listePartages;
    }

    /** Retourne le contexte de l'application. */
    public String getContexte() {
        return contexte;
    }

    /** Fixe le contexte de l'application. */
    public void setContexte(final String pContexte) {
        contexte = pContexte;
    }

    /** Retourne la liste des partages d'une application.*/
    public List<Partage> getListePartages() {
        return listePartages;
    }

    /** Ajoute un partage (correspondant à un dossier) à la liste des partages d'une application. */
    public void addPartage(final Partage pPartage) {
        listePartages.add(pPartage);
    }
}

package com.developpez.rpouiller.partagelibrairiesversionnees.loader.config;

/** Classe contenant les informations concernant un dossier de partage. */
public class Dossier {

    private String nom;
    private String chemin;

    /** Constructeur sans paramètres */
    public Dossier() {
    }

    /** Constructeur avec paramètres */
    public Dossier(final String pNom, final String pChemin) {
        nom = pNom;
        chemin = pChemin;
    }

    /** Retourne le nom du dossier de partage. */
    public String getNom() {
        return nom;
    }

    /** Fixe le nom du dossier de partage. */
    public void setNom(final String pNom) {
        nom = pNom;
    }

    /** Retourne le chemin du dossier de partage. */
    public String getChemin() {
        return chemin;
    }

    /** Fixe le chemin du dossier de partage. */
    public void setChemin(final String pChemin) {
        chemin = pChemin;
    }
}

package com.developpez.rpouiller.partagelibrairiesversionnees.loader.config;

import java.util.LinkedList;
import java.util.List;

/** Classe contenant les informations des partages. */
public class Partages {

    private List<Dossier> listeDossiers = new LinkedList<Dossier>();
    private List<Application> listeApplications = new LinkedList<Application>();

    /** Retourne la liste des dossiers de partage. */
    public List<Dossier> getListeDossiers() {
        return listeDossiers;
    }

    /** Ajoute un dossier à la liste des dossiers de partage. */
    public void addDossier(final Dossier pDossier) {
        listeDossiers.add(pDossier);
    }

    /** Retourne la liste des applications avec partage. */
    public List<Application> getListeApplications() {
        return listeApplications;
    }

    /** Ajoute une application à la liste des applications avec partage. */
    public void addApplication(final Application pApplication) {
        listeApplications.add(pApplication);
    }
}

package com.developpez.rpouiller.partagelibrairiesversionnees.loader;

import java.io.File;
import java.util.HashMap;

import org.apache.catalina.loader.ResourceEntry;

/** Classe représentant un fichier jar dans un dossier de partage */
public class FichierJar {

    private String nomDossier;
    private File file;
    private HashMap<String, ResourceEntry> resourceEntries = 
        new HashMap<String, ResourceEntry>();

    /** Constructeur sans paramètres */
    public FichierJar() {
    }

    /** Constructeur avec paramètres */
    public FichierJar(final String pNomDossier, final File pFile) {
        nomDossier = pNomDossier;
        file = pFile;
    }

    /** Retourne le nom du dossier (correspond à l'attribut nom de Dossier) */
    public String getNomDossier() {
        return nomDossier;
    }

    /** Fixe le nom du dossier */
    public void setNomDossier(String pNomDossier) {
        nomDossier = pNomDossier;
    }

    /** Retourne le File correspondant au fichier jar*/
    public File getFile() {
        return file;
    }

    /** Fixe le File correspondant au fichier jar */
    public void setFile(File pFile) {
        file = pFile;
    }

    /** Retourne les ResourceEntry du cache */
    public HashMap<String, ResourceEntry> getResourceEntries() {
        return resourceEntries;
    }

    /** Recherche une ResourceEntry dans le cache */
    public ResourceEntry getResourceEntry(final String pNomRessource) {
        return resourceEntries.get(pNomRessource);
    }

    /** Ajoute une ResourceEntry dans le cache */
    public void ajouteResourceEntry(final String pNomRessource, final ResourceEntry pResourceEntry) {
        resourceEntries.put(pNomRessource, pResourceEntry);
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        FichierJar other = (FichierJar) obj;
        if (file == null) {
            if (other.file != null)
                return false;
        } else if (!file.equals(other.file))
            return false;
        if (nomDossier == null) {
            if (other.nomDossier != null)
                return false;
        } else if (!nomDossier.equals(other.nomDossier))
            return false;
        return true;
    }
}

package com.developpez.rpouiller.partagelibrairiesversionnees.loader;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.util.List;

import org.apache.catalina.LifecycleException;
import org.apache.catalina.loader.WebappLoader;
import org.apache.juli.logging.Log;
import org.apache.juli.logging.LogFactory;
import org.apache.tomcat.util.digester.Digester;

import com.developpez.rpouiller.partagelibrairiesversionnees.loader.config.Application;
import com.developpez.rpouiller.partagelibrairiesversionnees.loader.config.Dossier;
import com.developpez.rpouiller.partagelibrairiesversionnees.loader.config.Partages;

/** Loader avec partage des librairies versionnées. */
public class WebappLoaderAvecPartage extends WebappLoader {

    private final static Log LOG = LogFactory.getLog(WebappLoaderAvecPartage.class);

    /** 
     * Nom du fichier de configuration du partage.
     * Le fichier "partages.xml" est dans le dossier "conf" de Tomcat.
     */
    protected static String configFile = "conf/partages.xml";

    /** Indique si le fichier de configuration a été chargé */
    private static boolean configurationChargee = false;

    /** Informations des partages. */
    private static Partages partages;

    /**
     * Retourne un objet File object correspondant au fichier de configuration.
     * @return L'objet File
     */
    protected static File configFile() {
        File file = new File(configFile);
        if (!file.isAbsolute())
            file = new File(System.getProperty("catalina.base"), configFile);
        return (file);
    }

    /**
     * Fixe le nom du fichier de configuration du partage.
     * @param pConfigFile Le nom.
     */
    protected static void setConfigFile(final String pConfigFile) {
        configFile = pConfigFile;
    }

    /**
     * Fixe les informations des partages.
     * @param pPartages Les informations des partages.
     */
    public void setPartages(final Partages pPartages) {
        partages = pPartages;
    }

    /**
     * Retourne l'objet "Application" associé au contexte du Loader.
     * @return L'objet "Application".
     */
    private Application getApplicationContexte() {
        final String lNomContexte = getContainer().getName();
        for(final Application lApplication : partages.getListeApplications()) {
            if(lNomContexte.equals(lApplication.getContexte())) {
                return lApplication;
            }
        }
        return null;
    }

    /**
     * Crée et configure le Digester pour le chargement de la configuration.
     */
    protected Digester createDigester() {
        final Digester lDigester = new Digester();
        lDigester.setValidating(false);
        lDigester.setRulesValidation(true);

        lDigester.addObjectCreate("Partages",
                "com.developpez.rpouiller.partagelibrairiesversionnees.loader.config.Partages");
        lDigester.addSetNext("Partages", "setPartages",
                "com.developpez.rpouiller.partagelibrairiesversionnees.loader.config.Partages");

        lDigester.addObjectCreate("Partages/Dossier",
                "com.developpez.rpouiller.partagelibrairiesversionnees.loader.config.Dossier");
        lDigester.addSetProperties("Partages/Dossier");
        lDigester.addSetNext("Partages/Dossier", "addDossier",
                "com.developpez.rpouiller.partagelibrairiesversionnees.loader.config.Dossier");

        lDigester.addObjectCreate("Partages/Application",
                "com.developpez.rpouiller.partagelibrairiesversionnees.loader.config.Application");
        lDigester.addSetProperties("Partages/Application");
        lDigester.addSetNext("Partages/Application", "addApplication",
                "com.developpez.rpouiller.partagelibrairiesversionnees.loader.config.Application");

        lDigester.addObjectCreate("Partages/Application/Partage",
                "com.developpez.rpouiller.partagelibrairiesversionnees.loader.config.Partage");
        lDigester.addSetProperties("Partages/Application/Partage");
        lDigester.addSetNext("Partages/Application/Partage", "addPartage",
                "com.developpez.rpouiller.partagelibrairiesversionnees.loader.config.Partage");

        return lDigester;
    }

    /**
     * Charge la configuration depuis le fichier CONFIG_FILE
     */
    protected synchronized Partages chargerConfiguration() {
        if(!configurationChargee) {
            configurationChargee = true;

            final Digester lDigester = createDigester();
            try {
                final InputStream lInputStream = new FileInputStream(configFile());
                lDigester.push(this);
                lDigester.parse(lInputStream);
                lInputStream.close();
            } catch (FileNotFoundException e) {
                LOG.warn("Chargement impossible du fichier de configuration de partage : " + configFile().getAbsolutePath());
            } catch (ex.ception e) {
                LOG.warn("Erreur lors du chargement de " + configFile() + " : ", e);
            }
        }

        return partages;
    }

    /**
     * Initialise le Loader.
     * Comme il s'agit d'une substitution de la méthode de WebappLoader,
     * on appelle dans un premier temps la méthode de WebappLoader.
     * Puis, on charge la configuration depuis le fichier.
     */
    public void init() {
        super.init();

        chargerConfiguration();
    }

    /**
     * Start this component, initializing our associated class loader.
     * Pareil que pour la méthode init(), dans un premier temps,
     * on appelle la méthode de WebappLoader.
     * @exception LifecycleException if a lifecycle error occurs
     */
    public void start() throws LifecycleException {
        super.start();

        if(partages != null) {
            final List<Dossier> lListeDossiers = partages.getListeDossiers();
            WebappClassLoaderAvecPartage.setListeDossiers(lListeDossiers);

            final Application lApplication = getApplicationContexte();
            ((WebappClassLoaderAvecPartage)getClassLoader()).setApplication(lApplication);
        }
    }
}

package com.developpez.rpouiller.partagelibrairiesversionnees.loader;

import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FilenameFilter;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.util.LinkedList;
import java.util.List;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;

import javax.naming.NamingException;

import org.apache.catalina.loader.ResourceEntry;
import org.apache.catalina.loader.WebappClassLoader;
import org.apache.juli.logging.Log;
import org.apache.juli.logging.LogFactory;
import org.apache.naming.resources.Resource;

import com.developpez.rpouiller.partagelibrairiesversionnees.loader.config.Application;
import com.developpez.rpouiller.partagelibrairiesversionnees.loader.config.Dossier;
import com.developpez.rpouiller.partagelibrairiesversionnees.loader.config.Partage;

/** ClassLoader avec partage des librairies versionnées. */
public class WebappClassLoaderAvecPartage extends WebappClassLoader {

    private final static Log LOG = LogFactory.getLog(WebappClassLoaderAvecPartage.class);

    protected static List<FichierJar> listeFichiersJar;

    /** Unique instance du filtre */
    private static FilenameFilterJar FILENAME_FILTER_JAR = new FilenameFilterJar();

    /**
     * Filtre de nom de fichier de jar
     */
    private static class FilenameFilterJar implements FilenameFilter {

        public boolean accept(File dir, String name) {
            return name.toUpperCase().endsWith(".JAR");
        }
        
    }

    private List<FichierJar> listeFichiersJarApplication;

    /**
     * Détermine les fichiers jar constituant les possibilités de partage 
     * à partir de la liste des dossiers de la configuration.
     * 
     * Parcours les différents dossiers contenus dans la configuration.
     * Stocke les informations liées aux fichiers jar de ces dossiers dans la liste.
     * 
     * @param pListeDossiers
     */
    public static synchronized void setListeDossiers(final List<Dossier> pListeDossiers) {
        if(listeFichiersJar == null) {
            listeFichiersJar = new LinkedList<FichierJar>();

            for(final Dossier lDossier : pListeDossiers) {
                final String lNomDossier = lDossier.getNom();
                final String lCheminDossier = lDossier.getChemin();
                final File lFileDossier = new File(lCheminDossier);
                if(lFileDossier.exists()) {
                    LOG.info("Détermination des librairies du dossier de partage '" + lNomDossier + "' (" + lCheminDossier + ")");
                    final File[] lFichiersJarDuDossier = lFileDossier.listFiles(FILENAME_FILTER_JAR);

                    for(final File lFichierJarDuDossier : lFichiersJarDuDossier) {
                        LOG.info("Fichier '" + lFichierJarDuDossier + "' trouvé");

                        final FichierJar lFichierJar = new FichierJar();

                        lFichierJar.setNomDossier(lNomDossier);
                        lFichierJar.setFile(lFichierJarDuDossier);

                        listeFichiersJar.add(lFichierJar);
                    }
                }
                else {
                    LOG.warn("Le dossier de partage '" + lNomDossier + "' n'a pas été trouvé au chemin '" + lCheminDossier + "'");
                }
            }
        }
    }

    /**
     * Retourne la liste des fichiers jar constituant les possibilités de partage.
     * @return La liste des fichiers jar.
     */
    protected static List<FichierJar> getListeFichiersJar() {
        return listeFichiersJar;
    }

    /**
     * Constructeur sans paramètres.
     */
    public WebappClassLoaderAvecPartage() {
        super();
    }

    /**
     * Constructeur avec ClassLoader parent
     * @param pParent
     */
    public WebappClassLoaderAvecPartage(final ClassLoader pParent) {
        super(pParent);
    }

    /**
     * Retourne la liste des fichiers jar pour l'application.
     * @return La liste des fichiers jar pour l'application
     */
    protected List<FichierJar> getListeFichiersJarApplication() {
        return listeFichiersJarApplication;
    }



    /**
     * Fixe la configuration du partage pour une application 
     * correspondant à ce ClassLoader.
     * 
     * Détermine à partir de ces informations les fichiers jar 
     * qui concernent ce ClassLoader.
     * 
     * Pour être retenu le fichier jar doit appartenir à un dossier
     * de partage de cette application et son nom doit correspondre
     * à un jar des URL de ce ClassLoader.
     * 
     * Ces URL ont été settées dans la méthode start() de WebappLoader.
     * 
     * @param pApplication
     */
    public void setApplication(final Application pApplication) {
        listeFichiersJarApplication = new LinkedList<FichierJar>();

        LOG.info("Détermination des librairies partagées pour l'application '" + pApplication.getContexte() + "'");

        final List<Partage> lListePartages = pApplication.getListePartages();

        boucleFichierJar:
        for(final FichierJar lFichierJar : listeFichiersJar) {

            for(final Partage lPartage : lListePartages) {

                // Si le fichier jar appartient à un dossier de partage 
                // de l'application
                if(lFichierJar.getNomDossier().equals(lPartage.getNom())) {

                    for(final File lJarRealFile : jarRealFiles) {

                        final String lNomJarRealFile = lJarRealFile.getName();
                        final String lNomFichierPartage = lFichierJar.getFile().getName();

                        // Si le fichier jar correspond à un un des fichiers du classpath
                        // alors on l'ajout à la liste des jar de l'application
                        // et on passe au fichier jar suivant
                        if(lNomJarRealFile.equals(lNomFichierPartage)) {
                            LOG.info("Librairie retenue : dossier : '" + lFichierJar.getNomDossier() + "' - fichier : '" + lFichierJar.getFile() + "'");
                            listeFichiersJarApplication.add(lFichierJar);
                            continue boucleFichierJar;
                        }
                    }
                }
            }
        }
    }

    @Override
    protected Class findLoadedClass0(final String name) {
        // Trouve le fichier jar concerné par la ressource
        final String lTempPath = name.replace('.', '/');
        final FichierJar lFichierJar = getFichierJarForResource(lTempPath + ".class");

        if(lFichierJar != null) {
            // Si la ressource est déjà chargée, on la retourne depuis le cache
            final ResourceEntry lLoadedResourceEntry = lFichierJar.getResourceEntry(name);
            if(lLoadedResourceEntry != null) {
                return lLoadedResourceEntry.loadedClass;
            }
        }

        // Passe la main à la classe mère si la ressource n'est pas concernée par le partage
        return super.findLoadedClass0(name);
    }

    @Override
    protected InputStream findLoadedResource(final String name) {

        // Trouve le fichier jar concerné par la ressource
        final FichierJar lFichierJar = getFichierJarForResource(name);

        if(lFichierJar != null) {
            // Si la ressource est déjà chargée, on la retourne depuis le cache
            final ResourceEntry lLoadedResourceEntry = lFichierJar.getResourceEntry(name);
            if(lLoadedResourceEntry != null) {
                if (lLoadedResourceEntry.binaryContent != null) {
                    return new ByteArrayInputStream(lLoadedResourceEntry.binaryContent);
                }
            }
        }

        // Passe la main à la classe mère si la ressource n'est pas concernée par le partage
        return super.findLoadedResource(name);
    }

    @Override
    public URL findResource(final String name) {
        // Trouve le fichier jar concernée par la ressource
        final FichierJar lFichierJar = getFichierJarForResource(name);

        if(lFichierJar != null) {
            // Si la ressource est déjà chargée, on la retourne depuis le cache
            ResourceEntry lLoadedResourceEntry = lFichierJar.getResourceEntry(name);
            // Si elle n'était pas dans le cache, on essaye de la charger
            if (lLoadedResourceEntry == null) {
                lLoadedResourceEntry = findResourceInternal(name, name);
            }
            if (lLoadedResourceEntry != null) {
                return lLoadedResourceEntry.source;
            }
        }

        // Passe la main à la classe mère si la ressource n'est pas concernée par le partage
        return super.findResource(name);
    }

    @Override
    protected ResourceEntry findResourceInternal(final String name, final String path) {

        if (!started) {
            LOG.info(sm.getString("WebappClassLoaderAvecPartage.stopped", name));
            return null;
        }

        // Trouve le fichier jar concernée par la ressource
        final FichierJar lFichierJar = getFichierJarForResource(path);

        if(lFichierJar != null) {
            synchronized(lFichierJar) {
                // Si la ressource est déjà chargée, on la retourne depuis le cache
                final ResourceEntry lLoadedResourceEntry = lFichierJar.getResourceEntry(name);
                if(lLoadedResourceEntry != null) {
                    return lLoadedResourceEntry;
                }

                // Si la ressource n'est pas dans le cache, on la charge depuis le Jar
                try {
                    final File lFile = lFichierJar.getFile();
                    final JarFile lJarFile = new JarFile(lFile);
                    final JarEntry lJarEntry = lJarFile.getJarEntry(path);
                    if(lJarEntry != null) {
                        final ResourceEntry lResourceEntry = new ResourceEntry();
                        lResourceEntry.codeBase = getURL(lFile, false);
                        lResourceEntry.source = new URL("jar:" + getURI(lFile) + "!/" + path);
                        lResourceEntry.lastModified = lFile.lastModified();
                        lResourceEntry.manifest = lJarFile.getManifest();
                        final InputStream lInputStream = lJarFile.getInputStream(lJarEntry);
                        final byte[] lBinaryContent = new byte[(int)lJarEntry.getSize()];
                        
                        int lPosition = 0;
                        while (true) {
                            int n = lInputStream.read(lBinaryContent, lPosition, lBinaryContent.length - lPosition);
                            if (n <= 0)
                                break;
                            lPosition += n;
                        }
                        lInputStream.close();

                        if(needConvert && path.endsWith(".properties")) {
                            final String lStringBynaryContent = new String(lBinaryContent, 0, lPosition);
                            lResourceEntry.binaryContent = lStringBynaryContent.getBytes("UTF-8");
                        }
                        else {
                            lResourceEntry.binaryContent = lBinaryContent;
                        }

                        if (lJarEntry != null) {
                            lResourceEntry.certificates = lJarEntry.getCertificates();
                        }

                        lFichierJar.ajouteResourceEntry(name, lResourceEntry);

                        return lResourceEntry;
                    }
                } catch (IOException e) {
                    return null;
                }
            }
        }

        // Passe la main à la classe mère si la ressource n'est pas concernée par le partage
        return super.findResourceInternal(name, path);
    }

    /**
     * Retourne le fichier jar (du WEB-INF/lib par exemple) qui contient la ressource en fonction de son chemin.
     * Si la ressource n'est contenue par aucun jar ou qu'elle est trouvée ailleurs 
     * que dans un jar (ex. : WEB-INF/classes), la méthode retourne null.
     * @param pResourcePath Chemin de la ressource
     * @return Le fichier jar contenant la ressource
     */
    public File getFileContainsResource(final String pResourcePath) {
        for (int i=0;i<repositories.length;i++) {
            try {
                String fullPath = repositories[i] + pResourcePath;
                Object lookupResult = resources.lookup(fullPath);
                if (lookupResult instanceof Resource) {
                    return null;
                }
            } catch (NamingException e) {
            }
        }
        synchronized (jarFiles) {

            if (!openJARs()) {
                return null;
            }
            for (int i=0;i<jarFiles.length;i++) {

                final JarEntry lJarEntry = jarFiles[i].getJarEntry(pResourcePath);

                if (lJarEntry != null) {
                    return jarRealFiles[i];
                }
            }
        }
        return null;
    }

    /**
     * Retourne le fichier jar (FichierJar) de la liste des fichiers jar 
     * de l'application correspondant à la ressource passée en paramètre.
     * @param pResourcePath chemin de la ressource
     * @return Le fichier Jar; null si aucun ne correspond.
     */
    public FichierJar getFichierJarForResource(final String pResourcePath) {
        final File lFile = getFileContainsResource(pResourcePath);
        if(lFile != null) {
            final String lNomFichier = lFile.getName();
            for(final FichierJar lFichierJar : listeFichiersJarApplication) {
                final String lNomFichierJar = lFichierJar.getFile().getName();
                if(lNomFichierJar.equals(lNomFichier)) {
                    return lFichierJar;
                }
            }
        }
        return null;
    }
}

<?xml version='1.0' encoding='utf-8'?>
<Partages>

    <Dossier nom="A" chemin="c:\dossierA"/>
    <Dossier nom="B" chemin="c:\dossierB"/>
    <Dossier nom="C" chemin="c:\dossierC"/>

    <Application contexte="/application1">
        <Partage nom="A"/>
        <Partage nom="B"/>
        <Partage nom="C"/>
    </Application>
    <Application contexte="/application2">
        <Partage nom="A"/>
        <Partage nom="B"/>
    </Application>
    <Application contexte="/application3">
        <Partage nom="A"/>
        <Partage nom="C"/>
    </Application>
    <Application contexte="/application4">
        <Partage nom="A"/>
        <Partage nom="B"/>
        <Partage nom="C"/>
    </Application>

</Partages>

<?xml version='1.0' encoding='utf-8'?>
<Context>
    <Loader className="com.developpez.rpouiller.partagelibrairiesversionnees.loader.WebappLoaderAvecPartage" 
        loaderClass="com.developpez.rpouiller.partagelibrairiesversionnees.loader.WebappClassLoaderAvecPartage"
    />
</Context>