Como realmente ler o arquivo de texto do classpath em Java

366

Estou tentando ler um arquivo de texto definido na variável de sistema CLASSPATH. Não é uma variável de usuário.

Estou tentando obter fluxo de entrada para o arquivo como abaixo:

Coloque o diretório do arquivo ( D:\myDir) em CLASSPATH e tente abaixo:

InputStream in = this.getClass().getClassLoader().getResourceAsStream("SomeTextFile.txt");
InputStream in = this.getClass().getClassLoader().getResourceAsStream("/SomeTextFile.txt");
InputStream in = this.getClass().getClassLoader().getResourceAsStream("//SomeTextFile.txt");

Coloque o caminho completo do arquivo ( D:\myDir\SomeTextFile.txt) no CLASSPATH e tente o mesmo acima das 3 linhas de código.

Infelizmente, NENHUM deles está funcionando e estou sempre entrando nullno meu InputStream in.

Chaitanya MSV
fonte

Respostas:

605

Com o diretório no caminho de classe, a partir de uma classe carregada pelo mesmo carregador de classe, você poderá usar um dos seguintes:

// From ClassLoader, all paths are "absolute" already - there's no context
// from which they could be relative. Therefore you don't need a leading slash.
InputStream in = this.getClass().getClassLoader()
                                .getResourceAsStream("SomeTextFile.txt");
// From Class, the path is relative to the package of the class unless
// you include a leading slash, so if you don't want to use the current
// package, include a slash like this:
InputStream in = this.getClass().getResourceAsStream("/SomeTextFile.txt");

Se eles não estão funcionando, isso sugere que algo está errado.

Então, por exemplo, pegue este código:

package dummy;

import java.io.*;

public class Test
{
    public static void main(String[] args)
    {
        InputStream stream = Test.class.getResourceAsStream("/SomeTextFile.txt");
        System.out.println(stream != null);
        stream = Test.class.getClassLoader().getResourceAsStream("SomeTextFile.txt");
        System.out.println(stream != null);
    }
}

E esta estrutura de diretórios:

code
    dummy
          Test.class
txt
    SomeTextFile.txt

E então (usando o separador de caminho Unix como eu estou em uma caixa Linux):

java -classpath code:txt dummy.Test

Resultados:

true
true
Jon Skeet
fonte
2
Você misturou caminhos relativos e absolutos. Um caminho que começa com "/" é absoluto (ou seja, começa com o que estiver listado em CLASSPATH). Todos os outros caminhos são relativos ao pacote da classe em que você chamagetResourceAsStream()
Aaron Digulla
13
Não, você quebrou meu exemplo. Editarei os comentários para torná-los mais claros, mas o ponto é que, usando o ClassLoader, todos os caminhos já são considerados absolutos. Não há nada para eles serem relativos.
23909 Jon Skeet
6
Também não use Java.IO.File.Separator. Não vai funcionar no Windows. Se você estiver executando este código no Windows ainda tem que ser '/' e não '\'
Pradhan
28
@ Pradhan: Não, você não deveria estar usando File.Separator- porque você não está pedindo um arquivo , está pedindo um recurso . É importante entender que a abstração envolvida não é o sistema de arquivos.
Jon Skeet
11
@jagdpanzer: Bem, é apenas para classes que são carregadas pelo mesmo carregador de classe, basicamente - e é porque Class.getResourceAsStreamé realmente um método conveniente para chamar ClassLoader.getResourceAsStream, mas com o recurso adicional de recursos "relativos". Se você estiver especificando um recurso absoluto, qualquer chamada usando o mesmo carregador de classe fará a mesma coisa.
Jon Skeet
115

Ao usar o Spring Framework (como uma coleção de utilitários ou contêiner - você não precisa usar a última funcionalidade), pode usar facilmente a abstração de Recurso .

Resource resource = new ClassPathResource("com/example/Foo.class");

Através da interface do recurso , você pode acessar o recurso como InputStream , URL , URI ou arquivo . Alterar o tipo de recurso para, por exemplo, um recurso do sistema de arquivos é uma simples questão de alterar a instância.

