Cambiare la directory di lavoro corrente in Java?

Come posso cambiare l'attuale directory di lavoro da un programma Java? Tutto ciò che sono stato in grado di trovare sul problema afferma che semplicemente non puoi farlo, ma non posso credere che sia davvero così.

Ho un pezzo di codice che apre un file usando un percorso di file relativo codificato dalla directory in cui è normalmente avviato, e voglio solo essere in grado di usare quel codice da un altro programma Java senza doverlo avviare dall'interno una directory particolare. Sembra che dovresti essere in grado di chiamare System.setProperty( "user.dir", "/path/to/dir" ), ma per quanto posso capire, chiamare quella linea fallisce silenziosamente e non fa nulla.

Vorrei capire se Java non ti ha permesso di fare questo, se non fosse per il fatto che ti consente di ottenere la directory di lavoro corrente e ti consente anche di aprire i file usando i percorsi dei file relativi ....

Non esiste un modo affidabile per farlo in Java puro. L'impostazione della user.dirproprietà tramite System.setProperty()o java -Duser.dir=...sembra influire sulle creazioni successive di Files, ma non ad es FileOutputStreams.

Il File(String parent, String child)costruttore può essere utile se si crea il percorso della directory separatamente dal percorso del file, consentendo uno scambio più semplice.

Un'alternativa è configurare uno script per eseguire Java da una directory diversa o utilizzare il codice nativo JNI come suggerito di seguito .

Il relativo bug Sun è stato chiuso nel 2008 come "non risolverà".

Se esegui il tuo programma legacy con ProcessBuilder , sarai in grado di specificare la sua directory di lavoro .

V'è un modo per farlo utilizzando la proprietà di sistema "user.dir". La parte fondamentale da capire è che getAbsoluteFile () deve essere chiamato (come mostrato di seguito) altrimenti i percorsi relativi verranno risolti rispetto al valore "user.dir" predefinito .

import java.io.*;

public class FileUtils
{
    public static boolean setCurrentDirectory(String directory_name)
    {
        boolean result = false;  // Boolean indicating whether directory was set
        File    directory;       // Desired current working directory

        directory = new File(directory_name).getAbsoluteFile();
        if (directory.exists() || directory.mkdirs())
        {
            result = (System.setProperty("user.dir", directory.getAbsolutePath()) != null);
        }

        return result;
    }

    public static PrintWriter openOutputFile(String file_name)
    {
        PrintWriter output = null;  // File to open for writing

        try
        {
            output = new PrintWriter(new File(file_name).getAbsoluteFile());
        }
        catch (Exception exception) {}

        return output;
    }

    public static void main(String[] args) throws Exception
    {
        FileUtils.openOutputFile("DefaultDirectoryFile.txt");
        FileUtils.setCurrentDirectory("NewCurrentDirectory");
        FileUtils.openOutputFile("CurrentDirectoryFile.txt");
    }
}

È possibile modificare il PWD, usando JNA / JNI per effettuare chiamate a libc. I ragazzi di JRuby hanno una comoda libreria java per effettuare chiamate POSIX chiamate jna-posix Ecco le informazioni di Maven

Puoi vedere un esempio del suo utilizzo qui (codice Clojure, scusa). Guarda la funzione chdirToRoot

Come accennato, non è possibile modificare il CWD della JVM ma se si dovesse avviare un altro processo utilizzando Runtime.exec () è possibile utilizzare il metodo sovraccarico che consente di specificare la directory di lavoro. Questo non è proprio per l'esecuzione del programma Java in un'altra directory, ma per molti casi quando è necessario avviare un altro programma come uno script Perl, ad esempio, è possibile specificare la directory di lavoro di quello script lasciando invariata la directory di lavoro della JVM.

Vedi Runtime.exec javadocs

In particolare,

public Process exec(String[] cmdarray,String[] envp, File dir) throws IOException

dove si dirtrova la directory di lavoro in cui eseguire il sottoprocesso

Se ho capito bene, un programma Java inizia con una copia delle variabili di ambiente correnti. Eventuali modifiche tramite System.setProperty(String, String)stanno modificando la copia, non le variabili di ambiente originali. Non che ciò fornisca una ragione completa per cui Sun abbia scelto questo comportamento, ma forse fa luce un po '...

