java - 如何获取正在运行的 JAR 文件的路径？

Question

我的代码在一个 JAR 文件中运行，比如foo.jar，我需要在代码中知道正在运行的foo.jar在哪个文件夹中。

因此，如果foo.jar在 中C:\FOO\，无论我当前的工作目录是什么，我都想获取该路径。

Answer 1

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

将“MyClass”替换为您的班级名称。

显然，如果您的类是从非文件位置加载的，这会做一些奇怪的事情。

Answer 2

对我来说最好的解决方案：

String path = Test.class.getProtectionDomain().getCodeSource().getLocation().getPath();
String decodedPath = URLDecoder.decode(path, "UTF-8");

这应该解决空格和特殊字符的问题。

Answer 3

要获得File给定的Class，有两个步骤：

1. 将 转换Class为URL
2. 将 转换URL为File

重要的是要了解这两个步骤，而不是将它们混为一谈。

一旦你有了File，你可以调用getParentFile来获取包含的文件夹，如果这是你需要的。

第 1 步：Class到URL

正如其他答案中所讨论的，有两种主要方法可以找到与 aURL相关的 a Class。

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

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

两者都有优点和缺点。

该getProtectionDomain方法产生类的基本位置（例如，包含 JAR 文件）。SecurityException但是，调用时可能会抛出 Java 运行时的安全策略getProtectionDomain()，因此如果您的应用程序需要在各种环境中运行，最好在所有环境中进行测试。

该getResource方法产生类的完整 URL 资源路径，您需要从中执行额外的字符串操作。它可能是一条file:路径，但也可能是jar:file:甚至更糟糕的东西，例如bundleresource://346.fwk2106232034:4/foo/Bar.class在 OSGi 框架中执行时。相反，该方法即使在 OSGi 中也能getProtectionDomain正确生成URL。file:

请注意，当类驻留在 JAR 文件中时，两者都失败了getResource("")；getResource(".")两个调用都返回 null。所以我推荐上面显示的#2 调用，因为它看起来更安全。

第 2 步：URL到File

无论哪种方式，一旦你有了URL，下一步就是转换为File。这是它自己的挑战；有关详细信息，请参阅Kohsuke Kawaguchi 的博客文章new File(url.toURI())，但简而言之，只要 URL 格式完全正确，您就可以使用。

最后，我强烈反对使用URLDecoder. URL 的某些字符，:尤其/是无效的 URL 编码字符。从URLDecoder Javadoc：

假设编码字符串中的所有字符都是以下之一：“a”到“z”，“A”到“Z”，“0”到“9”，以及“-”、“_”、“ 。“， 和 ”*”。允许使用字符“%”，但将其解释为特殊转义序列的开始。

...

该解码器有两种可能的方式来处理非法字符串。它可以单独留下非法字符，也可以抛出 IllegalArgumentException。解码器采用哪种方法留给实现。

在实践中，URLDecoder一般不会IllegalArgumentException像上面所威胁的那样抛出。如果您的文件路径中有空格编码为%20，则此方法可能会起作用。但是，如果您的文件路径包含其他非字母数字字符，例如+您将无法URLDecoder修改文件路径。

工作代码

要实现这些步骤，您可能有如下方法：

