Javaのクラスローディングを制御する

Class-Path: mystuff/utils.jar
   mystuff/logging.jar mylib/

<?xml version="1.0"?>
<component name=
   "com.jeffhanson.components.HelloWorld">
   <component-archive>
      HelloWorldComponentV1.jar
   </component-archive>

   <ancillary-resources>
      <ancillary-resource>
         log4j-1.2.12.jar
      </ancillary-resource>

      <ancillary-resource>
         concurrent-1.3.4.jar
      </ancillary-resource>
   </ancillary-resources>
</component>

<?xml version="1.0"?>
<component name=
   "com.jeffhanson.components.HelloWorld">
   <component-archive>
      HelloWorldComponentV2.jar
   </component-archive>

   <ancillary-resources>
      <ancillary-resource>
         log4j-1.2.12.jar
      </ancillary-resource>

      <ancillary-resource>
         concurrent-1.3.4.jar
      </ancillary-resource>
   </ancillary-resources>
</component>

package com.jeffhanson.components;

import java.net.URL;
import java.net.URLClassLoader;

public class RestrictedURLClassLoader
   extends URLClassLoader
{
  public RestrictedURLClassLoader(
     URL[] urls)
  {
     super(urls, null);
  }

  public Class loadClass(String name)
     throws ClassNotFoundException
  {
     Class cls = super.loadClass(name);

     if (cls == null)
     {
        throw new ClassNotFoundException(
           "Restricted ClassLoader" +
            " is unable to find class: " +
            name);
     }

     return cls;
  }
}

package com.jeffhanson.components;

import org.apache.commons.configuration.
   ConfigurationException;
import org.apache.commons.configuration.
   XMLConfiguration;
import org.apache.commons.configuration.Configuration;

import org.apache.log4j.Logger;

import java.net.URL;
import java.util.*;
import java.io.IOException;

public class ComponentContainer
{
   // ===============================================
   // static fields
   // ===============================================

   private static Logger log =
      Logger.getLogger(ComponentContainer.class);

   // ===============================================
   // member fields
   // ===============================================

   private String componentArchive = "";
   private URL[] ancillaryClassPathURLs = null;
   private HashMap componentCache = new HashMap();

   // ===============================================
   // constructors
   // ===============================================

   /**
    * Constructs a new ComponentContainer for
    * components named by the specified component
    * names. The names are assumed to
    * refer to JAR/zip files which will be downloaded
    * and opened as needed.
    *
    * @param componentConfigFileName   the name of the
    *                                  configuration
    *                                  file for the
    *                                  component from
    *                                  which to
    *                                  load classes
    *                                  and resources
    */
   public ComponentContainer(String
      componentConfigFileName)
      throws ConfigurationException
   {
      XMLConfiguration config =
         new XMLConfiguration(
         componentConfigFileName);
      this.componentArchive =
         config.getString("component-archive");
      Configuration subConfig =
         config.subset("ancillary-resources");
      if (subConfig != null)
      {
         String[] resNameArr =
            subConfig.getStringArray(
               "ancillary-resource");
         if (resNameArr != null &&
            resNameArr.length > 0)
         {
            this.ancillaryClassPathURLs =
               new URL[resNameArr.length];
            for (int i = 0; i < resNameArr.length;
               i++)
            {
               this.ancillaryClassPathURLs[i] =
                  Thread.currentThread().
                     getContextClassLoader().
                        getResource(resNameArr[i]);
            }
         }
      }
   }

   /**
    * Constructs a new ComponentContainer for
    * components named by the specified component
    * names. The names are assumed to refer to JAR/zip
    * files which will be downloaded and opened
    * as needed.
    *
    * @param componentArchive   the name of the
    *                           archive from which
    *                           to load the component,
    *                           classes and resources
    */
   public ComponentContainer(String componentArchive,
      URL[] ancillaryClassPathURLs)
   {
      this.componentArchive = componentArchive;

      if (ancillaryClassPathURLs != null &&
          ancillaryClassPathURLs.length > 0)
      {
         this.ancillaryClassPathURLs =
            new URL[ancillaryClassPathURLs.length];
         System.arraycopy(ancillaryClassPathURLs, 0,
            this.ancillaryClassPathURLs, 0,
            ancillaryClassPathURLs.length);
      }
   }

   // ==============================================
   // non-public methods
   // ==============================================

