was soll ich jetzt also tun?
was soll ich lesen bzw lernen und mein ziel zu erreichen?
Was ist denn dein Ziel?
Du willst Ressourcen aus einem Verzeichnis innerhalb eines Jar-Archivs lesen richtig?
Ein solches Verzeichnis auf URL-Basis liefert die meine zuvor gepostete “JarFile”-Klasse. Die Methode in Zeile 48 kann man auch ganz leicht auf String-Parameter umbauen, sodas man Sub-Verzeichnisse nicht unbedingt per JarEntry selektieren muss.
Aber das könnte ich ja dann nicht in eclipse laufen lassen, denn dort läuft das ganze ja nicht als jar?
[QUOTE=mymaksimus]Aber das könnte ich ja dann nicht in eclipse laufen lassen, denn dort läuft das ganze ja nicht als jar?[/QUOTE]jep… stimmt auffallend…
Dann schau dir dieses hier
http://forum.byte-welt.net/entries/2-Von-Arbeits-Installations-und-Resourcepfaden
nochmal an… Da bekommst du auch in Eclipse die korrekten Verzeichnisse. Das einzige was du brauchst um an eine Code- oder JarBase heranzukommen ist eine Klasse aus diesem Archiv oder Verzeichnis.
aber ich brauch doch gar kein code oder jarbase… 
nochmal - ich habe folgende Struktur:
src
—code
-------klasse1.java
-------klasse2.java
—res
-------bildrgunriau.png
-------bil245kjnaerjng.png
-------vg43.png
-------eqa389jv.png
-------v23ts9.jpg
-------poip00.gif
-------f4498jv9srej.png
Nun würde ich normalerweise ein neues FileObjekt erzeugen von dem verzeichnis /res/ und mit listFiles() hätte ich dann alles von bildrgunriau.png…bis…f4498jv9srej.png
So. Das geht ja wie ich verstanden habe nicht in einer jar.
Ich will jetzt aber um…
BufferedImage bildrgunriau = getClass().getResource("/res/bildrgunriau.png");
BufferedImage bil245kjnaerjng = getClass().getResource("/res/bil245kjnaerjng.png");
BufferedImage vg43 = getClass().getResource("/res/vg43.png");
BufferedImage eqa389jv = getClass().getResource("/res/eqa389jv.png");
BufferedImage v23ts9 = getClass().getResource("/res/v23ts9.jpg");
BufferedImage poip00 = getClass().getResource("/res/poip00.gif");
BufferedImage f4498jv9srej = getClass().getResource("/res/f4498jv9srej.png");
…zu vermeiden, eine Lösung finden, mit der ich wie mit listFiles() diesen ordner komplett auslesen kann, die aber eben auch in einer jar funktioniert…
Den Inhalt einer Jar-Datei kannst du bspw. so auslesen:
import java.io.*;
import java.util.*;
import java.util.jar.*;
public class JarFileReader {
public static void main(String[] args) {
JarFile jf = null;
try {
jf = new JarFile(new File("C:/Program Files (x86)/Java/jdk1.7.0_17/lib/dt.jar"));
Enumeration en = jf.entries();
while(en.hasMoreElements()) {
System.out.println(en.nextElement());
}
}
catch(FileNotFoundException fnfe) {
fnfe.printStackTrace();
}
catch(IOException ioe) {
ioe.printStackTrace();
}
}
}```
Kommst du damit weiter?Dagegen ist in Java leider noch kein Kraut gewachsen. Du müsstest dazu die komplette Jar extrahieren und auf Platte speichern (Für Applets z.B. ein absolutes NoGo). Da würde schon eher so ein Ansatz wie der von Fancy passen. Muss ja nicht mit Enums sein. Dynamischer wirds da mit Property-Files:
bildrgunriau=/res/bildrgunriau.png
...
Eine solche Datei brauchst dann nur noch editieren, wenn was neues hinzukommt und dann kannst du es mit
import java.io.IOException;
import java.util.Collections;
import java.util.Map;
import java.util.Properties;
import java.util.TreeMap;
import javax.imageio.ImageIO;
public final class DynamicResources {
private static final BufferedImage FAILURE_IMAGE = new BufferedImage(1, 1, BufferedImage.TYPE_BYTE_BINARY);
private static final Map<String, BufferedImage> IMAGES = new TreeMap<>();
private static final Map<String, String> IMAGE_NAMES;
static {
try {
Map<String, String> imageNames = new TreeMap<>();
Properties p = new Properties();
ClassLoader cl = DynamicResources.class.getClassLoader();
p.load(cl.getResourceAsStream("RessourceList.txt"));
for(Object rName : p.keySet()) {
String resName = rName.toString();
imageNames.put(resName, p.getProperty(resName));
}
IMAGE_NAMES = Collections.unmodifiableMap(imageNames);
} catch(IOException e) {
throw new RuntimeException(e);
}
}
public static BufferedImage getImage(String name) {
if(!IMAGE_NAMES.containsKey(name)) {
return null;
}
synchronized (IMAGES) {
BufferedImage rc = IMAGES.get(name);
if(rc == null) {
try {
rc = ImageIO.read(DynamicResources.class.getClassLoader().getResource(IMAGE_NAMES.get(name)));
} catch(IOException e) {
rc = FAILURE_IMAGE;
}
IMAGES.put(name, rc);
}
return rc;
}
}
}```laden. Dieses lädt die komplette RessourceList als Stringreferenzen und erst wenn ein Bild per "getImage()" geholt wird, wird dieses einmalig geladen. Weitere Aufrufe von "getImage()" mit der selben Stringreferenz geben dann immer das bereits geladene Bild zurück.
@L-ectron-X : Deines funktioniert nur wieder bei Jars. nicht aber während der Entwicklung in Eclipse.okay, jetzt hast du glaube ich verstanden was ich meinte…
na gut, dann gehts halt nicht.
Das hatte ich befürchtet zu hören…
Aber mal ersnthaft: stellt euch mal vor, man hat soetwas wie wenn user eigene bilder einfügen können…
dann muss immer so einer dumme datei erweitert werden wo die ganzen bild namen drinstehen… ist ja fast lächerlich.
aber naja.
Trozdem vielen vielen dank für eueren zeitaufwand!!
Den Fall gibt es aber nicht, denn erstens wissen Anwender nicht, was eine Jar-Datei ist und zweitens wird die niemand auspacken, verändern und wieder packen. Das ist von der Usability alles andere als optimal und spätestens, wenn die Jar signiert ist, wäre die neue Jar nicht mehr signiert und dann? In solchen Fällen verwendet man entweder einen Unterordner, um dem Benutzer die Möglichkeit zu geben eigene Bilder hinzu zu fügen oder aber eine Datenbank, dann müsste das Hinzufügen aber von der Software aus geschehen. Diese Dynamik, wie du sie dir vorstellst, ist daher nur theoretischer Natur und kommt in der Realität eigentlich nicht vor, jedenfalls nicht im Sinne einer händischen Manipulation einer Jar-Datei. Wenn du also mit den Ressourcen einer Jar arbeitest, dann kannst du ohne Bedenken mit festen Pfaden arbeiten oder aber um die paar Zeilen Code zu sparen auch eine Textdatei mit den Einträgen anlegen, die du dann ausliest, so wie Spacerat es schon vorgeschlagen hat. Wenn der Benutzer in der Lage sein soll eigene Bilder oder auch andere Ressource einbinden zu können, dann musst du ihm die Möglichkeit dazu geben, wie auch immer diese aussehen mag, aber kein Benutzer wird an einer Jar rumbasteln, nicht müssen, nicht dürfen und auch nicht sollen. Das hat auch nicht nur mit Ressourcen zu tun, sondern stell dir mal vor er löscht da aus Versehen irgendwelche Dateien, z.B. Class-Dateien oder archiviert das Ganze dann falsch oder sonst was, dann geht die ganze Anwendung nicht mehr. Man ist wütend, enttäuscht, vielleicht depri, weil man es nicht richtig hinbekommt und flucht im Endeffekt nur, wie scheiße die Anwendung ist. Also das vergiss mal lieber 
Machs über einen Unterordner ^^ Dann kannst du auch wieder mit File-Objekten arbeiten, wie du es gewohnt bist und es ist dann egal, ob du es aus einer IDE startest oder es eine Jar-Datei ist.
gut, ich habs verstanden…
danke!