Como realmente ler o arquivo de texto do classpath em Java

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.

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

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.

É 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

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.

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

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

String url = this.getClass().getResource("").getPath();

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.

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

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

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.

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

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

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" .

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

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

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

this.getClass().getResourceAsStream("/SomeTextFile.txt");

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

    }

}

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