Myujth

To access a file in a jar you have two options:

• Place the file in directory structure matching your package name (after extracting .jar file, it should be in the same directory as .class file), then access it using getClass().getResourceAsStream("file.txt")




• Place the file at the root (after extracting .jar file, it should be in the root), then access it using Thread.currentThread().getContextClassLoader().getResourceAsStream("file.txt")

The first option may not work when jar is used as a plugin.

If you wanna read as a file, I believe there still is a similar solution:

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

I had this problem before and I made fallback way for loading. Basically first way work within .jar file and second way works within eclipse or other IDE.

public class MyClass 

 public static InputStream accessFile() 
 String resource = "my-file-located-in-resources.txt";

 // this is the path within the jar file
 InputStream input = MyClass.class.getResourceAsStream("/resources/" + resource);
 if (input == null) 
 // this is how we load file within editor (eg eclipse)
 input = MyClass.class.getClassLoader().getResourceAsStream(resource);
 

 return input;
 

Make sure that you work with the correct separator. I replaced all / in a relative path with a File.separator. This worked fine in the IDE, however did not work in the build JAR.

Up until now (December 2017), this is the only solution I found which works both inside and outside the IDE.

Use PathMatchingResourcePatternResolver

Note: it works also in spring-boot

In this example I'm reading some files located in src/main/resources/my_folder:

try 
 // Get all the files under this inner resource folder: my_folder
 String scannedPackage = "my_folder/*";
 PathMatchingResourcePatternResolver scanner = new PathMatchingResourcePatternResolver();
 Resource resources = scanner.getResources(scannedPackage);

 if (resources == null catch (Exception e) 
 throw new Exception("Failed to read the resources folder: " + e.getMessage(), e);

You could also just use java.nio. Here is an example to slurp in text from a file at resourcePath in classpath:

new String(Files.readAllBytes(Paths.get(getClass().getResource(resourcePath).toURI())))

After a lot of digging around in Java, the only solution that seems to work for me is to manually read the jar file itself unless you're in a development environment(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;
 
 
 );

Note: The above code only seems to work correctly for jar files if it is in the main class. I'm not sure why.

I think this should be works in java as well. The following code I use is using kotlin.

val resource = Thread.currentThread().contextClassLoader.getResource('resources.txt')

You can use class loader which will read from classpath as ROOT path (without "/" in the beginning)

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

If you are using spring, then you can use the the following method to read file from 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();