Java get application path

How to get the current directory path of a JAR in Java

It’s a common task in applications to require to interact with files located in a relative path from where the application is executed. In the case of Java there isn’t a specific API to get that value, however there are a lot of ways to get the value easily. Let’s see them.

System.Property

When we execute a Java application, it has a lot properties populated by default by the JVM, one of them is the “ user.dir ” property, and its value contains the “user working directory“, which in most of the cases will have the directory of the jar executable.

String userDirectory = System.getProperty("user.dir");

File and NIO Files API

Another approach is using the Files API to get the current directory, using the relative path «.» or an empty relative path, it should return the current location of the executable.

//Using the Old File api String userDirectory2 = new File("").getAbsolutePath(); //Using Files NIO api String userDirectory3 = Paths.get("") .toAbsolutePath() .toString();

The relative “empty” or «.» path will use the user current working directory internally. Therefore, it will return the same value as the “user.dir” approach.

When the path value is not the expected JAR location

There are some situations where the values returned by the previous approaches doesn’t return the expected value where the JAR is located.

• On Linux, running the jar file by opening it from the File Explorer (eg, double click on the jar file). It will return the home directory of the user, regardless of the location where the jar is located.
• On Windows, in some old versions, running jar from command line with “Admin User permissions” might return “ C://windows/system32 “

This is because the user working directory indicated by the system might not be the jar location. For example, in Linux File explorer even though we have navigated through the folders and the path is different than the home directory, when the JAR is executed the “user.dir” property will contain the home directory. This will not happened when navigating through the command line, because the cd command will override the working directory of the user.

For that purpose we can use following snippet code:

File file = new File(MyClass.class.getProtectionDomain().getCodeSource() .getLocation().toURI().getPath()); String basePath = file.getParent();

The first line will return the location of the jar file. The second line will get the container directory of that file.

public class MyApp < static < //This static block runs at the very begin of the APP, even before the main method. try< File file = new File(MyApp.class.getProtectionDomain().getCodeSource() .getLocation().toURI().getPath()); String basePath = file.getParent(); //Overrides the existing value of "user.dir" System.getProperties().put("user.dir", basePath); >catch(Exception ex) < //log the error >> public static void main(String args []) < //Your app logic // Use any of the other approaches with the expected value String userDirectory = System.getProperty("user.dir"); String userDirectory2 = new File("").getAbsolutePath(); >>

With that static block of code at the very beginning of the application, we can get the real location of the JAR file and override the value of the system property “ user.dir “. So, we can use any of the other approaches in the application logic, and see the value is the expected regardless of the way the application was executed (command line, double click) or the environment (Windows, Linux, Mac).

References

Источник

Java: Get application path, in IDE and JAR file

How to get the application path in a Java application.

Let’s have look at different approaches, how to get the application path in a Java application. There are different approaches and which one is the right for you depends on your application scenario. In my case, I want to access some files in the application folder. This should work in the IDE and also for the JAR file.

My demo application looks like that:

new File(«.»).getCanonicalPath();

This is an often proposed solution for the problem. The solution usually works, however we are not getting the application path here, instead this returns the working folder.

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

If we run this in the IDE, we get the path to the root of the project, which is fine.

C:\_git\Learning.git\multimaven

The output from the JAR gives us also the path where the JAR file resides:

C:\_git\Learning.git\multimaven\Application\target

The solution breaks if we run our application from the different path:

C:\_git\Learning.git\multimaven\Application

As you can see, we call the JAR file from a folder below and this returns this folder. This behavior makes this function not very reliable for my use cases.

System.getProperty(«user.dir»)

This approach is also regularly mentioned, but there is no difference to the approach used before. It returns the working folder.

C:\_git\Learning.git\multimaven

