Gestione dei Pool di Connessioni con Java

Queste operazioni sono spesso nascoste all'occhio dello sviluppatore che stabilisce la connessione con una o due chiamate di funzione. L'esecuzione di questa procedura è molto onerosa e richiede alcuni secondi per essere portata a termine.

Questo tempo è del tutto trascurabile nel caso di un'applicazione stand-alone che spesso viene mantenuta in esecuzione per tempi molto lunghi. Nel caso di un'applicazione web le cose cambiano: lo scopo infatti è quello di gestire una singola richiesta, accedere al database e dare la risposta nel tempo minore possibile. Se per ogni richiesta non fosse necessario stabilire una nuova connessione verso il database, i tempi di risposta ne risulterebbero significativamente migliorati; inoltre il server sarebbe meno sottoposto a problemi di sovraccarico, potendo così gestire un maggior numero di visitatori.

Un altro processo che debba accedere alla base di dati può in tal caso prelevare una connessione esistente dalla cache invece di stabilirne una nuova.

Per gestire le connessioni disponibili, la struttura dati migliore è una coda. In tal caso quando un processo deve accedere al database otterrà, prelevandola dalla coda, la connessione più vecchia fra quelle in cache, minimizzando la possibilità di caduta per le connessioni inutilizzate da troppo tempo.

Se non ci sono connessioni disponibili, il pool deve essere in grado di stabilirne una nuova. Pertanto deve avere a sua disposizione tutte le informazioni per farlo: generalmente si tratta di conoscere il driver, il login, la password di accesso e il nome del database.

In base a quanto detto sopra, il codice che gestisce un pool deve contenere almeno tre funzioni: getConnection per ottenere una nuova connessione prelevandola dalla coda o creandone una nuova se necessario; releaseConnection per liberare una connessione già utilizzata e garantirne il riutilizzo da parte di altri processi, inserendola nella coda delle connessioni disponibili; inoltre poiché se getConnection non trova nessuna connessione disponibile nella coda deve stabilirne una nuova, è necessario aggiungere la funzione newConnection che sia in grado di farlo quando richiesto.

Costruiamo innanzitutto una classe ConnectionPoolException, le cui istanze sono le eccezioni che verranno sollevate quando si dovesse presentare un errore a runtime nella classe ConnectionPool.

// Classe che gestisce le eccezioni sollevate a runtime dalla
// classe ConnectionPool
public class ConnectionPoolException extends Exception {
        public ConnectionPoolException() {
        }
}

L'idea è quella di avere una variabile statica connectionPool all'interno della classe ConnectionPool. Un metodo statico, getConnectionPool, permetterà di accedere a questa variabile da parte dei processi che ne fanno richiesta. Se la variabile non è stata ancora istanziata il metodo getConnectionPool provvederà alla sua istanziazione.

Dal momento che più processi accedono a getConnectionPool in concorrenza, definiamo il metodo come synchronized.

...

// La classe che gestisce un pool di connessioni
public class ConnectionPool {

...

// La variabile che gestisce l'unica istanza di ConnectionPool
private static ConnectionPool connectionPool = null;

...

public static synchronized ConnectionPool getConnectionPool()
                throws ConnectionPoolException {
        if(connectionPool == null) {
                connectionPool = new ConnectionPool();
        }
        return connectionPool;
}

...

}

Osserviamo che il costruttore è privato. In questo modo garantiamo che l'accesso ad esso avvenga solo tramite la funzione pubblica getConnectionPool.

import java.util.*;

...

// La classe che gestisce un pool di connessioni
public class ConnectionPool {

...

private Vector freeConnections; // La coda di connessioni libere
private String dbUrl;           // Il nome del database
private String dbDriver;        // Il driver del database
private String dbLogin;         // Il login per il database
private String dbPassword;      // La password di accesso al database

...

// Costruttore della classe ConnectionPool
private ConnectionPool() throws ConnectionPoolException {
        // Costruisce la coda delle connessioni libere
        freeConnections = new Vector();


        // Carica I parametric per l'accesso alla base di dati
        loadParameters();

        // Carica il driver del database
        loadDriver();
}

// Funzione privata che carica i parametri per l'accesso al database
private loadParameters() {
        // Url per un database locale
        dbUrl = "jdbc:mysql://localhost/prova";
        // Driver per database mysql
        dbDriver = "org.gjt.mm.mysql.Driver";
        // Login della base di dati
        dbLogin = "Login";
        // Password per l'accesso al database
        dbPassword = "Password";
}


// Funzione privata che carica il driver per l'accesso al database.
// In caso di errore durante il caricamento del driver solleva un'eccezione.
private loadDriver() throws ConnectionPoolException {
        try {
                java.lang.Class.forName(
                        dbDriver + "?user=" +
                        dbUser + "&password=" + dbPassword);
        } catch (Exception e) {
                throw new ConnectionPoolException();
        }
}

...

}

Se la coda e' vuota, getConnection chiama newConnection per stabilire una nuova connessione. Il metodo getConnection è di tipo synchronized perché può essere richiamato da più processi concorrenti.

Il metodo newConnection non deve necessariamente essere synchronized perché viene richiamato da getConnection che già opera in mutua esclusione.

import java.sql.*;

...

// Il metodo getConnection restituisce una connessione libera prelevandola
// dalla coda freeConnections oppure se non ci sono connessioni disponibili
// creandone una nuova con una chiamata a newConnection
public synchronized Connection getConnection()
throws ConnectionPoolException {

        Connection con;

        if(freeConnections.size() > 0) {

                // Se la coda delle connessioni libere non è vuota
                // preleva il primo elemento e lo rimuove dalla coda
                con = (Connection) freeConnections.firstElement();
                freeConnections.removeElementAt(0);

                try {
                        // Verifica se la connessione non è più valida
                        if(con.isClosed()) {
	                        // Richiama getConnection ricorsivamente
                                con = getConnection();
                        }
                } catch(SQLException e) {
                        // Se c'è un errore richiama GetConnection
                        // ricorsivamente
                        con = getConnection();
                }
        } else {
                // se la coda delle connessioni libere è vuota
                // crea una nuova connessione
                con = newConnection();
        }

        // restituisce la connessione
        return con;
}

// Il metodo newConnection restituisce una nuova connessione
private Connection newConnection() throws ConnectionPoolException {

        Connection con = null;

        try {
                // crea la connessione
                con = DriverManager.getConnection(dbUrl);
        } catch(SQLException e) {
                // in caso di errore solleva un'eccezione
                throw new ConnectionPoolException();
        }
        // restituisce la nuova connessione
        return con;
}

...
 

Questo metodo come getConnection opera in regime di concorrenza e deve quindi essere synchronized.

...

// Il metodo releaseConnection rilascia una connessione inserendola
// nella coda delle connessioni libere
public synchronized void releaseConnection(Connection con) {
        // Inserisce la connessione nella coda
        freeConnections.add(con);
}
..

Tecniche per gestire eccezioni e per la programmazione concorrente:
Java la guida completa - Patrick Naughton e Herbert Schildt - Mc Graw Hill
Core Java - Gary Cornell e Cay S. Horstmann - Sunsoft Press
Java Fondamenti di programmazione - Deitel & Deitel - Apogeo

Sviluppo di siti web dinamici tramite servlet:
Java Servlet Programmino - Jason Hunter e Williiam Crawford - O'Reilly

Accesso a database MySql da codice Java:
JSP Servlet e MySql - David Harms - McGraw Hill

Max length of comments: 1000 chars.

i commenti non sono un forum, leggi la documentazione di quel coso o domanda sul loro forum di supporto.

Add a comment (max 1000 chars)