Wie man wirklich eine Textdatei aus dem Klassenpfad in Java liest

Ich versuche, eine Textdatei zu lesen, die in der Systemvariablen CLASSPATH festgelegt ist. Keine Benutzervariable.

Ich versuche, den Eingabestream wie folgt in die Datei zu bringen:

Platzieren Sie das Verzeichnis von file ( D:\myDir) in CLASSPATH und versuchen Sie es unten:

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

Platzieren Sie den vollständigen Pfad von file ( D:\myDir\SomeTextFile.txt) in CLASSPATH und versuchen Sie dasselbe über 3 Codezeilen.

Aber leider funktioniert KEINER von ihnen und ich nullkomme immer in meinen InputStream in.

Mit dem Verzeichnis im Klassenpfad aus einer Klasse, die von demselben Klassenladeprogramm geladen wurde, sollten Sie Folgendes verwenden können:

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

Wenn diese nicht funktionieren, deutet dies darauf hin, dass etwas anderes nicht stimmt.

Nehmen Sie zum Beispiel diesen 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);
    }
}

Und diese Verzeichnisstruktur:

code
    dummy
          Test.class
txt
    SomeTextFile.txt

Und dann (mit dem Unix-Pfadtrennzeichen wie auf einer Linux-Box):

java -classpath code:txt dummy.Test

Ergebnisse:

true
true

Wenn Sie das Spring Framework verwenden (entweder als Sammlung von Dienstprogrammen oder als Container - Sie müssen die letztere Funktionalität nicht verwenden), können Sie die Ressourcenabstraktion problemlos verwenden .

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

Über die Ressourcenschnittstelle können Sie als InputStream , URL , URI oder Datei auf die Ressource zugreifen . Das Ändern des Ressourcentyps in z. B. eine Dateisystemressource ist eine einfache Angelegenheit zum Ändern der Instanz.

So lese ich mit Java 7 NIO alle Zeilen einer Textdatei in meinem Klassenpfad:

...
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 dies ist ein Beispiel dafür, wie es gemacht werden kann. Sie müssen bei Bedarf Verbesserungen vornehmen. Dieses Beispiel funktioniert nur, wenn die Datei tatsächlich in Ihrem Klassenpfad vorhanden ist. Andernfalls wird eine NullPointerException ausgelöst, wenn getResource () null zurückgibt und .toURI () darauf aufgerufen wird.

Seit Java 7 besteht eine bequeme Möglichkeit, Zeichensätze anzugeben, darin, die in definierten Konstanten zu verwenden java.nio.charset.StandardCharsets (diese sind laut ihren Javadocs "garantiert bei jeder Implementierung der Java-Plattform verfügbar").

Wenn Sie also die Codierung der Datei als UTF-8 kennen, geben Sie den Zeichensatz explizit an StandardCharsets.UTF_8

Bitte versuche

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

Ihre Versuche haben nicht funktioniert, da nur der Klassenlader für Ihre Klassen aus dem Klassenpfad geladen werden kann. Sie haben den Klassenlader für das Java-System selbst verwendet.

Um den Inhalt der Datei tatsächlich zu lesen, verwende ich gerne Commons IO + Spring Core. Angenommen, Java 8:

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

Alternative:

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

Um den absoluten Klassenpfad zu erhalten, versuchen Sie Folgendes:

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

Irgendwie funktioniert die beste Antwort bei mir nicht. Ich muss stattdessen einen etwas anderen Code verwenden.

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

Ich hoffe, dies hilft denen, die auf das gleiche Problem stoßen.

Wenn Sie Guave verwenden:

import com.google.common.io.Resources;

Wir können die URL von CLASSPATH erhalten:

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

oder InputStream:

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

Um den Inhalt einer Datei in einen String aus dem zu lesen classpath, können Sie Folgendes verwenden:

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

Hinweis:
IOUtilsist Teil vonCommons IO .

Nennen Sie es so:

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

Sie sagen: "Ich versuche, eine Textdatei zu lesen, die in der Systemvariablen CLASSPATH festgelegt ist." Ich vermute, dies ist unter Windows und Sie verwenden diesen hässlichen Dialog, um die "Systemvariablen" zu bearbeiten.

Jetzt führen Sie Ihr Java-Programm in der Konsole aus. Und das funktioniert nicht: Die Konsole erhält beim Start einmal eine Kopie der Werte der Systemvariablen . Dies bedeutet jede Änderung im Dialog danach keine Auswirkungen hat.

