Come leggere davvero il file di testo dal percorso di classe in Java

Sto cercando di leggere un file di testo impostato nella variabile di sistema CLASSPATH. Non una variabile utente.

Sto cercando di ottenere il flusso di input al file come di seguito:

Inserisci la directory di file ( D:\myDir) in CLASSPATH e prova di seguito:

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

Inserisci il percorso completo del file ( D:\myDir\SomeTextFile.txt) in CLASSPATH e prova lo stesso sopra le 3 righe di codice.

Ma sfortunatamente NESSUNO di loro sta funzionando e vado sempre nullnel mio InputStream in.

Con la directory sul classpath, da una classe caricata dallo stesso classloader, dovresti essere in grado di usare uno di:

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

Se quelli non funzionano, ciò suggerisce che qualcos'altro è sbagliato.

Quindi, ad esempio, prendi questo codice:

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

E questa struttura di directory:

code
    dummy
          Test.class
txt
    SomeTextFile.txt

E poi (usando il separatore di percorso Unix mentre sono su un box Linux):

java -classpath code:txt dummy.Test

risultati:

true
true

Quando si utilizza Spring Framework (sia come raccolta di utilità o contenitore - non è necessario utilizzare quest'ultima funzionalità) è possibile utilizzare facilmente l' astrazione delle risorse .

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

Tramite l' interfaccia delle risorse è possibile accedere alla risorsa come InputStream , URL , URI o File . La modifica del tipo di risorsa, ad esempio una risorsa del file system, è una semplice questione di modifica dell'istanza.

Ecco come ho letto tutte le righe di un file di testo sul mio percorso di classe, usando Java 7 NIO:

...
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Paths;

...

Files.readAllLines(
    Paths.get(this.getClass().getResource("res.txt").toURI()), Charset.defaultCharset());

NB questo è un esempio di come si può fare. Dovrai apportare miglioramenti se necessario. Questo esempio funzionerà solo se il file è effettivamente presente sul tuo percorso di classe, altrimenti verrà generata una NullPointerException quando getResource () restituisce null e .toURI () viene invocato su di esso.

Inoltre, dal momento che Java 7, un modo conveniente per specificare i set di caratteri è usare le costanti definite in java.nio.charset.StandardCharsets (queste sono, secondo i loro javadocs , "garantite per essere disponibili su ogni implementazione della piattaforma Java").

Quindi, se conosci la codifica del file come UTF-8, specifica esplicitamente il set di caratteri StandardCharsets.UTF_8

Vi preghiamo di provare

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

I tuoi tentativi non hanno funzionato perché solo il caricatore di classi per le tue classi è in grado di caricare dal percorso di classe. Hai usato il caricatore di classi per il sistema java stesso.

Per leggere effettivamente il contenuto del file, mi piace usare Commons IO + Spring Core. Supponendo Java 8:

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

In alternativa:

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

Per ottenere il percorso assoluto della classe prova questo:

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

In qualche modo la risposta migliore non funziona per me. Devo usare invece un codice leggermente diverso.

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

Spero che questo aiuti chi incontra lo stesso problema.

Se usi Guava:

import com.google.common.io.Resources;

possiamo ottenere l'URL da CLASSPATH:

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

o InputStream:

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

Per leggere il contenuto di un file in una stringa da classpath, è possibile utilizzare questo:

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

Nota:
IOUtilsfa parte di Commons IO.

Chiamalo così:

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

Dici "Sto cercando di leggere un file di testo impostato nella variabile di sistema CLASSPATH." Suppongo che questo sia su Windows e stai usando questa brutta finestra di dialogo per modificare le "Variabili di sistema".

Ora esegui il tuo programma Java nella console. E non funziona: la console ottiene una copia dei valori delle variabili di sistema una volta avviata . Ciò significa che qualsiasi modifica della finestra di dialogo successiva non ha alcun effetto.

Esistono queste soluzioni:

1. Avvia una nuova console dopo ogni modifica

2. Utilizzare set CLASSPATH=...nella console per impostare la copia della variabile nella console e quando il codice funziona, incollare l'ultimo valore nella finestra di dialogo della variabile.

3. Metti la chiamata a Java in un .BATfile e fai doppio clic su di essa. Ciò creerà una nuova console ogni volta (copiando così il valore corrente della variabile di sistema).

ATTENZIONE: se si dispone anche di una variabile utente CLASSPATH, verrà oscurata la variabile di sistema. Ecco perché di solito è meglio inserire la chiamata al tuo programma Java in un .BATfile e impostare il percorso di classe lì (usando set CLASSPATH=) piuttosto che fare affidamento su un sistema globale o una variabile utente.

Questo assicura anche che sul tuo computer sia presente più di un programma Java perché sono tenuti ad avere percorsi di classe diversi.

La mia risposta non è esattamente ciò che viene chiesto nella domanda. Piuttosto sto dando una soluzione esattamente con che facilità possiamo leggere un file nell'applicazione java dal nostro percorso di classe del progetto.

Ad esempio, supponiamo che un nome di file di configurazione example.xml si trovi in ​​un percorso come di seguito: -

com.myproject.config.dev

e il nostro file di classe eseguibile java si trova nel percorso seguente: -

com.myproject.server.main

ora basta controllare sia il percorso sopra che è la directory / cartella comune più vicina da cui è possibile accedere sia a dev che alla directory / cartella principale (com.myproject.server.main - dove esiste la classe eseguibile java della nostra applicazione) - Possiamo vedere che è la cartella / directory di myproject che è la directory / cartella comune più vicina da cui possiamo accedere al nostro file example.xml. Quindi da una classe eseguibile java risiede nella cartella / directory principale dobbiamo tornare indietro di due passaggi come ../../ per accedere a myproject . Ora seguendo questo, vedere come possiamo leggere il file: -

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

Se compili il tuo progetto in un file jar: puoi mettere il tuo file in risorse / file / tuo_file.testo o pdf;

e usa questo codice:

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

Sto usando webshpere application server e il mio modulo Web è basato su Spring MVC. Si Test.propertiestrovavano nella cartella delle risorse, ho provato a caricare questi file usando il seguente:

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

Nessuno dei codici precedenti ha caricato il file.

Ma con l'aiuto del codice seguente il file delle proprietà è stato caricato correttamente:

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

Grazie all'utente "user1695166" .

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

Scenario:

1) client-service-1.0-SNAPSHOT.jarha dipendenzaread-classpath-resource-1.0-SNAPSHOT.jar

