abstracttreeclassloadermanager.java

树形的java classloader,树形的java classloader,树形的java classloader,

package org.codehaus.classloader;

import java.io.IOException;
import java.net.URL;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.NoSuchElementException;

/**
 * This class provides basic implementation of hierarchical class loader manager,
 * where classes in the same branch take precendence over those in siblings.
 * <p>
 * @author Ben Yu
 * Aug 2, 2006 7:03:18 PM
 */
public abstract class AbstractTreeClassLoaderManager implements ClassLoaderManager, ClassProvider {
  private final ClassLoaderManager up;
  
  protected ClassLoaderManager getManager() {
    return up;
  }

  public AbstractTreeClassLoaderManager(ClassLoaderManager up) {
    this.up = up;
  }
  //null is returned if not found.
  private Class lookupClassInChildren(Object except, String name, ClassLoaderManager man)
  throws ClassNotFoundException{
    for(Iterator it=children(); it.hasNext();){
      final ClassProvider provider = (ClassProvider)it.next();
      if(provider==except) continue;
      try{
        return provider.provideClass(name);
      }
      catch(ClassNotFoundException e2){
        continue;
      }
    }
    return man.lookupClass(this, name);
  }
  private String lookupLibraryInChildren(Object except, String libname, ClassLoaderManager man) {
    for(Iterator it=children(); it.hasNext();){
      final ClassProvider provider = (ClassProvider)it.next();
      if(provider==except) continue;
      final String result = provider.provideLibrary(libname);
      if(result!=null) return result;
    }
    return man.lookupLibrary(this, libname);
  }
  private URL lookupResourceInChildren(Object except, String name, ClassLoaderManager man) {
    for(Iterator it=children(); it.hasNext();){
      final ClassProvider provider = (ClassProvider)it.next();
      if(provider==except) continue;
      final URL result = provider.provideResource(name);
      if(result!=null) return result;
    }
    return man.lookupResource(this, name);
  }
  private Enumeration lookupResourcesInChildren(final Object except, final String name, final ClassLoaderManager man) throws IOException {
    final Enumeration sibling = new Enumeration(){
      private final Iterator it = children();
      private Enumeration enumeration = null;
      private Enumeration getNextEnumeration()
      throws IOException{
        for(;it.hasNext();){
          final ClassProvider provider = (ClassProvider)it.next();
          if(provider!=except){
            final Enumeration enumeration = provider.provideResources(name);
            if(enumeration.hasMoreElements()){
              this.enumeration = enumeration;
              return enumeration;
            }
          }
        }
        return man.lookupResources(this, name);
      }
      private Enumeration getCurrent() {
        if(enumeration ==null || !enumeration.hasMoreElements()){
          try{
            return getNextEnumeration();
          }
          catch(IOException e){
            throw new RuntimeException(e);
          }
        }
        return enumeration;
      }
      public boolean hasMoreElements() {
        final Enumeration enumeration = getCurrent();
        return (enumeration!=null) && enumeration.hasMoreElements();
      }

      public Object nextElement() {
        final Enumeration enumeration =  getCurrent();
        if(enumeration==null){
          throw new NoSuchElementException(name);
        }
        return enumeration.nextElement();
      }
    };
    return sibling;
  }
  /*
  private Package lookupPackageInChildren(Object except, String name, ClassLoaderManager man) {
    for(Iterator it=children(); it.hasNext();){
      final ClassProvider provider = (ClassProvider)it.next();
      if(provider==except) continue;
      final Package result = provider.providePackage(name);
      if(result!=null) return result;
    }
    return man.lookupPackage(this, name);
  }
  private Package[] lookupPackagesInChildren(Object except, ClassLoaderManager man) {
    final ArrayList buf = new ArrayList();
    for(Iterator it=children(); it.hasNext();){
      final ClassProvider provider = (ClassProvider)it.next();
      if(provider==except) continue;
      final Package[] pkgs = provider.providePackages();
      if(pkgs!=null && pkgs.length>0)
        buf.addAll(Arrays.asList(pkgs));
    }
    buf.addAll(Arrays.asList(man.lookupPackages(this)));
    return toPackageArray(buf);
  }
  private static Package[] toPackageArray(List buf){
    final Package[] result = new Package[buf.size()];
    buf.toArray(result);
    return result;
  }*/
  public Class lookupClass(Object except, String name) throws ClassNotFoundException {
    return lookupClassInChildren(except, name, up);
  }


  public String lookupLibrary(Object except, String libname) {
    return lookupLibraryInChildren(except, libname, up);
  }


  public URL lookupResource(Object except, String name) {
    return lookupResourceInChildren(except, name, up);
  }

  public Enumeration lookupResources(final Object except, final String name) throws IOException {
    return lookupResourcesInChildren(except, name, up);
  }
/*
  public Package lookupPackage(Object except, String name) {
    return lookupPackageInChildren(except, name, up);
  }

  public Package[] lookupPackages(Object except) {
    return lookupPackagesInChildren(except, up);
  }
*/
  public Class provideClass(String name) throws ClassNotFoundException {
    return lookupClassInChildren(null, name, NilClassLoaderManager.instance());
  }

  public URL provideResource(String name) {
    return lookupResourceInChildren(null, name, NilClassLoaderManager.instance());
  }

  public Enumeration provideResources(String name) throws IOException {
    return lookupResourcesInChildren(null, name, NilClassLoaderManager.instance());
  }
/*
  public Package providePackage(String name) {
    return lookupPackageInChildren(null, name, NilClassLoaderManager.instance());
  }

  public Package[] providePackages() {
    return lookupPackagesInChildren(null, NilClassLoaderManager.instance());
  }
*/
  public String provideLibrary(String libname) {
    return lookupLibraryInChildren(null, libname, NilClassLoaderManager.instance());
  }
  protected abstract Iterator children();
}