/**
 * 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);
}

您可以在SciJava 通用库中找到这些方法：

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

Answer 4

您还可以使用：

CodeSource codeSource = YourMainClass.class.getProtectionDomain().getCodeSource();
File jarFile = new File(codeSource.getLocation().toURI().getPath());
String jarDir = jarFile.getParentFile().getPath();

Answer 5

使用 ClassLoader.getResource() 查找当前类的 URL。

例如：

package foo;

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

（这个例子取自一个类似的问题。）

要找到该目录，您需要手动拆分 URL。有关 jar URL 的格式，请参阅JarClassLoader 教程。

Answer 6

我很惊讶地发现最近没有人提议使用Path. 引用如下：“该类Path包括各种方法，可用于获取有关路径的信息、访问路径的元素、将路径转换为其他形式或提取路径的一部分”

因此，一个很好的选择是将对象获取Path为：

Path path = Paths.get(Test.class.getProtectionDomain().getCodeSource().getLocation().toURI());

Answer 7

唯一适用于 Linux、Mac 和 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();
}

Answer 8

这是对其他评论的升级，在我看来，这些评论的细节并不完整

使用 .jar 文件外部的相对“文件夹”（在 jar 的同一位置）：

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"));

Answer 9

我有同样的问题，我是这样解决的：

File currentJavaJarFile = new File(Main.class.getProtectionDomain().getCodeSource().getLocation().getPath());   
String currentJavaJarFilePath = currentJavaJarFile.getAbsolutePath();
String currentRootDirectoryPath = currentJavaJarFilePath.replace(currentJavaJarFile.getName(), "");

我希望我对你有帮助。

Answer 10

如果你真的在寻找一种简单的方法来获取 JAR 所在的文件夹，你应该使用这个实现。像这样的解决方案很难找到，许多解决方案不再受支持，许多其他解决方案提供文件的路径而不是实际目录。这比您将要找到的其他解决方案更容易，并且适用于 java 版本 1.12。

new File(".").getCanonicalPath()

从其他答案中收集输入也是一个简单的方法：

String localPath=new File(getClass().getProtectionDomain().getCodeSource().getLocation().toURI()).getParentFile().getPath()+"\\"; 

两者都将返回具有以下格式的字符串：

"C:\Users\User\Desktop\Folder\"

在一个简单而简洁的行中。

Answer 11

为了获取运行jar文件的路径，我研究了上述解决方案并尝试了所有彼此存在一些差异的方法。如果这些代码在 Eclipse IDE 中运行，它们都应该能够找到包含指定类的文件的路径，并使用找到的路径打开或创建指定的文件。

但是比较棘手的是，直接或者通过命令行运行可运行的jar文件时，会失败，因为通过上述方法得到的jar文件的路径会在jar文件中给出一个内部路径，即它总是给出一个路径作为

rsrc:project-name（也许我应该说它是主类文件的包名——指示的类）

我无法将 rsrc:... 路径转换为外部路径，即在 Eclipse IDE 之外运行 jar 文件时无法获取 jar 文件的路径。

在 Eclipse IDE 之外获取运行 jar 文件路径的唯一可能方法是

System.getProperty("java.class.path")

这行代码可能会返回运行jar文件的生存路径（包括文件名）（注意返回路径不是工作目录），如java文档和有人说会返回所有class文件的路径在同一个目录中，但是当我的测试在同一个目录中包含许多jar文件时，它只返回运行jar的路径（关于多路径问题确实发生在Eclipse中）。

Answer 12

其他答案似乎指向不是目录的 Jar 文件位置的代码源。

采用

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

Answer 13

如果您通过从 Gnome 桌面环境（而不是任何脚本或终端）单击来运行 jar，则上面选择的答案不起作用。

相反，我喜欢以下解决方案无处不在：

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

Answer 14

在我终于找到一个可行的（和简短的）解决方案之前，我不得不搞砸了很多。
可能jarLocation带有前缀file:\或jar:file\，可以使用删除String#substring()。

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

Answer 15

实际上这是一个更好的版本 - 如果文件夹名称中有空格，旧版本会失败。

  private String getJarFolder() {
    // get name and path
    String name = getClass().getName().replace('.', '/');
    name = getClass().getResource("/" + name + ".class").toString();
    // remove junk
    name = name.substring(0, name.indexOf(".jar"));
    name = name.substring(name.lastIndexOf(':')-1, name.lastIndexOf('/')+1).replace('%', ' ');
    // remove escape characters
    String s = "";
    for (int k=0; k<name.length(); k++) {
      s += name.charAt(k);
      if (name.charAt(k) == ' ') k += 2;
    }
    // replace '/' with system separator char
    return s.replace('/', File.separatorChar);
  }

至于小程序失败，您通常无论如何都无法访问本地文件。我对 JWS 了解不多，但要处理本地文件可能无法下载该应用程序。？

Answer 16

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;}

在 Windows 上运行良好

Answer 17

我试图让jar运行路径使用

String folder = MyClassName.class.getProtectionDomain().getCodeSource().getLocation().getPath();

c:\app>java -jar application.jar

在 Windows 上的文件夹“ c:\app ”中运行名为“application.jar”的 jar 应用程序，字符串变量“folder”的值为“ \c:\app\application.jar ”，我在测试时遇到了问题路径的正确性

File test = new File(folder);
if(file.isDirectory() && file.canRead()) { //always false }

所以我试图将“测试”定义为：

String fold= new File(folder).getParentFile().getPath()
File test = new File(fold);

以正确的格式获取路径，例如“ c:\app ”而不是“ \c:\app\application.jar ”，我注意到它可以工作。

Answer 18

最简单的解决方案是在运行 jar 时将路径作为参数传递。

您可以使用 shell 脚本（Windows 中的 .bat，其他任何地方的 .sh）自动执行此操作：

java -jar my-jar.jar .

我曾经.传递当前工作目录。

更新

您可能希望将 jar 文件粘贴在子目录中，以免用户意外单击它。您的代码还应检查以确保已提供命令行参数，并在缺少参数时提供良好的错误消息。

Answer 19

String path = getClass().getResource("").getPath();

路径始终引用 jar 文件中的资源。

Answer 20

试试这个：

String path = new File("").getAbsolutePath();

Answer 21

这段代码帮助我确定程序是否在 JAR 文件或 IDE 中执行：

private static boolean isRunningOverJar() {
    try {
        String pathJar = Application.class.getResource(Application.class.getSimpleName() + ".class").getFile();

        if (pathJar.toLowerCase().contains(".jar")) {
            return true;
        } else {
            return false;
        }
    } catch (Exception e) {
        return false;
    }
}

如果我需要获取 JAR 文件的 Windows 完整路径，我正在使用这种方法：

    private static String getPathJar() {
        try {
            final URI jarUriPath =
                    Application.class.getResource(Application.class.getSimpleName() + ".class").toURI();
            String jarStringPath = jarUriPath.toString().replace("jar:", "");
            String jarCleanPath  = Paths.get(new URI(jarStringPath)).toString();

            if (jarCleanPath.toLowerCase().contains(".jar")) {
                return jarCleanPath.substring(0, jarCleanPath.lastIndexOf(".jar") + 4);
            } else {
                return null;
            }
        } catch (Exception e) {
            log.error("Error getting JAR path.", e);
            return null;
        }
    }

我的完整代码与使用CommandLineRunner实现的 Spring Boot 应用程序一起使用，以确保应用程序始终在控制台视图中执行（在 JAR 文件名中错误地双击），我正在使用下一个代码：

@SpringBootApplication
public class Application implements CommandLineRunner {
    public static void main(String[] args) throws IOException {
        Console console = System.console();

        if (console == null && !GraphicsEnvironment.isHeadless() && isRunningOverJar()) {
            Runtime.getRuntime().exec(new String[]{"cmd", "/c", "start", "cmd", "/k",
                    "java -jar \"" + getPathJar() + "\""});
        } else {
            SpringApplication.run(Application.class, args);
        }
    }

    @Override
    public void run(String... args) {
        /*
        Additional code here...
        */
    }

    private static boolean isRunningOverJar() {
        try {
            String pathJar = Application.class.getResource(Application.class.getSimpleName() + ".class").getFile();

            if (pathJar.toLowerCase().contains(".jar")) {
                return true;
            } else {
                return false;
            }
        } catch (Exception e) {
            return false;
        }
    }

    private static String getPathJar() {
        try {
            final URI jarUriPath =
                    Application.class.getResource(Application.class.getSimpleName() + ".class").toURI();
            String jarStringPath = jarUriPath.toString().replace("jar:", "");
            String jarCleanPath  = Paths.get(new URI(jarStringPath)).toString();

            if (jarCleanPath.toLowerCase().contains(".jar")) {
                return jarCleanPath.substring(0, jarCleanPath.lastIndexOf(".jar") + 4);
            } else {
                return null;
            }
        } catch (Exception e) {
            return null;
        }
    }
}

