Comment obtenir le chemin d'accès d'un fichier JAR?

return new File(MyClass.class.getProtectionDomain().getCodeSource().getLocation()
    .toURI()).getPath();

Remplacer "MyClass" avec le nom de votre classe

Évidemment, cela va faire des choses bizarres si votre classe a été chargé à partir d'un non-emplacement du fichier.

OriginalL'auteur Zarkonnen

Pour obtenir le File pour un Class, il y a deux étapes:

1. Convertir le Class à un URL
2. Convertir le URL à un File

Il est important de comprendre à la fois des mesures, et non pas l'amalgame entre eux.

Une fois que vous avez la File, vous pouvez appeler getParentFile pour obtenir le dossier contenant, si c'est ce que vous avez besoin.

Étape 1: Class à URL

Tel que discuté dans d'autres réponses, il y a deux grandes façons de trouver un URL pertinents pour une Class.

1. URL url = Bar.class.getProtectionDomain().getCodeSource().getLocation();

2. URL url = Bar.class.getResource(Bar.class.getSimpleName() + ".class");

Les deux ont des avantages et des inconvénients.

La getProtectionDomain approche donne l'emplacement de la base de la classe (par exemple, le fichier JAR contenant). Toutefois, il est possible que le runtime Java de la politique de sécurité va lancer SecurityException lors de l'appel de getProtectionDomain(), donc, si votre application a besoin pour fonctionner dans une variété d'environnements, il est préférable de le tester dans tous les d'entre eux.

La getResource approche donne l'URL complète chemin d'accès aux ressources de la classe, à partir de laquelle vous devrez effectuer supplémentaires de manipulation de chaîne. Il peut être un file: chemin, mais il pourrait aussi être jar:file: ou même quelque chose de plus méchant comme bundleresource://346.fwk2106232034:4/foo/Bar.class lors de l'exécution à l'intérieur d'un framework OSGi. À l'inverse, la getProtectionDomain approche correctement donne un file: URL, même de l'intérieur OSGi.

Noter que les deux getResource("") et getResource(".") échoué dans mes tests, lorsque la classe se trouvaient à l'intérieur d'un fichier JAR; les deux invocations retourné null. Je recommande donc le n ° 2 de l'invocation indiqué ci-dessus au lieu de cela, comme il semble plus sûr.

Étape 2: URL à File

De toute façon, une fois que vous avez un URL, la prochaine étape est de les convertir à un File. C'est son propre défi; voir Kohsuke nous Kawaguchi blog post à ce sujet pour plus de détails, mais en bref, vous pouvez utiliser new File(url.toURI()) tant que l'URL est complètement bien formé.

Enfin, j' décourage fortement à l'aide de URLDecoder. Certains caractères de l'URL, : et / en particulier, ne sont pas valides URL caractères encodés. À partir de la URLDecoder Javadoc:

Il est supposé que tous les caractères de la chaîne codée est l'un des suivants: "a" à "z", "A" à "Z", "0" à "9", et "-", "_", ".", et "*". Le caractère "%" est autorisée, mais est interprété comme le début d'une échappé à la séquence.

...

Il y a deux façons possibles de ce décodeur peut traiter illégale des chaînes de caractères. Il pourrait laisser des caractères illégaux seul, ou qu'il pourrait jeter une IllegalArgumentException. Qui approche le décodeur prend est laissé à la mise en œuvre.

Dans la pratique, URLDecoder généralement ne pas jeter IllegalArgumentException menacées ci-dessus. Et si votre chemin d'accès de fichier avec des espaces codés comme des %20, cette approche peut sembler fonctionner. Toutefois, si votre chemin d'accès du fichier à d'autres fins non alphameric des caractères tels que + vous avez des problèmes avec URLDecoder modificateur de votre chemin d'accès au fichier.

Code de travail

À la réalisation de ces étapes, vous pourriez avoir des méthodes comme suit:

