Visualizzazione dei risultati da 1 a 10 su 10

Discussione: (java) Serializzazione

  1. #1
    Utente di HTML.it
    Registrato dal
    Oct 2002
    Messaggi
    883

    (java) Serializzazione

    Ho un'applicazione swing nella quale c'è una menubar
    Nel menu è possibile scegliere la voce "Settings"
    Scegliendo questa voce si apre una jdialog con i settaggi del programma (nella jdialog ci sono 10 bottoni checkbox)

    Volevo fare in modo che ogni volta che si apre il pannello dei settings il programma si ricordi quali bottoni sono stati spuntati e quali no
    La prima soluzione che avevo adottato era quella di creare un file di testo sul quale scrivere gli stati dei bottoni
    Però volevo sapere, la serializzazione mi può aiutare?
    Come devo fare?
    Esempio di codice:

    public class SettingsDialog implements serializable {
    public SettingsDialog() {
    //codice che crea e visualizza la jdialog
    creo un bottone
    setto lo stato del bottone a "non selezionato"
    }
    }

    Se implemento il programma nel seguente modo:

    Eseguo il programma, viene creata la jdialog ma non viene visualizzata
    La prima volta che viene premuto la voce del menu "Settings"
    -mostro la jdialog
    L'utente seleziona e deseleziona dei bottoni e poi preme OK
    -nascondo la jdialog
    Viene chiuso il programma
    Quando viene riaperto il programma e viene premuto la voce del menu "Settings" perdo i settaggi perchè viene ricreata la jdialog che nel costruttore ha i pulsanti disattivati

    Come devo implementare la serializzazione?

  2. #2
    Moderatore di Programmazione L'avatar di LeleFT
    Registrato dal
    Jun 2003
    Messaggi
    17,304
    Secondo me, la via più semplice è la seguente:

    1) Dovresti preparare preventivamente un file con i bottoni settati a NON SELEZIONATO. In questo modo, la prima volta che viene aperta la JDialog, va a leggere il file e recupera i dati (inizializzati a dovere!)

    2) Ogni volta che viene chisa la JDialog (magari mediante pressione su un pulsante, non so come l'hai gestito tu questo evento), viene salvato il file con le impostazioni selezionate dall'utente. In questo modo, la prossima volta che viene aperta la JDialog, essa provvede a aleggere il file (che questa volta contiene già i dati modificati) e li visualizza correttamente.

    Ho notato una cosa: la serializzazione tu la applichi all'intera JDialog... non è sbagliato, ma è scomodo: in questo caso, infatti, dovresti leggere dal file di configurazione un oggetto di tipo JDialog, mentre se tu implementassi la serializzazione solamente negli oggetti in essa contenuti, dovresti leggere solamente quelli (cosa più leggera).


    Ciao.
    "Perchè spendere anche solo 5 dollari per un S.O., quando posso averne uno gratis e spendere quei 5 dollari per 5 bottiglie di birra?" [Jon "maddog" Hall]
    Fatti non foste a viver come bruti, ma per seguir virtute e canoscenza

  3. #3
    Utente di HTML.it
    Registrato dal
    Oct 2002
    Messaggi
    883
    l'implementazione con un file di testo è quella che uso attualmente e funziona. Invece di questa soluzione volevo implementare la serializzazione
    Ma oltre che implementare l'interfaccia serializable non so cosa bisogna fare. Qualcuno mi può dare una spegazione?

  4. #4
    Moderatore di Programmazione L'avatar di LeleFT
    Registrato dal
    Jun 2003
    Messaggi
    17,304
    Quando si usa la serializzazione si fa uso di due classi:

    - ObjectOutputStream: che permette di scrivere su di un file.

    - ObjectInputStream: che permette di leggere dal file

    Tramite queste due classi è possibile salvare su di un file una classe, che implementi l'interfaccia Serializable. In questo modo nel file viene salvato il Byte Code relativo alla classe, in modo che possa, poi, essere recuperato mediante l'uso di un oggetto ObjectInputStream.

    Ti faccio un esempio, così ti risulterà più chiaro:
    codice:
    import java.io.*;
    
    class MioOggetto implements Serializable {
       private String dsc;
       private int valore;
       public MioOggetto() {
          dsc = "";
          valore = 0;
       }
       public void setDsc(String dsc) { this.dsc = dsc; }
       public void setValore(int valore) { this.valore = valore; }
       public String getDsc() { return dsc; }
       public int getValore() { return valore; }
    }
    
    class ProvaSalva {
       public static void main(String [] args) {
          OutputStream fileOut = new FileOutputStream("file.dat");
          ObjectOutputStream oos = new ObjectOutputStream(fileOut);
          MioOggetto oggetto = new MioOggetto();
          oggetto.setDsc("Descrizione");
          oggetto.setValore(10);
    
          oos.writeObject(oggetto); // Salvo un oggetto sul file
    
       }
    }
    
    class ProvaApri {
       public static void main(String [] args) {
          InputStream fileIn = new FileInputStream("file.dat");
          ObjectInputStream ois = new ObjectInputStream(fileIn);
    
          // Leggo l'oggetto salvato precedentemente.
          // Serve un cast perchè readObject() restituisce un oggetto di tipo Object
          MioOggetto obj = ((MioOggetto) ois.readObject());
       }
    }
    Spero di averti spiegato sufficientemente bene come si usa la serializzazione. Nota che non è necessario salvare tutte le proprietà di un oggetto: io salvo una classe e leggo una classe.
    Un'ultima osservazione. Se un oggetto eredita da una classe che implementa Serializable, dall'eseritarietà derica che anch'esso è Serializable; mentre per gli oggetti contenuti (Oggetti, non dati di tipo primitivo) non è valida la stessa cosa: questo significa che se voglio salvare un oggetto che contiene altri oggetti, anche questi oggetti interni DEVONO implementare Serializable.


    Ciao.
    "Perchè spendere anche solo 5 dollari per un S.O., quando posso averne uno gratis e spendere quei 5 dollari per 5 bottiglie di birra?" [Jon "maddog" Hall]
    Fatti non foste a viver come bruti, ma per seguir virtute e canoscenza

  5. #5
    Utente di HTML.it
    Registrato dal
    Oct 2002
    Messaggi
    883
    esempio perfetto
    Con la serializzazione volevo provare ad aggirare il seguente problema.
    Siccome la mia applicazione swing la compatto in un file jar eseguibile e siccome non si può scrivere un file di testo dentro un file jar, mi toccava creare un file di testo all'esterno del jar dove salvare le impostazione del pannello di settings
    Volevo provare ad usare la serializzazione per aggirare questo cosa.
    Noto però che per serializzare un oggetto bisogna usare la stringa di codice:

    OutputStream fileOut = new FileOutputStream("file.dat");

    cioè per serializzare bisogna specificare un file su cui salvare l'oggetto da serializzare e quindi sono al punto di prima

  6. #6
    Moderatore di Programmazione L'avatar di LeleFT
    Registrato dal
    Jun 2003
    Messaggi
    17,304
    Eh già... per serializzare, bisogna comunque salvare in un file. Del resto non esistono altri modi per salvare le impostazioni...



    Ciao.
    "Perchè spendere anche solo 5 dollari per un S.O., quando posso averne uno gratis e spendere quei 5 dollari per 5 bottiglie di birra?" [Jon "maddog" Hall]
    Fatti non foste a viver come bruti, ma per seguir virtute e canoscenza

  7. #7
    Utente di HTML.it
    Registrato dal
    Oct 2002
    Messaggi
    883
    possibile che non ci sia un modo per divulgare un'applicazione scritta in java in un unico file jar senza altri file voltanti? (ovvero il file che contiene i settaggi dell'applicazione stessa)

  8. #8
    ma non puoi mettere le variabili di istanza delle varie classi settate in un certo modo (settaggio di default) e nel momento in cui un utente modifica alcune voci ti crei un file con i settaggi personalizzati che andrai a leggere all'avvio?

  9. #9
    Utente di HTML.it
    Registrato dal
    Oct 2002
    Messaggi
    883
    è quello che faccio
    Però come vedi appena un utente modifica i settaggi di default devo creare un file, esterno al jar, dove memorizzare le preferenze. Cosa che volevo evitare

    Voglio poter distribuire un'applicazione in un unico file e che rimanga come unico file

  10. #10
    Bè credo che cmq sia corretto utilizzare un file esterno al jar , in questo modo basta cambiare il file esterno per far variare le proprie impostazioni , ad esempio un utente può crearsi 2 file e li usa in modo alternato senza toccare il jar.Oppure due utenti possono scambiarsi il file
    Lang=Java
    Ambiente = Eclipse forever
    Ubuntu & Win XP Pro

Permessi di invio

  • Non puoi inserire discussioni
  • Non puoi inserire repliche
  • Non puoi inserire allegati
  • Non puoi modificare i tuoi messaggi
  •  
Powered by vBulletin® Version 4.2.1
Copyright © 2024 vBulletin Solutions, Inc. All rights reserved.