Answer 22

令人沮丧的是，当您在 Eclipse 中进行开发时，MyClass.class.getProtectionDomain().getCodeSource().getLocation()返回的/bin目录很好，但是当您将其编译为 jar 时，该路径包含了/myjarname.jar为您提供非法文件名的部分。

为了让代码在 ide 和编译成 jar 后都能工作，我使用以下代码：

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");
}

Answer 23

不太确定其他人，但在我的情况下，它不适用于“可运行的 jar”，我通过将 phchen2 答案和来自此链接的另一个代码一起修复代码来使其工作：如何获取正在运行的 JAR 文件的路径？ 编码：

               String path=new java.io.File(Server.class.getProtectionDomain()
                .getCodeSource()
                .getLocation()
                .getPath())
          .getAbsolutePath();
       path=path.substring(0, path.lastIndexOf("."));
       path=path+System.getProperty("java.class.path");

Answer 24

已经尝试了几种解决方案，但对于（可能是特殊的）可运行 jar 已在 Eclipse 中使用“打包外部库”导出的情况，都没有产生正确的结果。由于某种原因，在这种情况下，所有基于 ProtectionDomain 的解决方案都会导致 null。

通过结合上面的一些解决方案，我设法实现了以下工作代码：

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);

Answer 25

上述方法在我的 Spring 环境中对我不起作用，因为 Spring 将实际类隐藏到一个名为 BOOT-INF 的包中，因此不是运行文件的实际位置。我找到了另一种通过Permissions已授予运行文件的对象检索运行文件的方法：

