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

366

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.

Chaitanya MSV
la source

Réponses:

605

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
Jon Skeet
la source
2
Vous avez mélangé les chemins relatifs et absolus. Un chemin commençant par "/" est absolu (c'est-à-dire qu'il commence à partir de tout ce qui est répertorié dans CLASSPATH). Tous les autres chemins sont relatifs au package de la classe sur laquelle vous appelezgetResourceAsStream()
Aaron Digulla
13
Non, tu as cassé mon exemple. Je vais modifier les commentaires pour les rendre plus clairs, mais le fait est qu'en utilisant ClassLoader, tous les chemins sont déjà supposés absolus. Il n'y a rien pour eux d'être relatif.
Jon Skeet
6
N'utilisez pas non plus Java.IO.File.Separator. Cela ne fonctionnera pas sur les fenêtres. Si vous exécutez ce code sur Windows, il doit toujours être '/' et non '\'
Pradhan
28
@Pradhan: Non, vous ne devriez pas utiliser File.Separator- parce que vous ne demandez pas de fichier , vous demandez une ressource . Il est important de comprendre que l'abstraction impliquée n'est pas le système de fichiers.
Jon Skeet
1
@jagdpanzer: Eh bien, ce n'est que pour les classes qui sont chargées par le même chargeur de classe, essentiellement - et c'est parce que Class.getResourceAsStreamc'est vraiment une méthode pratique pour appeler ClassLoader.getResourceAsStream, mais avec la fonctionnalité supplémentaire de ressources "relatives". Si vous spécifiez une ressource absolue, tout appel utilisant le même chargeur de classe fera la même chose.
Jon Skeet
115

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.

