Checking Write Permissions of a Directory in Java | Baeldung

1. Introduction

In Java, interacting with file systems for reading, writing, or other manipulation is a common task. Managing files and directories often involves checking their permissions.

In this tutorial, we’ll explore various approaches to check the write permissions of a directory in Java.

2. Test Setup

We’ll need two directories with read and write permission to test our logic. We can do this setup as part of the @BeforeEach lifecycle method in JUnit:

@BeforeEach
void create() throws IOException {
    Files.createDirectory(Paths.get(writeDirPath));
    Set<PosixFilePermission> permissions = new HashSet<>();
    permissions.add(PosixFilePermission.OWNER_WRITE);
    Files.setPosixFilePermissions(Paths.get(writeDirPath), permissions);

    Files.createDirectory(Paths.get(readDirPath));
    permissions = new HashSet<>();
    permissions.add(PosixFilePermission.OWNER_READ);
    Files.setPosixFilePermissions(Paths.get(readDirPath), permissions);
}

Similarly, for cleanup, we can delete these directories as part of the @AfterEach lifecycle method:

@AfterEach
void destroy() throws IOException {
    Files.delete(Paths.get(readDirPath));
    Files.delete(Paths.get(writeDirPath));
}

3. Using Java IO

Java IO is a core part of Java programming language that provides a framework for reading and writing data to various sources such as files, network connections, memory buffers, etc. To work with files, it includes the File class which provides out-of-the-box methods such as canRead(), canWrite(), and canExecute(). These methods are instrumental in checking permissions on files:

boolean usingJavaIO(String path){
    File dir = new File(path);
    return dir.exists() && dir.canWrite();
}

In the above logic we’re using canWrite() to check write permissions on the directory.

We can write a simple test to verify the result:

@Test
void givenDirectory_whenUsingJavaIO_thenReturnsPermission(){
    CheckWritePermission checkWritePermission = new CheckWritePermission();
    assertTrue(checkWritePermission.usingJavaIO(writeDirPath));
    assertFalse(checkWritePermission.usingJavaIO(readDirPath));
}

4. Using Java NIO

Java NIO (New I/O) is an alternative to the standard Java IO API that offers non-blocking IO operations. Java NIO is designed to improve the performance and scalability of IO operations in Java applications.

To check file permission using NIO, we can utilize the Files class from the java.nio.file package. The Files class provides various helper methods such as isReadable(), isWritable(), and isExecutable(), which are instrumental in checking permissions on files:

boolean usingJavaNIOWithFilesPackage(String path){
    Path dirPath = Paths.get(path);
    return Files.isDirectory(dirPath) && Files.isWritable(dirPath);
}

In the above logic, we’re using  isWritable() method to check write permission on the directory.

We can write a simple test to verify the results:

@Test
void givenDirectory_whenUsingJavaNIOWithFilesPackage_thenReturnsPermission(){
    CheckWritePermission checkWritePermission = new CheckWritePermission();
    assertTrue(checkWritePermission.usingJavaNIOWithFilesPackage(writeDirPath));
    assertFalse(checkWritePermission.usingJavaNIOWithFilesPackage(readDirPath));
}

4.1. POSIX Permission

POSIX file permissions,  a common permission system in Unix and Unix-like operating systems are based on three types of access for three types of users: owner, group, and others. The Files class provides the getPosixFilePermissions() method that returns a Set of PosixFilePermission enum values representing the permissions:

boolean usingJavaNIOWithPOSIX(String path) throws IOException {
    Path dirPath = Paths.get(path);
    Set<PosixFilePermission> permissions = Files.getPosixFilePermissions(dirPath);
    return permissions.contains(PosixFilePermission.OWNER_WRITE);
}

In the above logic, we’re returning the POSIX permissions on the directory and checking if the write permission is included.

We can write a simple test to verify the result:

@Test
void givenDirectory_whenUsingJavaNIOWithPOSIX_thenReturnsPermission() throws IOException {
    CheckWritePermission checkWritePermission = new CheckWritePermission();
    assertTrue(checkWritePermission.usingJavaNIOWithPOSIX(writeDirPath));
    assertFalse(checkWritePermission.usingJavaNIOWithPOSIX(readDirPath));
}

5. Conclusion

In this article, we explored three different approaches to checking the write permission of a directory in Java. While Java IO may provide simple methods to check permissions, Java NIO offers more flexibility in checking permissions and getting them in POSIX format.

As usual, the complete source code for the examples is available over on GitHub.