¿Cómo cambio los permisos de archivo mediante programación?

En Java, estoy creando dinámicamente un conjunto de archivos y me gustaría cambiar los permisos de archivo en estos archivos en un sistema de archivos linux / unix. Me gustaría poder ejecutar el equivalente en Java de chmod. ¿Es eso posible Java 5? ¿Si es así, cómo?

Sé que en Java 6 el Fileobjeto tiene setReadable()/ setWritable()métodos. También sé que podría hacer una llamada al sistema para hacer esto, pero me gustaría evitarlo si es posible.

El control total sobre los atributos del archivo está disponible en Java 7, como parte de la "nueva" función New IO ( NIO.2 ). Por ejemplo, los permisos POSIX se pueden establecer en un archivo existente con setPosixFilePermissions(), o de forma atómica en la creación del archivo con métodos como createFile()o newByteChannel().

Puede crear un conjunto de permisos utilizando EnumSet.of(), pero el método auxiliar PosixFilePermissions.fromString()utilizará un formato convencional que será más legible para muchos desarrolladores. Para las API que aceptan a FileAttribute, puede ajustar el conjunto de permisos con con PosixFilePermissions.asFileAttribute().

Set<PosixFilePermission> ownerWritable = PosixFilePermissions.fromString("rw-r--r--");
FileAttribute<?> permissions = PosixFilePermissions.asFileAttribute(ownerWritable);
Files.createFile(path, permissions);

En versiones anteriores de Java, el uso de su propio código nativo o las executilidades de línea de comandos -ing son enfoques comunes.

Además de las sugerencias de erickson, también existe jna , que le permite llamar a bibliotecas nativas sin usar jni. Es sorprendentemente fácil de usar y lo he usado en un par de proyectos con gran éxito.

La única advertencia es que es más lento que jni, por lo que si está haciendo esto con una gran cantidad de archivos, puede ser un problema para usted.

(Edición para agregar ejemplo)

Aquí hay un ejemplo completo de jna chmod:

import com.sun.jna.Library;
import com.sun.jna.Native;

public class Main {
    private static CLibrary libc = (CLibrary) Native.loadLibrary("c", CLibrary.class);

    public static void main(String[] args) {
        libc.chmod("/path/to/file", 0755);
    }
}

interface CLibrary extends Library {
    public int chmod(String path, int mode);
}

Antes de Java 6, no se admite la actualización de permisos de archivos a nivel de Java. Debe implementar su propio método nativo o llamar Runtime.exec()para ejecutar un comando de nivel de sistema operativo como chmod .

A partir de Java 6, puede utilizar File.setReadable()/File.setWritable()/File.setExecutable()para establecer permisos de archivo. Pero no simula el sistema de archivos POSIX que permite establecer permisos para diferentes usuarios. File.setXXX () solo permite establecer permisos para el propietario y todos los demás.

A partir de Java 7, se introduce el permiso de archivo POSIX. Puede establecer permisos de archivo como lo ha hecho en los sistemas * nix. La sintaxis es:

File file = new File("file4.txt");
file.createNewFile();

Set<PosixFilePermission> perms = new HashSet<>();
perms.add(PosixFilePermission.OWNER_READ);
perms.add(PosixFilePermission.OWNER_WRITE);

Files.setPosixFilePermissions(file.toPath(), perms);

Este método solo se puede usar en el sistema de archivos POSIX, esto significa que no puede llamarlo en el sistema Windows.

Para obtener detalles sobre la administración de permisos de archivos, le recomendamos que lea esta publicación .

para windows 7 con nio 2.0:

public static void main(String[] args) throws IOException
{
    Path file = Paths.get("c:/touch.txt");
    AclFileAttributeView aclAttr = Files.getFileAttributeView(file, AclFileAttributeView.class);
    System.out.println(aclAttr.getOwner());
    for(AclEntry aclEntry : aclAttr.getAcl()){
        System.out.println(aclEntry);
    }
    System.out.println();

    UserPrincipalLookupService upls = file.getFileSystem().getUserPrincipalLookupService();
    UserPrincipal user = upls.lookupPrincipalByName(System.getProperty("user.name"));
    AclEntry.Builder builder = AclEntry.newBuilder();       
    builder.setPermissions( EnumSet.of(AclEntryPermission.READ_DATA, AclEntryPermission.EXECUTE, 
            AclEntryPermission.READ_ACL, AclEntryPermission.READ_ATTRIBUTES, AclEntryPermission.READ_NAMED_ATTRS,
            AclEntryPermission.WRITE_ACL, AclEntryPermission.DELETE
    ));
    builder.setPrincipal(user);
    builder.setType(AclEntryType.ALLOW);
    aclAttr.setAcl(Collections.singletonList(builder.build()));
}

Si desea establecer el permiso 777 para su archivo creado, puede usar el siguiente método:

