Java 类java.net.URLStreamHandlerFactory 实例源码

/**
 * Creates a new URLStreamHandler instance with the specified protocol.
 * Will return null if the protocol is not <code>jndi</code>.
 * 
 * @param protocol the protocol (must be "jndi" here)
 * @return a URLStreamHandler for the jndi protocol, or null if the 
 * protocol is not JNDI
 */
@Override
public URLStreamHandler createURLStreamHandler(String protocol) {
    if (protocol.equals("jndi")) {
        return new DirContextURLStreamHandler();
    } else if (protocol.equals("classpath")) {
        return new ClasspathURLStreamHandler();
    } else {
        for (URLStreamHandlerFactory factory : userFactories) {
            URLStreamHandler handler =
                factory.createURLStreamHandler(protocol);
            if (handler != null) {
                return handler;
            }
        }
        return null;
    }
}

/**
 * Creates a URL from the specified protocol name, host name, port number,
 * and file name.
 * <p/>
 * No validation of the inputs is performed by this method.
 *
 * @param protocol the name of the protocol to use
 * @param host     the name of the host
 * @param port     the port number
 * @param file     the file on the host
 * @return URL created using specified protocol, host, and file
 * @throws MalformedURLException if an unknown protocol is specified
 */
public static URL createURL(String protocol,
                            String host,
                            int port,
                            String file) throws MalformedURLException {
    URLStreamHandlerFactory factory = _factories.get(protocol);

    // If there is no URLStreamHandlerFactory registered for the
    // scheme/protocol, then we just use the regular URL constructor.
    if (factory == null) {
        return new URL(protocol, host, port, file);
    }

    // If there is a URLStreamHandlerFactory associated for the
    // scheme/protocol, then we create a URLStreamHandler. And, then use
    // then use the URLStreamHandler to create a URL.
    URLStreamHandler handler = factory.createURLStreamHandler(protocol);
    return new URL(protocol, host, port, file, handler);
}

/**
 * Convert an array of String to an array of URL and return it.
 *
 * @param input The array of String to be converted
 * @param factory Handler factory to use to generate the URLs
 */
protected static URL[] convert(String input[],
                               URLStreamHandlerFactory factory) {

    URLStreamHandler streamHandler = null;

    URL url[] = new URL[input.length];
    for (int i = 0; i < url.length; i++) {
        try {
            String protocol = parseProtocol(input[i]);
            if (factory != null)
                streamHandler = factory.createURLStreamHandler(protocol);
            else
                streamHandler = null;
            url[i] = new URL(null, input[i], streamHandler);
        } catch (MalformedURLException e) {
            url[i] = null;
        }
    }
    return (url);

}

/**
 * Creates a new URLStreamHandler instance with the specified protocol.
 * Will return null if the protocol is not <code>jndi</code>.
 * 
 * @param protocol the protocol (must be "jndi" here)
 * @return a URLStreamHandler for the jndi protocol, or null if the 
 * protocol is not JNDI
 */
@Override
public URLStreamHandler createURLStreamHandler(String protocol) {
    if (protocol.equals("jndi")) {
        return new DirContextURLStreamHandler();
    } else if (protocol.equals("classpath")) {
        return new ClasspathURLStreamHandler();
    } else {
        for (URLStreamHandlerFactory factory : userFactories) {
            URLStreamHandler handler =
                factory.createURLStreamHandler(protocol);
            if (handler != null) {
                return handler;
            }
        }
        return null;
    }
}

/**
 * Creates a new URLClassPath for the given URLs. The URLs will be
 * searched in the order specified for classes and resources. A URL
 * ending with a '/' is assumed to refer to a directory. Otherwise,
 * the URL is assumed to refer to a JAR file.
 *
 * @param urls the directory and JAR file URLs to search for classes
 *        and resources
 * @param factory the URLStreamHandlerFactory to use when creating new URLs
 * @param acc the context to be used when loading classes and resources, may
 *            be null
 */
public URLClassPath(URL[] urls,
                    URLStreamHandlerFactory factory,
                    AccessControlContext acc) {
    for (int i = 0; i < urls.length; i++) {
        path.add(urls[i]);
    }
    push(urls);
    if (factory != null) {
        jarHandler = factory.createURLStreamHandler("jar");
    }
    if (DISABLE_ACC_CHECKING)
        this.acc = null;
    else
        this.acc = acc;
}

