La lecture d'un fichier de ressources à partir de l'intérieur de jar

Plutôt que d'essayer de l'adresse de la ressource en tant que Fichier il suffit de demander le Chargeur de classe de retour d'un InputStream de la ressource par le biais d' getResourceAsStream:

InputStream in = getClass().getResourceAsStream("/file.txt"); 
BufferedReader reader = new BufferedReader(new InputStreamReader(in));

Tant que le file.txt ressource est disponible dans le classpath ensuite, cette approche va fonctionner de la même façon, indépendamment de savoir si le file.txt ressource en classes/ répertoire ou à l'intérieur d'un jar.

La URI is not hierarchical se produit parce que l'URI d'une ressource dans un fichier jar va ressembler à quelque chose comme ceci: file:/example.jar!/file.txt. Vous ne pouvez pas lire les écritures dans un jar (un zip fichier) comme si c'était un simple vieux Fichier.

C'est bien expliqué par les réponses à:

• Comment puis-je lire un fichier de ressources à partir d'un fichier jar Java?
• Java Jar fichier: utilisation des ressources erreurs: URI n'est pas hiérarchique

Si vous voulez lire un fichier, je crois qu'il y a toujours une solution similaire:

    ClassLoader classLoader = getClass().getClassLoader();
    File file = new File(classLoader.getResource("file/test.xml").getFile());

Assurez-vous que vous travaillez avec le bon séparateur. J'ai remplacé tous les / dans un chemin relatif avec un File.separator. Cela a bien fonctionné dans l'IDE, mais ne fonctionne pas dans la version JAR.

Après beaucoup de creuser autour de Java, la seule solution qui semble fonctionner pour moi, c'est manuellement lire le fichier jar de lui-même, sauf si vous êtes dans un environnement de développement(IDE):

/** @return The root folder or jar file that the class loader loaded from */
public static final File getClasspathFile() {
return new File(YourMainClass.class.getProtectionDomain().getCodeSource().getLocation().getFile());
}
/** @param resource The path to the resource
* @return An InputStream containing the resource's contents, or
*         <b><code>null</code></b> if the resource does not exist */
public static final InputStream getResourceAsStream(String resource) {
resource = resource.startsWith("/") ? resource : "/" + resource;
if(getClasspathFile().isDirectory()) {//Development environment:
return YourMainClass.class.getResourceAsStream(resource);
}
final String res = resource;//Jar or exe:
return AccessController.doPrivileged(new PrivilegedAction<InputStream>() {
@SuppressWarnings("resource")
@Override
public InputStream run() {
try {
final JarFile jar = new JarFile(getClasspathFile());
String resource = res.startsWith("/") ? res.substring(1) : res;
if(resource.endsWith("/")) {//Directory; list direct contents:(Mimics normal getResourceAsStream("someFolder/") behaviour)
ByteArrayOutputStream baos = new ByteArrayOutputStream();
Enumeration<JarEntry> entries = jar.entries();
while(entries.hasMoreElements()) {
JarEntry entry = entries.nextElement();
if(entry.getName().startsWith(resource) && entry.getName().length() > resource.length()) {
String name = entry.getName().substring(resource.length());
if(name.contains("/") ? (name.endsWith("/") && (name.indexOf("/") == name.lastIndexOf("/"))) : true) {//If it's a folder, we don't want the children's folders, only the parent folder's children!
name = name.endsWith("/") ? name.substring(0, name.length() - 1) : name;
baos.write(name.getBytes(StandardCharsets.UTF_8));
baos.write('\r');
baos.write('\n');
}
}
}
jar.close();
return new ByteArrayInputStream(baos.toByteArray());
}
JarEntry entry = jar.getJarEntry(resource);
InputStream in = entry != null ? jar.getInputStream(entry) : null;
if(in == null) {
jar.close();
return in;
}
final InputStream stream = in;//Don't manage 'jar' with try-with-resources or close jar until the
return new InputStream() {//returned stream is closed(closing the jar closes all associated InputStreams):
@Override
public int read() throws IOException {
return stream.read();
}
@Override
public int read(byte b[]) throws IOException {
return stream.read(b);
}
@Override
public int read(byte b[], int off, int len) throws IOException {
return stream.read(b, off, len);
}
@Override
public long skip(long n) throws IOException {
return stream.skip(n);
}
@Override
public int available() throws IOException {
return stream.available();
}
@Override
public void close() throws IOException {
try {
jar.close();
} catch(IOException ignored) {
}
stream.close();
}
@Override
public synchronized void mark(int readlimit) {
stream.mark(readlimit);
}
@Override
public synchronized void reset() throws IOException {
stream.reset();
}
@Override
public boolean markSupported() {
return stream.markSupported();
}
};
} catch(Throwable e) {
e.printStackTrace();
return null;
}
}
});
}

Remarque: Le code ci-dessus ne semble fonctionner correctement pour les fichiers jar si elle est dans la classe principale. Je ne sais pas pourquoi.

Pour quelque raison classLoader.getResource() retourne toujours la valeur null lorsque j'ai déployé l'application web de WildFly 14. l'obtention du chargeur de classe de getClass().getClassLoader() ou Thread.currentThread().getContextClassLoader() renvoie la valeur null.

getClass().getClassLoader() API doc a dit,

"Renvoie le chargeur de classe pour la classe. Certaines implémentations peuvent utiliser la valeur null pour représenter la classe de bootstrap loader. Cette méthode retourne la valeur null dans leur mise en œuvre si cette classe a été chargé par la classe de bootstrap loader."

peut-être si vous êtes à l'aide de WildFly et le vôtre application web essayez cette

request.getServletContext().getResource() renvoyé l'url de ressource. Ici, la demande est un objet de ServletRequest.

Code ci-dessous fonctionne avec Spring boot(kotlin):

val authReader = InputStreamReader(javaClass.getResourceAsStream("/file1.json"))

Si vous utilisez le printemps, vous pouvez utiliser la méthode suivante pour lire le fichier de répertoire src/main/resources:

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import org.springframework.core.io.ClassPathResource;
public String readFileToString(String path) throws IOException {
StringBuilder resultBuilder = new StringBuilder("");
ClassPathResource resource = new ClassPathResource(path);
try (
InputStream inputStream = resource.getInputStream();
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream))) {
String line;
while ((line = bufferedReader.readLine()) != null) {
resultBuilder.append(line);
}
}
return resultBuilder.toString();
}