public void setPermission(File file) throws IOException{
    Set<PosixFilePermission> perms = new HashSet<>();
    perms.add(PosixFilePermission.OWNER_READ);
    perms.add(PosixFilePermission.OWNER_WRITE);
    perms.add(PosixFilePermission.OWNER_EXECUTE);

    perms.add(PosixFilePermission.OTHERS_READ);
    perms.add(PosixFilePermission.OTHERS_WRITE);
    perms.add(PosixFilePermission.OTHERS_EXECUTE);

    perms.add(PosixFilePermission.GROUP_READ);
    perms.add(PosixFilePermission.GROUP_WRITE);
    perms.add(PosixFilePermission.GROUP_EXECUTE);

    Files.setPosixFilePermissions(file.toPath(), perms);
}

Solo para actualizar esta respuesta a menos que alguien se encuentre con esto más adelante, ya que JDK 6 puede usar

File file = new File('/directory/to/file');
file.setWritable(boolean);
file.setReadable(boolean);
file.setExecutable(boolean);

puede encontrar la documentación en Oracle File (Java Platform SE 7) . Tenga en cuenta que estos comandos solo funcionan si el usuario actual tiene la propiedad o acceso de escritura a ese archivo. Soy consciente de que OP quería acceso de tipo chmod para una configuración de usuario más compleja. estos establecerán la opción en todos los ámbitos para todos los usuarios.

Puede utilizar los métodos de la clase File: http://docs.oracle.com/javase/7/docs/api/java/io/File.html

para Oralce Java 6:

private static int chmod(String filename, int mode) {
    try {
        Class<?> fspClass = Class.forName("java.util.prefs.FileSystemPreferences");
        Method chmodMethod = fspClass.getDeclaredMethod("chmod", String.class, Integer.TYPE);
        chmodMethod.setAccessible(true);
        return (Integer)chmodMethod.invoke(null, filename, mode);
    } catch (Throwable ex) {
        return -1;
    }
}

funciona bajo solaris / linux.

Apache ant chmod (no muy elegante, agregándolo para completar) crédito compartido con @msorsky

    Chmod chmod = new Chmod();
    chmod.setProject(new Project());
    FileSet mySet = new FileSet();
    mySet.setDir(new File("/my/path"));
    mySet.setIncludes("**");
    chmod.addFileset(mySet);
    chmod.setPerm("+w");
    chmod.setType(new FileDirBoth());
    chmod.execute();

simple java code  for change file permission in java  

   String path="D:\\file\\read.txt";
        File file=new File(path);
        if (file.exists()) {
            System.out.println("read="+file.canRead());
            System.out.println("write="+file.canWrite());
            System.out.println("Execute="+file.canExecute());
            file.setReadOnly();
        }     

Referencia: cómo cambiar el permiso del archivo en java

Hay una clase de ejemplo en Oracle Docs que funciona de manera muy similar al chmod de UNIX. Sin embargo, funciona con java se 7+.

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.attribute.FileAttribute;
import java.nio.file.attribute.PosixFileAttributes;
import java.nio.file.attribute.PosixFilePermission;
import java.nio.file.attribute.PosixFilePermissions;
import java.util.Set;

public class FileAndDirectory1 {
    public static void main(String[] args) {
        
        File file = new File("fileTest1.txt");
        System.out.println(file.getAbsoluteFile());
        try {
            //file.createNewFile();
            if(!file.exists())
            {
                //PosixFilePermission is an enum class, PosixFilePermissions is a final class
                
                //create file permissions from string
                Set<PosixFilePermission> filePermissions = PosixFilePermissions.fromString("---------"/* "rwxrwxrwx" */);
                FileAttribute<?> permissions = PosixFilePermissions.asFileAttribute(filePermissions);
                Files.createFile(file.toPath(), permissions);
                // printing the permissions associated with the file
                System.out.println("Executable: " + file.canExecute());
                System.out.println("Readable: " + file.canRead());
                System.out.println("Writable: "+ file.canWrite());

                file.setExecutable(true);
                file.setReadable(true);
                file.setWritable(true);
            }
            else
            {
                //modify permissions
                
                //get the permission using file attributes
                Set<PosixFilePermission> perms = Files.readAttributes(file.toPath(), PosixFileAttributes.class).permissions();
                perms.remove(PosixFilePermission.OWNER_WRITE);

                perms.add(PosixFilePermission.OWNER_READ);
                perms.add(PosixFilePermission.OWNER_EXECUTE);
                perms.add(PosixFilePermission.GROUP_WRITE);
                perms.add(PosixFilePermission.GROUP_READ);
                perms.add(PosixFilePermission.GROUP_EXECUTE);
                perms.add(PosixFilePermission.OTHERS_WRITE);
                perms.add(PosixFilePermission.OTHERS_READ);
                perms.add(PosixFilePermission.OTHERS_EXECUTE);
                Files.setPosixFilePermissions(file.toPath(), perms);

                System.out.println("Executable: " + file.canExecute());
                System.out.println("Readable: " + file.canRead());
                System.out.println("Writable: "+ file.canWrite());

                file.delete();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        Path path = Paths.get(String.valueOf(file));
        System.out.println(path);
    }
}