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.