getResourceAsStream retorna nulo

Estou carregando um arquivo de texto de dentro de um pacote em um JAR compilado do meu projeto Java. A estrutura de diretórios relevante é a seguinte:

/src/initialization/Lifepaths.txt

Meu código carrega um arquivo chamando Class::getResourceAsStreampara retornar a InputStream.

public class Lifepaths {
    public static void execute() {
        System.out.println(Lifepaths.class.getClass().
            getResourceAsStream("/initialization/Lifepaths.txt"));
    }

    private Lifepaths() {}

    //This is temporary; will eventually be called from outside
    public static void main(String[] args) {execute();}
}

A impressão sempre será impressa null, não importa o que eu use. Não sei por que o que foi dito acima não funcionaria, então também tentei:

• "/src/initialization/Lifepaths.txt"
• "initialization/Lifepaths.txt"
• "Lifepaths.txt"

Nenhum desses trabalhos. Eu li várias perguntas até agora sobre o tópico, mas nenhuma delas foi útil - geralmente, elas dizem apenas para carregar arquivos usando o caminho raiz, o que eu já estou fazendo. Isso, ou apenas carregue o arquivo do diretório atual (apenas carregue filename), o que eu também tentei. O arquivo está sendo compilado no JAR no local apropriado com o nome apropriado.

Como eu resolvo isso?

Lifepaths.class.getClass().getResourceAsStream(...) carrega recursos usando o carregador de classes do sistema, ele obviamente falha porque não vê seus JARs

Lifepaths.class.getResourceAsStream(...) carrega recursos usando o mesmo carregador de classe que carregou a classe Lifepaths e deve ter acesso aos recursos em seus JARs

As regras são as seguintes:

1. verifique o local do arquivo que você deseja carregar dentro do JAR (e, assim, verifique também se ele foi realmente adicionado ao JAR)
2. use um caminho absoluto: o caminho começa na raiz do JAR
3. use um caminho relativo: o caminho começa no diretório de pacotes da classe que você está chamando getResource / getResoucreAsStream

E tentar:

Lifepaths.class.getResourceAsStream("/initialization/Lifepaths.txt")

ao invés de

Lifepaths.class.getClass().getResourceAsStream("/initialization/Lifepaths.txt")

(não tenho certeza se isso faz diferença, mas o primeiro usará o ClassLoader / JAR correto, enquanto eu não tiver certeza do último)

Portanto, existem várias maneiras de obter um recurso de um jar e cada uma possui uma sintaxe ligeiramente diferente, onde o caminho precisa ser especificado de maneira diferente.

A melhor explicação que eu vi é este artigo do JavaWorld . Resumirei aqui, mas se você quiser saber mais, consulte o artigo.

Métodos

1) ClassLoader.getResourceAsStream().

Formato: "/" - nomes separados; sem "/" inicial (todos os nomes são absolutos).

Exemplo: this.getClass().getClassLoader().getResourceAsStream("some/pkg/resource.properties");

2) Class.getResourceAsStream()

Formato: "/" - nomes separados; "/" inicial indica nomes absolutos; todos os outros nomes são relativos ao pacote da classe

Exemplo: this.getClass().getResourceAsStream("/some/pkg/resource.properties");

Não use caminhos absolutos, torne-os relativos ao diretório 'recursos' no seu projeto. Código rápido e sujo que exibe o conteúdo do MyTest.txt do diretório 'recursos'.