Es gibt diese Lösungen:

1. Starten Sie nach jeder Änderung eine neue Konsole

2. Verwenden Sie diese Option set CLASSPATH=...in der Konsole, um die Kopie der Variablen in der Konsole festzulegen. Wenn Ihr Code funktioniert, fügen Sie den letzten Wert in den Variablendialog ein.

3. Legen Sie den Aufruf von Java in eine .BATDatei und doppelklicken Sie darauf. Dadurch wird jedes Mal eine neue Konsole erstellt (wodurch der aktuelle Wert der Systemvariablen kopiert wird).

ACHTUNG: Wenn Sie auch eine Benutzervariable haben, CLASSPATHwird diese Ihre Systemvariable beschatten. Aus diesem Grund ist es normalerweise besser, den Aufruf Ihres Java-Programms in eine .BATDatei zu schreiben und dort den Klassenpfad festzulegen (usingset CLASSPATH= ), als sich auf ein globales System oder eine Benutzervariable zu verlassen.

Dadurch wird auch sichergestellt, dass auf Ihrem Computer mehr als ein Java-Programm ausgeführt werden kann, da diese unterschiedliche Klassenpfade haben müssen.

Meine Antwort ist nicht genau das, was in der Frage gestellt wird. Vielmehr gebe ich eine Lösung genau an, wie einfach wir eine Datei aus unserem Projektklassenpfad in unsere Java-Anwendung einlesen können.

Angenommen, ein Konfigurationsdateiname example.xml befindet sich in einem Pfad wie folgt: -

com.myproject.config.dev

und unsere ausführbare Java-Klassendatei befindet sich im folgenden Pfad: -

com.myproject.server.main

Checken Sie jetzt einfach den obigen Pfad ein, der das nächste gemeinsame Verzeichnis / Ordner ist, von dem aus Sie sowohl auf dev als auch auf das Hauptverzeichnis / den Hauptordner zugreifen können (com.myproject.server.main - wo die ausführbare Java-Klasse unserer Anwendung vorhanden ist) dass es sich um myproject Ordner / Verzeichnis handelt, das das nächste gemeinsame Verzeichnis / Ordner ist, von dem aus wir auf unsere Datei example.xml zugreifen können. Daher müssen wir von einer ausführbaren Java-Klasse im Ordner / Verzeichnis main zwei Schritte wie ../../ zurückgehen, um auf myproject zuzugreifen . Sehen Sie sich nun an, wie wir die Datei lesen können: -

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

Wenn Sie Ihr Projekt in einer JAR-Datei kompilieren: Sie können Ihre Datei in resources / files / your_file.text oder pdf ablegen.

und benutze diesen 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;
    } 
}

Ich verwende den Webshpere-Anwendungsserver und mein Webmodul basiert auf Spring MVC. Die Test.propertiesbefanden sich im Ressourcenordner, ich habe versucht, diese Dateien wie folgt zu laden:

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

Keiner der oben genannten Codes hat die Datei geladen.

Mit Hilfe des folgenden Codes wurde die Eigenschaftendatei jedoch erfolgreich geladen:

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

Vielen Dank an den Benutzer "user1695166" .

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

Szenario:

1) client-service-1.0-SNAPSHOT.jarhat Abhängigkeitread-classpath-resource-1.0-SNAPSHOT.jar

2) Wir möchten den Inhalt von Klassenpfadressourcen lesen (sample.txt ) von read-classpath-resource-1.0-SNAPSHOT.jardurchclient-service-1.0-SNAPSHOT.jar .

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

Hier ist ein Beispielcode, den ich vorbereitet habe. Nachdem ich 2-3 Tage meine Entwicklungszeit verschwendet hatte, fand ich die vollständige End-to-End-Lösung. Ich hoffe, dies hilft Ihnen, Zeit zu sparen

1. pom.xmlvonread-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 Klasse read-classpath-resource-1.0-SNAPSHOT.jar, die den Inhalt der Klassenpfadressourcendatei lädt.

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.xml vonclient-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.java Instanziieren Sie die ClassPathResourceReadTest.javaKlasse, in die sie geladen wird, sample.txtund drucken Sie auch ihren Inhalt.

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. Führen Sie das ausführbare Glas wie folgt aus:

[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

Verwenden Sie nicht die Methode getClassLoader () und das "/" vor dem Dateinamen. "/" ist sehr wichtig

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

    }

}

Sie müssen Ihre 'Systemvariable' in den Java-Klassenpfad einfügen.