/**
* Gets the base location of the given class.
* <p>
* If the class is directly on the file system (e.g.,
* "/path/to/my/package/MyClass.class") then it will return the base directory
* (e.g., "file:/path/to").
* </p>
* <p>
* If the class is within a JAR file (e.g.,
* "/path/to/my-jar.jar!/my/package/MyClass.class") then it will return the
* path to the JAR (e.g., "file:/path/to/my-jar.jar").
* </p>
*
* @param c The class whose location is desired.
* @see FileUtils#urlToFile(URL) to convert the result to a {@link File}.
*/
public static URL getLocation(final Class<?> c) {
if (c == null) return null; //could not load the class
//try the easy way first
try {
final URL codeSourceLocation =
c.getProtectionDomain().getCodeSource().getLocation();
if (codeSourceLocation != null) return codeSourceLocation;
}
catch (final SecurityException e) {
//NB: Cannot access protection domain.
}
catch (final NullPointerException e) {
//NB: Protection domain or code source is null.
}
//NB: The easy way failed, so we try the hard way. We ask for the class
//itself as a resource, then strip the class's path from the URL string,
//leaving the base path.
//get the class's raw resource path
final URL classResource = c.getResource(c.getSimpleName() + ".class");
if (classResource == null) return null; //cannot find class resource
final String url = classResource.toString();
final String suffix = c.getCanonicalName().replace('.', '/') + ".class";
if (!url.endsWith(suffix)) return null; //weird URL
//strip the class's path from the URL string
final String base = url.substring(0, url.length() - suffix.length());
String path = base;
//remove the "jar:" prefix and "!/" suffix, if present
if (path.startsWith("jar:")) path = path.substring(4, path.length() - 2);
try {
return new URL(path);
}
catch (final MalformedURLException e) {
e.printStackTrace();
return null;
}
} 
/**
* Converts the given {@link URL} to its corresponding {@link File}.
* <p>
* This method is similar to calling {@code new File(url.toURI())} except that
* it also handles "jar:file:" URLs, returning the path to the JAR file.
* </p>
* 
* @param url The URL to convert.
* @return A file path suitable for use with e.g. {@link FileInputStream}
* @throws IllegalArgumentException if the URL does not correspond to a file.
*/
public static File urlToFile(final URL url) {
return url == null ? null : urlToFile(url.toString());
}
/**
* Converts the given URL string to its corresponding {@link File}.
* 
* @param url The URL to convert.
* @return A file path suitable for use with e.g. {@link FileInputStream}
* @throws IllegalArgumentException if the URL does not correspond to a file.
*/
public static File urlToFile(final String url) {
String path = url;
if (path.startsWith("jar:")) {
//remove "jar:" prefix and "!/" suffix
final int index = path.indexOf("!/");
path = path.substring(4, index);
}
try {
if (PlatformUtils.isWindows() && path.matches("file:[A-Za-z]:.*")) {
path = "file:/" + path.substring(5);
}
return new File(new URL(path).toURI());
}
catch (final MalformedURLException e) {
//NB: URL is not completely well-formed.
}
catch (final URISyntaxException e) {
//NB: URL is not completely well-formed.
}
if (path.startsWith("file:")) {
//pass through the URL as-is, minus "file:" prefix
path = path.substring(5);
return new File(path);
}
throw new IllegalArgumentException("Invalid URL: " + url);
}

Vous pouvez trouver ces méthodes dans le SciJava Commune bibliothèque:

• org.scijava.util.ClassUtils
• org.scijava.util.FileUtils.

OriginalL'auteur ctrueden

Utilisation Du Chargeur De Classe.getResource() pour trouver l'URL de votre classe actuelle.

Par exemple:

package foo;
public class Test
{
public static void main(String[] args)
{
ClassLoader loader = Test.class.getClassLoader();
System.out.println(loader.getResource("foo/Test.class"));
}
}

(Cet exemple pris de une question similaire.)

Pour trouver le répertoire, vous pouvez avoir besoin de prendre part à l'URL manuellement. Voir la JarClassLoader tutoriel pour le format d'un pot de l'URL.

OriginalL'auteur Jon Skeet

La seule solution qui fonctionne pour moi sur Linux, Mac et Windows:

public static String getJarContainingFolder(Class aclass) throws Exception {
CodeSource codeSource = aclass.getProtectionDomain().getCodeSource();
File jarFile;
if (codeSource.getLocation() != null) {
jarFile = new File(codeSource.getLocation().toURI());
}
else {
String path = aclass.getResource(aclass.getSimpleName() + ".class").getPath();
String jarFilePath = path.substring(path.indexOf(":") + 1, path.indexOf("!"));
jarFilePath = URLDecoder.decode(jarFilePath, "UTF-8");
jarFile = new File(jarFilePath);
}
return jarFile.getParentFile().getAbsolutePath();
}

OriginalL'auteur Dmitry Trofimov

Ici de la mise à niveau à d'autres commentaires, qui me semblent incomplètes pour les spécificités de

à l'aide d'un membre de la famille "dossier" à l'extérieur .fichier jar (dans le pot de la même
l'emplacement):

String path = 
YourMainClassName.class.getProtectionDomain().
getCodeSource().getLocation().getPath();
path = 
URLDecoder.decode(
path, 
"UTF-8");
BufferedImage img = 
ImageIO.read(
new File((
new File(path).getParentFile().getPath()) +  
File.separator + 
"folder" + 
File.separator + 
"yourfile.jpg"));

