Cómo leer realmente un archivo de texto de classpath en Java

Estoy tratando de leer un archivo de texto que se establece en la variable de sistema CLASSPATH. No es una variable de usuario.

Estoy tratando de obtener la secuencia de entrada al archivo de la siguiente manera:

Coloque el directorio de archivo ( D:\myDir) en CLASSPATH e intente a continuación:

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 la ruta completa del archivo ( D:\myDir\SomeTextFile.txt) en CLASSPATH e intente lo mismo arriba de las 3 líneas de código.

Pero desafortunadamente NINGUNO de ellos está funcionando y siempre estoy nullingresando a mi InputStream in.

Con el directorio en el classpath, desde una clase cargada por el mismo cargador de clases, debería poder usar cualquiera de:

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

Si esos no funcionan, eso sugiere que algo más está mal.

Entonces, por ejemplo, tome 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);
    }
}

Y esta estructura de directorios:

code
    dummy
          Test.class
txt
    SomeTextFile.txt

Y luego (usando el separador de ruta Unix ya que estoy en una caja de Linux):

java -classpath code:txt dummy.Test

Resultados:

true
true

Cuando use Spring Framework (ya sea como una colección de utilidades o contenedor, no necesita usar esta última funcionalidad) puede usar fácilmente la abstracción de recursos .

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

A través de la interfaz de Recursos puede acceder al recurso como InputStream , URL , URI o Archivo . Cambiar el tipo de recurso a, por ejemplo, un recurso del sistema de archivos es una simple cuestión de cambiar la instancia.

Así es como leo todas las líneas de un archivo de texto en mi classpath, usando 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());

Nota: este es un ejemplo de cómo se puede hacer. Tendrás que hacer mejoras según sea necesario. Este ejemplo solo funcionará si el archivo está realmente presente en su classpath; de lo contrario, se generará una NullPointerException cuando getResource () devuelve nulo y se invoca .toURI () en él.

Además, desde Java 7, una forma conveniente de especificar conjuntos de caracteres es usar las constantes definidas en java.nio.charset.StandardCharsets (estas son, de acuerdo con sus javadocs , "están garantizados para estar disponibles en cada implementación de la plataforma Java").

Por lo tanto, si sabe que la codificación del archivo es UTF-8, especifique explícitamente el juego de caracteres StandardCharsets.UTF_8

Por favor, inténtalo

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

Sus intentos no funcionaron porque solo el cargador de clases para sus clases puede cargarse desde el classpath. Usó el cargador de clases para el sistema java mismo.

Para leer realmente el contenido del archivo, me gusta usar Commons IO + Spring Core. Suponiendo 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 obtener la ruta absoluta de clase intente esto:

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

De alguna manera, la mejor respuesta no funciona para mí. Necesito usar un código ligeramente diferente en su lugar.

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

Espero que esto ayude a aquellos que enfrentan el mismo problema.

Si usas guayaba:

import com.google.common.io.Resources;

podemos obtener URL de CLASSPATH:

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

o InputStream:

InputStream is = Resources.getResource("test.txt").openStream();

Para leer el contenido de un archivo en una Cadena desde classpath, puede usar esto:

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

Nota:
IOUtilses parte de Commons IO.

Llámalo así:

String fileContents = resourceToString("ImOnTheClasspath.txt");

Usted dice "Estoy tratando de leer un archivo de texto que está configurado en la variable de sistema CLASSPATH". Supongo que esto está en Windows y está utilizando este diálogo feo para editar las "Variables del sistema".

Ahora ejecuta su programa Java en la consola. Y eso no funciona: la consola obtiene una copia de los valores de las variables del sistema una vez que se inicia . Esto significa cualquier cambio en el diálogo posterior no tiene ningún efecto.

Existen estas soluciones:

1. Inicie una nueva consola después de cada cambio.

2. Use set CLASSPATH=...en la consola para configurar la copia de la variable en la consola y cuando su código funcione, pegue el último valor en el cuadro de diálogo de la variable.

3. Ponga la llamada a Java en el .BATarchivo y haga doble clic en él. Esto creará una nueva consola cada vez (copiando así el valor actual de la variable del sistema).

CUIDADO: si también tiene una variable de usuario, CLASSPATHentonces sombreará la variable de su sistema. Es por eso que generalmente es mejor poner la llamada a su programa Java en un .BATarchivo y establecer la ruta de clase allí (usando set CLASSPATH=) en lugar de confiar en un sistema global o variable de usuario.

Esto también asegura que pueda tener más de un programa Java trabajando en su computadora porque seguramente tendrán diferentes classpaths.

Mi respuesta no es exactamente lo que se pregunta en la pregunta. Más bien, estoy dando una solución exactamente con qué facilidad podemos leer un archivo en nuestra aplicación Java desde nuestra ruta de clase de proyecto.

Por ejemplo, suponga que un nombre de archivo de configuración example.xml se encuentra en una ruta como la siguiente:

com.myproject.config.dev

y nuestro archivo de clase ejecutable de Java está en la ruta a continuación:

com.myproject.server.main

ahora solo marque en la ruta anterior, que es el directorio / carpeta común más cercano desde donde puede acceder tanto a dev como al directorio / carpeta principal (com.myproject.server.main, donde existe la clase ejecutable java de nuestra aplicación) - Podemos ver que es myproject folder / directory que es el directorio / carpeta común más cercano desde donde podemos acceder a nuestro archivo example.xml. Por lo tanto, desde una clase ejecutable de Java que reside en la carpeta / directorio principal , tenemos que retroceder dos pasos como ../../ para acceder a myproject . Ahora, siguiendo esto, vea cómo podemos leer el archivo:

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

Si compila su proyecto en un archivo jar: puede colocar su archivo en resources / files / your_file.text o pdf;

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

Estoy usando el servidor de aplicaciones webshpere y mi módulo web está construido en Spring MVC. Se Test.propertiesubicaron en la carpeta de recursos, intenté cargar estos archivos usando lo siguiente:

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

Ninguno de los códigos anteriores cargó el archivo.

Pero con la ayuda del siguiente código, el archivo de propiedades se cargó correctamente:

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

Gracias al usuario "user1695166" .

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

Guión:

1) client-service-1.0-SNAPSHOT.jartiene dependenciaread-classpath-resource-1.0-SNAPSHOT.jar

2) queremos leer el contenido de los recursos de ruta de clase ( sample.txt) de read-classpath-resource-1.0-SNAPSHOT.jarthrough client-service-1.0-SNAPSHOT.jar.

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

Aquí está el código de muestra que preparé, después de 2-3 días perdiendo mi tiempo de desarrollo, encontré la solución completa de principio a fin, espero que esto ayude a ahorrar tiempo

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.java clase en read-classpath-resource-1.0-SNAPSHOT.jarque carga el contenido del archivo de recursos de ruta de clase.

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.javainstanciarClassPathResourceReadTest.java clase donde, se va a cargar sample.txte imprime su contenido también.

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

5. Ejecute jar ejecutable de la siguiente manera:

[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

No use el método getClassLoader () y use "/" antes del nombre del archivo. "/" es muy 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();
                    }
                }
            }
        }

    }

}

tienes que poner tu 'variable de sistema' en el classpath de Java.