Resources aus Jar Datei lesen

Ich möchte zum Beispiel Bild oder Textdateien aus einer Jar Datei laden. Die einfachsten Methode ist mittels getClass().getResource(). Diese Methode finde ich zum einen unelegant und zum anderen funktioniert dies innerhalb statischer Methoden nicht mehr.

Eine andere Methode ist mittels eines ZipFiles einfach die Resources auszulesen. Nun habe ich zwei Fragen dazu:

Gibt es eine einfachere Möglichkeit Dateien aus einem Jar Archiv auszulesen?
Wie erhalte ich mitten innerhalb meines Programms den Namen des aktuell ausgeführten Jar-Archivs?

Besten Dank für Eure Mühen!

Jar-Archiv Benutzer schrieb:

getClass().getResource(). Diese Methode finde ich zum einen unelegant und zum anderen funktioniert dies innerhalb statischer Methoden nicht mehr.

Da kann man auch ClassLoader.getSystemResource(...) nutzen. Diese Methode ist statisch und funktioniert ganz ähnlich wie getResource. ...man muss nur den Parameter etwas modifizieren.

Jar-Archiv Benutzer schrieb:

Eine andere Methode ist mittels eines ZipFiles einfach die Resources auszulesen. Nun habe ich zwei Fragen dazu:

Gibt es eine einfachere Möglichkeit Dateien aus einem Jar Archiv auszulesen?
Wie erhalte ich mitten innerhalb meines Programms den Namen des aktuell ausgeführten Jar-Archivs?

...ich habe mir da vor einiger Zeit mal ne Klasse geschreiben. Kannst dir den Code mal etwas angucken, zumindest geht es da auch um das Laden von Resourcen und der Name des aktuellen JAR-Files wird auch herausgefunden (in der Methode loadStandardResources()):

package controller;

import java.util.*;
import java.util.jar.*;
import java.io.*;
import java.net.*;

import container.*;

public class ResourceLoader
{
   private final LinkedList<File> directoryList;
   private final LinkedList<JarFile> jarList;

   public ResourceLoader()
   {
      directoryList = new LinkedList<File> ();
      jarList = new LinkedList<JarFile> ();
   }

   public void loadStandardResources()
   {
      final String resourceString = getClass().getName().replace('.','/') + ".class";
      final URL location = ClassLoader.getSystemResource(resourceString);
      assert(location != null);
      final String locationString = location.toString();
      try
      {
         if (locationString.startsWith("jar:"))
         {
            final int jarEnd = locationString.indexOf("!");
            assert(jarEnd >= 0);
            final String jarString = locationString.substring(4,jarEnd);
            loadResources(new JarFile(new File(new URI(jarString))));
         }
         else
         {
            final int baseEnd = locationString.indexOf("/" + resourceString);
            assert(baseEnd >= 0);
            final String baseString = locationString.substring (0,baseEnd);
            loadResources(new File (new URI(baseString)));
         }
      }
      catch (URISyntaxException e)
      {
         assert(false);
      }
      catch (IOException e)
      {
         assert(false);
      }
   }

   public boolean loadResources(final JarFile jarFile)
   {
      if (jarFile == null) return false;
      if (jarList.contains(jarFile)) return false;
      jarList.add(jarFile);
      return true;
   }

   public boolean loadResources(final File directory)
   {
      if (directory == null) return false;
      if (!directory.isDirectory()) return false;
      if (directoryList.contains(directory)) return false;
      directoryList.add(directory);
      return true;
   }

   public List<URL> getResourceURLs()
   {
      return getResourceURLs(new AcceptAllURLFilter());
   }

   public List<BufferedInputStream> getResourceStreams ()
   {
      return getResourceStreams(new AcceptAllURLFilter());
   }

   public List<Pair<URL,URL>> getResourceBaseURLPairs ()
   {
      return getResourceBaseURLPairs(new AcceptAllURLFilter());
   }

   public List<URL> getResourceURLs(final URLFilter filter)
   {
      if (filter == null) throw new NullPointerException();
      return getResources(filter,new URLDescriptor());
   }

   public List<BufferedInputStream> getResourceStreams (final URLFilter filter)
   {
      if (filter == null) throw new NullPointerException();
      return getResources(filter,new StreamDescriptor());
   }

   public List<Pair<URL,URL>> getResourceBaseURLPairs (final URLFilter filter)
   {
      if (filter == null) throw new NullPointerException();
      return getResources(filter,new BaseURLPairDescriptor());
   }

