Jak naprawdę odczytać plik tekstowy ze ścieżki klas w Javie

Próbuję odczytać plik tekstowy ustawiony w zmiennej systemowej CLASSPATH. Nie zmienna użytkownika.

Próbuję uzyskać strumień wejściowy do pliku, jak poniżej:

Umieść katalog file ( D:\myDir) w CLASSPATH i spróbuj poniżej:

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

Umieść pełną ścieżkę file ( D:\myDir\SomeTextFile.txt) w CLASSPATH i wypróbuj tę samą powyżej 3 linii kodu.

Ale niestety ŻADNA z nich nie działa i zawsze wchodzę nullw mój InputStream in.

Mając katalog w ścieżce klas, z klasy ładowanej przez ten sam moduł ładujący klasy, powinieneś być w stanie użyć jednego z:

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

Jeśli te nie działają, to sugeruje, że coś innego jest nie tak.

Na przykład weź ten kod:

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

I ta struktura katalogów:

code
    dummy
          Test.class
txt
    SomeTextFile.txt

A następnie (używając separatora ścieżek Unixa, gdy jestem na Linux-ie):

java -classpath code:txt dummy.Test

Wyniki:

true
true

Korzystając z Spring Framework (jako zestawu narzędzi lub kontenera - nie musisz korzystać z tej drugiej funkcji), możesz łatwo użyć abstrakcji zasobów .

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

Poprzez interfejs zasobu możesz uzyskać dostęp do zasobu jako InputStream , URL , URI lub Plik . Zmiana typu zasobu na np. Zasób systemu plików to prosta kwestia zmiany instancji.

Oto jak czytam wszystkie wiersze pliku tekstowego na mojej ścieżce klasy, używając 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());

Uwaga: jest to przykład tego, jak można to zrobić. W razie potrzeby będziesz musiał wprowadzić poprawki. Ten przykład będzie działał tylko wtedy, gdy plik rzeczywiście znajduje się w ścieżce klasy, w przeciwnym razie zostanie wygenerowany wyjątek NullPointerException, gdy getResource () zwróci null i zostanie na nim wywołane .toURI ().

Ponadto, od wersji Java 7, jednym z wygodnych sposobów określania zestawów znaków jest użycie stałych zdefiniowanych w java.nio.charset.StandardCharsets (zgodnie z ich javadocami „gwarantuje się, że będą one dostępne na każdej implementacji platformy Java”).

Dlatego jeśli znasz kodowanie pliku w formacie UTF-8, określ jawnie zestaw znaków StandardCharsets.UTF_8

Proszę spróbować

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

Twoje próby nie zadziałały, ponieważ tylko moduł ładujący klasy dla twoich klas jest w stanie załadować ze ścieżki klas. Użyłeś modułu ładującego klasy dla samego systemu Java.

Aby faktycznie odczytać zawartość pliku, lubię używać Commons IO + Spring Core. Zakładając Java 8:

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

Alternatywnie:

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

Aby uzyskać bezwzględną ścieżkę klasy, spróbuj:

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

Jakoś najlepsza odpowiedź nie działa dla mnie. Zamiast tego muszę użyć nieco innego kodu.

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

Mam nadzieję, że pomoże to tym, którzy napotykają ten sam problem.

Jeśli używasz Guawy:

import com.google.common.io.Resources;

możemy uzyskać adres URL z CLASSPATH:

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

lub InputStream:

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

Aby odczytać zawartość pliku z ciągu znaków classpath, możesz użyć tego:

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

Uwaga:
IOUtilsjest częścią Commons IO.

Nazwij to tak:

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

Mówisz „Próbuję odczytać plik tekstowy ustawiony w zmiennej systemowej CLASSPATH”. Domyślam się, że jest to w systemie Windows i używasz tego brzydkiego okna dialogowego do edycji „Zmiennych systemowych”.

Teraz uruchamiasz program Java w konsoli. I to nie działa: Konsola dostaje kopię wartości zmiennych systemowych raz , gdy jest on zaczął . Oznacza to, że późniejsza zmiana w oknie dialogowym nie ma żadnego efektu.

Istnieją następujące rozwiązania:

