Newsgroup: it.comp.java
Titolo: Accesso a DB con una solo connessione

Ho un progetto java su web (jsp, servlet, classi) che
pubblica dei servizi su web. Ogni utente che si connette
al server (apche e tomcat) apro una connessione al DB.
Come si potrebbe fare pr aprire una connessione
unica al DB e poi permettere a tutti gli utenti di usare
solo ed unicamente quella connessione????
Ciao e grazie, Sboffo.

 ha scritto nel messaggio 
news:ckb0ia$7nk$1...@fata.cs.interbusiness.it...

Sarei curioso di sapere perchè vuoi ottenere una cosa simile...
Comunque devi stare attento che l'oggetto Connection venga utulizzato da un 
thread alla volta.
Connection conn = Manager.getConnection();
PreparedStatment pst = conn.prepareStatement("..");
ResultSet rs = pst.executeQuery();
...
rs.close();
pst.close();
Non credo che ci siano problemi se 2 thread eseguono pst.executeQuery 
contemporaneamente (oppure possono modificare la connessione che li ha 
generati?).
Problemi di concorrenza invece dovrebbero riscontrarsi in 
conn.prepareStatement();
Quindi potresti wrappare Connection con un'altra classe che sincronizza 
(rendendoli atomici) i metodi a rischio.
Se inveec anche pst.execute da problemi di concorrenza allora potresti 
mettere tutto il codice in un metodo sincronizzato di un'altra classe, e 
richiamarlo esternamente nella tua applicazione.

> Sarei curioso di sapere perchè vuoi ottenere una cosa simile...
Forse mi sono spiegato male.
Non ho problemi con la connessione, o con la concorrenza.
I miei sono solo problemi di prestazione.
Ogni volta che un utente si connette ad una pagina web e richiede
dati dal DB si apre una connessione al DB.
Alla fine della lettura dei dati, la connessione viene chiusa.
Se ho 10 utenti, ed in ogni sessione si chiedono dati al DB per 5 volte,
potrei avere 50 connessioni e 50 chiusure nel giro di pochi secondi.
Io vorrei avere una connessione aperta unica, per tutto il giorno.
Su questa connessione aperta, andro` poi a fare le 50 query
del caso, senza un continuo APRI-CHIUDI, APRI-CHIUDI, ...
Spero di essermi spiegato.
Ciao e grazie. Sboffo.

 ha scritto nel messaggio 
news:ckb8hh$sn5$1...@fata.cs.interbusiness.it...

Ah ora ho capito...usa il connection pooling.
Se stai usando tomcat c'è il pacchetto in tomcat/common/lib e puoi usarlo 
nella tua applicazione web.
Il connection pooling ti permette di aprire un certo numero di connessioni 
all'iniizo di di riutilizzarle continuamente senza aprirle e chiuderle ogni 
volta. 

 volta.
Non hai 2 righe di esempio?
Dopo non ti stresso piu`.
Comunque grazie 1000.
Ciao, Sboffo.

 ha scritto nel messaggio 
news:ckb9qg$r4j$1...@carabinieri.cs.interbusiness.it...

hai tomcat? che versione? 

 hai tomcat? che versione?


puoi configurarlo dentro il contesto della tua applicazione 
(conf/catalina/localhost/tuaapplicazione.xml)
<Context path="/corsi" docBase="c:/unive/ClientServer/src/"
        debug="5" reloadable="false" crossContext="false" 
swallowOutput="true">
  <Logger className="org.apache.catalina.logger.FileLogger"
             prefix="localhost_corsi_log." suffix=".txt"
             timestamp="true"/>
<Resource name="jdbc/mysql" auth="Container"
          type="javax.sql.DataSource"/>
<ResourceParams name="jdbc/mysql">
  <parameter>
    <name>factory</name>
    <value>org.apache.commons.dbcp.BasicDataSourceFactory</value>
  </parameter>
  <parameter>
    <name>driverClassName</name>
    <value>com.mysql.jdbc.Driver</value>
  </parameter>
  <parameter>
    <name>url</name>
    <value>jdbc:mysql:///corsi</value>
  </parameter>
  <parameter>
    <name>username</name>
    <value>alberto</value>
  </parameter>
  <parameter>
    <name>password</name>
    <value>dfgdfg</value>
  </parameter>
  <parameter>
    <name>maxActive</name>
    <value>20</value>
  </parameter>
  <parameter>
    <name>maxIdle</name>
    <value>10</value>
  </parameter>
  <parameter>
    <name>maxWait</name>
    <value>-1</value>
  </parameter>
</ResourceParams>
</Context>
Per caricare il Datasource  (che ha un ruolo simile al DriverManager che 
sicuramente conosci) puoi fare
        DataSource ds = null;
        try {
            Context initCtx = new InitialContext();
            Context envCtx = (Context) initCtx.lookup("java:comp/env");
            ds = (DataSource) envCtx.lookup("jdbc/mysql");
            Connection conn = ds.getConnection();
            ...
            conn.close();
In verità la connessione non viene chiusa ma resa disponibile per le future 
richieste.
Ovviamente anzichè fare tutto questo lavoro per ottenere il datasource dal 
contesto di conviene metterlo in una classe manager che gestisce il 
datasource.
Poi ti basterà fare
Manager.getConnection(); per ottenere la connessione quando necessario.

Grazie 1000.
Adesso si butto un occhio.
Ciao e buona domenica.
Sboffo.

 thread alla volta.
Certo, questo è il ruolo del pool: quando una classe richiede una
connessione, la deve "estrarre" dal pool, e non servirla più finché quella
connessione non viene restituita.

> Ah ora ho capito...usa il connection pooling.
Ah, ecco, mi pareva strano che non lo conoscessi! ;)

Nota: per questo genere di necessità di gestione dei pool è molto utile a
mio parere spendere una volta per tutte una giornata per imparare l'uso di
una libreria di aiuto come quella fornita dallo spring framework (spring
jdbc): spring ad esempio offre dei metodi per effettuare in maniera
"trasparente" una serie di operazioni che altrimenti dovresti effettuare
manualmente (in particolare restituire la connessione al pool). La mia
esperienza è che la quantità di codice necessaria per scrivere applicazioni
che fanno uso di jdbc si può ridurre drasticamente, e che può essere molto
più semplice usare funzionalità a cui magari non penseresti neanche (come il
batching, nei casi di update multipli in cascata).