   private <DescriptionType> List<DescriptionType> getResources(final URLFilter filter,
                                                   final ResourceDescriptor<DescriptionType> descriptor)
   {
      final List<DescriptionType> list = new LinkedList<DescriptionType> ();
      for (final File directory : directoryList)
      {
         assert(directory != null);
         addFileResources(list,filter,descriptor,directory,directory);
      }
      for (final JarFile jarFile : jarList)
      {
         assert(jarFile != null);
         addJarResources(list,filter,descriptor,jarFile);
      }
      return list;
   }

   private static <DescriptionType> void addFileResources(final List<DescriptionType> list,
                                                   final URLFilter filter,
                                                   final ResourceDescriptor<DescriptionType> descriptor,
                                                   final File directory, final File baseDirectory)
   {
      assert(list != null);
      assert(filter != null);
      assert(descriptor != null);
      assert(baseDirectory != null);
      assert(baseDirectory.isDirectory());
      assert(directory != null);
      assert(directory.isDirectory());
      for (final File file : directory.listFiles())
      {
         if (file.isDirectory())
         {
            addFileResources(list,filter,descriptor,file,baseDirectory);
         }
         else
         {
            try
            {
               final URL url = file.toURI().toURL();
               if (!filter.acceptsURL(url)) continue;
               final DescriptionType resource = descriptor.getFileResource(baseDirectory,file,url);
               if (resource == null) continue;
               list.add(resource);
            }
            catch (MalformedURLException e)
            {
               assert(false);
            }
         }
      }
   }

   private static <DescriptionType> void addJarResources(final List<DescriptionType> list,
                                                  final URLFilter filter,
                                                  final ResourceDescriptor<DescriptionType> descriptor,
                                                  final JarFile jarFile)
   {
      assert(list != null);
      assert(filter != null);
      assert(descriptor != null);
      assert(jarFile != null);
      final Enumeration jarEntries = jarFile.entries ();
      final String urlPrefix = "jar:file:" + jarFile.getName() + "!/";
      while (jarEntries.hasMoreElements())
      {
         final JarEntry entry = (JarEntry)jarEntries.nextElement();
         try
         {
            final URL url = new URL(urlPrefix + entry.getName());
            if (!filter.acceptsURL(url)) continue;
            final DescriptionType resource = descriptor.getJarResource(jarFile,entry,url);
            if (resource == null) continue;
            list.add(resource);
         }
         catch (MalformedURLException e)
         {
            assert(false);
         }
      }
   }

   private static interface ResourceDescriptor<DescriptionType>
   {
      public DescriptionType getFileResource (final File baseDirectory, final File file, final URL url);
      public DescriptionType getJarResource (final JarFile jar, final JarEntry entry, final URL url);
   }

   private static class StreamDescriptor implements ResourceDescriptor<BufferedInputStream>
   {
      public BufferedInputStream getFileResource (final File baseDirectory, final File file,
                                                  final URL url)
      {
         try
         {
            return new BufferedInputStream(new FileInputStream (file));
         }
         catch (IOException e)
         {
            assert(false);
         }
         return null;
      }

      public BufferedInputStream getJarResource (final JarFile jar, final JarEntry entry, final URL url)
      {
         try
         {
            return new BufferedInputStream (jar.getInputStream(entry));
         }
         catch (IOException e)
         {
            assert(false);
         }
         return null;
      }
   }

   private static class URLDescriptor implements ResourceDescriptor<URL>
   {
      public URL getFileResource (final File baseDirectory, final File file, final URL url)
      {
         return url;
      }

      public URL getJarResource (final JarFile jar, final JarEntry entry, final URL url)
      {
         return url;
      }
   }

   private static class BaseURLPairDescriptor implements ResourceDescriptor<Pair<URL,URL>>
   {
      public Pair<URL,URL> getFileResource (final File baseDirectory, final File file, final URL url)
      {
         try
         {
            return new Pair<URL,URL> (baseDirectory.toURI().toURL(),url);
         }
         catch (MalformedURLException e)
         {
            assert(false);
         }
         return null;
      }

      public Pair<URL,URL> getJarResource (final JarFile jar, final JarEntry entry, final URL url)
      {
         try
         {
            return new Pair<URL,URL> (new URL("file:" + jar.getName()), url);
         }
         catch (MalformedURLException e)
         {
            assert(false);
         }
         return null;
      }
   }

   private static class AcceptAllURLFilter implements URLFilter
   {
      public boolean acceptsURL (final URL url)
      {
         return true;
      }
   }
}

Vielen Dank Gregor! Hat mir weitergeholfen!

Foll geiler Code