2) vogliamo leggere il contenuto delle risorse del percorso di classe ( sample.txt) di read-classpath-resource-1.0-SNAPSHOT.jarthrough client-service-1.0-SNAPSHOT.jar.

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

Ecco il codice di esempio funzionante che ho preparato, dopo 2-3 giorni che ho perso il mio tempo di sviluppo, ho trovato la soluzione end-to-end completa, spero che questo ti aiuti a risparmiare tempo

1. pom.xmldiread-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.javaclass read-classpath-resource-1.0-SNAPSHOT.jarche carica il contenuto del file delle risorse del percorso di 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.xmldiclient-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. classe AccessClassPathResource.javaistanza ClassPathResourceReadTest.javadove, caricherà sample.txte stampa anche il suo contenuto.

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. Eseguire il vaso eseguibile come segue:

[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

Non utilizzare il metodo getClassLoader () e utilizzare "/" prima del nome del file. "/" è molto importante

this.getClass().getResourceAsStream("/SomeTextFile.txt");

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class ReadFile

{
    /**
     * * feel free to make any modification I have have been here so I feel you
     * * * @param args * @throws InterruptedException
     */

    public static void main(String[] args) throws InterruptedException {
        // thread pool of 10
        File dir = new File(".");
        // read file from same directory as source //
        if (dir.isDirectory()) {
            File[] files = dir.listFiles();
            for (File file : files) {
                // if you wanna read file name with txt files
                if (file.getName().contains("txt")) {
                    System.out.println(file.getName());
                }

                // if you want to open text file and read each line then
                if (file.getName().contains("txt")) {
                    try {
                        // FileReader reads text files in the default encoding.
                        FileReader fileReader = new FileReader(
                                file.getAbsolutePath());
                        // Always wrap FileReader in BufferedReader.
                        BufferedReader bufferedReader = new BufferedReader(
                                fileReader);
                        String line;
                        // get file details and get info you need.
                        while ((line = bufferedReader.readLine()) != null) {
                            System.out.println(line);
                            // here you can say...
                            // System.out.println(line.substring(0, 10)); this
                            // prints from 0 to 10 indext
                        }
                    } catch (FileNotFoundException ex) {
                        System.out.println("Unable to open file '"
                                + file.getName() + "'");
                    } catch (IOException ex) {
                        System.out.println("Error reading file '"
                                + file.getName() + "'");
                        // Or we could just do this:
                        ex.printStackTrace();
                    }
                }
            }
        }

    }

}

devi mettere la tua "variabile di sistema" sul percorso di classe java.