bâillement
la source
6
Pourriez-vous s'il vous plaît fournir un exemple de code sur la façon dont cela peut être utilisé dans les E / S de fichiers? Je ne peux pas trouver un moyen décent , explicite et simple sur la façon de l'utiliser sur Internet: ((((
Fonctionne comme un charme. La doublure fournie est tout ce dont vous avez besoin. Utilisez l'analyse de flux à partir d'autres exemples si vous ne savez pas comment obtenir une chaîne à partir du flux.
Joseph Lust
J'ai également eu un peu de mal à savoir exactement quoi faire avec la variable de ressource. J'ai édité la réponse avec un peu plus de détails
DavidZemon
J'utilisais déjà Spring et j'essayais la méthode "pure java". Cela me tuait, les différences entre getResource, getResourceAsStream, etc., sans bons exemples de travail. Ceci est un parfait exemple d'encapsulation, donc je n'ai pas à m'en soucier.
TinkerTenorSoftwareGuy
1
Attention, si vous empaquetez votre projet dans un bocal, vous devez utiliser un InputStream. Si vous utilisez un fichier, il fonctionnera dans votre IDE mais échouera si vous le testez depuis le bocal. Si vous avez vraiment besoin d'un fichier, essayez avec stackoverflow.com/questions/4317035/…
Rafael Membrives
58

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

Peter Perháč
la source
1
Merci pour la solution NIO - si peu de gens utilisent cette excellente API, c'est dommage.
mvreijn
7
Pour lire dans une seule chaîne, essayez. nouvelle chaîne (Files.readAllBytes (Paths.get (MyClass.class.getResource (resource) .toURI ())));
Theo Briscoe
2
La meilleure solution pour moi, car elle n'a pas besoin de dépendances, comme Spring ou Commons IO.
Bernie
1
Cela échouera si votre fichier de ressources se trouve dans un bocal, par exemple un module maven. Dans ce cas, vous devrez utiliser quelque chose comme Spring's' StreamUtils.copyToString.
Somu
26

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.

tangens
la source
Je ne suis pas sûr du "/". Un chemin relatif pourrait mieux fonctionner dans ce cas.
VonC
3
Si vous l'utilisez sans "/", vous recherchez votre fichier dans le package de "this".
tangens
1
Fichier InputStream = this.getClass (). GetResourceAsStream ("SomeTextFile.txt"); Fichier InputStream = this.getClass (). GetResourceAsStream ("/ SomeTextFile.txt"); Fichier InputStream = this.getClass (). GetResourceAsStream ("// SomeTextFile.txt"); Aucun des éléments ci-dessus n'a fonctionné :(
Chaitanya MSV
@Chaitanya: Pouvez-vous exécuter l'exemple de la réponse de John Skeet?
Aaron Digulla
20

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);
}
Pavel
la source
Qu'en est-il de la fermeture du flux d'entrée?
Stephan
Le flux sera fermé automatiquement. C'est une fonctionnalité de Java 7 "Essayez avec les ressources" docs.oracle.com/javase/tutorial/essential/exceptions/…
Michał Maciej Gałuszka
Seulement s'il se trouve à l'intérieur de l'instruction try, ce qui n'est pas le cas ici. Il aurait dû être essayé (flux InputStream final = nouveau ClassPathResource ("/ log4j.xml"). GetInputStream ()) {...
andresp
15

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

String url = this.getClass().getResource("").getPath();
webcom
la source
Et maintenant quoi? Cette information n'est d'aucune utilité en soi.
Marquis de Lorne
Cette information était parfaite. Il ne me manquait que getPath ()!
Patrick
@Patrick Cette réponse ne fournit pas le «chemin absolu de classe». Il fournit une URL. Pas du tout la même chose.
Marquis de Lorne
12

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.

user1695166
la source
Cela m'a également aidé sur Android où une classe était chargée par le chargeur d'application, mais une clé dont elle avait besoin était chargée paresseusement dans le thread d'interface utilisateur.
asokan
Vous devez fournir des informations sur les raisons pour lesquelles la meilleure réponse ne fonctionne pas pour vous (par exemple, la structure de votre application, le cadre que vous utilisez, l'erreur, etc.). La meilleure réponse indique clairement que 1) le répertoire doit être sur classpath, 2) vous devez demander à une classe chargée par le même chargeur de classe. Les chances sont que l'une de ces hypothèses ne s'applique pas à votre candidature. Le chargeur de classe de contexte est également très déconseillé car il a été présenté comme un hack. Certains frameworks l'utilisent mais il est important de connaître l'implication (qui nécessite de décrire l'arrière-plan de votre projet)
Xinchao
6

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();
Alexey Simonov
la source
Le chemin d'accès au fichier n'est d'aucune utilité si la ressource se trouve dans un fichier JAR ou WAR.
Marquis de Lorne
La méthode getFile de l'URL ne renvoie pas de nom de fichier. Il renvoie simplement la partie chemin de l'URL, qui n'est pas garantie d'être un nom de fichier valide. (La classe d'URL faisait partie de Java 1.0; à l'époque, la plupart des URL faisaient en fait référence à des fichiers physiques sur le même ordinateur ou sur un ordinateur différent.)
VGR
3

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");
BullyWiiPlaza
la source
1

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.

Aaron Digulla
la source
0

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();
   }
}
Abhijit Pritam Dutta
la source
0

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;
    } 
}
Ahmed Ali
la source
-1

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

Sardar Saikh
la source
1
Bienvenue dans Stack Overflow! Veuillez ne pas ajouter "merci" comme réponses même si vous fournissez également partiellement comment votre solution s'est déroulée, si vos solutions sont les mêmes qu'un autre article, il n'est pas nécessaire de les ajouter. Après avoir investi un peu de temps dans le site, vous obtiendrez des privilèges suffisants pour voter sur les réponses que vous aimez, ce qui est la façon de dire merci de Stack Overflow.
SuperBiasMan
-1

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

Charu Khurana
la source
la référence à src ne doit pas être utilisée ... Ne fonctionne pas dans l'artefact final.
L. Holanda
-1

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
ravibeli
la source
-2

N'utilisez pas la méthode getClassLoader () et utilisez le "/" avant le nom du fichier. "/" c'est tres important

this.getClass().getResourceAsStream("/SomeTextFile.txt");
sachinthana87
la source
L'utilisation de l'interligne /a exactement le même effet que l'utilisation de la getClassLoader()méthode.
Marquis 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();
                    }
                }
            }
        }

    }

}
Assistant
la source
Ne répond en aucune façon à la question.
Marquis de Lorne
-5

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

Salandur
la source
Je mets la variable système elle-même.
Chaitanya MSV
La «variable système» est le CLASSPATH Java. La réponse n'a pas de sens.
Marquis de Lorne
Totalement vrai ...
je