/**
 * Creates a new URLClassPath for the given URLs. The URLs will be
 * searched in the order specified for classes and resources. A URL
 * ending with a '/' is assumed to refer to a directory. Otherwise,
 * the URL is assumed to refer to a JAR file.
 *
 * @param urls the directory and JAR file URLs to search for classes
 *        and resources
 * @param factory the URLStreamHandlerFactory to use when creating new URLs
 * @param acc the context to be used when loading classes and resources, may
 *            be null
 */
public URLClassPath(URL[] urls,
                    URLStreamHandlerFactory factory,
                    AccessControlContext acc) {
    List<URL> path = new ArrayList<>(urls.length);
    for (URL url : urls) {
        path.add(url);
    }
    this.path = path;
    push(urls);
    if (factory != null) {
        jarHandler = factory.createURLStreamHandler("jar");
    } else {
        jarHandler = null;
    }
    if (DISABLE_ACC_CHECKING)
        this.acc = null;
    else
        this.acc = acc;
}

/**
 * Installs the GIT protocol that we use to identify certain file versions.
 */
protected void installGitProtocol() {
  // Install protocol.
  try {
  URL.setURLStreamHandlerFactory(new URLStreamHandlerFactory() {
    @Override
    public URLStreamHandler createURLStreamHandler(String protocol) {
      if (protocol.equals(GitRevisionURLHandler.GIT_PROTOCOL)) {
        URLStreamHandler handler = new GitRevisionURLHandler();
        return handler;
      }

      return null;
    }
  });
  } catch (Throwable t) {
    if (!t.getMessage().contains("factory already defined")) {
      logger.info(t, t);
    }
  } 
}

/**
 * Creates a new URLStreamHandler instance with the specified protocol. Will
 * return null if the protocol is not <code>jndi</code>.
 * 
 * @param protocol
 *            the protocol (must be "jndi" here)
 * @return a URLStreamHandler for the jndi protocol, or null if the protocol
 *         is not JNDI
 */
@Override
public URLStreamHandler createURLStreamHandler(String protocol) {
    if (protocol.equals("jndi")) {
        return new DirContextURLStreamHandler();
    } else if (protocol.equals("classpath")) {
        return new ClasspathURLStreamHandler();
    } else {
        for (URLStreamHandlerFactory factory : userFactories) {
            URLStreamHandler handler = factory.createURLStreamHandler(protocol);
            if (handler != null) {
                return handler;
            }
        }
        return null;
    }
}

/**
 * Tries to parse a <code>String</code> as an URL.
 * 
 * @param spec the <code>String</code> to parse
 * @param urlHandlerFactory an URL stream handler factory to use
 * @return an URL if the parsing is successful
 * @see #getURLHandler(String, URLStreamHandlerFactory)
 * @see #getURLHandlerFactory(URLStreamHandlerFactory)
 */
public static URL createURL(String spec, URLStreamHandlerFactory urlHandlerFactory)
{
    URLStreamHandler handler = getURLHandler(spec, urlHandlerFactory);
    URL url;
    try
    {
        if (handler == null)
        {
            url = new URL(spec);
        }
        else
        {
            url = new URL(null, spec, handler);
        }
    }
    catch (MalformedURLException e)
    {
        url = null;
    }
    return url;
}

/**
 * Returns an URL stream handler for an URL specified as a <code>String</code>.
 * 
 * @param spec the <code>String</code> to parse as an URL
 * @param urlHandlerFact an URL stream handler factory
 * @return an URL stream handler if one was found for the protocol of the URL
 * @see #getURLHandlerFactory(URLStreamHandlerFactory)
 */
public static URLStreamHandler getURLHandler(String spec, URLStreamHandlerFactory urlHandlerFact)
{
    URLStreamHandlerFactory urlHandlerFactory = urlHandlerFact;//getURLHandlerFactory(urlHandlerFact);

    URLStreamHandler handler = null;
    if (urlHandlerFactory != null)
    {
        String protocol = getURLProtocol(spec);
        if (protocol != null)
        {
            handler = urlHandlerFactory.createURLStreamHandler(protocol);
        }
    }
    return handler;
}