new File(Main.class.getProtectionDomain() …

Another solution. This will get us the path to the current class directory, however this returns us different paths for running the in IDE and from the JAR file.

var path = new File(Main.class.getProtectionDomain().getCodeSource().getLocation().toURI()).getPath();

If we run the code in the IDE, we get the „classes“ folder returned, where the IDE puts the compiled versions of our classes.

C:\_git\Learning.git\multimaven\Application\target\classes

If we package our application in a JAR file, we get the folder and filename for the JAR file.

C:\_git\Learning.git\multimaven\Application\target\Application-1.0-SNAPSHOT-shaded.jar

ProgDirUtil.getProgramDirectory()

After some searching the internet, I found this post on StackOverflow.

The approach uses a utility class:

var path = ProgDirUtil.getProgramDirectory();

public class ProgDirUtil < private static String getJarName() < return new File(ProgDirUtil.class.getProtectionDomain().getCodeSource().getLocation().getPath()).getName(); >private static boolean runningFromJAR() < String jarName = getJarName(); return jarName.contains(".jar"); >public static String getProgramDirectory() < if (runningFromJAR()) < return getCurrentJARDirectory(); >else < return getCurrentProjectDirectory(); >> private static String getCurrentProjectDirectory() < return new File("").getAbsolutePath(); >private static String getCurrentJARDirectory() < try < return new File(ProgDirUtil.class.getProtectionDomain().getCodeSource().getLocation().toURI().getPath()).getParent(); >catch (URISyntaxException exception) < exception.printStackTrace(); >return null; > >

The class checks if our code is running from the JAR file or from class files, like in the IDE. This returns the same path for both our scenarios, and also returns the correct path if we run the JAR file from a different working directory.

C:\_git\Learning.git\multimaven

Conclusion

What solution is best really depends on your requirements, but in the end the utility class seems to offer the most reliable way to get the application path, as it works consistent in the development environment and also when running the JAR file.

Источник

How to get the real path of java application at runtime?

When developing a Java application, it is sometimes necessary to obtain the real path of the application at runtime. This can be useful for accessing resources that are stored within the application directory, such as configuration files or data files. However, getting the real path of the application can be challenging, especially when the application is running in a complex environment like a Java Enterprise Edition (JEE) server or a cloud-based environment. The real path of the application is not the same as the working directory, which can change depending on the environment in which the application is running. Therefore, it is important to use a robust and reliable method to get the real path of the application at runtime.

Method 1: Using System Properties

To get the real path of a Java application at runtime using System Properties, you can use the following code:

String path = System.getProperty("java.class.path"); String[] paths = path.split(System.getProperty("path.separator")); String currentDir = System.getProperty("user.dir"); for (String p : paths)  if (currentDir.endsWith(p))  String fullPath = currentDir + File.separator + "myFile.txt"; System.out.println("Full path: " + fullPath); break; > >

In this code, we first get the class path of the Java application using the System.getProperty() method. We then split the class path using the path separator, which is different depending on the operating system.

Next, we get the current directory using the System.getProperty() method again. We then loop through each path in the class path and check if the current directory ends with that path. If it does, we can then construct the full path to our file by appending the file name to the current directory and using the File.separator constant to separate the directory and file name.

Finally, we print out the full path to our file using the System.out.println() method.

This method can be useful when you need to access files or resources that are located relative to your Java application’s location on disk.

Method 2: Using ServletContext

To get the real path of a Java application at runtime, you can use the getRealPath() method of the ServletContext interface. This method returns a String containing the real path for a given virtual path.

Here’s an example code snippet that demonstrates how to use getRealPath() :

import javax.servlet.ServletContext; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; public class MyServlet extends HttpServlet  public void doGet(HttpServletRequest request, HttpServletResponse response)  ServletContext context = getServletContext(); String fullPath = context.getRealPath("/WEB-INF/myfile.txt"); // do something with the full path > >

In this example, we first obtain the ServletContext object by calling the getServletContext() method. We then call the getRealPath() method on this object, passing in the virtual path of the file we want to locate. The method returns the full path to the file on the server’s filesystem.

Note that the virtual path passed to getRealPath() is relative to the root of the web application. In this example, we’re looking for a file called myfile.txt located in the WEB-INF directory.

It’s worth noting that the getRealPath() method may return null if the virtual path does not correspond to a valid file on the server’s filesystem. Therefore, it’s important to check the return value before using it.

That’s it! By using getRealPath() with ServletContext , you can easily obtain the real path of a Java application at runtime.

Method 3: Using ClassLoader

To get the real path of a Java application at runtime using ClassLoader, you can follow these steps:

ClassLoader classLoader = getClass().getClassLoader();

URL resourceUrl = classLoader.getResource("");

String filePath = new File(resourceUrl.getPath()).getAbsolutePath();

Here is the complete Java code:

public class RealPathExample  public static void main(String[] args)  ClassLoader classLoader = RealPathExample.class.getClassLoader(); URL resourceUrl = classLoader.getResource(""); String filePath = new File(resourceUrl.getPath()).getAbsolutePath(); System.out.println("Real Path: " + filePath); > >

This code creates a ClassLoader object, gets the resource URL, and converts it to a file path. The file path is then printed to the console.

There are some important things to note about this code. First, the getResource(«») method is used to get the URL of the current directory. The empty string parameter is necessary to ensure that the URL points to the correct directory.

Second, the getPath() method of the URL object returns a URL-encoded string. This string must be converted to a file path using the File class.

Overall, this code is a simple and effective way to get the real path of a Java application at runtime using ClassLoader.

Method 4: Using FileSystems

To get the real path of a Java application at runtime using FileSystems, you can follow these steps:

1. First, get the path of the current working directory using the System.getProperty() method with the «user.dir» argument. This will give you the path of the directory where your application is running from.

String currentPath = System.getProperty("user.dir");

Path currentDir = Paths.get(currentPath);

FileSystem fileSystem = FileSystems.getDefault();

1. Finally, call the getPath() method on the file system object and pass in the currentDir object to get the real path of your Java application at runtime.

Path realPath = fileSystem.getPath(currentDir.toString());

Here’s the full code example:

String currentPath = System.getProperty("user.dir"); Path currentDir = Paths.get(currentPath); FileSystem fileSystem = FileSystems.getDefault(); Path realPath = fileSystem.getPath(currentDir.toString());

This code will give you the real path of your Java application at runtime using FileSystems.

Источник