在 Java 中，您可以使用相同的 API 但使用不同的 URL 协议来加载各种资源：
file:///tmp.txt
http://127.0.0.1:8080/a.properties
jar:http://www.foo.com/bar/baz.jar!/COM/foo/Quux.class
这很好地将资源的实际加载与需要资源的应用程序分离，并且由于 URL 只是一个字符串，因此资源加载也很容易配置。
是否有使用当前类加载器加载资源的协议？这类似于 Jar 协议，只是我不需要知道资源来自哪个 jar 文件或类文件夹。
当然，我可以使用 来做到这一点Class.getResourceAsStream("a.xml")，但这需要我使用不同的 API，因此需要更改现有代码。我希望能够在我已经可以为资源指定 URL 的所有地方使用它，只需更新属性文件即可。
首先，您至少需要一个 URLStreamHandler。这实际上将打开到给定 URL 的连接。请注意，这只是简单地调用Handler；这允许您指定java -Djava.protocol.handler.pkgs=org.my.protocols并且它会自动被拾取，使用“简单”包名称作为支持的协议（在本例中为“类路径”）。
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();
}
}
如果你控制代码，你可以做
new URL(null, "classpath:some/package/resource.extension", new org.my.protocols.classpath.Handler(ClassLoader.getSystemClassLoader()))
这将使用您的处理程序打开连接。
但同样，这不太令人满意，因为您不需要 URL 来执行此操作 - 您想要这样做是因为您无法（或不想）控制的某些库想要 url...
最终的选择是注册一个URLStreamHandlerFactory将处理整个 jvm 的所有 url：
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")像第一个例子一样，然后离开。
请注意，每个 JVM 只能调用此方法一次，请注意 Tomcat 将使用此方法注册 JNDI 处理程序 (AFAIK)。试试码头（我会的）；在最坏的情况下，您可以先使用该方法，然后它必须在您周围工作！
我将其发布到公共领域，并询问您是否希望修改您在某处启动 OSS 项目并在此处评论详细信息。更好的实现是URLStreamHandlerFactory使用s为每个ThreadLocals 存储s 。我什至会给你我的修改和测试课程。URLStreamHandlerThread.currentThread().getContextClassLoader()
URL url = getClass().getClassLoader().getResource("someresource.xxx");
那应该这样做。
我认为这是值得自己回答的——如果你使用的是 Spring，那么你已经有了这个
Resource firstResource =
context.getResource("http://www.google.fi/");
Resource anotherResource =
context.getResource("classpath:some/resource/path/myTemplate.txt");
就像在春季文档中解释的那样，并在 skaffman 的评论中指出。
您还可以在启动期间以编程方式设置属性：
final String key = "java.protocol.handler.pkgs";
String newValue = "org.my.protocols";
if (System.getProperty(key) != null) {
final String previousValue = System.getProperty(key);
newValue += "|" + previousValue;
}
System.setProperty(key, newValue);
使用这个类：
package org.my.protocols.classpath;
import java.io.IOException;
import java.net.URL;
import java.net.URLConnection;
import java.net.URLStreamHandler;
public class Handler extends URLStreamHandler {
@Override
protected URLConnection openConnection(final URL u) throws IOException {
final URL resourceUrl = ClassLoader.getSystemClassLoader().getResource(u.getPath());
return resourceUrl.openConnection();
}
}
因此，您可以获得最少干扰的方式来执行此操作。:) java.net.URL 将始终使用系统属性中的当前值。
从 Java 9+ 起，您可以定义一个新的URLStreamHandlerProvider. 该类URL使用服务加载器框架在运行时加载它。
创建提供者：
package org.example;
import java.io.IOException;
import java.net.URL;
import java.net.URLConnection;
import java.net.URLStreamHandler;
import java.net.spi.URLStreamHandlerProvider;
public class ClasspathURLStreamHandlerProvider extends URLStreamHandlerProvider {
@Override
public URLStreamHandler createURLStreamHandler(String protocol) {
if ("classpath".equals(protocol)) {
return new URLStreamHandler() {
@Override
protected URLConnection openConnection(URL u) throws IOException {
return ClassLoader.getSystemClassLoader().getResource(u.getPath()).openConnection();
}
};
}
return null;
}
}
java.net.spi.URLStreamHandlerProvider在目录中创建一个名为的文件META-INF/services，其内容为：
org.example.ClasspathURLStreamHandlerProvider
现在，当 URL 类看到类似以下内容时，它将使用提供程序：
URL url = new URL("classpath:myfile.txt");
（类似于阿兹德的回答，但略有不同。）
我不相信类路径中的内容有预定义的协议处理程序。（所谓的classpath:协议）。
但是，Java 确实允许您添加自己的协议。这是通过提供具体的实现java.net.URLStreamHandler和java.net.URLConnection.
本文描述了如何实现自定义流处理程序： http://java.sun.com/developer/onlineTraining/protocolhandlers/。
我创建了一个类，它有助于减少设置自定义处理程序时的错误，并利用系统属性，因此首先调用方法或不在正确的容器中没有问题。如果你弄错了，还有一个异常类：
CustomURLScheme.java:
/*
* The CustomURLScheme class has a static method for adding cutom protocol
* handlers without getting bogged down with other class loaders and having to
* call setURLStreamHandlerFactory before the next guy...
*/
package com.cybernostics.lib.net.customurl;
import java.net.URLStreamHandler;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* Allows you to add your own URL handler without running into problems
* of race conditions with setURLStream handler.
*
* To add your custom protocol eg myprot://blahblah:
*
* 1) Create a new protocol package which ends in myprot eg com.myfirm.protocols.myprot
* 2) Create a subclass of URLStreamHandler called Handler in this package
* 3) Before you use the protocol, call CustomURLScheme.add(com.myfirm.protocols.myprot.Handler.class);
* @author jasonw
*/
public class CustomURLScheme
{
// this is the package name required to implelent a Handler class
private static Pattern packagePattern = Pattern.compile( "(.+\\.protocols)\\.[^\\.]+" );
/**
* Call this method with your handlerclass
* @param handlerClass
* @throws Exception
*/
public static void add( Class<? extends URLStreamHandler> handlerClass ) throws Exception
{
if ( handlerClass.getSimpleName().equals( "Handler" ) )
{
String pkgName = handlerClass.getPackage().getName();
Matcher m = packagePattern.matcher( pkgName );
if ( m.matches() )
{
String protocolPackage = m.group( 1 );
add( protocolPackage );
}
else
{
throw new CustomURLHandlerException( "Your Handler class package must end in 'protocols.yourprotocolname' eg com.somefirm.blah.protocols.yourprotocol" );
}
}
else
{
throw new CustomURLHandlerException( "Your handler class must be called 'Handler'" );
}
}
private static void add( String handlerPackage )
{
// this property controls where java looks for
// stream handlers - always uses current value.
final String key = "java.protocol.handler.pkgs";
String newValue = handlerPackage;
if ( System.getProperty( key ) != null )
{
final String previousValue = System.getProperty( key );
newValue += "|" + previousValue;
}
System.setProperty( key, newValue );
}
}
CustomURLHandlerException.java:
/*
* Exception if you get things mixed up creating a custom url protocol
*/
package com.cybernostics.lib.net.customurl;
/**
*
* @author jasonw
*/
public class CustomURLHandlerException extends Exception
{
public CustomURLHandlerException(String msg )
{
super( msg );
}
}
灵感来自@Stephen https://stackoverflow.com/a/1769454/980442 和http://docstore.mik.ua/orelly/java/exp/ch09_06.htm
使用
new URL("classpath:org/my/package/resource.extension").openConnection()
只需将此类创建到sun.net.www.protocol.classpath包中并将其运行到 Oracle JVM 实现中即可像魅力一样工作。
package sun.net.www.protocol.classpath;
import java.io.IOException;
import java.net.URL;
import java.net.URLConnection;
import java.net.URLStreamHandler;
public class Handler extends URLStreamHandler {
@Override
protected URLConnection openConnection(URL u) throws IOException {
return Thread.currentThread().getContextClassLoader().getResource(u.getPath()).openConnection();
}
}
如果您使用另一个 JVM 实现，请设置java.protocol.handler.pkgs=sun.net.www.protocol系统属性。
注册 URLStreamHandlers 的解决方案当然是最正确的，但有时需要最简单的解决方案。因此，我为此使用以下方法：
/**
* Opens a local file or remote resource represented by given path.
* Supports protocols:
* <ul>
* <li>"file": file:///path/to/file/in/filesystem</li>
* <li>"http" or "https": http://host/path/to/resource - gzipped resources are supported also</li>
* <li>"classpath": classpath:path/to/resource</li>
* </ul>
*
* @param path An URI-formatted path that points to resource to be loaded
* @return Appropriate implementation of {@link InputStream}
* @throws IOException in any case is stream cannot be opened
*/
public static InputStream getInputStreamFromPath(String path) throws IOException {
InputStream is;
String protocol = path.replaceFirst("^(\\w+):.+$", "$1").toLowerCase();
switch (protocol) {
case "http":
case "https":
HttpURLConnection connection = (HttpURLConnection) new URL(path).openConnection();
int code = connection.getResponseCode();
if (code >= 400) throw new IOException("Server returned error code #" + code);
is = connection.getInputStream();
String contentEncoding = connection.getContentEncoding();
if (contentEncoding != null && contentEncoding.equalsIgnoreCase("gzip"))
is = new GZIPInputStream(is);
break;
case "file":
is = new URL(path).openStream();
break;
case "classpath":
is = Thread.currentThread().getContextClassLoader().getResourceAsStream(path.replaceFirst("^\\w+:", ""));
break;
default:
throw new IOException("Missed or unsupported protocol in path '" + path + "'");
}
return is;
}
我不知道是否已经有一个，但是您可以轻松地自己制作。
那个不同的协议示例在我看来就像一个门面模式。当每种情况有不同的实现时，您就有一个通用接口。
您可以使用相同的原理，创建一个 ResourceLoader 类，该类从您的属性文件中获取字符串，并检查我们的自定义协议
myprotocol:a.xml
myprotocol:file:///tmp.txt
myprotocol:http://127.0.0.1:8080/a.properties
myprotocol:jar:http://www.foo.com/bar/baz.jar!/COM/foo/Quux.class
从字符串的开头剥离 myprotocol: ，然后决定以哪种方式加载资源，并为您提供资源。
Dilums 回答的扩展：
在不更改代码的情况下，您可能需要按照 Dilum 的建议实现 URL 相关接口的自定义实现。为了简化您的工作，我建议您查看Spring Framework 的 Resources的源代码。虽然代码不是流处理程序的形式，但它的设计完全符合您的要求，并且在 ASL 2.0 许可下，使其足够友好，可以在您的代码中重用并获得应有的信任。
在 Spring Boot 应用程序中，我使用以下内容获取文件 URL，
Thread.currentThread().getContextClassLoader().getResource("PromotionalOfferIdServiceV2.wsdl")
如果你在类路径上有tomcat，它很简单：
TomcatURLStreamHandlerFactory.register();
这将为“war”和“classpath”协议注册处理程序。
我尽量避免URL上课，而是依靠URI. 因此，对于需要URL在没有 Spring 的情况下进行 Spring Resource 的事情，我会执行以下操作：
public static URL toURL(URI u, ClassLoader loader) throws MalformedURLException {
if ("classpath".equals(u.getScheme())) {
String path = u.getPath();
if (path.startsWith("/")){
path = path.substring("/".length());
}
return loader.getResource(path);
}
else if (u.getScheme() == null && u.getPath() != null) {
//Assume that its a file.
return new File(u.getPath()).toURI().toURL();
}
else {
return u.toURL();
}
}
要创建 URI，您可以使用URI.create(..). 这种方式也更好，因为您可以控制ClassLoader将进行资源查找的方式。
我注意到其他一些答案试图将 URL 解析为字符串以检测方案。我认为最好传递 URI 并使用它来解析。
实际上，我不久前已经向 Spring Source 提出了一个问题，请求他们将他们的资源代码从中分离出来，core这样你就不需要所有其他 Spring 的东西了。