Qualche consiglio sulla grafica

[Jamie04]

Ora che ci penso, non so bene come gestire il menu. Nel senso che ogni menu è una specie di categoria che contiene un certo numero di prodotti. Quando faccio l'inserimento, come dovrei comportarmi?
Lasciando la maschera com'è, potrei fare in modo che l'utente debba inserire prima il menu, salvare, e successivamente inserire i prodotti che ne fanno parte. Oppure...?

[Patrick Jane]

Si in pratica è in quel modo che puoi abilitare e disabilitare un campo.

Per quanto riguarda la connessione c'è già la Pillola di Lele con tutte le istruzioni del caso: http://forum.html.it/forum/showthrea...hreadid=801696 ti consiglio comunque di scriverti tutto tu, guarda solo come ci si connette.

Ora che ci penso, non so bene come gestire il menu. Nel senso che ogni menu è una specie di categoria che contiene un certo numero di prodotti. Quando faccio l'inserimento, come dovrei comportarmi?
Lasciando la maschera com'è, potrei fare in modo che l'utente debba inserire prima il menu, salvare, e successivamente inserire i prodotti che ne fanno parte. Oppure...?

Graficamente puoi gestirli come meglio credi. Forse quanto hai descritto è più comodo. Un altra idea potrebbe essere avere tutti i campi non abilitati ad esclusione del menu. Qui usi un pulsante per l'inserimento del menu e dal momento che viene premuto inserendo il menu, abiliti tutti gli altri campi disabilitando il Menu. Quando poi premi Nuovo lo abiliti e disabiliti gli altri etc...

Comunque piuttosto che preoccuparmi della grafica mi preoccuperei di come gestire i dati all'interno del software. Come li stai rappresentando? Hai già idee spero... non so, avrai delle classi ad esempio. In che modo sono strutturate? E' questo ciò che dovresti progettare prima della grafica... il modo in cui mostrare i dati puoi variarlo in ogni momento.

[Jamie04]

Ciao, di nuovo scusa il ritardo ma vari impicci mi tengono lontana a fasi alterne da questo benedetto progetto...
Dunque ho letto la guida, anche se ho usato i file che ci aveva dato il prof modificandoli per la connessione e l'interazione col db, ma ho un problema: quando provo a lanciare la classe di test per la connessione al db ottengo:

>>> ClassNotFoundException! <<<
Message: com.mysql.jdbc.Driver
Java Result: 1

ora il file jar del driver jdbc io l'ho messo un po' dappertutto... come da istruzioni l'ho messo sia nella cartella dell'applicazione (scompattato e non) sia nella cartella d'installazione di java (/usr/lib/jvm/java-7-oracle/lib (ma qui non c'e' una cartella /lib/ext)) ma non me lo trova comunque! Cosa dovrei fare?
Grazie mille!

[Jamie04]

Ok per quanto sopra ho risolto, la cartella com deve stare in src dell'applicazione.
Ho provato a lanciare il file di test per la connessione ma ottengo:
Exception in thread "main" java.lang.NullPointerException
at tablemanager.DBConnection.closeConnection(DBConnec tion.java:84)
at tablemanager.DBConnectionTest.main(DBConnectionTes t.java:84)
Java Result: 1

Che vuol dire?
La riga a cui punta è composta da questa istruzione:
DBConnection.closeConnection();

[Jamie04]

Ho risolto anche quest'ultimo problema, quindi ora ho la mia brava classe che fa la connessione al database...
A domani per altre domande...adesso non ce la posso fare

[Jamie04]

Ok adesso avrei qualche dubbio sulla gestione del database. Perdonate le domande forse banali ma sinceramente queste cose a me non le ha spiegate nessuno e online i tutorial che si trovano spesso non danno queste indicazioni generali.
1) Io ho la classe che fa la connessione al database, questa classe deve essere eseguita alla partenza dell'applicazione o soltanto quando serve, ovvero solo quando deve rispondere alle richieste d'inserimento dati nel db, quindi come azione dei pulsanti che l'utente premerà quando vorrà inserire i dati nel db?
2) Nel passaggio da una finestra all'altra dell'applicazione, cosa è meglio fare per le finestre "precedenti"? Renderle invisibili e poi rimetterle visibili nel caso l'utente torni indietro o che?
Grazie!