OriginalL'auteur Zon

la réponse sélectionnée ci-dessus ne fonctionne pas si vous exécutez votre bocal par cliquez sur à partir de l'environnement de bureau Gnome (pas de n'importe quel script ou terminal).

Au lieu de cela, j'ai de bons que la solution suivante est de travailler partout:

    try {
return URLDecoder.decode(ClassLoader.getSystemClassLoader().getResource(".").getPath(), "UTF-8");
} catch (UnsupportedEncodingException e) {
return "";
}

OriginalL'auteur lviggiani

La solution la plus simple est de passer le chemin d'accès comme argument lors de l'exécution de la jarre.

Vous pouvez automatiser cela avec un script shell (.chauve-souris dans Windows, .sh n'importe où ailleurs):

java -jar my-jar.jar .

J'ai utilisé . pour passer le répertoire de travail courant.

Mise à JOUR

Vous pouvez coller le fichier jar dans un sous-répertoire de sorte que les utilisateurs ne l'avez pas accidentellement sur elle. Votre code doit également vérifier que les arguments de ligne de commande ont été fournis, et de fournir un bon message d'erreur si les arguments sont manquantes.

OriginalL'auteur Max Heiber

J'ai dû le désordre autour d'un lot avant, j'ai enfin trouvé un travail (et court) solution.

Il est possible que le jarLocation est livré avec un préfixe comme file:\ ou jar:file\, qui peuvent être supprimés en utilisant String#substring().

URL jarLocationUrl = MyClass.class.getProtectionDomain().getCodeSource().getLocation();
String jarLocation = new File(jarLocationUrl.toString()).getParent();

OriginalL'auteur Jelle

public static String dir() throws URISyntaxException
{
URI path=Main.class.getProtectionDomain().getCodeSource().getLocation().toURI();
String name= Main.class.getPackage().getName()+".jar";
String path2 = path.getRawPath();
path2=path2.substring(1);
if (path2.contains(".jar"))
{
path2=path2.replace(name, "");
}
return path2;}

Fonctionne bien sur Windows

OriginalL'auteur Denton

Quelque chose qui est frustrant, c'est que lorsque vous êtes en développement dans Eclipse MyClass.class.getProtectionDomain().getCodeSource().getLocation() renvoie la /bin répertoire qui est très bien, mais quand vous compilez pour un bocal, le chemin d'accès inclut la /myjarname.jar partie qui vous donne illégale des noms de fichier.

Pour avoir le code du travail à la fois dans l'ide et une fois qu'il est compilé pour un pot, j'utilise le bout de code suivant:

URL applicationRootPathURL = getClass().getProtectionDomain().getCodeSource().getLocation();
File applicationRootPath = new File(applicationRootPathURL.getPath());
File myFile;
if(applicationRootPath.isDirectory()){
myFile = new File(applicationRootPath, "filename");
}
else{
myFile = new File(applicationRootPath.getParentFile(), "filename");
}

OriginalL'auteur Alexander

Avoir essayé plusieurs solutions là-haut, mais aucun n'a abouti à des résultats corrects pour la (probablement spécial) que le runnable jar a été exporté avec "l'Emballage des bibliothèques externes" dans Eclipse. Pour une raison que toutes les solutions basées sur la ProtectionDomain faire suite à null dans ce cas.

À partir de la combinaison de certaines des solutions ci-dessus, j'ai réussi à atteindre les objectifs suivants code de travail:

String surroundingJar = null;
//gets the path to the jar file if it exists; or the "bin" directory if calling from Eclipse
String jarDir = new File(ClassLoader.getSystemClassLoader().getResource(".").getPath()).getAbsolutePath();
//gets the "bin" directory if calling from eclipse or the name of the .jar file alone (without its path)
String jarFileFromSys = System.getProperty("java.class.path").split(";")[0];
//If both are equal that means it is running from an IDE like Eclipse
if (jarFileFromSys.equals(jarDir))
{
System.out.println("RUNNING FROM IDE!");
//The path to the jar is the "bin" directory in that case because there is no actual .jar file.
surroundingJar = jarDir;
}
else
{
//Combining the path and the name of the .jar file to achieve the final result
surroundingJar = jarDir + jarFileFromSys.substring(1);
}
System.out.println("JAR File: " + surroundingJar);

OriginalL'auteur DragonGamer

Mentionner qu'elle n'est vérifiée que dans Windows mais je pense qu'il fonctionne parfaitement sur d'autres Systèmes d'Exploitation [Linux,MacOs,Solaris] :).

---

J'avais 2 .jar fichiers dans le même répertoire . Je voulais partir d'une .jar fichier pour démarrer l'autre .jar fichier qui est dans le même répertoire.

Le problème est que lorsque vous le démarrez à partir de la cmd le répertoire courant est system32.

---

Avertissements!

• Ci-dessous semble fonctionner assez bien dans tous les test que j'ai fait, même
  avec le nom du dossier ;][[;'57f2g34g87-8+9-09!2#@!$%^^&() ou ()%&$%^@#
  il fonctionne bien.
• Je suis en utilisant le ProcessBuilder avec le ci-dessous comme suit:

..

//The class from which i called this was the class `Main`
String path = getBasePathForClass(Main.class);
String applicationPath=  new File(path + "application.jar").getAbsolutePath();
System.out.println("Directory Path is : "+applicationPath);
//Your know try catch here
//Mention that sometimes it doesn't work for example with folder `;][[;'57f2g34g87-8+9-09!2#@!$%^^&()` 
ProcessBuilder builder = new ProcessBuilder("java", "-jar", applicationPath);
builder.redirectErrorStream(true);
Process process = builder.start();
//...code

---

getBasePathForClass(Class<?> classs):

    /**
* Returns the absolute path of the current directory in which the given
* class
* file is.
* 
* @param classs
* @return The absolute path of the current directory in which the class
*         file is.
* @author GOXR3PLUS[StackOverFlow user] + bachden [StackOverFlow user]
*/
public static final String getBasePathForClass(Class<?> classs) {
//Local variables
File file;
String basePath = "";
boolean failed = false;
//Let's give a first try
try {
file = new File(classs.getProtectionDomain().getCodeSource().getLocation().toURI().getPath());
if (file.isFile() || file.getPath().endsWith(".jar") || file.getPath().endsWith(".zip")) {
basePath = file.getParent();
} else {
basePath = file.getPath();
}
} catch (URISyntaxException ex) {
failed = true;
Logger.getLogger(classs.getName()).log(Level.WARNING,
"Cannot firgue out base path for class with way (1): ", ex);
}
//The above failed?
if (failed) {
try {
file = new File(classs.getClassLoader().getResource("").toURI().getPath());
basePath = file.getAbsolutePath();
//the below is for testing purposes...
//starts with File.separator?
//String l = local.replaceFirst("[" + File.separator +
//"/\\\\]", "")
} catch (URISyntaxException ex) {
Logger.getLogger(classs.getName()).log(Level.WARNING,
"Cannot firgue out base path for class with way (2): ", ex);
}
}
//fix to run inside eclipse
if (basePath.endsWith(File.separator + "lib") || basePath.endsWith(File.separator + "bin")
|| basePath.endsWith("bin" + File.separator) || basePath.endsWith("lib" + File.separator)) {
basePath = basePath.substring(0, basePath.length() - 4);
}
//fix to run inside netbeans
if (basePath.endsWith(File.separator + "build" + File.separator + "classes")) {
basePath = basePath.substring(0, basePath.length() - 14);
}
//end fix
if (!basePath.endsWith(File.separator)) {
basePath = basePath + File.separator;
}
return basePath;
}

OriginalL'auteur GOXR3PLUS

J'écris en Java 7, et testez-le dans Windows 7 avec l'Oracle de l'exécution, et Ubuntu avec l'open source de l'exécution. Cela fonctionne parfaitement pour les systèmes:

Le chemin d'accès pour le répertoire parent de l'exécution d'un fichier jar (en supposant que la classe de l'appel de ce code est un enfant direct de l'jar archive elle-même):

try {
fooDir = new File(this.getClass().getClassLoader().getResource("").toURI());
} catch (URISyntaxException e) {
//may be sloppy, but don't really need anything here
}
fooDirPath = fooDir.toString(); //converts abstract (absolute) path to a String

Donc, le chemin de foo.jar serait:

fooPath = fooDirPath + File.separator + "foo.jar";

Encore une fois, ce n'était pas testé sur un Mac ou un Windows plus ancien

OriginalL'auteur sudoBen

J'ai une autre façon d'obtenir de la Chaîne à l'emplacement d'une classe.

URL path = Thread.currentThread().getContextClassLoader().getResource("");
Path p = Paths.get(path.toURI());
String location = p.toString();

La Chaîne de sortie sera de la forme de

C:\Users\Administrator\new Workspace\...

Les espaces et autres caractères sont traités, et dans la forme, sans file:/. Ce sera plus facile à utiliser.

OriginalL'auteur NoSegfault