/**
 * Creates a new URLClassPath for the given URLs. The URLs will be
 * searched in the order specified for classes and resources. A URL
 * ending with a '/' is assumed to refer to a directory. Otherwise,
 * the URL is assumed to refer to a JAR file.
 *
 * @param urls the directory and JAR file URLs to search for classes
 *        and resources
 * @param factory the URLStreamHandlerFactory to use when creating new URLs
 * @param acc the context to be used when loading classes and resources, may
 *            be null
 */
public URLClassPath(URL[] urls,
                    URLStreamHandlerFactory factory,
                    AccessControlContext acc) {
    for (int i = 0; i < urls.length; i++) {
        path.add(urls[i]);
    }
    push(urls);
    if (factory != null) {
        jarHandler = factory.createURLStreamHandler("jar");
    }
    if (DISABLE_ACC_CHECKING)
        this.acc = null;
    else
        this.acc = acc;
}

/**
 * Creates a new URLClassPath for the given URLs. The URLs will be
 * searched in the order specified for classes and resources. A URL
 * ending with a '/' is assumed to refer to a directory. Otherwise,
 * the URL is assumed to refer to a JAR file.
 *
 * @param urls the directory and JAR file URLs to search for classes
 *        and resources
 * @param factory the URLStreamHandlerFactory to use when creating new URLs
 * @param acc the context to be used when loading classes and resources, may
 *            be null
 */
public URLClassPath(URL[] urls,
                    URLStreamHandlerFactory factory,
                    AccessControlContext acc) {
    for (int i = 0; i < urls.length; i++) {
        path.add(urls[i]);
    }
    push(urls);
    if (factory != null) {
        jarHandler = factory.createURLStreamHandler("jar");
    }
    if (DISABLE_ACC_CHECKING)
        this.acc = null;
    else
        this.acc = acc;
}

private JarURLLoader(URLClassLoader classloader, URLStreamHandlerCache cache,
                     URLStreamHandlerFactory factory,
                     URL baseURL, URL absoluteUrl,
                     Set indexSet)
{
  super(classloader, cache, factory, baseURL, absoluteUrl);

  URL newBaseURL = null;
  try
    {
      // Cache url prefix for all resources in this jar url.
      String base = baseURL.toExternalForm() + "!/";
      newBaseURL = new URL("jar", "", -1, base, cache.get(factory, "jar"));
    }
  catch (MalformedURLException ignore)
    {
      // Ignore.
    }
  this.baseJarURL = newBaseURL;
  this.classPath = null;
  this.indexSet = indexSet;
}

public synchronized URLStreamHandler get(URLStreamHandlerFactory factory,
                                         String protocol)
{
  if (factory == null)
    return null;
  // Check if there're handler for the same protocol in cache.
  HashMap<String, URLStreamHandler> cache = factoryCache.get(factory);
  URLStreamHandler handler = cache.get(protocol);
  if (handler == null)
    {
      // Add it to cache.
      handler = factory.createURLStreamHandler(protocol);
      cache.put(protocol, handler);
    }
  return handler;
}

public static void setupPizzaURLLoader() {
    if (!customUrlLoader) {
        URL.setURLStreamHandlerFactory(new URLStreamHandlerFactory() {
            @Override
            public URLStreamHandler createURLStreamHandler(String protocol) {
                if (protocol.equals("pizza")) {
                    return new PizzaUrlHandler();
                } else {
                    return null;
                }
            }
        });

        customUrlLoader = true;
    }
}

/**
 * Convenience method to set up the necessary HttpClient protocol and URL handler.
 *
 * Only works for HttpClient, because it's not possible (or at least very difficult)
 * to provide a different socket factory for the HttpURLConnection class.
 */
public static void setup(){
    final String LOOPBACK = "loopback"; // $NON-NLS-1$

    // This ensures tha HttpClient knows about the protocol
    Protocol.registerProtocol(LOOPBACK, new Protocol(LOOPBACK,new LoopbackHttpClientSocketFactory(),1));

    // Now allow the URL handling to work.
    URLStreamHandlerFactory ushf = new URLStreamHandlerFactory(){
        @Override
        public URLStreamHandler createURLStreamHandler(String protocol) {
            if (protocol.equalsIgnoreCase(LOOPBACK)){
                return new URLStreamHandler(){
                    @Override
                    protected URLConnection openConnection(URL u) throws IOException {
                        return null;// not needed for HttpClient
                    }
                };
            }
            return null;
        }
    };

    java.net.URL.setURLStreamHandlerFactory(ushf);
}

