介绍和基本实现

首先，您至少需要一个 URLStreamHandler.这实际上会打开到给定 URL 的连接.请注意，这被简单地称为Handler；这允许您指定 java -Djava.protocol.handler.pkgs=org.my.protocols 并且它会自动被拾取，使用简单"包名称作为支持的协议(在这种情况下类路径").

Intro and basic Implementation

First up, you're going to need at least a URLStreamHandler. This will actually open the connection to a given URL. Notice that this is simply called Handler; this allows you to specify java -Djava.protocol.handler.pkgs=org.my.protocols and it will automatically be picked up, using the "simple" package name as the supported protocol (in this case "classpath").

new URL("classpath:org/my/package/resource.extension").openConnection();

代码

package org.my.protocols.classpath;

import java.io.IOException;
import java.net.URL;
import java.net.URLConnection;
import java.net.URLStreamHandler;

/** A {@link URLStreamHandler} that handles resources on the classpath. */
public class Handler extends URLStreamHandler {
    /** The classloader to find resources from. */
    private final ClassLoader classLoader;

    public Handler() {
        this.classLoader = getClass().getClassLoader();
    }

    public Handler(ClassLoader classLoader) {
        this.classLoader = classLoader;
    }

    @Override
    protected URLConnection openConnection(URL u) throws IOException {
        final URL resourceUrl = classLoader.getResource(u.getPath());
        return resourceUrl.openConnection();
    }
}

启动问题

如果你和我一样，你不想依赖启动中设置的属性来帮助你到达某个地方(就我而言，我喜欢保留我的选择像 Java WebStart 一样打开 - 这就是为什么我需要所有这些).

Launch issues

If you're anything like me, you don't want to rely on a property being set in the launch to get you somewhere (in my case, I like to keep my options open like Java WebStart - which is why I need all this).

如果你控制了代码，你就可以做到

If you control the code, you can do

new URL(null, "classpath:some/package/resource.extension", new org.my.protocols.classpath.Handler(ClassLoader.getSystemClassLoader()))

这将使用您的处理程序打开连接.

and this will use your handler to open the connection.

但同样，这并不令人满意，因为您不需要 URL 来执行此操作 - 您想要执行此操作是因为某些您无法(或不想)控制的库需要 url...

But again, this is less than satisfactory, as you don't need a URL to do this - you want to do this because some lib you can't (or don't want to) control wants urls...

最终的选择是注册一个 URLStreamHandlerFactory 来处理整个 jvm 的所有 url:

The ultimate option is to register a URLStreamHandlerFactory that will handle all urls across the jvm:

package my.org.url;

import java.net.URLStreamHandler;
import java.net.URLStreamHandlerFactory;
import java.util.HashMap;
import java.util.Map;

class ConfigurableStreamHandlerFactory implements URLStreamHandlerFactory {
    private final Map<String, URLStreamHandler> protocolHandlers;

    public ConfigurableStreamHandlerFactory(String protocol, URLStreamHandler urlHandler) {
        protocolHandlers = new HashMap<String, URLStreamHandler>();
        addHandler(protocol, urlHandler);
    }

    public void addHandler(String protocol, URLStreamHandler urlHandler) {
        protocolHandlers.put(protocol, urlHandler);
    }

    public URLStreamHandler createURLStreamHandler(String protocol) {
        return protocolHandlers.get(protocol);
    }
}

要注册处理程序，请使用您配置的工厂调用 URL.setURLStreamHandlerFactory().然后像第一个示例一样执行 new URL("classpath:org/my/package/resource.extension") 就可以了.

To register the handler, call URL.setURLStreamHandlerFactory() with your configured factory. Then do new URL("classpath:org/my/package/resource.extension") like the first example and away you go.

请注意，每个 JVM 只能调用此方法一次，并注意 Tomcat 将使用此方法注册 JNDI 处理程序 (AFAIK).尝试码头(我会)；最坏的情况是，您可以先使用该方法，然后它必须在您身边工作！

Note that this method may only be called once per JVM, and note well that Tomcat will use this method to register a JNDI handler (AFAIK). Try Jetty (I will be); at worst, you can use the method first and then it has to work around you!

我将其发布到公共领域，并询问如果您想修改您在某处启动 OSS 项目并在此处评论详细信息.更好的实现是有一个 URLStreamHandlerFactory，它使用 ThreadLocals 为每个 Thread.currentThread().getContextClassLoader 存储 URLStreamHandlers().我什至会给你我的修改和测试类.

I release this to the public domain, and ask that if you wish to modify that you start a OSS project somewhere and comment here with the details. A better implementation would be to have a URLStreamHandlerFactory that uses ThreadLocals to store URLStreamHandlers for each Thread.currentThread().getContextClassLoader(). I'll even give you my modifications and test classes.