如何获取正在运行的JAR文件的路径?

使用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教程。

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

将“MyClass”替换为类名。

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

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

路径总是引用jar文件中的资源。

这个方法从存档中的代码中调用，返回.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运行派生

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

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

至于applet失败的原因，您通常无法访问本地文件。我不太了解JWS，但要处理本地文件，可能无法下载该应用程序。

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

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

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

你还可以使用:

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

如果你从Gnome桌面环境(不是任何脚本或终端)点击运行jar，上面所选的答案是不工作的。

相反，我认为下面的解决方案在任何地方都适用:

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

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

使用。jar文件外的相对“文件夹”(在jar的相同 位置):< / p >

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

对于给定的Class，要获得File，有两个步骤:

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

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

有了File之后，如果需要的话，可以调用getParentFile来获取包含它的文件夹。

步骤1:Class到URL

正如在其他答案中讨论的那样，有两种主要方法可以找到与Class相关的URL。

1. # EYZ0

2. # EYZ0

两者都有利弊。

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

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

注意，当类驻留在JAR文件中时，getResource("")和getResource(".")在我的测试中都失败了;两次调用都返回null。因此，我推荐使用上面所示的#2调用，因为它似乎更安全。

第二步:URL到File

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

最后，我将高度抑制使用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 . cn
• # EYZ0。

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上运行良好

我也遇到过同样的问题，我是这样解决的:

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

希望我能对你有所帮助。

对我来说，在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();
}

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

因此，一个很好的替代方法是获得Path对象为:

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

我试图让罐子运行路径使用

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

C:\app>java -jar application.jar

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

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

所以我试着将“test”定义为:

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

以正确的格式获取路径，如“c: \应用”而不是“\ c: \ app \ application.jar”，我注意到它是有效的。

我用Java 7编写，用Oracle的运行时在Windows 7上测试，用开源运行时在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上进行测试

getProtectionDomain方法有时可能不起作用，例如，当你必须为一些核心java类找到jar时(例如，在我的案例中，IBM JDK中的StringBuilder类)，但是下面的工作无缝对接:

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

我有另一种方法来获取类的String位置。

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

输出字符串的形式为

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

空格和其他字符被处理，并且在没有file:/的表单中。这样会更容易使用。

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

你可以用一个shell脚本(Windows中的.bat，其他任何地方的.sh)自动化这个:

java -jar my-jar.jar .

我使用.来传递当前工作目录。

更新

您可能希望将jar文件放在子目录中，这样用户就不会意外地单击它。您的代码还应该检查以确保提供了命令行参数，如果缺少参数，则提供良好的错误消息。

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

但这很棘手，当直接或通过命令行运行可运行的jar文件时，它将失败，因为从上述方法获得的jar文件的路径将在jar文件中给出一个内部路径，也就是说它总是给出一个路径

rsrc:project-name(也许我应该说它是主类文件的包名-指定的类)

我不能转换rsrc:…路径到外部路径，即当在Eclipse IDE外部运行jar文件时，无法获得jar文件的路径。

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

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

这段代码行可能返回的生活路径(包括文件名)运行jar文件(注意,返回路径不是工作目录),作为java文档,有些人说,它将返回所有类文件在同一个目录的路径,但随着我的测试中,如果在相同的目录中包括许多jar文件,它只返回运行jar的路径(约多条路径问题确实发生在Eclipse)。

令人沮丧的是，当您在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");
}

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

使用

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

不太确定其他人，但在我的情况下，它不与“可运行的罐子”，我得到了它的工作通过修复代码一起从phchen2答案和另一个从这个链接:如何获得一个运行的jar文件的路径? 代码:< / p >

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

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

提到它只在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

🍂# EYZ0:

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

这段代码对我很有用:

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

我已经尝试了上面的几种解决方案，但是对于在Eclipse中使用“打包外部库”导出可运行jar的情况(可能是特殊情况)，没有一个产生正确的结果。出于某种原因，所有基于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);

试试这个:

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

这段代码用于识别程序是否在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;
}
}
}

new File(".").getCanonicalPath()

从其他答案中收集输入，这也是一个简单的答案:

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

两者都会返回如下格式的String:

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

用简洁明了的线条。

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

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

对于一些愚蠢的简单的东西，你只需要这一行:

对于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();
}

对于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(用于目录路径)