private JarURLLoader(URLClassLoader classloader, URLStreamHandlerCache cache,
                     URLStreamHandlerFactory factory,
                     URL baseURL, URL absoluteUrl,
                     Set indexSet)
{
  super(classloader, cache, factory, baseURL, absoluteUrl);

  URL newBaseURL = null;
  try
    {
      // Cache url prefix for all resources in this jar url.
      String base = baseURL.toExternalForm() + "!/";
      newBaseURL = new URL("jar", "", -1, base, cache.get(factory, "jar"));
    }
  catch (MalformedURLException ignore)
    {
      // Ignore.
    }
  this.baseJarURL = newBaseURL;
  this.classPath = null;
  this.indexSet = indexSet;
}

public synchronized URLStreamHandler get(URLStreamHandlerFactory factory,
                                         String protocol)
{
  if (factory == null)
    return null;
  // Check if there're handler for the same protocol in cache.
  HashMap<String, URLStreamHandler> cache = factoryCache.get(factory);
  URLStreamHandler handler = cache.get(protocol);
  if (handler == null)
    {
      // Add it to cache.
      handler = factory.createURLStreamHandler(protocol);
      cache.put(protocol, handler);
    }
  return handler;
}

static URLStreamHandlerFactory loadUrlStreamHandlerFactory(String protocol) {
    String artifact = System.getProperty(protocol+"MvnUrlHandler",String.format(HANDLER_FACTORT_ARTIFACT,protocol));

    Collection<URLStreamHandlerFactory> urlStreamHandlerFactories = MavenServiceLoader.loadServices(
            artifact, URLStreamHandlerFactory.class);

    if(urlStreamHandlerFactories.isEmpty()){
        return null;
    } else if(urlStreamHandlerFactories.size() == 1){
        return urlStreamHandlerFactories.iterator().next();
    } else {
        URLStreamHandlerFactory[] streamHandlerFactories = urlStreamHandlerFactories.toArray(
                new URLStreamHandlerFactory[urlStreamHandlerFactories.size()]);
        return new ChainURLStreamHandlerFactory(streamHandlerFactories);
    }
}

/**
 * Creates a URL from the specified protocol name, host name, port number,
 * and file name.
 * <p/>
 * No validation of the inputs is performed by this method.
 *
 * @param protocol the name of the protocol to use
 * @param host     the name of the host
 * @param port     the port number
 * @param file     the file on the host
 * @return URL created using specified protocol, host, and file
 * @throws MalformedURLException if an unknown protocol is specified
 */
public static URL createURL(String protocol,
                            String host,
                            int port,
                            String file) throws MalformedURLException {
    URLStreamHandlerFactory factory = _factories.get(protocol);

    // If there is no URLStreamHandlerFactory registered for the
    // scheme/protocol, then we just use the regular URL constructor.
    if (factory == null) {
        return new URL(protocol, host, port, file);
    }

    // If there is a URLStreamHandlerFactory associated for the
    // scheme/protocol, then we create a URLStreamHandler. And, then use
    // then use the URLStreamHandler to create a URL.
    URLStreamHandler handler = factory.createURLStreamHandler(protocol);
    return new URL(protocol, host, port, file, handler);
}

