Pool de conexões, modelo normal?

Programação Java
#1

Ola amigos estou com um problema em relação ao pool de conexões. Antes utilizava apenas a abertura e fechamento de conexões JDBC normais. Porém senti a necessidade de incrementar um pouco mais a minha apliacação para aumentar a performance. Resolvi implementar um pool de conexões. Contudo acho que alguma coisa no meu modelo de pool está no local errado, pois vira e mexe as minhas páginas travam e não conseguem mais consultar o banco, gostaria de saber se alguém poderia me dar uma maneira de acabar com esse problema, vou descrever o meu modelo.

Criei um bean para criar o pool de conexões:
É o seguinte:

PersistenciaBDPool.java


package objetos;

import org.apache.commons.dbcp.ConnectionFactory;
import org.apache.commons.dbcp.DriverManagerConnectionFactory;
import org.apache.commons.dbcp.PoolableConnectionFactory;
import org.apache.commons.dbcp.PoolingDataSource;
import org.apache.commons.pool.ObjectPool;
import org.apache.commons.pool.impl.GenericObjectPool;


public class PersistenciaBDPool {

    //Driver do fabricante de banco de dados (MySql)
	private static String drv = "org.gjt.mm.mysql.Driver";
	
	//Localização do host da base de dados
	private static String url = "jdbc:mysql://localhost:3306/dbintranet";
	
	//Usuário e Senha de conexão com o banco
	private static String user = "root";
	private static String password = "";

    private static PoolingDataSource dataSource;
    
    private static boolean registroOk = false;
    
	/**
	 * Método que registra o banco de dados em uso, utilizando os atributos da classe
	 * e utiliza a API dbcp commons da jakarta apache para implementar o pool de 
	 * conexões do banco de dados
	 */
	public static void registrarPoolDoBanco() {
	    
		try {
			Class.forName(drv);
		} catch (ClassNotFoundException e) {
			System.err.print(
				"Erro ao carregar o driver do banco.\nContacte o administrador do sistema.");
			e.printStackTrace();
		}
		
		ObjectPool connectionPool = new GenericObjectPool(null);
		ConnectionFactory connectionFactory = new DriverManagerConnectionFactory(url,null);
		PoolableConnectionFactory poolableConnectionFactory = new PoolableConnectionFactory(connectionFactory,connectionPool,null,null,false,true);
		dataSource = new PoolingDataSource(connectionPool);
		registroOk = true;
	}
	
    public static PoolingDataSource getDataSource() {
        return dataSource;
    }
    public static void setDrv(String drv) {
        PersistenciaBDPool.drv = drv;
    }
    public static void setPassword(String password) {
        PersistenciaBDPool.password = password;
    }
    public static void setUrl(String url) {
        PersistenciaBDPool.url = url;
    }
    public static void setUser(String user) {
        PersistenciaBDPool.user = user;
    }
    public static boolean isRegistroOk() {
        return registroOk;
    }
    public static void main(String[] args) {
    }

}

Toda vez que o usuário vai fazer alguma ação, cadastrar, pesquisar, alterar, chamo o método dentro da classe correspondente e lá verifico se o pool já foi carregado na memória, caso tenha sido utilizo os elementos JDBC normais (ResultSet e Statement) e realizo as operações, caso contrário mando carregar o pool de conexões pelo método visto acima (registrarPoolDoBanco()). Segue abaixo um exemplo com a classe Noticia.java. Aonde para visualizar uma noticia utilizo o metodo visualizar(). A classe com os elementos JDBC que trabalham com o pool e a classe exemplo (Noticia.java) seguem abaixo:

classe PersistenciaBD.java

package objetos;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class PersistenciaBD {

	//Objetos de manipulação da base de dados. (Connection, Statement e ResultSet)
	private Connection con;
	private Statement stmt;
	private ResultSet rs;
	
	/**
	 * Realiza a conexão com o banco
	 * @throws SQLException
	 */
	public void fabricarConexao() throws SQLException {
        //Verifica se o pool de conexões já está carregado na memória.
	    //Caso não esteja ele registra o pool para obter as conexões.
	    if(!PersistenciaBDPool.isRegistroOk()) {
            PersistenciaBDPool.registrarPoolDoBanco();
        }
        
	    //Obtém uma conexão do pool
        con = PersistenciaBDPool.getDataSource().getConnection();
        stmt = con.createStatement();
        
    }
	
	/**
	 * Finaliza a conexão com o banco
	 * Devolvendo ao pool a conexão solicitada anteriormente
	 */
	public void destruirConexao() throws SQLException {

	    try {

	        //Operações a serem realizadas antes de fechar os elementos
	        //da conexão

		} finally {
			try { rs.close(); } catch(Exception e) {}
			try { stmt.close(); } catch(Exception e) {}
			try { con.close(); } catch(Exception e) {}
		}
	}


    public Connection getCon() {
        return con;
    }
    public ResultSet getRs() {
        return rs;
    }
    public Statement getStmt() {
        return stmt;
    }
	public static void main(String[] args) {
	}
}

classe Noticia.java


package objetos;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.text.SimpleDateFormat;
import java.util.ArrayList;

public class Noticia {
    
    //Atributos da classe notícia
    private String titulo, subTitulo, fonte, 
    			   conteudo, dataNoticia, imagem;

    private int cod,capa;
    /**
     * Retorna um objeto da classe Noticia, para ser visualizado.
     * O objeto retornado é selecionado de acordo com o parametro cod
     * @param cod utilizado para localizar o registro na base de dados
     * @return um objeto da classe Noticia para ser visualizado
     */
    public void visualizar(int cod) {
	    
        boolean retorno = true;
        PersistenciaBD persistenciaBD = new PersistenciaBD();
        Noticia noticia = new Noticia();
        
        try {
            
            persistenciaBD.fabricarConexao();
			
		    Statement stmt = persistenciaBD.getStmt();
			ResultSet rs = persistenciaBD.getRs();
			
            rs = stmt.executeQuery("select * from Noticia where cod = " + cod);

            if(rs.next()) {
                this.cod = rs.getInt("cod");
                titulo = rs.getString("titulo");
                subTitulo = rs.getString("subtitulo");
                conteudo = rs.getString("conteudo");
                dataNoticia = new SimpleDateFormat("dd/MM/yy").format(rs
                        .getDate("dataNoticia"));
                imagem = rs.getString("imagem");
                capa = rs.getInt("capa");
                fonte = rs.getString("fonte");
            }
            
            persistenciaBD.destruirConexao();
           
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

Se alguém souber de algum motivo os quais podem estar prejudicando o bom funcionamento da aplicação estou a aguardar. Talvez a lógica utilizada no modelo não seja a melhor, estou aguardando sugestões. Um grande abraço a todos.!

PS: O POOL QUE ESTOU UTILIZANDO É O commons/dbcp da JAKARTA.

Um grande abraço a todos.

#2