URL para cargar recursos desde classpath en Java

URL url = getClass().getClassLoader().getResource("someresource.xxx");

Eso debería bastar.

Creo que esto vale su propia respuesta: si estás usando Spring, ya lo tienes con

Resource firstResource =
    context.getResource("http://www.google.fi/");
Resource anotherResource =
    context.getResource("classpath:some/resource/path/myTemplate.txt");

Como se explica en la documentación de la primavera y se señala en los comentarios de skaffman.

También puede establecer la propiedad mediante programación durante el inicio:

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);

Usando esta clase:

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();
    }
}

Así se obtiene la forma menos intrusiva de hacer esto. :) de java.net.URL siempre utilizará el valor actual de las propiedades del sistema.

He creado una clase que ayuda a reducir los errores en la configuración de manejadores personalizados y aprovecha la propiedad del sistema para que no haya problemas con llamar a un método primero o no estar en el contenedor correcto. También hay una clase de excepción si te equivocas:

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 );
    }

}

(Similar a la respuesta de Azder, pero con un tacto ligeramente diferente.)

No creo que haya un manejador de protocolo predefinido para el contenido del classpath. (El llamado protocolo classpath:).

Sin embargo, Java le permite agregar sus propios protocolos. Esto se hace a través de implementaciones concretas java.net.URLStreamHandler y java.net.URLConnection.

Este artículo describe cómo un manejador de flujo personalizado puede ser aplicado: http://java.sun.com/developer/onlineTraining/protocolhandlers/.

La solución con el registro de URLStreamHandlers es la más correcta, por supuesto, pero a veces se necesita la solución más simple. Por lo tanto, utilizo el siguiente método para eso:

/**
 * 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;
}

Inspire por @Stephen https://stackoverflow.com/a/1769454/980442 y http://docstore.mik.ua/orelly/java/exp/ch09_06.htm

Utilizar

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

Simplemente cree esta clase en el paquete sun.net.www.protocol.classpath y ejecútela en la implementación de Oracle JVM para que funcione como un encanto.

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();
    }
}

En caso de que esté utilizando otra implementación JVM, establezca la propiedad del sistema java.protocol.handler.pkgs=sun.net.www.protocol.

FYI: http://docs.oracle.com/javase/7/docs/api/java/net/URL.html#URL(java.lang.String,%20java.lang.String,%20int,%20java.lang.String)

Una extensión de La respuesta de Dilums :

Sin cambiar el código, es probable que necesite implementar implementaciones personalizadas de interfaces relacionadas con URL como recomienda Dilum. Para simplificar las cosas para usted, puedo recomendar mirar el origen de Recursos de Spring Framework . Si bien el código no está en la forma de un controlador de flujo, ha sido diseñado para hacer exactamente lo que está buscando hacer y está bajo la licencia ASL 2.0, lo que lo hace lo suficientemente amigable para su reutilización en su código con due crédito.

No sé si ya hay uno, pero puedes hacerlo tú mismo fácilmente.

Ese ejemplo de protocolos diferentes me parece un patrón de fachada. Tiene una interfaz común cuando hay diferentes implementaciones para cada caso.

Podría usar el mismo principio, hacer una clase ResourceLoader que tome la cadena de su archivo de propiedades, y verifique un protocolo personalizado nuestro

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

Tira el myprotocol: desde el inicio de la cadena y luego hace un decisión de qué manera cargar el recurso, y solo le da el recurso.

Trato de evitar la clase URL y en su lugar me baso en URI. Por lo tanto, para las cosas que necesitan URL donde me gustaría hacer Recurso de Primavera como buscar con out Spring hago lo siguiente:

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();
    }
}

Para crear un URI puede usar URI.create(..). De esta manera también es mejor porque usted controla el ClassLoader que hará la búsqueda de recursos.

Noté algunas otras respuestas tratando de analizar la URL como una cadena para detectar el esquema. Creo que es mejor pasar URI y usarlo para analizar en su lugar.

De hecho, he presentado un problema hace un tiempo con Spring Source rogándoles que separen su código de recurso de core para que no necesite todas las otras cosas de Spring.

En una aplicación de Spring Boot, usé lo siguiente para obtener la URL del archivo,

Thread.currentThread().getContextClassLoader().getResource("PromotionalOfferIdServiceV2.wsdl")