Come creare una cartella in eclissi per la memorizzazione di oggetti serializzati?

Question

Voglio serializzare alcuni oggetti nel mio codice Java. Non voglio metterlo in una cartella casuale sul disco rigido. Voglio che si trovi all'interno di A FOLDER nella mia cartella del progetto eclipse. Come posso creare questa cartella e archiviarmi i miei oggetti?

È una buona pratica? Ci sarà un problema se provo a creare un JAR autosufficiente da questo progetto?

Answer 1

Di seguito il codice sorgente mostra come creare sottocartella nella directory corrente:

import java.io.File; 

public class SourceCodeProgram { 

    public static void main(String argv[]) throws Exception { 
     File currentFolder = new File("."); 
     File workingFolder = new File(currentFolder, "serialized"); 
     if (!workingFolder.exists()) { 
      workingFolder.mkdir(); 
     } 
     System.out.println(workingFolder.getAbsolutePath()); 
    } 
} 

Quando si esegue questo codice sorgente e aggiorna progetto Eclipse si dovrebbe vedere serialized directory nella struttura del progetto Eclipse. Ora puoi usarlo e memorizzare tutti i file al suo interno.

Nella mia app, quando voglio memorizzare alcuni dati nel disco rigido, utilizzo sempre la raccomandazione dell'utente. Creo application.properties il file che contiene la chiave:

working.folder=/example/app-name 

App legge questo file alla partenza e crea questa cartella se ne ha bisogno. La seconda soluzione può essere "parametro app". Quando ho bisogno solo di uno o due parametri dagli utenti, lo leggo dalla riga di comando. Per esempio utente eseguire la mia applicazione usando il comando:

java -jar app.jar -dir /example/app-name 

Quando l'utente non fornisce alcuna cartella Io uso cartella predefinita - directory corrente.

link utili:

• How to get Current Directory through File.
• Getting the Current Working Directory in Java.
• List item.
• args4j.
• Reading Properties file in Java

Answer 2

Dipende dall'informazione di quegli oggetti serializzabili.

Inoltre, se si vuole avere una cartella all'interno del vostro codice di base (ma schierato come solo una cartella), è possibile scrivere codice, a scrivere o leggere i file:

URL dir_url = ClassLoader.getSystemResource(dir_path); 
// Turn the resource into a File object 
File dir = new File(dir_url.toURI()); 
// List the directory 
String files = dir.list() 

directory nota dovrebbe essere nel classpath.

Answer 3

Non è consigliabile scrivere nella directory degli utenti, ad es. in una sottocartella come .myApp/?

Si potrebbe fare qualcosa di simile per impostare/inizializzare la directory:

File userDir = new File(System.getProperty("user.home")); 
File storageDir = new File(userDir, ".myApp"); 
if (!storageDir.exists()) 
    storageDir.mkdir(); 
// store your file in storageDir 

Date un'occhiata here per scoprire dove si trova di solito userDir (se non hanno necessariamente bisogno di cure).

Answer 4

Passi:

1. del tasto destro la cartella del vostro progetto in Esplora pacchetto
2. Individuare la voce di menu "Nuovo" e librarsi si
3. Locate "Cartella" in aperto menu e fare clic su di esso
4. Assegna un nome alla cartella
5. Fare clic sul Pulsante "Fine" nella parte inferiore

Ciò creerà una cartella che dovrebbe essere accessibile dalla directory di lavoro durante l'esecuzione da all'interno di eclipse.

È una cattiva idea gingillare con i file che si trovano nel file JAR durante il runtime. Immagina uno scenario in cui ci sono due o più JVM che eseguono lo stesso JAR, questo significa anche che funzionano con gli stessi file e che la lettura/scrittura di quei file potrebbe causare collisioni. In genere si desidera separare questi file gli uni dagli altri.

Quindi, a meno che tali file sono di sola lettura, non si dovrebbe includerli nella tua JAR (altrimenti è bene)

Answer 5

È possibile ignorare Eclipse e creare la directory (ei file in essa contenuti) a livello di codice, o manualmente.

Quindi, aggiornare la vista Esplora progetti in Eclipse e voilà, la directory e i file fanno parte della vista.

Answer 6

Se si avvia il programma in Eclipse, per impostazione predefinita la directory di lavoro corrente del processo sarà la directory radice del progetto. Quindi è possibile inizializzare e utilizzare una directory chiamata serialized nella radice del proprio progetto come questo:

File serializedDir = new File("serialized"); 
if (!serializedDir.exists()) { 
    serializedDir.mkdir(); 
} 

percorsi relativi nel codice sarà relativo alla directory di lavoro, che è radice del progetto per impostazione predefinita. È possibile modificare la directory di lavoro predefinita nella configurazione del programma di avvio.

Dipende dal progetto se questa è una buona soluzione oppure no. Se non vuoi/devi condividere gli oggetti serializzati con gli altri, non vedo nulla di sbagliato in questo.

Quando si utilizza la funzione Esporta di Eclipse per creare un jar dal progetto, tenere presente che la cartella verrà selezionata per impostazione predefinita. Devi deselezionarlo esplicitamente per escluderlo dal barattolo. (In ogni caso, è meglio usare Maven o Ant per generare giare invece di Eclipse, che devi configurare una volta sola, quindi non preoccuparti che la directory venga inclusa accidentalmente.)

Probabilmente vorresti anche escludere la directory dal controllo di versione.

Answer 7

Per fare ciò sono necessari due elementi: A) Accesso/Creazione della cartella specifica B) Effettivamente serializzare gli oggetti e salvarli su disco.

Per A), questa è sicuramente la risposta delle altre risposte qui che mostrano come: 1) Verificare se la cartella esiste. 2) Crea la cartella se non esiste. Inoltre, i progetti avviati in eclissi hanno come directory di lavoro la cartella del progetto eclipse.

Per B) è necessario serializzare gli oggetti utilizzando FileOutputStream. Vedere http://www.tutorialspoint.com/java/java_serialization.htm. È possibile serializzare ciascun oggetto in un file separato oppure creare una classe con una ArrayList (o un'altra struttura di dati) che contiene riferimenti a tutti gli oggetti.

Sotto una classe di esempio che esegue esattamente ciò che è stato chiesto utilizzando i metodi statici in quanto non volevo istanziare un oggetto. Inoltre, è necessario premere F5 nel progetto Eclipse per aggiornare il pacchetto explorer e visualizzare la nuova cartella e i file.

Come la domanda riferita a progetti all'interno di eclipse, quanto sopra è per il codice all'interno di un progetto di eclissi. Se vuoi interagire con Eclipse, parliamo dello sviluppo di plugin di eclipse che è completamente un'altra storia, quindi devi specificarlo.

Infine, è anche possibile creare una classe personalizzata contenente tutte le variabili desiderate e creare un'istanza di un oggetto singleton per contenere tutti gli altri oggetti. Esistono tuttavia alcune limitazioni durante la serializzazione di oggetti, ad es. : - I riferimenti oggetto con modificatore statico non sono serializzabili.

vedere questo per alcune regole/consigli per qualche serializable: http://www.xyzws.com/Javafaq/what-are-rules-of-serialization-in-java/208