Pagina 1 di 5 1 2 3 ... ultimoultimo
Visualizzazione dei risultati da 1 a 10 su 42
  1. #1
    Moderatore di Programmazione L'avatar di LeleFT
    Registrato dal
    Jun 2003
    Messaggi
    17,162

    [PILLOLA][JAVA] Connettere un'applicazione Java con un database MySQL

    Ho notato che spesso compaiono delle richieste di aiuto per la connessione di Java ad un database MySQL. Così ho deciso di aprire questa discussione-pillola in cui spiegherò come effettuare questa connessione, utilizzando il driver JDBC Connector-J offerto da MySQL.

    Introduco questa discussione offrendo una brevissima panoramica sui vari modi a disposizione del programmatore per poter connettere un'applicazione Java con un database in generale. Vi sono essenzialmente 2 modi:

    1) mediante l'utilizzo di un driver JDBC;
    2) mediante l'utilizzo del bridge JDBC-ODBC offerto da Java.

    In questa discussione tratterò solamente la prima alternativa, mentre per la seconda mi limiterò a descriverla brevemente.

    Quando si ha la possibilità di utilizzare un driver JDBC specifico per un determinato database è preferibile scegliere la prima opzione. Questo perchè l'utilizzo di un driver JDBC fornisce un accesso diretto al database, ottimizzato per esso, senza alcuna perdita di prestazioni. E' il produttore stesso del database, infatti, che distribuisce il driver JDBC ed in questo modo vengono sfruttate a pieno tutte le caratteristiche del database. Graficamente ecco cosa succede:

    Java --> Driver JDBC --> Database

    Quando, invece, non si possiede un driver JDBC specifico, si può tranquillamente ricorrere al bridge JDBC-ODBC. Questa caratteristica, da un lato, offre una estrema maneggevolezza: in tutti quei casi in cui non sia facilmente reperibile un driver JDBC (a volte, infatti, non esiste un driver JDBC apposito per un database), è possibile scaricare un driver ODBC ed utilizzare un DSN ODBC di sistema per potervi accedere. Driver ODBC, infatti, esistono oramai per quasi tutti i database esistenti, essendo ODBC uno standard de facto realizzato da Microsoft per la connettività dei database.
    Dall'altro lato, però, questa opportunitò ha uno svantaggio: la perdita di prestazioni. Quando si utilizza questa opzione, infatti, i passi che vengono eseguiti per la connessione sono 2: Java si connette al bridge JDBC-ODBC; questo si connette al DSN ODBC di sistema; quest'ultimmo, infine, utilizza il driver ODBC per agganciarsi al database. Graficamente, quindi:

    Java --> Bridge JDBC-ODBC --> Driver ODBC --> Database

    Il reperimento dei dati e gli aggiornamenti, quindi, sono più lenti perchè seguono una strada più lunga e vie è, effettivamente, una perdita di prestazioni. Ribadisco, comunque, che quest'ultima scelta è senza dubbio molto comoda in tutti quei casi in cui non si desisdera distribuire driver JDBC con l'applicazione, delegando all'utente "l'onere" di fornire un DSN ODBC per il database.

    Vediamo, ora, come si fa per connettere un'applicazione Java con un database MySQL facendo uso dell'apposito driver JDBC (chiamato Connector-J). Innanzitutto è necessario scaricare il driver, direttamente dal sito di MySQL. Il seguente link permette di accedere direttamente alla pagina dedicata a Connector-J.

    Poi si può scegliere una delle seguenti alternative, per poter utilizzare il driver JDBC:

    1) scompattare il JAR del driver nella cartella lib/ext della JDK;
    2) scompattare il JAR del driver nella cartella dell'applicazione.

    Io, personalmente, preferisco la seconda alternativa poichè svincola l'utente dall'avere driver preinstallati nella macchina. Scompattanto in JAR nella cartella dell'applicazione, infatti, esso sarà già disponibile per la distribuzione assieme all'applicazione; il driver sarà contenuto nel pacchetto di installazione dell'applicazione e quest'ultima saprà esattamente dove andarlo a cercare.

    A questo punto tutto è pronto per la scrittura dell'applicazione. Innanzitutto è doveroso ricordare che vi sono diversi tipi di connessione al database: una connessione mediante autenticazione (con nomeutente e password) e una connessione anonima. Non sempre la connessione anonima è supportata, per questo si darà la possibilità a chi scrive l'applicazione di scegliere che tipo di connessione effettuale.
    Per facilitare il tutto ho scritto una classe apposita che permette al programmatore di astrarre da tutti i dettagli della connessione vera e propria e che mette a disposizione una serie minimale di metodi per la connessione, l'interrogazione del database, l'aggiornamento, la disconnessione ed il reperimento di eventuali errori riscontrati.
    "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

  2. #2
    Moderatore di Programmazione L'avatar di LeleFT
    Registrato dal
    Jun 2003
    Messaggi
    17,162
    Questo è il codice della classe:
    codice:
    /*
     * Classe dedicata alla gestione del Database.
     * Gestisce l'apertura e la chiusura della connessione col Database
     * Fornisce i metodi per l'esecuzione delle query sul Database
     */
    import java.sql.*;
    import java.util.Vector;
    
    public class Database {
       private String nomeDB;       // Nome del Database a cui connettersi
       private String nomeUtente;   // Nome utente utilizzato per la connessione al Database
       private String pwdUtente;    // Password usata per la connessione al Database
       private String errore;       // Raccoglie informazioni riguardo l'ultima eccezione sollevata
       private Connection db;       // La connessione col Database
       private boolean connesso;    // Flag che indica se la connessione è attiva o meno
    
       public Database(String nomeDB) { this(nomeDB, "", ""); }
    
       public Database(String nomeDB, String nomeUtente, String pwdUtente) {
          this.nomeDB = nomeDB;
          this.nomeUtente = nomeUtente;
          this.pwdUtente = pwdUtente;
          connesso = false;
          errore = "";
       }
    
       // Apre la connessione con il Database
       public boolean connetti() {
          connesso = false;
          try {
    
             // Carico il driver JDBC per la connessione con il database MySQL
             Class.forName("com.mysql.jdbc.Driver");
    
             // Controllo che il nome del Database non sia nulla
             if (!nomeDB.equals("")) {
    
                // Controllo se il nome utente va usato o meno per la connessione
                if (nomeUtente.equals("")) {
    
                   // La connessione non richiede nome utente e password
                   db = DriverManager.getConnection("jdbc:mysql://localhost/" + nomeDB);
                } else {
    
                   // La connessione richiede nome utente, controllo se necessita anche della password
                   if (pwdUtente.equals("")) {
    
                      // La connessione non necessita di password
                      db = DriverManager.getConnection("jdbc:mysql://localhost/" + nomeDB + "?user=" + nomeUtente);
                   } else {
    
                      // La connessione necessita della password
                      db = DriverManager.getConnection("jdbc:mysql://localhost/" + nomeDB + "?user=" + nomeUtente + "&password=" + pwdUtente);
                   }
                }
    
                // La connessione è avvenuta con successo
                connesso = true;
             } else {
                System.out.println("Manca il nome del database!!");
                System.out.println("Scrivere il nome del database da utilizzare all'interno del file \"config.xml\"");
                System.exit(0);
             }
          } catch (Exception e) { errore = e.getMessage(); e.printStackTrace(); }
          return connesso;
       }
    
       // Esegue una query di selezione dati sul Database
       // query: una stringa che rappresenta un'istruzione SQL di tipo SELECT da eseguire
       // colonne: il numero di colonne di cui sarà composta la tupla del risultato
       // ritorna un Vector contenente tutte le tuple del risultato
       public Vector eseguiQuery(String query) {
          Vector v = null;
          String [] record;
          int colonne = 0;
          try {
             Statement stmt = db.createStatement();     // Creo lo Statement per l'esecuzione della query
             ResultSet rs = stmt.executeQuery(query);   // Ottengo il ResultSet dell'esecuzione della query
             v = new Vector();
             ResultSetMetaData rsmd = rs.getMetaData();
             colonne = rsmd.getColumnCount();
    
             while(rs.next()) {   // Creo il vettore risultato scorrendo tutto il ResultSet
                record = new String[colonne];
                for (int i=0; i<colonne; i++) record[i] = rs.getString(i+1);
                v.add( (String[]) record.clone() );
             }
             rs.close();     // Chiudo il ResultSet
             stmt.close();   // Chiudo lo Statement
          } catch (Exception e) { e.printStackTrace(); errore = e.getMessage(); }
    
          return v;
       }
    
       // Esegue una query di aggiornamento sul Database
       // query: una stringa che rappresenta un'istuzione SQL di tipo UPDATE da eseguire
       // ritorna TRUE se l'esecuzione è adata a buon fine, FALSE se c'è stata un'eccezione
       public boolean eseguiAggiornamento(String query) {
          int numero = 0;
          boolean risultato = false;
          try {
             Statement stmt = db.createStatement();
             numero = stmt.executeUpdate(query);
             risultato = true;
             stmt.close();
          } catch (Exception e) {
             e.printStackTrace();
             errore = e.getMessage();
             risultato = false;
          }
          return risultato;
       }
    
       // Chiude la connessione con il Database
       public void disconnetti() {
          try {
             db.close();
             connesso = false;
          } catch (Exception e) { e.printStackTrace(); }
       }
    
       public boolean isConnesso() { return connesso; }   // Ritorna TRUE se la connessione con il Database è attiva
       public String getErrore() { return errore; }       // Ritorna il messaggio d'errore dell'ultima eccezione sollevata
    }
    Vediamo ciò che offre questa classe e come si usa.

    Ci sono 2 costruttori: il primo prende un solo parametro, che rappresenta il nome del database MySQL al quale connettersi (per l'accesso anonimo); il secondo, invece, prevede l'introduzione, oltre al nome del database, anche di un nome utente e di una password (per l'accesso tramite autenticazione).

    Vi è poi il metodo connetti(), che permette di evitare di preoccuparsi di tutti i dettagli della connessione. Questo metodo effettua la connessione al database utilizzando tutti i parametri passati al costruttore e ritorna un valore booleano: se ritorna true la connessione è avvenuta con successo, altrimenti si sono verificati dei problemi.
    Il metodo disconnetti(), al contrario, permette di terminare la connessione con il database.

    Sono, poi, forniti due metodi per l'accesso al database: eseguiQuery() e eseguiAggiornamento(). Questi due metodi sono i metodi principali della classe, che sono effettivamente utilizzati per reperire le informazioni dal database e per poterlo aggiornare.

    Il primo prende un parametro di tipo String, che rappresenta la query di tipo SELECT da eseguire sul database. Viene restituito un Vector contenente tutti i record restituiti dalla query, sottoforma di array di stringhe. Ciascun record, quindi, è rappresentato da un array di Stringhe, dove ciascun elemento dell'array è l'equivalente di un campo del record.

    Il secondo metodo prende anch'esso una stringa come parametro, che rappresenta una query da eseguire sul database. In questo caso, però, la query che viene eseguita è di aggiornamento (UPDATE). Il metodo ritorna true se l'aggiornamento è andato a buon fine, false altrimenti.

    Se vi sono stati degli errori è possibile reperirli tramite il metodo getErrore() che ritorna il messaggio dell'ultimo errore che è avvenuto.

    Vi è poi il metodo isConnesso() che indica se l'applicazione ha effettuato effettivamente la connessione con il database oppure no. Questo meotdo ritorna true se il metodo connetti() ha ritornato true e, viceversa, ritorna false se il metodo connetti() ha ritornato false.

    Vediamo un semplice esempio di utilizzo di questa classe. Come possiamo vedere è molto semplice utilizzarla e non ci si deve preoccupare di tutta la gestione della connessione e delle relative eccezioni che possono essere lanciate.
    codice:
    Database db = new Database("nome");
    if ( !db.connetti() ) {
       System.out.println("Errore durante la connessione.");
       System.out.println( db.getErrore() );
       System.exit(0);
    }
    
    // Eseguo una query sul database. La tabella si chiama Tbl.
    Vector v = db.eseguiQuery( "SELECT * FROM Tbl;" );
    
    // Stampiamo i risultati:
    i = 0;
    while ( i<v.size() ) {
       String[] record = (String[]) v.elementAt(i);
       System.out.println("Record numero " + (i+1) );
       for (int j=0; j<record.length; j++) {
          System.out.println( record[j] );
       }
    }
    
    // Eseguo un aggiornamento sul campo 'nomecampo' della tabella Tbl:
    if ( !db.eseguiAggiornamento("UPDATE Tbl SET nomecampo=valore WHERE nomecampo>0;") ) {
       System.out.println("Errore nell'aggiornamento!");
       System.out.println( db.getErrore() );
    }
    
    // Ora chiudo la connessione col Database:
    db.disconnetti();
    Come ho già detto, questa classe offre un set minimale di metodi per lpaccesso al database. E' possibile ampliarla in modo da poter offrire anche tutto un set di metodi per il reperimento dei Metadati, per l'utilizzo dei PreparedStatement e per altri scopi.


    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 L'avatar di plafo
    Registrato dal
    Sep 2000
    Messaggi
    84
    Ciao!
    complimenti per la pillola che mi segnerò sicuramente tra i 3d preferiti
    ho una domanda da farti, lavorando con vari database (DB2,SQLServer ecc ecc) e dovendomi connettere sempre via jdbc ho notato che alcune volte nel caricare i driver per la connessione bisognava fare cosi:
    Class.forName("com.mysql.jdbc.Driver").newIstance( );
    volevo semplicemente chiederti l'utilità di newIstance() visto che in base a quello che ho fatto io, metterlo o non metterlo, sembra non influenzare la connessione al database.
    ah volevo segnalarti che il link per scaricare i driver mySQL non è attivo
    comunque ancora complimenti!!!!




    ciao ciao

    Carlo
    non può piovere per sempre

  4. #4
    Moderatore di Programmazione L'avatar di LeleFT
    Registrato dal
    Jun 2003
    Messaggi
    17,162
    Effettivamente ho notato che molti utilizzano il metodo newInstance() della classe Class quando devono caricare i driver JDBC di MySQL. Questo, però, non è esplicitamente richiesto nelle specifiche di tale driver (basta guardare il README file accluso con Connector-J). Ciò mi fa pensare che non sia necessario creare un'istanza di tale driver, ma sia sufficiente inizializzarla. Per inizializzare una classe, infatti, è sufficiente fare ricorso al metodo forName() della classe Class, mentre il metodo newInstance() fa di più: inizializza la classe se non è già stata inizializzata (ciò viene fatto dal metodo forName() ) e ne crea anche un'istanza.


    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
    Moderatore di Programmazione L'avatar di LeleFT
    Registrato dal
    Jun 2003
    Messaggi
    17,162
    Mi sono dimenticato di inserire il link per la pagina di Connector-J. Provvedo immediatamente: Connector-J .


    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

  6. #6
    Utente di HTML.it L'avatar di plafo
    Registrato dal
    Sep 2000
    Messaggi
    84
    Originariamente inviato da LeleFT
    Effettivamente ho notato che molti utilizzano il metodo newInstance() della classe Class quando devono caricare i driver JDBC di MySQL. Questo, però, non è esplicitamente richiesto nelle specifiche di tale driver (basta guardare il README file accluso con Connector-J). Ciò mi fa pensare che non sia necessario creare un'istanza di tale driver, ma sia sufficiente inizializzarla. Per inizializzare una classe, infatti, è sufficiente fare ricorso al metodo forName() della classe Class, mentre il metodo [n]newInstance()[/b] fa di più: inizializza la classe se non è già stata inizializzata (ciò viene fatto dal metodo forName() ) e ne crea anche un'istanza.


    Ciao.



    grazie per la spiegazione!




    ciao ciao
    Carlo
    non può piovere per sempre

  7. #7
    Moderatore di Programmazione L'avatar di LeleFT
    Registrato dal
    Jun 2003
    Messaggi
    17,162

    continua...

    Dato che non mi sembrava costruttivo lasciare la pillola a metà, ho deciso di completarla fornendo anche una classe che permetta la connessione di un'applicazione Java ad un database utilizzando il bridge JDBC-ODBC.
    Questo tipo di connessione, infatti, risulta utile in tutti quei casi dove il reperimento di un driver JDBC sia difficile o impossibile. Inoltre, questo metodo di connessione permette l'accesso ai database single-file (come sono, ad esempio, i database Microsoft Access).

    La classe qui di seguito offre, come nel precedente caso, i metodi per il reperimento dei record (esecuzione query SELECT) e di aggiornamento (esecuzione query UPDATE); un set minimale anche in questo caso, che può essere ampliato a piacere.

    Vediamo il codice e, successivamente, spieghiamo come funziona e quali sono le caratteristiche che offre:
    codice:
    /*
     * Classe dedicata alla gestione del Database.
     * Gestisce l'apertura e la chiusura della connessione col Database
     * Fornisce i metodi per l'esecuzione delle query sul Database
     */
    import java.sql.*;
    import java.util.Vector;
    
    public class ODBCDatabase {
    
       private String nomeDSN;         // Nome DSN dell'origine dati ODBC
       private String[][] attributi;   // Insieme di attributi da usare per la connessione
       private String errore;          // Stringa contenente un eventuale messaggio di errore
       private Connection db;          // Oggetto che rappresenta la connessione col DB
       private boolean connesso;       // Flag che indica se il DB è connesso o meno
    
       public ODBCDatabase(String nomeDSN) {
          this.nomeDSN = nomeDSN;
          attributi = new String[0][0];
          connesso = false;
       }
    
       public ODBCDatabase(String nomeDSN, String [][] attributi) {
          this.nomeDSN = nomeDSN;
          this.attributi = attributi;
          connesso = false;
       }
    
       public boolean connetti() {
          connesso = false;
          try {
    
             // Carico il bridge JDBC-ODBC per la connessione con il database
             Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
    
             String conString = "jdbc:odbc:" + nomeDSN;   // Il nome del DSN può anche essere vuoto!!
    
             // Controllo se ci sono attributi ausiliari da usare per la connessione
             if (attributi.length > 0) {
    
                // Uso gli attributi per la connessione
                for (int i=0; i<attributi.length; i++) {
                   conString += ";" + attributi[i][0] + "=" + attributi[i][1];
                }
             }
    
             // Effettuo la connessione
             db = DriverManager.getConnection( conString );
    
             // La connessione è avvenuta con successo
             connesso = true;
          } catch (Exception e) { errore = e.getMessage(); }
    
          return connesso;
       }
    
       // Esegue una query di selezione dati sul Database
       // query: una stringa che rappresenta un'istruzione SQL di tipo SELECT da eseguire
       // colonne: il numero di colonne di cui sarà composta la tupla del risultato
       // ritorna un Vector contenente tutte le tuple del risultato
       public Vector eseguiQuery(String query) {
          Vector v = null;
          String [] record;
          int colonne = 0;
          try {
             Statement stmt = db.createStatement();     // Creo lo Statement per l'esecuzione della query
             ResultSet rs = stmt.executeQuery(query);   // Ottengo il ResultSet dell'esecuzione della query
             v = new Vector();
             ResultSetMetaData rsmd = rs.getMetaData();
             colonne = rsmd.getColumnCount();
    
             while(rs.next()) {   // Creo il vettore risultato scorrendo tutto il ResultSet
                record = new String[colonne];
                for (int i=0; i<colonne; i++) record[i] = rs.getString(i+1);
                v.add( (String[]) record.clone() );
             }
    
             rs.close();     // Chiudo il ResultSet
             stmt.close();   // Chiudo lo Statement
          } catch (Exception e) { e.printStackTrace(); errore = e.getMessage(); }
    
          return v;
       }
    
       // Esegue una query di aggiornamento sul Database
       // query: una stringa che rappresenta un'istuzione SQL di tipo UPDATE da eseguire
       // ritorna TRUE se l'esecuzione è adata a buon fine, FALSE se c'è stata un'eccezione
       public boolean eseguiAggiornamento(String query) {
          int numero = 0;
          boolean risultato = false;
          try {
             Statement stmt = db.createStatement();
             numero = stmt.executeUpdate(query);
             risultato = true;
             stmt.close();
          } catch (Exception e) {
             e.printStackTrace();
             errore = e.getMessage();
             risultato = false;
          }
          return risultato;
       }
    
       // Chiude la connessione con il Database
       public void disconnetti() {
          try {
             db.close();
             connesso = false;
          } catch (Exception e) { e.printStackTrace(); }
       }
    
       public boolean isConnesso() { return connesso; }   // Ritorna TRUE se la connessione con il Database è attiva
       public String getErrore() { return errore; }       // Ritorna il messaggio d'errore dell'ultima eccezione sollevata
    }
    Cominciamo, innanzitutto, a trattare i 2 costruttori: il primo prende un solo parametro stringa che rappresenta il nome del DSN a cui agganciarsi (può anche essere la stringa vuota, ma non ha molto senso in questo caso...), mentre il secondo prende due parametri; il primo rappresenta sempre il DSN che fa riferimento all'origine dati ODBC a cui collegarsi (e anche in questo caso può essere vuota, che ha più senso di prima ), mentre il secondo parametro è una matrice di stringhe, che rappresenta tutti i parametri da passare al DSN. Questa matrice ha il seguente schema
    codice:
    |-------------|------------|
    | PARAMETRO_1 |  VALORE_1  |
    |-------------|------------|
    | PARAMETRO_2 |  VALORE_2  |
    |-------------|------------|
    |     ...     |     ...    |
    |-------------|------------|
    | PARAMETRO_N |  VALORE_N  |
    |-------------|------------|
    con la seguente semantica:
    codice:
    PARAMETRO_1=VALORE_1
    PARAMETRO_2=VALORE_2
    ...
    PARAMETRO_N=VALORE_N
    Il DSN ODBC, infatti, prevede una stringa di connessione di questo tipo:
    codice:
    jdbc:odbc:nomeDSN;
              PARAMETRO_1=VALORE1;
              PARAMETRO_2=VALORE_2;
              ...;
              PARAMETRO_N=VALORE_N
    e la classe si occupa, automaticamente, di costruire tale stringa in base ai valori passati dall'utente. In questo modo si ha a portata di mano tutta la maneggevolezza di Java applicata a tutte le potenzialità di ODBC.

    I metodi eseguiQuery() e eseguiAggiornamento(), come prima, permettono di eseguire una query di interrogazione ricevendo un Vector contenente tutti i record sottoforma di array di stringhe e di effettuare un aggiornamento ricevendo un valore booleano che indica l'andata a buon fine dell'operazione.

    Vediamo un semplice esempio di utilizzo di questa classe per collegarsi ad un database Microsoft Access, il cui file si chiama "MioDatabase.MDB" posizionato nella cartella denominata "MiaCartella", all'interno della cartella dove gira l'applicazione:
    codice:
    String [][] parametri = {{"DRIVER", "Microsoft Access Driver (*.mdb)"},
                             {"DBQ", ".\\MiaCartella\\MioDatabase.MDB"}
                            };
    
    ODBCDatabase db = new ODBCDatabase("", parametri);  // Nota: il nome DSN è vuoto!
    
    // Effettuiamo la connessione:
    if ( !db.connetti() ) {
       System.out.println("Errore durante la connessione!");
       System.out.println( db.getErrore() );
       System.exit(0);
    }
    
    // Reperiamo i dati attraverso una query. Nome della tabella: Tbl.
    Vector v = db.eseguiQuery("SELECT * FROM Tbl;");
    
    // Stampiamo i risultati:
    int i=0;
    while ( i<v.size() ) {
       System.out.println("Record numero " + (i+1));
       String [] record = (String[]) v.elementAt(i);
       for (int j=0; j<record.length; j++)
          System.out.println( record[j] );
    }
    
    // Eseguiamo un'aggiornamento sulla tabella Tbl:
    if ( !db.eseguiAggiornamento("UPDATE Tbl SET campo=valore WHERE campo>1;") ) {
       System.out.println("Errore nell'aggiornamento!");
       System.out.println( db.getErrore() );
    }
    
    // Chiudiamo la connessione col database:
    db.disconnetti();
    Anche in questo caso è possibile aggiungere alla classe i metodi per il reperimento dei Metadati dal DB, per l'utilizzo delle Prepared Statement o qualsiasi altra aggiunta necessaria.


    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

  8. #8
    Utente di HTML.it
    Registrato dal
    Jul 2005
    Messaggi
    2
    Salve sono un novizio dell'accesso al database da programma java, precisamente volevo accedere ad un database creato con il Jdatastore, ma non riesco a connettermi con il db, mi da sempre questo errore:

    java.sql.SQLException: No suitable driver

    mi sembra di aver capito che c'è qualcosa che nn va con il driver, ma nn capisco fisicamnte qual'e il file dove è contenuto il driver? dove lo devo piazzare? c'è qualche parametro da inserire nel progetto(io uso il jbuiderX personal edition)?

    Ringrazio in anticipo, chi sappia dare risposta ai miei dubbi

    Ciao

    PL0

  9. #9
    Moderatore di Programmazione L'avatar di LeleFT
    Registrato dal
    Jun 2003
    Messaggi
    17,162
    Premetto che non conosco Jdatastore, ma il messaggio d'errore indica che il driver che stai tentando di utilizzare non è quello adatto al database con cui ti vuoi collegare.
    Questo solitamente accade quando si tenta di instaurare una connessione JDBC con un DB, non avendo il relativo driver JDBC.

    Prova a cercare con Google se riesci a trovare un driver JDBC adatto al tuo tipo di database, altrimenti prova a seguire la procedura per il collegamento tramite bridge JDBC-ODBC (in questo caso devi essere in possesso di un driver ODBC adatto).


    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

  10. #10
    ciao, innanzitutto complimenti per la pillola

    mi stà risultando molto utile..

    la mia domanda però era un'altra

    io ho fatto la mia applicazione che si connette a MySQL, ora però volevo fare in modo di crearci sopra una interfacci di tipo web utilizzando il JSP...

    c'è qualche controindicazione??
    posso continuare ad utiulizzare la tua classe per la connessione oppure il procedimento è totalmente diverso???

    grazie.
    Let's your dream came true!

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 © 2020 vBulletin Solutions, Inc. All rights reserved.