public static void main(String args[]) {

        // Unlock Security Management
        System.setSecurityManager(new UnsafeSecurityManager());

        // Set URL Stream Handler for jeditresource (hack/fix for jEdit Web
        // Start)
        try {
            URLStreamHandlerFactory factory;
            factory = new JEditURLStreamHandlerFactory();

            if (factory != null) {
                URL.setURLStreamHandlerFactory(factory);
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }


        // Loader Window
        LoaderJFrame loader = new LoaderJFrame();
        loader.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        //loader.autoload();
    }

/**
 * Install the mvn protocol handler for URLs.
 */
public static void registerMavenUrlHandler() {
    try {
        new URL("mvn:foo/bar");
    } catch (MalformedURLException e) {

        // handles mvn local repository
        String mvnLocalRepo = System.getProperty("maven.repo.local");
        if (mvnLocalRepo != null) {
            System.setProperty("org.ops4j.pax.url.mvn.localRepository", mvnLocalRepo);
        }

        // If the URL above failed, the mvn protocol needs to be installed.
        URL.setURLStreamHandlerFactory(new URLStreamHandlerFactory() {

            @Override
            public URLStreamHandler createURLStreamHandler(String protocol) {
                if (ServiceConstants.PROTOCOL.equals(protocol)) {
                    return new MavenUrlStreamHandler();
                } else {
                    return null;
                }
            }
        });
    }
}

@BeforeClass
public static void setupMavenUrlHandler() {
    try {
        new URL("mvn:foo/bar");
    } catch (MalformedURLException e) {
        // handles mvn local repository
        String mvnLocalRepo = System.getProperty("maven.repo.local");
        if (mvnLocalRepo != null) {
            System.setProperty("org.ops4j.pax.url.mvn.localRepository", mvnLocalRepo);
        }
        URL.setURLStreamHandlerFactory(new URLStreamHandlerFactory() {

            @Override
            public URLStreamHandler createURLStreamHandler(String protocol) {
                if (ServiceConstants.PROTOCOL.equals(protocol)) {
                    return new Handler();
                } else {
                    return null;
                }
            }
        });
    }
}

@BeforeClass
public static void setupMavenUrlHandler() {
    try {
        new URL("mvn:foo/bar");
    } catch (MalformedURLException e) {
        // handles mvn local repository
        String mvnLocalRepo = System.getProperty("maven.repo.local");
        if (mvnLocalRepo != null) {
            System.setProperty("org.ops4j.pax.url.mvn.localRepository", mvnLocalRepo);
        }
        URL.setURLStreamHandlerFactory(new URLStreamHandlerFactory() {

            @Override
            public URLStreamHandler createURLStreamHandler(String protocol) {
                if (ServiceConstants.PROTOCOL.equals(protocol)) {
                    return new Handler();
                } else {
                    return null;
                }
            }
        });
    }
}

/**
 * Creates a new URLStreamHandler instance with the specified protocol.
 * Will return null if the protocol is not <code>jndi</code>.
 * 
 * @param protocol the protocol (must be "jndi" here)
 * @return a URLStreamHandler for the jndi protocol, or null if the 
 * protocol is not JNDI
 */
@Override
public URLStreamHandler createURLStreamHandler(String protocol) {
    if (protocol.equals("jndi")) {
        return new DirContextURLStreamHandler();
    } else {
        for (URLStreamHandlerFactory factory : userFactories) {
            URLStreamHandler handler =
                factory.createURLStreamHandler(protocol);
            if (handler != null) {
                return handler;
            }
        }
        return null;
    }
}

/**
 * @tests java.net.URLClassLoader#URLClassLoader(java.net.URL[], java.lang.ClassLoader,
 *        java.net.URLStreamHandlerFactory)
 */
public void test_Constructor$Ljava_net_URLLjava_lang_ClassLoaderLjava_net_URLStreamHandlerFactory()
        throws Exception {
    class TestFactory implements URLStreamHandlerFactory {
        public URLStreamHandler createURLStreamHandler(String protocol) {
            if ("jar".equals(protocol)) {
                return new Handler();
            }

            fail("Should be jar Handler. But " + protocol);
            return null;
        }
    }

    final URL base = getClass().getResource("lf.jar");

    final URL[] urls = { base };
    final URLClassLoader ucl = new URLClassLoader(urls, null, new TestFactory());

    final URL res = ucl.findResource("swt.dll");
    assertNotNull(res);

    final URI e = new URI("jar:" + base.toExternalForm() + "!/swt.dll");
    final URI a = res.toURI();
    assertEquals(e, a);
}

private JarURLLoader(URLClassLoader classloader, URLStreamHandlerCache cache,
                     URLStreamHandlerFactory factory,
                     URL baseURL, URL absoluteUrl,
                     Set indexSet)
{
  super(classloader, cache, factory, baseURL, absoluteUrl);

  URL newBaseURL = null;
  try
    {
      // Cache url prefix for all resources in this jar url.
      String base = baseURL.toExternalForm() + "!/";
      newBaseURL = new URL("jar", "", -1, base, cache.get(factory, "jar"));
    }
  catch (MalformedURLException ignore)
    {
      // Ignore.
    }
  this.baseJarURL = newBaseURL;
  this.classPath = null;
  this.indexSet = indexSet;
}

public synchronized URLStreamHandler get(URLStreamHandlerFactory factory,
                                         String protocol)
{
  if (factory == null)
    return null;
  // Check if there're handler for the same protocol in cache.
  HashMap<String, URLStreamHandler> cache = factoryCache.get(factory);
  URLStreamHandler handler = cache.get(protocol);
  if (handler == null)
    {
      // Add it to cache.
      handler = factory.createURLStreamHandler(protocol);
      cache.put(protocol, handler);
    }
  return handler;
}

/**
 * Creates a new URLStreamHandler instance with the specified protocol.
 * Will return null if the protocol is not <code>jndi</code>.
 * 
 * @param protocol the protocol (must be "jndi" here)
 * @return a URLStreamHandler for the jndi protocol, or null if the 
 * protocol is not JNDI
 */
@Override
public URLStreamHandler createURLStreamHandler(String protocol) {
    if (protocol.equals("jndi")) {
        return new DirContextURLStreamHandler();
    } else {
        for (URLStreamHandlerFactory factory : userFactories) {
            URLStreamHandler handler =
                factory.createURLStreamHandler(protocol);
            if (handler != null) {
                return handler;
            }
        }
        return null;
    }
}

/**
 * Creates a new URLStreamHandler instance with the specified protocol.
 * Will return null if the protocol is not <code>jndi</code>.
 * 
 * @param protocol the protocol (must be "jndi" here)
 * @return a URLStreamHandler for the jndi protocol, or null if the 
 * protocol is not JNDI
 */
@Override
public URLStreamHandler createURLStreamHandler(String protocol) {
    if (protocol.equals("jndi")) {
        return new DirContextURLStreamHandler();
    } else {
        for (URLStreamHandlerFactory factory : userFactories) {
            URLStreamHandler handler =
                factory.createURLStreamHandler(protocol);
            if (handler != null) {
                return handler;
            }
        }
        return null;
    }
}

private static void hookURLStreamHandlerFactory(final Class<?> cls) {
    if (cls == null || !URLStreamHandlerFactory.class.isAssignableFrom(cls)) return;
    for (final Method method : cls.getMethods()) {
        // method.setAccessible(true);
        final Class<?> returnType = method.getReturnType();
        if (HostnameVerifier.class.isAssignableFrom(returnType)) {
            hookMethod(method, XC_MethodReplacement.returnConstant(new AllowAllHostnameVerifierImpl()));
        } else if (javax.net.ssl.SSLSocketFactory.class.isAssignableFrom(returnType)) {
            hookMethod(method, XC_MethodReplacement.returnConstant(TrustAllSSLSocketFactory.getSocketFactory()));
        } else if (URLStreamHandler.class.isAssignableFrom(returnType)) {
            hookMethod(method, new CreateURLStreamHandlerHook());
        } else if (HttpURLConnection.class.isAssignableFrom(returnType)) {
            hookMethod(method, new OkHttpClientModifyRequestCallback());
        }
    }
}

/**
 * Convert an array of String to an array of URL and return it.
 *
 * @param input The array of String to be converted
 * @param factory Handler factory to use to generate the URLs
 */
protected static URL[] convert(String input[],
                               URLStreamHandlerFactory factory) {

    URLStreamHandler streamHandler = null;

    URL url[] = new URL[input.length];
    for (int i = 0; i < url.length; i++) {
        try {
            String protocol = parseProtocol(input[i]);
            if (factory != null)
                streamHandler = factory.createURLStreamHandler(protocol);
            else
                streamHandler = null;
            url[i] = new URL(null, input[i], streamHandler);
        } catch (MalformedURLException e) {
            url[i] = null;
        }
    }
    return (url);

}

private JarURLLoader(URLClassLoader classloader, URLStreamHandlerCache cache,
                     URLStreamHandlerFactory factory,
                     URL baseURL, URL absoluteUrl,
                     Set<String> indexSet)
{
  super(classloader, cache, factory, baseURL, absoluteUrl);

  URL newBaseURL = null;
  try
    {
      // Cache url prefix for all resources in this jar url.
      String base = baseURL.toExternalForm() + "!/";
      newBaseURL = new URL("jar", "", -1, base, cache.get(factory, "jar"));
    }
  catch (MalformedURLException ignore)
    {
      // Ignore.
    }
  this.baseJarURL = newBaseURL;
  this.classPath = null;
  this.indexSet = indexSet;
}

public synchronized URLStreamHandler get(URLStreamHandlerFactory factory,
                                         String protocol)
{
  if (factory == null)
    return null;
  // Check if there're handler for the same protocol in cache.
  HashMap<String, URLStreamHandler> cache = factoryCache.get(factory);
  URLStreamHandler handler = cache.get(protocol);
  if (handler == null)
    {
      // Add it to cache.
      handler = factory.createURLStreamHandler(protocol);
      cache.put(protocol, handler);
    }
  return handler;
}

/**
 * @tests java.net.URLClassLoader#URLClassLoader(java.net.URL[], java.lang.ClassLoader,
 *        java.net.URLStreamHandlerFactory)
 */
public void test_Constructor$Ljava_net_URLLjava_lang_ClassLoaderLjava_net_URLStreamHandlerFactory()
        throws Exception {
    class TestFactory implements URLStreamHandlerFactory {
        public URLStreamHandler createURLStreamHandler(String protocol) {
            if ("jar".equals(protocol)) {
                return new Handler();
            }

            fail("Should be jar Handler. But " + protocol);
            return null;
        }
    }

    final URL base = getClass().getResource("lf.jar");

    final URL[] urls = { base };
    final URLClassLoader ucl = new URLClassLoader(urls, null, new TestFactory());

    final URL res = ucl.findResource("swt.dll");
    assertNotNull(res);

    final URI e = new URI("jar:" + base.toExternalForm() + "!/swt.dll");
    final URI a = res.toURI();
    assertEquals(e, a);
}

/**
 * Creates a new URLStreamHandler instance with the specified protocol.
 * Will return null if the protocol is not <code>jndi</code>.
 * 
 * @param protocol the protocol (must be "jndi" here)
 * @return a URLStreamHandler for the jndi protocol, or null if the 
 * protocol is not JNDI
 */
@Override
public URLStreamHandler createURLStreamHandler(String protocol) {
    if (protocol.equals("jndi")) {
        return new DirContextURLStreamHandler();
    } else {
        for (URLStreamHandlerFactory factory : userFactories) {
            URLStreamHandler handler =
                factory.createURLStreamHandler(protocol);
            if (handler != null) {
                return handler;
            }
        }
        return null;
    }
}

/**
 * Convenience method to set up the necessary HttpClient protocol and URL handler.
 *
 * Only works for HttpClient, because it's not possible (or at least very difficult)
 * to provide a different socket factory for the HttpURLConnection class.
 */
public static void setup(){
    final String LOOPBACK = "loopback"; // $NON-NLS-1$

    // This ensures tha HttpClient knows about the protocol
    Protocol.registerProtocol(LOOPBACK, new Protocol(LOOPBACK,new LoopbackHttpClientSocketFactory(),1));

    // Now allow the URL handling to work.
    URLStreamHandlerFactory ushf = new URLStreamHandlerFactory(){
        @Override
        public URLStreamHandler createURLStreamHandler(String protocol) {
            if (protocol.equalsIgnoreCase(LOOPBACK)){
                return new URLStreamHandler(){
                    @Override
                    protected URLConnection openConnection(URL u) throws IOException {
                        return null;// not needed for HttpClient
                    }
                };
            }
            return null;
        }
    };

    java.net.URL.setURLStreamHandlerFactory(ushf);
}

@Override
public void resultChanged(LookupEvent ev) {
    Collection<? extends URLStreamHandlerFactory> c = r.allInstances();
    synchronized (this) {
        handlers = c.toArray(new URLStreamHandlerFactory[c.size()]);
    }
}

@Override
public URLStreamHandlerFactory createURLStreamHandlerFactory() {
    // Returning null causes this factory to pass though, which ends up using the platform's
    // implementation.
    return new URLStreamHandlerFactory() {
        @Override
        public URLStreamHandler createURLStreamHandler(String protocol) {
            return null;
        }
    };
}

/**
 * Construct a new ClassLoader with no defined repositories and the
 * specified parent ClassLoader.
 *
 * @param parent The parent ClassLoader
 * @param factory the URLStreamHandlerFactory to use when creating URLs
 */
public StandardClassLoader(ClassLoader parent,
                           URLStreamHandlerFactory factory) {

    super((new URL[0]), parent, factory);
    this.factory = factory;

}