[Patrick Jane]

No problem, io guardo quasi tutti i giorni, ma non proprio sempre.

Ok adesso avrei qualche dubbio sulla gestione del database. Perdonate le domande forse banali ma
1) Io ho la classe che fa la connessione al database, questa classe deve essere eseguita alla partenza dell'applicazione o soltanto quando serve, ovvero solo quando deve rispondere alle richieste d'inserimento dati nel db, quindi come azione dei pulsanti che l'utente premerà quando vorrà inserire i dati nel db?

Dovrai dichiarare una variabile Connection come membro della classe, così che resti in vita per tutta la durata del programma. Ovviamente all'avvio verrà creato l'oggetto di Connection, poi non dovrai più creare altri oggetti (quindi potrebbe essere il costruttore della tua classe che stabilisce la connessione). Tutte le volte successive che utilizzerai Connection sarà per ottenere uno Statement. Puo anche ottenerlo "al volo". In pratica nel corpo del metodo che deve ad esempio inserire dei dati nel db, scriverai qualcosa come:

Statement stm = con.createStatement();
//...

una volta utilizzato lo chiudi con stm.close(). Non chiudere anche Connection, altrimenti non appena dovrai richiamarlo otterrai un errore. Connection va chiuso al termine del programma.

2) Nel passaggio da una finestra all'altra dell'applicazione, cosa è meglio fare per le finestre "precedenti"? Renderle invisibili e poi rimetterle visibili nel caso l'utente torni indietro o che?
Grazie!

