Comment créer un parent-last / child-first ClassLoader en Java, ou comment modifier une ancienne version de Xerces qui était déjà chargée dans le CL parent?

le code suivant est celui que j'utilise. Il a l'avantage par rapport à l'autre réponse qu'il ne casse pas la chaîne mère (vous pouvez suivre getClassLoader().getParent() ).

il a aussi un avantage sur le WebappClassLoader de tomcat en ne réinventant pas la roue et en ne dépendant pas d'autres objets. Il réutilise le code de URLClassLoader autant que possible.

(il n'honore pas encore le chargeur de classe système, mais quand j'obtiens que corrigé je vais mettre à jour le réponse)

il honore le chargeur de classe système (pour java.* classes, dir approuvé, etc.). Cela fonctionne aussi lorsque la sécurité est activée et que le classloader n'a pas accès à son parent (oui, cette situation est étrange, mais possible).

public class ChildFirstURLClassLoader extends URLClassLoader {

    private ClassLoader system;

    public ChildFirstURLClassLoader(URL[] classpath, ClassLoader parent) {
        super(classpath, parent);
        system = getSystemClassLoader();
    }

    @Override
    protected synchronized Class<?> loadClass(String name, boolean resolve)
            throws ClassNotFoundException {
        // First, check if the class has already been loaded
        Class<?> c = findLoadedClass(name);
        if (c == null) {
            if (system != null) {
                try {
                    // checking system: jvm classes, endorsed, cmd classpath, etc.
                    c = system.loadClass(name);
                }
                catch (ClassNotFoundException ignored) {
                }
            }
            if (c == null) {
                try {
                    // checking local
                    c = findClass(name);
                } catch (ClassNotFoundException e) {
                    // checking parent
                    // This call to loadClass may eventually call findClass again, in case the parent doesn't find anything.
                    c = super.loadClass(name, resolve);
                }
            }
        }
        if (resolve) {
            resolveClass(c);
        }
        return c;
    }

    @Override
    public URL getResource(String name) {
        URL url = null;
        if (system != null) {
            url = system.getResource(name); 
        }
        if (url == null) {
            url = findResource(name);
            if (url == null) {
                // This call to getResource may eventually call findResource again, in case the parent doesn't find anything.
                url = super.getResource(name);
            }
        }
        return url;
    }

    @Override
    public Enumeration<URL> getResources(String name) throws IOException {
        /**
        * Similar to super, but local resources are enumerated before parent resources
        */
        Enumeration<URL> systemUrls = null;
        if (system != null) {
            systemUrls = system.getResources(name);
        }
        Enumeration<URL> localUrls = findResources(name);
        Enumeration<URL> parentUrls = null;
        if (getParent() != null) {
            parentUrls = getParent().getResources(name);
        }
        final List<URL> urls = new ArrayList<URL>();
        if (systemUrls != null) {
            while(systemUrls.hasMoreElements()) {
                urls.add(systemUrls.nextElement());
            }
        }
        if (localUrls != null) {
            while (localUrls.hasMoreElements()) {
                urls.add(localUrls.nextElement());
            }
        }
        if (parentUrls != null) {
            while (parentUrls.hasMoreElements()) {
                urls.add(parentUrls.nextElement());
            }
        }
        return new Enumeration<URL>() {
            Iterator<URL> iter = urls.iterator();

            public boolean hasMoreElements() {
                return iter.hasNext(); 
            }
            public URL nextElement() {
                return iter.next();
            }
        };
    }

    @Override
    public InputStream getResourceAsStream(String name) {
        URL url = getResource(name);
        try {
            return url != null ? url.openStream() : null;
        } catch (IOException e) {
        }
        return null;
    }

}

en lisant le code source de Jetty ou Tomcat, qui fournissent tous deux des chargeurs de dernière classe pour implémenter la sémantique webapp.

http://svn.apache.org/repos/asf/tomcat/tc7.0.x/tags/TOMCAT_7_0_0/java/org/apache/catalina/loader/WebappClassLoader.java

, C'est-à-dire en supplantant la méthode findClass dans votre classe ClassLoader . Mais pourquoi réinventer la roue quand on peut voler?

en lisant vos différentes mises à jour, je vois que vous avez rencontré des problèmes classiques avec le système XML SPI.

le problème général est le suivant: si vous créez un chargeur de classe complètement isolé, alors il est difficile d'utiliser les objets qu'il renvoie. Si vous autorisez le partage, vous pouvez avoir des problèmes lorsque le parent contient les mauvaises versions de choses.

