Comment lire vraiment un fichier texte depuis un chemin de classe en Java

J'essaie de lire un fichier texte qui est défini dans la variable système CLASSPATH. Pas une variable utilisateur.

J'essaye d'obtenir le flux d'entrée dans le fichier comme ci-dessous:

Placez le répertoire de file ( D:\myDir) dans CLASSPATH et essayez ci-dessous:

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

Placez le chemin complet du fichier ( D:\myDir\SomeTextFile.txt) dans CLASSPATH et essayez la même chose au-dessus de 3 lignes de code.

Mais malheureusement, AUCUN d'entre eux ne fonctionne et je suis toujours nulldans mon InputStream in.

Avec le répertoire sur le chemin de classe, à partir d'une classe chargée par le même chargeur de classe, vous devriez pouvoir utiliser l'un des éléments suivants:

// 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 ceux-ci ne fonctionnent pas, cela suggère que quelque chose d'autre ne va pas.

Par exemple, prenez ce code:

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

Et cette structure de répertoire:

code
    dummy
          Test.class
txt
    SomeTextFile.txt

Et puis (en utilisant le séparateur de chemin Unix car je suis sur une boîte Linux):

java -classpath code:txt dummy.Test

Résultats:

true
true

Lorsque vous utilisez Spring Framework (soit comme une collection d'utilitaires ou un conteneur - vous n'avez pas besoin d'utiliser cette dernière fonctionnalité), vous pouvez facilement utiliser l' abstraction des ressources .

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

Grâce à l' interface de ressource , vous pouvez accéder à la ressource en tant que InputStream , URL , URI ou fichier . Changer le type de ressource par exemple en une ressource de système de fichiers est une simple question de changer l'instance.

Voici comment je lis toutes les lignes d'un fichier texte sur mon chemin de classe, en utilisant 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 ceci est un exemple de la façon dont cela peut être fait. Vous devrez apporter des améliorations si nécessaire. Cet exemple ne fonctionnera que si le fichier est réellement présent sur votre chemin de classe, sinon une NullPointerException sera levée lorsque getResource () retourne null et .toURI () est invoqué dessus.

De plus, depuis Java 7, un moyen pratique de spécifier les jeux de caractères consiste à utiliser les constantes définies dans java.nio.charset.StandardCharsets (ce sont, selon leur javadocs , "garanties d'être disponibles sur chaque implémentation de la plate-forme Java").

Par conséquent, si vous savez que le codage du fichier est UTF-8, spécifiez explicitement le jeu de caractères StandardCharsets.UTF_8

S'il vous plaît essayez

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

Vos essais n'ont pas fonctionné car seul le chargeur de classe pour vos classes peut charger à partir du chemin de classe . Vous avez utilisé le chargeur de classe pour le système java lui-même.

Pour lire réellement le contenu du fichier, j'aime utiliser Commons IO + Spring Core. En supposant que Java 8:

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

Alternativement:

InputStream stream = null;
try {
    stream = new ClassPathResource("/log4j.xml").getInputStream();
    IOUtils.toString(stream);
} finally {
    IOUtils.closeQuietly(stream);
}

Pour obtenir le chemin absolu de la classe, essayez ceci:

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

D'une certaine manière, la meilleure réponse ne fonctionne pas pour moi. Je dois utiliser un code légèrement différent à la place.

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

J'espère que cela aidera ceux qui rencontrent le même problème.

Si vous utilisez la goyave:

import com.google.common.io.Resources;

nous pouvons obtenir l'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();

Pour lire le contenu d'un fichier dans une chaîne à partir de classpath, vous pouvez utiliser ceci:

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

Remarque:
IOUtilsfait partie de Commons IO.

Appelez ça comme ceci:

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

Vous dites "J'essaie de lire un fichier texte défini dans la variable système CLASSPATH". Je suppose que c'est sur Windows et vous utilisez cette boîte de dialogue laide pour éditer les "Variables système".

Vous exécutez maintenant votre programme Java dans la console. Et cela ne fonctionne pas: la console obtient une copie des valeurs des variables système une fois au démarrage . Cela signifie que toute modification ultérieure de la boîte de dialogue n'a aucun effet.

Il y a ces solutions:

1. Démarrer une nouvelle console après chaque changement

2. Utilisez set CLASSPATH=...dans la console pour définir la copie de la variable dans la console et lorsque votre code fonctionne, collez la dernière valeur dans la boîte de dialogue des variables.

3. Mettez l'appel à Java dans un .BATfichier et double-cliquez dessus. Cela créera une nouvelle console à chaque fois (copiant ainsi la valeur actuelle de la variable système).

ATTENTION: Si vous avez également une variable utilisateur, CLASSPATHelle occultera votre variable système. C'est pourquoi il est généralement préférable de placer l'appel à votre programme Java dans un .BATfichier et de définir le chemin d'accès aux classes (en utilisant set CLASSPATH=) plutôt que de compter sur un système global ou une variable utilisateur.

Cela garantit également que plusieurs programmes Java peuvent fonctionner sur votre ordinateur car ils sont liés par des chemins de classe différents.

Ma réponse n'est pas exactement ce qui est demandé dans la question. Je donne plutôt une solution exactement avec quelle facilité nous pouvons lire un fichier dans notre application java à partir de notre chemin de classe de projet.

Par exemple, supposons un nom de fichier de configuration example.xml se trouve dans un chemin comme ci-dessous: -

com.myproject.config.dev

et notre fichier de classe exécutable java est dans le chemin ci-dessous: -

com.myproject.server.main

il suffit maintenant de vérifier à la fois le chemin ci-dessus qui est le répertoire / dossier commun le plus proche d'où vous pouvez accéder à la fois au répertoire / dossier dev et principal (com.myproject.server.main - où la classe exécutable java de notre application a existé) - Nous pouvons voir que c'est le dossier / répertoire myproject qui est le répertoire / dossier commun le plus proche à partir duquel nous pouvons accéder à notre fichier example.xml. Par conséquent , à partir d' une classe réside exécutables Java dans le dossier / répertoire principal , nous devons revenir à deux pas comme ../../ d'accès myproject . Maintenant, après cela, voyez comment nous pouvons lire le fichier: -

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 vous compilez votre projet dans un fichier jar: vous pouvez mettre votre fichier dans resources / files / your_file.text ou pdf;

et utilisez ce code:

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

J'utilise le serveur d'applications Webshpere et mon module Web est basé sur Spring MVC. Ils Test.propertiesétaient situés dans le dossier des ressources, j'ai essayé de charger ces fichiers en utilisant les éléments suivants:

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

Aucun des codes ci-dessus n'a chargé le fichier.

Mais à l'aide du code ci-dessous, le fichier de propriétés a été chargé avec succès:

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

Merci à l'utilisateur "user1695166" .

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

Scénario:

1) client-service-1.0-SNAPSHOT.jara une dépendanceread-classpath-resource-1.0-SNAPSHOT.jar

2) nous voulons lire le contenu des ressources de chemin de classe ( sample.txt) de à read-classpath-resource-1.0-SNAPSHOT.jartraversclient-service-1.0-SNAPSHOT.jar .

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

Voici un exemple de code de travail que j'ai préparé, après avoir perdu 2-3 jours mon temps de développement, j'ai trouvé la solution complète de bout en bout, j'espère que cela vous aidera à gagner du temps

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 dans read-classpath-resource-1.0-SNAPSHOT.jarlaquelle charge le contenu du fichier de ressources du chemin de 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.javainstancier la ClassPathResourceReadTest.javaclasse où, il va charger sample.txtet imprimer également son contenu.

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. exécutez le fichier exécutable comme suit:

[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'utilisez pas la méthode getClassLoader () et utilisez le "/" avant le nom du fichier. "/" c'est tres important

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

    }

}

vous devez mettre votre «variable système» sur le chemin de classe java.