@Test
public void testDefaultResource() {
    // can we see default resources
    BufferedInputStream result = (BufferedInputStream) 
         Config.class.getClassLoader().getResourceAsStream("MyTest.txt");
    byte [] b = new byte[256];
    int val = 0;
    String txt = null;
    do {
        try {
            val = result.read(b);
            if (val > 0) {
                txt += new String(b, 0, val);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } 
    } while (val > -1);
    System.out.println(txt);
}

Você pode tentar isso para obter o fluxo, ou seja, primeiro obtenha o URL e abra-o como fluxo.

URL url = getClass().getResource("/initialization/Lifepaths.txt"); 
InputStream strm = url.openStream(); 

Uma vez tive uma pergunta semelhante: a leitura do arquivo txt do jar falha, mas a leitura da imagem funciona

Parece haver um problema com o ClassLoader que você está usando. Use o contextClassLoader para carregar a classe. Independentemente de estar em um método estático / não estático

Thread.currentThread().getContextClassLoader().getResourceAsStream......

Eu me encontrei em uma questão semelhante. Como estou usando o maven, precisava atualizar meu pom.xml para incluir algo como isto:

   ...
</dependencies>
<build>
    <resources>
        <resource>
            <directory>/src/main/resources</directory>
        </resource>
        <resource>
            <directory>../src/main/resources</directory>
        </resource>
    </resources>
    <pluginManagement>
        ...

Observe a etiqueta de recurso para especificar onde está essa pasta. Se você tiver projetos aninhados (como eu), convém obter recursos de outras áreas em vez de apenas no módulo em que está trabalhando. Isso ajuda a reduzir a manutenção do mesmo arquivo em cada repositório, se você estiver usando dados de configuração semelhantes

O que funcionou para mim foi adicionar o arquivo My Project/Java Resources/srce usar

this.getClass().getClassLoader().getResourceAsStream("myfile.txt");

Não precisei adicionar explicitamente esse arquivo ao caminho (adicioná-lo a /srcisso aparentemente)

Não sei se da ajuda, mas no meu caso, eu tinha meu recurso na pasta / src / e estava recebendo esse erro. Em seguida, mudei a imagem para a pasta bin e ela corrigiu o problema.

Verifique se o diretório de recursos (por exemplo, "src") está no seu caminho de classe (verifique se é um diretório de origem no caminho de construção no eclipse).

Verifique se o clazz está carregado no carregador de classe principal.

Em seguida, para carregar src / initialization / Lifepaths.txt, use

clazz.getResourceAsStream("/initialization/Lifepaths.txt");

Por que: clazz.getResourcesAsStream(foo)procura dentro do caminho de classe do clazz , em relação ao diretório em que o clazz vive . O "/" principal faz com que seja carregado a partir da raiz de qualquer diretório no caminho de classe do clazz.

A menos que você esteja em um contêiner de algum tipo, como o Tomcat, ou esteja fazendo algo diretamente com os ClassLoaders, é possível tratar apenas o caminho de classe do eclipse / linha de comando como o único caminho de classe do carregador de classes.

O carregador de classe JVM padrão usará pai-carregador de classe para carregar recursos primeiro: .

Lifepaths.class.getClass()O classloader de bootstrap classloader, portanto getResourceAsStream, pesquisará apenas $ JAVA_HOME, independentemente do usuário fornecido classpath. Obviamente, Lifepaths.txt não está lá.

Lifepaths.classO classloader de é system classpath classloader, portanto, getResourceAsStreamserá pesquisado definido pelo usuário classpathe Lifepaths.txt estará lá.

Ao usar java.lang.Class#getResourceAsStream(String name), o nome que não inicia com '/' será adicionado package namecomo prefixo. Se você quiser evitar isso, use java.lang.ClassLoader#getResourceAsStream. Por exemplo:

ClassLoader loader = Thread.currentThread().getContextClassLoader();
String resourceName = "Lifepaths.txt";
InputStream resourceStream = loader.getResourceAsStream(resourceName); 

A grosso modo:

getClass().getResource("/") ~ = Thread.currentThread().getContextClassLoader().getResource(".")

Suponha que a estrutura do seu projeto seja a seguinte:

├── src
│   ├── main
│   └── test
│   └── test
│       ├── java
│       │   └── com
│       │       └── github
│       │           └── xyz
│       │               └── proj
│       │                   ├── MainTest.java
│       │                   └── TestBase.java
│       └── resources
│           └── abcd.txt
└── target
    └── test-classes
        ├── com
        └── abcd.txt

// in MainClass.java
this.getClass.getResource("/") -> "~/proj_dir/target/test-classes/"
this.getClass.getResource(".") -> "~/proj_dir/target/test-classes/com/github/xyz/proj/"
Thread.currentThread().getContextClassLoader().getResources(".") -> "~/proj_dir/target/test-classes/"
Thread.currentThread().getContextClassLoader().getResources("/") ->  null

se você estiver usando o Maven, verifique se a sua embalagem é 'jar' e não 'pom'.

<packaging>jar</packaging>

O que você realmente precisa é de um classPath absoluto completo para o arquivo. Portanto, em vez de adivinhar, tente descobrir o ROOT e mova o arquivo para um local melhor, com base nas estruturas de arquivos <.war> ...

URL test1 = getClass().getResource("/");
URL test2 = getClass().getClassLoader().getResource("/");            
URL test3 = getClass().getClassLoader().getResource("../");

logger.info(test1.getPath()); 
logger.info(test2.getPath());
logger.info(test3.getPath());

O que funcionou para mim é que coloquei o arquivo em

src/main/java/myfile.log

e

InputStream is = getClass().getClassLoader().getResourceAsStream("myfile.log");
        
        if (is == null) {
            throw new FileNotFoundException("Log file not provided");
        }

@Emracool ... eu sugiro uma alternativa. Desde que você parece estar tentando carregar um arquivo * .txt. Melhor usar FileInputStream()do que isso getClass().getClassLoader().getResourceAsStream()ou irritante getClass().getResourceAsStream(). Pelo menos seu código será executado corretamente.