public static Path getEnclosingDirectory() {
    return Paths.get(FileUtils.class.getProtectionDomain().getPermissions()
            .elements().nextElement().getName()).getParent();
}

Answer 26

对于jar文件路径：

String jarPath = File(MyClass.class.getProtectionDomain().getCodeSource().getLocation()
    .toURI()).getPath();

要获取该 jar 文件的目录路径：

String dirPath = new File(MyClass.class.getProtectionDomain().getCodeSource().getLocation()
                        .toURI()).getParent();

上面两行的结果是这样的：

/home/user/MyPrograms/myapp/myjar.jar（用于 jar 路径）

/home/user/MyPrograms/myapp（用于目录路径）

Answer 27

提到它只被签入，Windows但我认为它在其他操作系统上完美运行 [ Linux,MacOs,Solaris] :)。

---

我在同一个目录中有2 个文件。 .jar我想从一个.jar文件中启动.jar位于同一目录中的另一个文件。

问题是当你从cmd当前目录启动它时是system32.

---

警告！

• 以下似乎在我所做的所有测试中都运行良好，即使使用文件夹名称;][[;'57f2g34g87-8+9-09!2#@!$%^^&()或()%&$%^@# 运行良好。
• 我正在使用ProcessBuilder以下内容：

..

//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;
    }

Answer 28

这段代码对我有用：

private static String getJarPath() throws IOException, URISyntaxException {
    File f = new File(LicensingApp.class.getProtectionDomain().().getLocation().toURI());
    String jarPath = f.getCanonicalPath().toString();
    String jarDir = jarPath.substring( 0, jarPath.lastIndexOf( File.separator ));
    return jarDir;
  }

Answer 29

此方法从存档中的代码调用，返回 .jar 文件所在的文件夹。它应该在 Windows 或 Unix 中工作。

  private String getJarFolder() {
    String name = this.getClass().getName().replace('.', '/');
    String s = this.getClass().getResource("/" + name + ".class").toString();
    s = s.replace('/', File.separatorChar);
    s = s.substring(0, s.indexOf(".jar")+4);
    s = s.substring(s.lastIndexOf(':')-1);
    return s.substring(0, s.lastIndexOf(File.separatorChar)+1);
  } 

源自代码：确定是否从 JAR 运行

Answer 30

该getProtectionDomain方法有时可能不起作用，例如，当您必须为某些核心 Java 类（例如，在我StringBuilder的 IBM JDK 中的案例类中）找到 jar 时，但以下工作无缝：

public static void main(String[] args) {
    System.out.println(findSource(MyClass.class));
    // OR
    System.out.println(findSource(String.class));
}

public static String findSource(Class<?> clazz) {
    String resourceToSearch = '/' + clazz.getName().replace(".", "/") + ".class";
    java.net.URL location = clazz.getResource(resourceToSearch);
    String sourcePath = location.getPath();
    // Optional, Remove junk
    return sourcePath.replace("file:", "").replace("!" + resourceToSearch, "");
}

Answer 31

我有另一种方法来获取类的字符串位置。

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

输出字符串的形式为

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

空格和其他字符被处理，并且以不带 . 的形式处理file:/。所以会更容易使用。

Answer 32

对于一些愚蠢的简单事情，您只需要这一行：

对于 Windows 用户，将“pwd”更改为“cd”

runCommand("pwd");

只需将此方法放入类中：

public static String runCommand(String command) {
    StringBuilder sb = new StringBuilder();
    try {
        ProcessBuilder pb = new ProcessBuilder(command);
        final Process p = pb.start();
        BufferedReader br = new BufferedReader(new InputStreamReader(p.getInputStream()));
        String line;
        sb.append(br.read());
        while ((line= br.readLine()) != null) sb.append(line).append("\n");
    }
    catch (IOException e) {e.printStackTrace();}
    return sb.toString();
}

Answer 33

我使用 Java 7 编写，并在 Windows 7 中使用 Oracle 运行时进行测试，并在 Ubuntu 中使用开源运行时进行测试。这非常适合这些系统：

任何正在运行的 jar 文件的父目录的路径（假设调用此代码的类是 jar 归档本身的直接子目录）：

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

因此， foo.jar 的路径将是：

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

同样，这没有在任何 Mac 或旧版 Windows 上进行测试