Va più a gusti... puoi scegliere anche diverse strade. Potresti caricare un pannello diverso al posto di creare una nuova finestra; in questo modo andrai solo a modificare il pannello, ma ovviamente dovrai avere i pannelli a disposizione (c'è CardLayout in questo caso che potrebbe tornare utile, trovi dei tutorial sul sito della Oracle). Insomma, puoi gestirli come preferisci...
Oppure puoi creare le finestre. In questo caso la finestra padre dovrai sempre tenerla, l'unica operazione che farai sulle vecchie finestre sarà un renderle non visibili per ripristinarle quando la figlia viene chiusa. Dovrai passare alle finestre figlie il riferimento alla finestra dell'oggetto padre.
Un esempio di tale funzionamento è il seguente: http://solopc.forumcommunity.net/?t=49777313

[Jamie04]

Dunque, questa è la classe della connessione al db:

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.FileNotFoundException;
import java.util.Properties;

public class DBConnection {

  private static Connection connection;
  private static String driver;
  private static String url;
  private static String admin;
  private static String adm_passwd;

  public static void init(String fileName)
          throws IOException, FileNotFoundException, ClassNotFoundException
  {
    Properties properties = new Properties();
    FileInputStream fileInputStream = new FileInputStream(fileName);
    properties.load(fileInputStream);
    driver = properties.getProperty("driver");
    url = properties.getProperty("url");
    admin = properties.getProperty("admin");
    adm_passwd = properties.getProperty("admin_passwd");
    Class.forName(driver); // carica il driver
  }

  public static Connection getConnection() throws SQLException
  {
    return connection=DriverManager.getConnection(url, admin, adm_passwd);
  }

  public static void closeConnection() throws SQLException
  {
    connection.close();
  }

}

E questa è la classe per testarla:

package tablemanager;
import java.sql.Connection;
import java.sql.SQLException;
import java.io.IOException;

public class DBConnectionTest
{

  public static void main(String[] args)
  {
    String fileName = "properties.txt";
    try
    {
      DBConnection.init(fileName);
    } 

    catch(IOException ioEx)
    {
      System.err.println(">>> IO Exception! <<<\n");
      System.err.println("Message: " + ioEx.getMessage());
      System.err.println("Stack trace: " + ioEx.getStackTrace());
      System.exit(1);
    } 
    catch(ClassNotFoundException cnfEx)
    {
      System.err.println(">>> ClassNotFoundException! <<<\n");
      System.err.println("Message: " + cnfEx.getMessage());
      System.exit(1);
    } 
    try
    {
        Connection connection = DBConnection.getConnection();
    }
    catch(SQLException sqlEx)
    {
      System.err.println(">>> SQLException! <<<\n");
      System.err.println("SQLState:  " + sqlEx.getSQLState());
      System.err.println("Message:  " + sqlEx.getMessage());
      System.err.println("Error code:  " + sqlEx.getErrorCode());
      System.err.println("Stack trace: " + sqlEx.getStackTrace());
      System.exit(1);
    } 

    finally
    {
      try
      {
        DBConnection.closeConnection();
      }
      catch(SQLException sqlEx)
      {
        System.err.println(">>> SQLException! <<<\n");
        System.err.println("SQLState:  " + sqlEx.getSQLState());
        System.err.println("Message:  " + sqlEx.getMessage());
        System.err.println("Error code:  " + sqlEx.getErrorCode());
        System.exit(1);
      }
    }
  }
}

Se ho capito bene, questa classe di test non mi serve più ovviamente, quindi dovrei inserire questa parte:
Connection connection = DBConnection.getConnection();
Che di fatto crea la connessione direttamente nella classe DBConnection (più la chiamata al DbInit immagino)

Quindi, sempre se ho capito questo passaggio:

Dovrai dichiarare una variabile Connection come membro della classe, così che resti in vita per tutta la durata del programma. Ovviamente all'avvio verrà creato l'oggetto di Connection, poi non dovrai più creare altri oggetti (quindi potrebbe essere il costruttore della tua classe che stabilisce la connessione).

Quando dici "all'avvio verrà creato l'oggetto di Connection" intendi che nelle classi dove mi interessa interagire col database devo istanziare un oggetto di Connection e successivi passaggi oppure devo farlo solo nella classe che fa partire l'applicazione? Nel secondo caso, in effetti nella classe di 'partenza' per ora mi sono limitata a fare la creazione della maschera principale con i pulsanti per richiamare le altre maschere...ho sbagliato?

Sul secondo punto: per adesso io ho gestito tutto in finestre separate, credevo fosse più logico così.
Le mie finestre vengono create con queste istruzioni:

        EventQueue.invokeLater(new Runnable() {
            public void run() {
                new StartPanel().setVisible(true);
            }
        });

Volevo gestire la cosa in modo che appena si va nelle finestre 'figlie' le finestre 'padri' diventino invisibili e poi ritornino visibili alla pressione di un apposito pulsante (per tornare indietro). Ecco, non sapevo come ri-renderle visibili, perché il metodo setVisible(true) si applica su oggetti, ma le finestre vengono istanziate come sopra, senza nessun 'reference'. Non so se mi sono spiegata
Ma poi ho visto che per rendere invisibile quella corrente mi basta invocare setVisible(false).
Ho fatto così per il pulsante indietro di una finestra 'figlia', è corretto secondo te?

    private void bBackActionPerformed(java.awt.event.ActionEvent evt) { 
        setVisible(false);
        new StartPanel().setVisible(true);
    }

Però mi sorge un dubbio...così facendo non sto occupando più memoria del necessario?
Cioè la finestra padre quando ho aperto la figlia è stata messa in invisibile; ma se poi dalla figlia voglio tornare al padre con la new di cui sopra non è come se stessi istanziando un nuovo oggetto? Oppure quando una finestra si mette in invisibile la memoria viene liberata?
Ma se non è così non so come fare :-/

Grazie di nuovo...gentilissimo davvero.

[Patrick Jane]

Vedo parecchia confusione. :P

Dunque, prima di tutto se guardi il sito che ho linkato vedi l'esempio di come gestire le finestre e di come farle "sparire" e "riapparire". In quel caso si esegue anche un controllo per essere certi di non aprire due volte la stessa finestra.

Non so bene come hai progettato il tutto, dovrei vedere il codice completo per farmi un idea. Una cosa fatta bene richiederebbe prima la parte di solo codice, la logica del tuo programma. Questo implica la parte delle chiamate al database anche. Ed in ultimo la parte della grafica, che non fa altro che chiamare alcuni metodi che poi scriveranno sul db. Qui a quanto vedo hai invece messo tutto insieme, e questo può complicare le cose in caso di modifiche/aggiustamenti in quanto rischi di dover modificare parti di codice se tocchi qualcosa (e poi non è concettualmente corretto).

Dove ho parlato di istanziare Connection io intendevo proprio creare un oggetto di tipo Connection; se vuoi usare la classe di Lele DBConnection allora utilizza quella, ma la devi utilizzare al completo. L'oggetto Connection ti permette di scrivere/leggere dati dal db, ma devi poter accedere ad esso tramite opportuni metodi.
Per non inserire tutto nella GUI potresti creare una classe che al suo interno si occupa di creare un oggetto Connection e mette a disposizione due metodi (almeno) per lettura e scrittura. Mi ripeto, se non vuoi creare questa classe... c'è quella di Lele che è già pronta all'uso! Qui trovi codice e descrizione riguardo la classe di Lele http://forum.html.it/forum/showthrea...hreadid=801696
Ciò che dovrai fare tu è ciò che fa nell'esempio: in pratica nel costruttore della tua classe (finestra principale, padre) crei l'oggetto DBConnection e chiami il metodo connetti(). Se tutto va a buon fine, non devi fare altro! Al momento della generazione di uno degli eventi, come l'invio dei dati di un form, allora verrà eseguito il codice all'interno del metodo actionPerformed(); qui sta a te capire quale bottone viene premuto (come ti avevo mostrato) e sapere se devi leggere o scrivere nel db. Per leggere e scriverei userai l'oggetto DBConnection precedente, sfruttando uno dei metodi messi a disposizione nella classe DBConnection.


Non serve comunque che avvii in un contesto diverso ogni finestra... è sufficiente la prima volta. Solitamente non ne servono altri, se non devi gestire altre cose (animazioni o audio ad esempio).
Ecco un esempio di codice, ma che non comprende il DB:

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;


// Finestra Figlio 1
// --------------------------------------------------------------------
class Finestra1 extends JFrame {
  // Riferimento al padre
  private Finestra f;

  Finestra1(Finestra f) {
    super("Finestra Figlio 1");
    this.f = f;
    
    JPanel panel = new JPanel();
    panel.add(new JLabel("Figlio 1"));
    add(panel);
    
    addWindowListener(new MyWindowListener());
  }
  
  private class MyWindowListener extends WindowAdapter {
    public void windowClosing(WindowEvent we) {
      f.setVisible(true);
      dispose();
    }
  }
}
// --------------------------------------------------------------------

// Finestra Figlio 2
// --------------------------------------------------------------------
class Finestra2 extends JFrame {
  // Riferimento al padre
  private Finestra f;

  Finestra2(Finestra f) {
    super("Finestra Figlio 2");
    this.f = f;
    
    JPanel panel = new JPanel();
    panel.add(new JLabel("Figlio 2"));
    add(panel);
    
    addWindowListener(new MyWindowListener());
  }
  
  private class MyWindowListener extends WindowAdapter {
    public void windowClosing(WindowEvent we) {
      f.setVisible(true);
      dispose();
    }
  }
}
// --------------------------------------------------------------------


// Finestra Padre
// --------------------------------------------------------------------
class Finestra extends JFrame implements ActionListener {
  private JButton figlio1, figlio2;
  
  Finestra() {
    super("Finestra Padre");
    
    JPanel panel = new JPanel();
    figlio1 = new JButton("Finestra 1");
    figlio2 = new JButton("Finestra 2");
    
    figlio1.addActionListener(this);
    figlio2.addActionListener(this);
    
    panel.add(figlio1);
    panel.add(figlio2);
    
    add(panel);
    
    setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
  }
  
  public void actionPerformed(ActionEvent ae) {
    JButton btn = (JButton) ae.getSource();
    String str = btn.getText();
    
    // se uguale a "Finestra 1", si tratta del primo bottone
    if(str.equals("Finestra 1")) {
      setVisible(false);
      Finestra1 f1 = new Finestra1(this);
      f1.setSize(300,300);
      f1.setVisible(true);
    } else {
      setVisible(false);
      Finestra2 f2 = new Finestra2(this);
      f2.setSize(300,300);
      f2.setVisible(true);
    }
  }
  
  
  public static void makeGUI() {
    Finestra f = new Finestra();
    f.setSize(500,500);
    f.setVisible(true);
  }
  
  public static void main(String[] args) {
    try {
      SwingUtilities.invokeAndWait(new Runnable() {
        public void run() {
          makeGUI();
        }
      });
    } catch(Exception e) {}
  }
}
// --------------------------------------------------------------------

Se vuoi provarlo (e te lo consiglio) salva tutto come Finestra.java

Come vedi non è complicato,si tratta solo di far riapparire il frame precedente.
Un discorso analogo vale per i JPanel, ma forse sarebbe leggermente più complicato.

Per quanto riguarda le risorse non devi preoccuparti. Prima di tutto non devi fare come hai fatto tu! Se crei un nuovo oggetto ogni volta ti ritrovi con una nuova finestra... e questo significa che avresti altri oggetti per la connessione, oltre che ad altri bottoni e ad altri elementi. Ciò che devi fare è quanto ti ho mostrato li sopra!
Nel codice li sopra, in Finestra, avrai anche questo:

dbConnection = new DBConnection(....);

if(dbConnection.connetti()) {

// ...
}

L'altro motivo per non preoccuparti è dato dal dispose() che viene chiamato quando chiudi la finestra figlia. Ovviamente, se da Finestra1 apri una nuova finestra dovrai passarle il riferimento a Finestra1 e non a Finestra (che è la principale).
Quando chiami il dispose accade questo:

Releases all of the native screen resources used by this Window, its subcomponents, and all of its owned children. That is, the resources for these Components will be destroyed, any memory they consume will be returned to the OS, and they will be marked as undisplayable.

Di nulla!


PS: ovviamente quando la finestra è non visibile, è comunque in memoria. Ma non ci sono alternative, se vuoi ripristinare lo stato precedente deve essere in memoria!

[Jamie04]

Ri-ciao... allora io ho il problema che avendo generato il codice della grafica tramite il designer di NB ho difficoltà a metterci le mani sopra perché mi impedisce quasi tutte le modifiche a meno che non le faccio tramite il designer che però mi permette solo di fare alcune cose. In pratica dovrei rifare tutto da capo per fare come dici tu. Ma magari domani ci provo. Però mi trovo così bene a fare la grafica col designer, mi permette di non perdere tempo appresso a dettagli come dimensioni, stile, posizionamenti di bottoni e finestre! Parlando del tuo esempio Finestra.java, mi sfugge una cosa: hai dichiarato 3 classi nella stessa classe, le due classi figlio sono quindi interne? Non ci sono regole riguardo il fatto che va dichiarata prima la classe principale e poi quelle interne? Questa cosa dev'essermi proprio sfuggita...
Riguardo al db non ho capito una cosa. Io creo il db sulla mia macchina, ma quando distribuisco l'applicazione come funziona? Bisogna che ci sia comunque MySql installato e configurato correttamente per far funzionare l'applicazione e va creato il database (se è vuoto all'inizio non c'e' problema, non devo fornire un db già popolato), giusto?
Invece riguardo la classe che fa partire l'applicazione, cosa dovrebbe contenere sommariamente?
Purtroppo in tutto il corso che ho fatto su java nessuno mi ha mai spiegato come mettere in piedi un'applicazione completa e complessa. Io molto prosaicamente ho messo per ora solo la finestra principale con i pulsanti che permettono di richiamare le altre parti dell'applicazione.
Grazie ancora...alla fine di tutto ti farò un monumento