Salvataggio dei dati del progetto. Come lo faresti?

Question

Sto sviluppando un programma GUI su larga scala, dove ho un sacco di dati di progetto che devono essere memorizzati su comando locally.

Attualmente, sto salvando tutte le strutture di dati a livello mondiale in una classe salvataggio (progetto), e poi la serializzazione in un file di disco fisso locale:

public void saveChanges() { 
    ArrayList<Student> studentList = new ArrayList<>(); 
    ArrayList<String> coursesList = new ArrayList<>(); 
    ArrayList<Requirement> reqList = new ArrayList<>(); 
    ArrayList<Risk> riskList = new ArrayList<>(); 
    for (int x = 0; x < dlm.getSize(); x++) { 
     studentList.add(dlm.elementAt(x)); 
    } 
    for (int x = 0; x < dlm2.getSize(); x++) { 
     coursesList.add(dlm2.elementAt(x)); 
    } 
    for (int x = 0; x < dlm3.getSize(); x++) { 
     reqList.add(dlm3.elementAt(x)); 
    } 
    for (int x = 0; x < riskTable.getRowCount(); x++) { 
     riskList.add((Risk) riskMap.get(dtm1.getValueAt(x, 0))); 
    } 

    project.setStudentAL(studentList); 
    project.setCoursesAL(coursesList); 
    project.setReqAL(reqList); 
    project.setRiskAL(riskList); 
    project.setLastUpdated(new Date().toString()); 

} 

ora sto serializzazione ad un file locale :

public void saveProject(boolean defaultPath, String path) { 
    saveChanges(); 
    FileOutputStream outFile; 
    try { 
     if (defaultPath) { 
      outFile = new FileOutputStream(directory + project.getProjectName() + ".proj"); 
     } else { 
      outFile = new FileOutputStream(path + ".proj"); 
     } 
     ObjectOutputStream outObject = new ObjectOutputStream(outFile); 
     outObject.writeObject(project); 
     outObject.close(); 
    } catch (IOException e) { 
     System.out.println("Failed to save project"); 
     e.printStackTrace(); 
    } 
} 

la mia domanda è questa: c'è un difetto; o un modo migliore per salvare i file sul tuo disco fisso locale? Non voglio usare XML o qualsiasi DB.

• Grazie in anticipo

Answer 1

Per le applicazioni a battente, mi piace molto utilizzando XML. Questo ha l'ulteriore vantaggio di rendere i dati salvati potenzialmente utili per altre applicazioni. JAXP fornisce i modi per scrivere e leggere dati XML all'interno del tuo programma: tutto ciò che devi fare è scrivere del codice per mantenere e ricreare lo stato che stai salvando.

Se si stanno scrivendo molti dati (sembra che tu sia), ti consiglio di utilizzare l'interfaccia SAX per leggerlo nella tua applicazione. Esiste un tutorial su come farlo here.

Un altro modo per archiviare i dati è utilizzare un database. Usare qualcosa come Apache Derby sarebbe un'opzione.

Answer 2

A mio parere, serialization è qualcosa che è molto difficile da utilizzare nel posto giusto.
A volte viene utilizzato come segnaposto, a causa dei bassi requisiti di manutenzione e della facilità di impostazione. Tuttavia miei punti contro l'uso serializzazione (automatica) come un proiettile d'argento (Non fraintendetemi, la serializzazione è divertente e ci sono molti casi in cui il suo uso è appropriato) sono questi:

• Velocità: Standard La serializzazione Java è lenta. Non necessariamente, ma se usato senza preparazione. Soluzione alternativa: utilizzare i metodi writeObject/readObject.

• Versioning: Certo, presta attenzione a non deserializzare roba che è troppo vecchio (serialVersionUID), ma non può aggiornamento la struttura interna. Se cambi il modo in cui fai le cose internamente, i tuoi vecchi salvataggi sono inutili.

• formato binario: Sei bloccato alla serializzazione Java standard ... Non è possibile (senza soluzioni) il cambiamento in un altro formato, né si può leggere da un'altra lingua ...

Un'alternativa:

Sembra che tu non voglia un database o xml (presumo che JSON sia un no-go). Quindi, ciò che rimane è progettare il proprio formato e scrivere i dati in formato binario. Questo ti dà la massima flessibilità (non dico che sia più facile dei formati di testo) e, se applicata correttamente, è molto più veloce della Serializzazione Java o xml.

I vantaggi tuttavia hanno un costo: non esiste un sistema prefabbricato (come dovrebbe esserci?) Che semplicemente fa it. Dovrete scrivere ancora un po 'di codice che con Java serializzazione e mi creda, (grande) file binari strutturati può essere fastidioso per eseguire il debug ...

Un esempio:

Immaginate di avere un oggetto chiamato Dati. Contiene una serie di galleggianti. In writeObject, si scrive la dimensione di quell'array e quindi si scrive ogni float nel flusso.
Su readObject, si legge la dimensione della matrice, si crea una matrice di tale dimensione e si riempie ogni elemento nell'array con i float di lettura.

Answer 3

Ho problemi a fare una raccomandazione reale perché non capisco abbastanza bene perché non prendere in considerazione XML o un database incorporato. Ma qui ci sono alcune cose a cui pensare.

• Versioning. Che cosa succede se è necessario aggiungere un campo a uno dei tuoi oggetti, ma hai già alcuni file salvati senza quel campo? A seconda della tecnica che usi per salvare lo stato, questo può essere un dolore enorme o un dolore moderato. Non penso che la serializzazione di oggetti java lo gestisca facilmente.

• Identità oggetto. Nel frammento di codice sopra, il progetto è identificato dal suo nome, che può anche fungere da identificatore umano. In generale è meglio avere una proprietà "senza significato" da usare per l'identità. In questo modo puoi cambiare il nome di un progetto e continuare ad avere lo stesso "oggetto". Devi anche preoccuparti delle collisioni, con 2 oggetti diversi che ottengono la stessa identità, in particolare se si tratta di una proprietà specificata dall'utente.

Ora qui ci sono alcuni altri formati di archiviazione che potreste considerare, ancora una volta senza conoscere i vostri vincoli.

• JSON. La libreria di serializzazione di Jackson è ottima per salvare/caricare oggetti java in formato JSON. Se hai oggetti in stile "java bean", è molto facile da usare. Una caratteristica interessante è che è possibile configurarlo in modo che una nuova proprietà dell'oggetto non causi problemi durante la lettura in un oggetto vecchio.

• binario, ad es. Buffer del protocollo. Questi sono più veloci di JSON, ma non così facili da usare. Può gestire campi aggiuntivi senza problemi.