C'est pour faire face à toute cette folie Qu'OSGi a été inventé, mais c'est une grosse pilule à avaler.

même dans les webapps, les Class loaders exemptent certains paquets du traitement "local-first" en partant de l'hypothèse que le conteneur et la webapp doivent s'entendre sur L'API entre eux.

(voir en bas pour une mise à jour sur une solution que j'ai trouvée)

il semble Qu'AntClassLoader ait un support pour parent first / last, (ne l'a pas encore testé)

http://svn.apache.org/repos/asf/ant/core/trunk/src/main/org/apache/tools/ant/AntClassLoader.java

voici un extrait

/**
 * Creates a classloader for the given project using the classpath given.
 *
 * @param parent The parent classloader to which unsatisfied loading
 *               attempts are delegated. May be <code>null</code>,
 *               in which case the classloader which loaded this
 *               class is used as the parent.
 * @param project The project to which this classloader is to belong.
 *                Must not be <code>null</code>.
 * @param classpath the classpath to use to load the classes.
 *                  May be <code>null</code>, in which case no path
 *                  elements are set up to start with.
 * @param parentFirst If <code>true</code>, indicates that the parent
 *                    classloader should be consulted  before trying to
 *                    load the a class through this loader.
 */
public AntClassLoader(
    ClassLoader parent, Project project, Path classpath, boolean parentFirst) {
    this(project, classpath);
    if (parent != null) {
        setParent(parent);
    }
    setParentFirst(parentFirst);
    addJavaLibraries();
}

mise à jour:

Found ce ainsi, lorsqu'en dernier recours, j'ai commencé à deviner les noms de classe dans google (c'est ce que ChildFirstURLClassLoader produit) - mais il semble être incorrect

mise à Jour 2:

la 1ère Option (AntClassLoader) est très couplée à Ant (nécessite un contexte de projet et pas facile de passer un URL[] à it

la 2e Option (d'un projet OSGI en code google ) n'était pas tout à fait ce dont j'avais besoin car il a cherché classloader parent avant le système classloader (Ant class loader le fait correctement d'ailleurs). Le problème comme je le vois, je pense que votre classloader parent inclut un pot (qu'il ne devrait pas avoir) d'une fonctionnalité qui n'était pas sur JDK 1.4 mais a été ajouté en 1.5, cela n'a aucun mal puisque le dernier class loader parent (modèle de délégation régulière, par exemple URLClassLoader) chargera toujours en premier les classes de JDK, mais ici l'enfant d'abord naïf l'implémentation semble dévoiler l'ancien bocal redondant dans le chargeur de classe parent, et suit la propre implémentation de JDK / JRE.

je n'ai pas encore trouver un certifié, entièrement testé, mature Parent Dernier / l'Enfant d'Abord la mise en œuvre correcte qui n'est pas couplé à une solution spécifique (Ant, Catalina/Tomcat)

mise à Jour 3 - je l'ai trouvé! Je regardais au mauvais endroit,

Je n'ai fait qu'ajouter META-INF/services/javax.xml.transform.TransformerFactory et restauré le JDK com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl au lieu de l'ancien Xalan org.apache.xalan.processor.TransformerFactoryImpl

la seule raison pour laquelle je n'accepte pas encore ma propre réponse est que je ne sais pas si l'approche META-INF/services a la même délégation de classe que les classes normales (par exemple, est-ce parent-premier / enfant-dernier ou parent-dernier / enfant-Premier?)

vous pouvez remplacer findClass() et loadClass() pour implémenter un chargeur enfant de première classe:

/**
 * Always throws {@link ClassNotFoundException}. Is called if parent class loader
 * did not find class.
 */
@Override
protected final Class findClass(String name)
        throws ClassNotFoundException
{
    throw new ClassNotFoundException();
}

@Override
protected Class loadClass(String name, boolean resolve)
        throws ClassNotFoundException
{
    synchronized (getClassLoadingLock(name)){
        /*
         * Check if we have already loaded this class.
         */
        Class c = findLoadedClass(name);

        if (c == null){
            try {
                /*
                 * We haven't previously loaded this class, try load it now
                 * from SUPER.findClass()
                 */
                c = super.findClass(name);
            }catch (ClassNotFoundException ignore){
                /*
                 * Child did not find class, try parent.
                 */
                return super.loadClass(name, resolve);
            }
        }

        if (resolve){
            resolveClass(c);
        }

        return c;
    }
}