bocejar
fonte
6
Você poderia fornecer um código de exemplo de como isso pode ser usado no arquivo I / O? Não consigo encontrar uma maneira decente , explícita e direta de como usá-lo na Internet: (((((
Funciona como um encanto. O forro fornecido é tudo o que você precisa. Use a análise de fluxo de outros exemplos se você não souber como obter uma string do fluxo.
Joseph Lust
Eu tive alguns problemas para descobrir exatamente o que fazer com a variável de recurso também. Eu editei a resposta com um pouco mais detalhadamente
DavidZemon
Eu já estava usando o Spring e tentando o modo "java puro". Isso estava me matando, as diferenças entre getResource, getResourceAsStream, etc, sem bons exemplos de trabalho. Este é um exemplo perfeito de encapsulamento, então não preciso me preocupar.
TinkerTenorSoftwareGuy
11
Cuidado, se você empacotar seu projeto em um jar, deverá usar um InputStream. Se você usar um arquivo, ele funcionará no seu IDE, mas falhará se você testá-lo no jar. Se você realmente precisa de um arquivo, tente com stackoverflow.com/questions/4317035/…
Rafael Membrives
58

É assim que leio todas as linhas de um arquivo de texto no meu caminho de classe, usando o Java 7 NIO:

...
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Paths;

...

Files.readAllLines(
    Paths.get(this.getClass().getResource("res.txt").toURI()), Charset.defaultCharset());

NB, este é um exemplo de como isso pode ser feito. Você precisará fazer melhorias conforme necessário. Este exemplo funcionará apenas se o arquivo estiver realmente presente no seu caminho de classe; caso contrário, uma NullPointerException será lançada quando getResource () retornar nulo e .toURI () for invocado nele.

Além disso, desde o Java 7, uma maneira conveniente de especificar conjuntos de caracteres é usar as constantes definidas em java.nio.charset.StandardCharsets (estas são, de acordo com seus javadocs , "garantidas para estar disponíveis em todas as implementações da plataforma Java").

Portanto, se você souber que a codificação do arquivo é UTF-8, especifique explicitamente o conjunto de caracteres StandardCharsets.UTF_8

Peter Perháč
fonte
11
Obrigado pela solução NIO - tão poucas pessoas usam essa ótima API que é uma pena.
Mvreijn
7
Para ler em uma única String, tente. new String (Files.readAllBytes (Paths.get (MyClass.class.getResource (resource) .toURI ())));
Theo Briscoe
2
A melhor solução para mim, pois não precisa de dependências, como Spring ou Commons IO.
Bernie
11
Isso falhará se o seu arquivo de recursos estiver dentro de um jar, por exemplo, um módulo maven. Nesse caso, você precisará usar algo como Spring's StreamUtils.copyToString.
Somu 14/02
26

Tente por favor

InputStream in = this.getClass().getResourceAsStream("/SomeTextFile.txt");

Suas tentativas não deram certo porque somente o carregador de classe para suas aulas é capaz de carregar a partir do classpath. Você usou o carregador de classes para o próprio sistema java.

tangens
fonte
Não tenho certeza sobre o "/" embora. Um caminho relativo pode funcionar melhor neste caso.
VonC 23/09/09
3
Se você usá-lo sem "/", você está procurando seu arquivo dentro do pacote "this".
tangens 23/09/09
11
Arquivo InputStream = this.getClass (). GetResourceAsStream ("SomeTextFile.txt"); Arquivo InputStream = this.getClass (). GetResourceAsStream ("/ SomeTextFile.txt"); Arquivo InputStream = this.getClass (). GetResourceAsStream ("// SomeTextFile.txt"); Nenhuma das opções acima funcionou :(
Chaitanya MSV
@Chaitanya: Você pode executar o exemplo da resposta de John Skeet?
Aaron Digulla 23/09/09
Aqui estão alguns bons exemplos de getResourceAsStream
drorw 17/11
20

Para realmente ler o conteúdo do arquivo, eu gosto de usar o Commons IO + Spring Core. Supondo Java 8:

try (InputStream stream = new ClassPathResource("package/resource").getInputStream()) {
    IOUtils.toString(stream);
}

Alternativamente:

InputStream stream = null;
try {
    stream = new ClassPathResource("/log4j.xml").getInputStream();
    IOUtils.toString(stream);
} finally {
    IOUtils.closeQuietly(stream);
}
Pavel
fonte
Que tal fechar o fluxo de entrada?
21716 Stephan
O fluxo será fechado automaticamente. É um recurso do Java 7 "Experimente com recursos" docs.oracle.com/javase/tutorial/essential/exceptions/…
Michał Maciej Gałuszka
Somente se estiver dentro da instrução try, que não é o caso aqui. Deveria ter sido tentar (fluxo final InputStream = new ClassPathResource ("/ log4j.xml"). GetInputStream ()) {...
andresp
15

Para obter o caminho absoluto da classe, tente o seguinte:

String url = this.getClass().getResource("").getPath();
webcom
fonte
E depois o que? Essa informação não serve para nada.
Marquês de Lorne
Esta informação foi perfeita. Só estava faltando getPath ()!
Patrick Patrick
@ Patrick Esta resposta não fornece o 'caminho absoluto da classe'. Ele fornece um URL. Não é a mesma coisa.
Marquês de Lorne
12

De alguma forma, a melhor resposta não funciona para mim. Eu preciso usar um código um pouco diferente.

ClassLoader loader = Thread.currentThread().getContextClassLoader();
InputStream is = loader.getResourceAsStream("SomeTextFile.txt");

Espero que isso ajude aqueles que encontram o mesmo problema.

user1695166
fonte
Isso também me ajudou no Android, onde uma classe foi carregada pelo carregador de aplicativos, mas uma chave necessária foi preguiçosa carregada no thread da interface do usuário.
Asokan
Você precisa fornecer informações sobre por que a melhor resposta não funciona para você (por exemplo, a estrutura do seu aplicativo, a estrutura que você está usando, o erro etc.). A melhor resposta disse claramente que 1) o diretório precisa estar no caminho de classe, 2) você precisa solicitar uma classe carregada pelo mesmo carregador de classes. As chances são de que uma dessas suposições não se aplica à sua aplicação. Além disso, o carregador de classes de contexto é muito desencorajado, pois foi introduzido como um hack. Alguns framework faz uso dele, mas é importante saber a implicação (que requer que você descreve fundo do seu projeto)
Xinchao
6

Se você usa o Goiaba:

import com.google.common.io.Resources;

podemos obter URL de CLASSPATH:

URL resource = Resources.getResource("test.txt");
String file = resource.getFile();   // get file path 

ou InputStream:

InputStream is = Resources.getResource("test.txt").openStream();
Alexey Simonov
fonte
O caminho do arquivo não será útil se o recurso estiver em um arquivo JAR ou WAR.
Marquês de Lorne
O método getFile da URL não retorna um nome de arquivo. Ele apenas retorna a parte do caminho da URL, que não garante um nome de arquivo válido. (A classe URL fazia parte do Java 1.0, naquela época, a maioria dos URLs de fato se referem a arquivos físicos de ambos no mesmo computador ou um computador diferente.)
VGR
3

Para ler o conteúdo de um arquivo em uma String a partir de classpath, você pode usar o seguinte:

private String resourceToString(String filePath) throws IOException, URISyntaxException
{
    try (InputStream inputStream = this.getClass().getClassLoader().getResourceAsStream(filePath))
    {
        return IOUtils.toString(inputStream);
    }
}

Nota:
IOUtilsfaz parte de Commons IO.

Chame assim:

String fileContents = resourceToString("ImOnTheClasspath.txt");
BullyWiiPlaza
fonte
1

Você diz "Estou tentando ler um arquivo de texto definido na variável de sistema CLASSPATH". Meu palpite é que está no Windows e você está usando esta caixa de diálogo feia para editar as "Variáveis ​​do sistema".

Agora você executa seu programa Java no console. E isso não funciona: o console obtém uma cópia dos valores das variáveis ​​do sistema uma vez quando é iniciado . Isso significa que qualquer alteração na caixa de diálogo posteriormente não terá nenhum efeito.

Existem estas soluções:

  1. Inicie um novo console após cada alteração

  2. Use set CLASSPATH=...no console para definir a cópia da variável no console e, quando seu código funcionar, cole o último valor na caixa de diálogo da variável.

  3. Coloque a chamada para Java no .BATarquivo e clique duas vezes nele. Isso criará um novo console sempre (copiando assim o valor atual da variável do sistema).

CUIDADO: Se você também tiver uma variável Usuário CLASSPATH, ela sombreará a variável do sistema. É por isso que geralmente é melhor colocar a chamada para seu programa Java em um .BATarquivo e definir o caminho de classe (usando set CLASSPATH=) em vez de depender de um sistema global ou variável de usuário.

Isso também garante que você possa ter mais de um programa Java trabalhando no seu computador, pois eles provavelmente terão caminhos de classe diferentes.

Aaron Digulla
fonte
0

Minha resposta não é exatamente o que é solicitado na pergunta. Em vez disso, estou dando uma solução exatamente com a facilidade com que podemos ler um arquivo em nosso aplicativo java a partir do caminho da classe do projeto.

Por exemplo, suponha que um nome de arquivo de configuração example.xml esteja localizado em um caminho como abaixo: -

com.myproject.config.dev

e nosso arquivo de classe executável java está no caminho abaixo: -

com.myproject.server.main

Agora, basta verificar o caminho acima, que é o diretório / pasta comum mais próximo, de onde você pode acessar o diretório / pasta dev e principal (com.myproject.server.main - onde existe a classe executável java do aplicativo) - Podemos ver é a pasta / diretório myproject que é o diretório / pasta comum mais próximo, de onde podemos acessar nosso arquivo example.xml. Portanto, a partir de uma classe executável java reside na pasta / diretório main , temos que voltar duas etapas como ../../ para acessar o meu projeto . Agora, depois disso, veja como podemos ler o arquivo: -

package com.myproject.server.main;

class Example {

  File xmlFile;

  public Example(){
       String filePath = this.getClass().getResource("../../config/dev/example.xml").getPath();
       this.xmlFile = new File(filePath);
    }

  public File getXMLFile() {
      return this.xmlFile;
  }
   public static void main(String args[]){
      Example ex = new Example();
      File xmlFile = ex.getXMLFile();
   }
}
Abhijit Pritam Dutta
fonte
0

Se você compilar seu projeto no arquivo jar: você pode colocar o arquivo em resources / files / your_file.text ou pdf;

e use este código:

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.*;

public class readFileService(){
    private static final Logger LOGGER = LoggerFactory.getLogger(readFileService.class);


    public byte[] getFile(){
        String filePath="/files/your_file";
        InputStream inputStreamFile;
        byte[] bytes;
        try{
            inputStreamFile = this.getClass().getResourceAsStream(filePath);
            bytes = new byte[inputStreamFile.available()];
            inputStreamFile.read(bytes);    
        } catch(NullPointerException | IOException e) {
            LOGGER.error("Erreur read file "+filePath+" error message :" +e.getMessage());
            return null;
        }
        return bytes;
    } 
}
Ahmed Ali
fonte
-1

Estou usando o servidor de aplicativos webshpere e meu módulo da Web é baseado no Spring MVC. Eles Test.propertiesestavam localizados na pasta de recursos, tentei carregar esses arquivos usando o seguinte:

  1. this.getClass().getClassLoader().getResourceAsStream("Test.properties");
  2. this.getClass().getResourceAsStream("/Test.properties");

Nenhum dos códigos acima carregou o arquivo.

Mas com a ajuda do código abaixo, o arquivo de propriedades foi carregado com sucesso:

Thread.currentThread().getContextClassLoader().getResourceAsStream("Test.properties");

Obrigado ao usuário "user1695166" .

Sardar Saikh
fonte
11
Bem-vindo ao Stack Overflow! Por favor, não adicione "obrigado" como respostas, mesmo que você também esteja fornecendo parcialmente como foi sua solução; se suas soluções são iguais a outra postagem, ela não precisa ser adicionada. Depois de investir algum tempo no site, você obterá privilégios suficientes para aprovar as respostas que desejar, que é a maneira do Stack Overflow de dizer obrigado.
precisa saber é o seguinte
-1

Usar org.apache.commons.io.FileUtils.readFileToString(new File("src/test/resources/sample-data/fileName.txt"));

Charu Khurana
fonte
a referência a src não deve ser usada ... Não funciona no artefato final.
112 Holanda L.
-1

Cenário:

1) client-service-1.0-SNAPSHOT.jartem dependênciaread-classpath-resource-1.0-SNAPSHOT.jar

2) queremos ler o conteúdo dos recursos do caminho da classe ( sample.txt) de read-classpath-resource-1.0-SNAPSHOT.jarthrough client-service-1.0-SNAPSHOT.jar.

3) read-classpath-resource-1.0-SNAPSHOT.jartemsrc/main/resources/sample.txt

Aqui está um exemplo de código que eu preparei, após 2-3 dias perdendo meu tempo de desenvolvimento, encontrei a solução completa de ponta a ponta, espero que isso ajude a economizar seu tempo

1. pom.xmlderead-classpath-resource-1.0-SNAPSHOT.jar

<?xml version="1.0" encoding="UTF-8"?>
        <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
            <modelVersion>4.0.0</modelVersion>
            <groupId>jar-classpath-resource</groupId>
            <artifactId>read-classpath-resource</artifactId>
            <version>1.0-SNAPSHOT</version>
            <name>classpath-test</name>
            <properties>
                <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
                <org.springframework.version>4.3.3.RELEASE</org.springframework.version>
                <mvn.release.plugin>2.5.1</mvn.release.plugin>
                <output.path>${project.artifactId}</output.path>
                <io.dropwizard.version>1.0.3</io.dropwizard.version>
                <commons-io.verion>2.4</commons-io.verion>
            </properties>
            <dependencies>
                <dependency>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring-core</artifactId>
                    <version>${org.springframework.version}</version>
                </dependency>
                <dependency>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring-context</artifactId>
                    <version>${org.springframework.version}</version>
                </dependency>
                <dependency>
                    <groupId>commons-io</groupId>
                    <artifactId>commons-io</artifactId>
                    <version>${commons-io.verion}</version>
                </dependency>
            </dependencies>
            <build>
                <resources>
                    <resource>
                        <directory>src/main/resources</directory>
                    </resource>
                </resources>
                <plugins>
                    <plugin>
                        <groupId>org.apache.maven.plugins</groupId>
                        <artifactId>maven-release-plugin</artifactId>
                        <version>${mvn.release.plugin}</version>
                    </plugin>
                    <plugin>
                        <groupId>org.apache.maven.plugins</groupId>
                        <artifactId>maven-compiler-plugin</artifactId>
                        <version>3.1</version>
                        <configuration>
                            <source>1.8</source>
                            <target>1.8</target>
                            <encoding>UTF-8</encoding>
                        </configuration>
                    </plugin>
                    <plugin>
                        <artifactId>maven-jar-plugin</artifactId>
                        <version>2.5</version>
                        <configuration>
                            <outputDirectory>${project.build.directory}/lib</outputDirectory>
                            <archive>
                                <manifest>
                                    <addClasspath>true</addClasspath>
                                    <useUniqueVersions>false</useUniqueVersions>
                                    <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
                                    <mainClass>demo.read.classpath.resources.ClassPathResourceReadTest</mainClass>
                                </manifest>
                                <manifestEntries>
                                    <Implementation-Artifact-Id>${project.artifactId}</Implementation-Artifact-Id>
                                    <Class-Path>sample.txt</Class-Path>
                                </manifestEntries>
                            </archive>
                        </configuration>
                    </plugin>
                    <plugin>
                        <groupId>org.apache.maven.plugins</groupId>
                        <artifactId>maven-shade-plugin</artifactId>
                        <version>2.2</version>
                        <configuration>
                            <createDependencyReducedPom>false</createDependencyReducedPom>
                            <filters>
                                <filter>
                                    <artifact>*:*</artifact>
                                    <excludes>
                                        <exclude>META-INF/*.SF</exclude>
                                        <exclude>META-INF/*.DSA</exclude>
                                        <exclude>META-INF/*.RSA</exclude>
                                    </excludes>
                                </filter>
                            </filters>
                        </configuration>
                        <executions>
                            <execution>
                                <phase>package</phase>
                                <goals>
                                    <goal>shade</goal>
                                </goals>
                                <configuration>
                                    <transformers>
                                        <transformer implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer" />
                                        <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                            <mainClass>demo.read.classpath.resources.ClassPathResourceReadTest</mainClass>
                                        </transformer>
                                    </transformers>
                                </configuration>
                            </execution>
                        </executions>
                    </plugin>
                </plugins>
            </build>
        </project>

2. ClassPathResourceReadTest.javaclasse em read-classpath-resource-1.0-SNAPSHOT.jarque carrega o conteúdo do arquivo de recursos do caminho da classe.

package demo.read.classpath.resources;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;

public final class ClassPathResourceReadTest {
    public ClassPathResourceReadTest() throws IOException {
        InputStream inputStream = getClass().getResourceAsStream("/sample.txt");
        BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
        List<Object> list = new ArrayList<>();
        String line;
        while ((line = reader.readLine()) != null) {
            list.add(line);
        }
        for (Object s1: list) {
            System.out.println("@@@ " +s1);
        }
        System.out.println("getClass().getResourceAsStream('/sample.txt') lines: "+list.size());
    }
}

3. pom.xmldeclient-service-1.0-SNAPSHOT.jar

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>client-service</groupId>
    <artifactId>client-service</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>jar-classpath-resource</groupId>
            <artifactId>read-classpath-resource</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <artifactId>maven-jar-plugin</artifactId>
                <version>2.5</version>
                <configuration>
                    <outputDirectory>${project.build.directory}/lib</outputDirectory>
                    <archive>
                        <manifest>
                            <addClasspath>true</addClasspath>
                            <useUniqueVersions>false</useUniqueVersions>
                            <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
                            <mainClass>com.crazy.issue.client.AccessClassPathResource</mainClass>
                        </manifest>
                        <manifestEntries>
                            <Implementation-Artifact-Id>${project.artifactId}</Implementation-Artifact-Id>
                            <Implementation-Source-SHA>${buildNumber}</Implementation-Source-SHA>
                            <Class-Path>sample.txt</Class-Path>
                        </manifestEntries>
                    </archive>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <createDependencyReducedPom>false</createDependencyReducedPom>
                    <filters>
                        <filter>
                            <artifact>*:*</artifact>
                            <excludes>
                                <exclude>META-INF/*.SF</exclude>
                                <exclude>META-INF/*.DSA</exclude>
                                <exclude>META-INF/*.RSA</exclude>
                            </excludes>
                        </filter>
                    </filters>
                </configuration>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <transformers>
                                <transformer implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer" />
                                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                    <mainClass>com.crazy.issue.client.AccessClassPathResource</mainClass>
                                </transformer>
                            </transformers>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

4. AccessClassPathResource.javainstanciar a ClassPathResourceReadTest.javaclasse onde, ele irá carregar sample.txte imprimir seu conteúdo também.

package com.crazy.issue.client;

import demo.read.classpath.resources.ClassPathResourceReadTest;
import java.io.IOException;

public class AccessClassPathResource {
    public static void main(String[] args) throws IOException {
        ClassPathResourceReadTest test = new ClassPathResourceReadTest();
    }
}

Execute o jar executável da seguinte maneira:

[ravibeli@localhost lib]$ java -jar client-service-1.0-SNAPSHOT.jar
****************************************
I am in resources directory of read-classpath-resource-1.0-SNAPSHOT.jar
****************************************
3) getClass().getResourceAsStream('/sample.txt'): 3
ravibeli
fonte
-2

Não use o método getClassLoader () e use o "/" antes do nome do arquivo. "/" é muito importante

this.getClass().getResourceAsStream("/SomeTextFile.txt");
sachinthana87
fonte
Usar o líder /tem exatamente o mesmo efeito que usar o getClassLoader()método
Marquês de Lorne
-4
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class ReadFile

{
    /**
     * * feel free to make any modification I have have been here so I feel you
     * * * @param args * @throws InterruptedException
     */

    public static void main(String[] args) throws InterruptedException {
        // thread pool of 10
        File dir = new File(".");
        // read file from same directory as source //
        if (dir.isDirectory()) {
            File[] files = dir.listFiles();
            for (File file : files) {
                // if you wanna read file name with txt files
                if (file.getName().contains("txt")) {
                    System.out.println(file.getName());
                }

                // if you want to open text file and read each line then
                if (file.getName().contains("txt")) {
                    try {
                        // FileReader reads text files in the default encoding.
                        FileReader fileReader = new FileReader(
                                file.getAbsolutePath());
                        // Always wrap FileReader in BufferedReader.
                        BufferedReader bufferedReader = new BufferedReader(
                                fileReader);
                        String line;
                        // get file details and get info you need.
                        while ((line = bufferedReader.readLine()) != null) {
                            System.out.println(line);
                            // here you can say...
                            // System.out.println(line.substring(0, 10)); this
                            // prints from 0 to 10 indext
                        }
                    } catch (FileNotFoundException ex) {
                        System.out.println("Unable to open file '"
                                + file.getName() + "'");
                    } catch (IOException ex) {
                        System.out.println("Error reading file '"
                                + file.getName() + "'");
                        // Or we could just do this:
                        ex.printStackTrace();
                    }
                }
            }
        }

    }

}
Ajudante
fonte
Não responde a pergunta de forma alguma.
Marquês de Lorne
-5

você precisa colocar sua 'variável de sistema' no caminho de classe java.

Salandur
fonte
Eu coloquei a variável System em si.
Chaitanya MSV
A 'variável de sistema' é o Java CLASSPATH. A resposta não faz sentido.
Marquês de Lorne
Totalmente verdade ... nem sequer me lembro de escrever esta resposta :)
Salandur