   protected Class findLoadedComponent(String name)
   {
      if (componentCache.get(name) != null)
      {
         return (Class)componentCache.get(name);
      }

      return null;
   }

   /**
    * Finds a component by name. This method will be
    * invoked by the loadComponent method.
    *
    * @param name   The name of the component
    * @return The component’s <tt>Class</tt> object
    * @throws ComponentNotFoundException   If the
    *                                      component
    *                                      could not
    *                                      be found
    */
   protected Class findComponent(String name)
      throws ComponentNotFoundException
   {
      ClassLoader ctxClsLoader =
         Thread.currentThread().
         getContextClassLoader();

      URL url = ctxClsLoader.getResource(
         componentArchive);
      if (url != null)
      {
         URL[] urls = null;
         if (ancillaryClassPathURLs != null &&
             ancillaryClassPathURLs.length > 0)
         {
            urls = new URL[
               ancillaryClassPathURLs.length + 1];
            System.arraycopy(ancillaryClassPathURLs,
               0, urls, 0,
               ancillaryClassPathURLs.length);
            urls[ancillaryClassPathURLs.length] = url;
         }
         else
         {
            urls = new URL[1];
            urls[0] = url;
         }

         RestrictedURLClassLoader urlClassLoader =
            new RestrictedURLClassLoader(urls);

         try
         {
            Class cls = urlClassLoader.loadClass(
               name);
            if (cls != null)
            {
               return cls;
            }
         }
         catch (ClassNotFoundException e)
         {
            // ignore
         }
      }

      throw new ComponentNotFoundException(name);
   }

   // ===============================================
   // public methods
   // ===============================================

   /**
    * Loads the component with the specified name.
    *
    * @param name   The name of the component
    * @return The component <tt>Class</tt> object
    * @throws ComponentNotFoundException   If the
    *                                      component
    *                                      was not
    *                                      found
    */
   public Class loadComponent(String name)
      throws ComponentNotFoundException
   {
      Class cls = findLoadedComponent(name);
      if (cls != null)
      {
         return cls;
      }

      cls = findComponent(name);

      if (cls != null)
      {
         componentCache.put(name, cls);
         return cls;
      }

      throw new ComponentNotFoundException(
         "Definition for " + "component: " +
         name + " was not found");
   }
   /**
    * Loads and instantiates the component with the
    * specified name.
    *
    * @param componentName
    * @return The component <tt>Class</tt> object
    * @throws ComponentNotFoundException
    */
   public Object createComponent(String componentName)
      throws ComponentNotFoundException
   {
      Class cls = loadComponent(componentName);

      try
      {
         Object componentObj = cls.newInstance();
         return componentObj;
      }
      catch (Exception e)
      {
         throw new ComponentNotFoundException(
            "Unable to" + " instantiate " +
            " component: " + componentName);
      }
   }
}

package com.jeffhanson.components;
import junit.framework.*;
import java.net.URL;

public class ComponentContainerTest extends TestCase
{
   // ==============================================
   // static methods
   // ==============================================

   public static junit.framework.Test suite()
   {
      return new TestSuite(
         ComponentContainerTest.class);
   }

   // ==============================================
   // constructors
   // ===============================================

   public ComponentContainerTest(String name)
   {
      super(name);
   }

   // ==============================================
   // non-public methods
   // ==============================================

   private String doLoadComponentTest(
      ComponentContainer container,
      String componentName)
      throws ComponentNotFoundException
   {
      Object componentObj =
         container.createComponent(componentName);
      return componentObj.toString();
   }

   // ==============================================
   // public methods
   // ==============================================

   public void setUp()
      throws Exception
   {
      super.setUp();
   }

   public void tearDown()
      throws Exception
   {
      super.tearDown();
   }

   public void testLoadComponent1()
      throws Exception
   {
      String componentName =
         "com.jeffhanson.components.HelloWorld";

      ComponentContainer container =
         new ComponentContainer(
         "HelloWorldV1-CDI.xml");

      String componentStr =
         doLoadComponentTest(container,
         componentName);

      assertNotNull(componentStr);
      assertTrue(componentStr.equals(
         "Hello world V1!"));

      container = new ComponentContainer(
         "HelloWorldV2-CDI.xml");

      componentStr = doLoadComponentTest(
         container, componentName);

      assertNotNull(componentStr);
      assertTrue(componentStr.equals(
         "Hello world V2!"));
   }
}