La directory di lavoro è una funzionalità del sistema operativo (impostata all'avvio del processo). Perché non passi semplicemente la tua proprietà di sistema ( -Dsomeprop=/my/path) e la usi nel tuo codice come genitore del tuo file:

File f = new File ( System.getProperty("someprop"), myFilename)

La cosa più intelligente / più facile da fare qui è semplicemente cambiare il codice in modo che invece di aprire il file supponendo che esista nella directory di lavoro corrente (suppongo che stai facendo qualcosa di simile new File("blah.txt"), costruisci tu stesso il percorso del file.

Consenti all'utente di passare nella directory di base, di leggerlo da un file di configurazione, di tornare indietro user.dirse non è possibile trovare le altre proprietà, ecc. Ma è molto più semplice migliorare la logica del tuo programma piuttosto che cambiare come le variabili d'ambiente funzionano.

Ho provato a invocare

String oldDir = System.setProperty("user.dir", currdir.getAbsolutePath());

Sembra funzionare Ma

File myFile = new File("localpath.ext"); InputStream openit = new FileInputStream(myFile);

genera un FileNotFoundExceptionpensiero

myFile.getAbsolutePath()

mostra il percorso corretto. Ho letto questo . Penso che il problema sia:

• Java conosce la directory corrente con la nuova impostazione.
• Ma la gestione dei file viene eseguita dal sistema operativo. Purtroppo non conosce la nuova directory corrente impostata.

La soluzione può essere:

File myFile = new File(System.getPropety("user.dir"), "localpath.ext");

Crea un oggetto file come assoluto con la directory corrente conosciuta dalla JVM. Ma quel codice dovrebbe esistere in una classe usata, ha bisogno di cambiare i codici riutilizzati.

~~~~ JcHartmut

Puoi usare

nuovo file ("relative / path"). getAbsoluteFile ()

dopo

System.setProperty ("user.dir", "/ some / directory")

System.setProperty("user.dir", "C:/OtherProject");
File file = new File("data/data.csv").getAbsoluteFile();
System.out.println(file.getPath());

Stamperà

C:\OtherProject\data\data.csv

L'altra possibile risposta a questa domanda potrebbe dipendere dal motivo per cui si sta aprendo il file. Si tratta di un file delle proprietà o di un file con una configurazione relativa all'applicazione?

In tal caso, potresti provare a caricare il file tramite il caricatore del percorso di classe, in questo modo puoi caricare qualsiasi file a cui Java abbia accesso.

Se esegui i tuoi comandi in una shell puoi scrivere qualcosa come "java -cp" e aggiungere tutte le directory che desideri siano separate da ":" se java non trova qualcosa in una directory, proverà a trovarle nelle altre directory, che è quello che faccio.

È possibile modificare la directory di lavoro effettiva del processo utilizzando JNI o ​​JNA.

Con JNI, è possibile utilizzare le funzioni native per impostare la directory. Il metodo POSIX è chdir(). Su Windows, puoi usare SetCurrentDirectory().

Con JNA, puoi racchiudere le funzioni native nei raccoglitori Java.

Per Windows:

private static interface MyKernel32 extends Library {
    public MyKernel32 INSTANCE = (MyKernel32) Native.loadLibrary("Kernel32", MyKernel32.class);

    /** BOOL SetCurrentDirectory( LPCTSTR lpPathName ); */
    int SetCurrentDirectoryW(char[] pathName);
}

Per i sistemi POSIX:

private interface MyCLibrary extends Library {
    MyCLibrary INSTANCE = (MyCLibrary) Native.loadLibrary("c", MyCLibrary.class);

    /** int chdir(const char *path); */
    int chdir( String path );
}

Usa FileSystemView

private FileSystemView fileSystemView;
fileSystemView = FileSystemView.getFileSystemView();
currentDirectory = new File(".");
//listing currentDirectory
File[] filesAndDirs = fileSystemView.getFiles(currentDirectory, false);
fileList = new ArrayList<File>();
dirList = new ArrayList<File>();
for (File file : filesAndDirs) {
if (file.isDirectory())
    dirList.add(file);
else
    fileList.add(file);
}
Collections.sort(dirList);
if (!fileSystemView.isFileSystemRoot(currentDirectory))
    dirList.add(0, new File(".."));
Collections.sort(fileList);
//change
currentDirectory = fileSystemView.getParentDirectory(currentDirectory);