1. Po każdej zmianie uruchom nową konsolę

2. Użyj set CLASSPATH=...w konsoli, aby ustawić kopię zmiennej w konsoli, a gdy kod zadziała, wklej ostatnią wartość do okna dialogowego zmiennej.

3. Umieść wywołanie Java w .BATpliku i kliknij go dwukrotnie. Spowoduje to utworzenie nowej konsoli za każdym razem (kopiując w ten sposób bieżącą wartość zmiennej systemowej).

UWAGA: jeśli masz również zmienną użytkownika CLASSPATH, będzie ona przesłaniać zmienną systemową. Dlatego zwykle lepiej jest umieścić wywołanie programu Java w .BATpliku i ustawić tam ścieżkę klasy (używającset CLASSPATH= ), zamiast polegać na globalnym systemie lub zmiennej użytkownika.

Zapewnia to również, że na komputerze może działać więcej niż jeden program Java, ponieważ mają one różne ścieżki klas.

Moja odpowiedź nie jest dokładnie taka, jak zadana w pytaniu. Daję raczej rozwiązanie dokładnie, jak łatwo możemy odczytać plik do naszej aplikacji Java z naszej ścieżki klasy projektu.

Załóżmy na przykład, że nazwa pliku konfiguracyjnego example.xml znajduje się w ścieżce jak poniżej: -

com.myproject.config.dev

a nasz plik klasy wykonywalnej Java jest w poniższej ścieżce: -

com.myproject.server.main

teraz wystarczy wpisać obie powyższe ścieżki, które są najbliższym wspólnym katalogiem / folderem, z którego można uzyskać dostęp zarówno do katalogu dev, jak i katalogu głównego / folder (com.myproject.server.main - gdzie istnieje klasa wykonywalna aplikacji java) - Widzimy że jest to folder / katalog myproject, który jest najbliższym wspólnym katalogiem / folderem, z którego możemy uzyskać dostęp do naszego pliku example.xml. Dlatego z klasy wykonywalnej java znajdującej się w głównym folderze / katalogu musimy cofnąć się o dwa kroki, jak ../../, aby uzyskać dostęp do myproject . Teraz, po tym, zobacz, jak możemy odczytać plik: -

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

Jeśli skompilujesz projekt w pliku jar: możesz umieścić plik w pliku resources / files / your_file.text lub pdf;

i użyj tego kodu:

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

Korzystam z serwera aplikacji webshpere, a mój moduł WWW jest oparty na Spring MVC. Test.propertiesZnajdowały się w folderze zasobów, próbowałem załadować pliki przy użyciu następujących:

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

Żaden z powyższych kodów nie załadował pliku.

Ale za pomocą poniższego kodu plik właściwości został pomyślnie załadowany:

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

Dzięki użytkownikowi „user1695166” .

Posługiwać się org.apache.commons.io.FileUtils.readFileToString(new File("src/test/resources/sample-data/fileName.txt"));

Scenariusz:

1) client-service-1.0-SNAPSHOT.jarma zależnośćread-classpath-resource-1.0-SNAPSHOT.jar

2) chcemy odczytać zawartość zasobów ścieżki klasy ( sample.txt) read-classpath-resource-1.0-SNAPSHOT.jarprzez client-service-1.0-SNAPSHOT.jar.

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

Oto działający przykładowy kod, który przygotowałem, po 2-3 dniach marnowania czasu na opracowanie, znalazłem kompletne kompleksowe rozwiązanie, mam nadzieję, że pomoże to zaoszczędzić Twój czas

1. pom.xmlzread-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.javaklasa, read-classpath-resource-1.0-SNAPSHOT.jarktóra ładuje zawartość pliku zasobów ścieżki klasy.

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.xmlzclient-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.javautwórz instancję ClassPathResourceReadTest.javaklasy, do której ładuje się sample.txti drukuje również jej zawartość.

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. Uruchom słoik wykonywalny w następujący sposób:

[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

Nie używaj metody getClassLoader () i używaj „/” przed nazwą pliku. "/" to bardzo ważne

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

    }

}

musisz umieścić swoją „zmienną systemową” na ścieżce klasy Java.