Bom dia a todos
Estava eu em um tópico na semana passada falando sobre conexões JDBC quando o vinny disse que uma boa prática para a aplicações desktop era fornecer conexões por meio de uma api especializada, e para isso e por isso me indicou o DBCP da apache.
Bom, eu fui no google pesquisei um bocado e encontrei um exemplo que me mostra como criar um pool, mas ainda não estou enxergando a vantagem disso. Estou dizendo isso por que eu não consegui por exemplo configurar a quantidade de conexões que o pool deve fornecer (nesse caso apenas uma) e por isso eu gostaria da opinião dos colegas a respeito da classe que foi criada.
O exemplo que estudei não foi copiado na integra coloquei algumas coisas minhas no meio mas em suma a classe está funcionando mas eu ainda não sei se essa é a forma ideal.
Segue a classe:
package dao;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Properties;
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;
import util.ArquivosUtil;
/**
* Arquivo criado em: 23/09/2010
* @author Laudelino Martins Cardoso Neto
*/
public class ConexaoDbcp {
private static ConexaoDbcp objeto = null;
private Properties props;
private ObjectPool connPool;
private PoolingDataSource dataSource;
private ConnectionFactory connFactory;
private PoolableConnectionFactory pcf;
private ConexaoDbcp() {
carregarConfiguracoesBd();
configurarDataSource1forRAC();
}
/**
* Método que carrega os dados de acesso ao banco a partir de um
* arquivo properties
*/
private void carregarConfiguracoesBd(){
try{
String caminhoBanco = ArquivosUtil.getCaminhoAplicacao()+"/conexao.properties";
File file = new File(caminhoBanco);
FileInputStream fis = null;
this.props = new Properties();
fis = new FileInputStream(file);
props.load(fis);
}catch(IOException ex){
System.out.println(ex.getMessage());
ex.printStackTrace();
}
}
/**
* Método que cria o dataSource
*/
private void configurarDataSource1forRAC(){
try{
Class.forName(props.getProperty("nome_da_classe_oracle"));
connPool = new GenericObjectPool();
connFactory = new DriverManagerConnectionFactory(props.getProperty("url_conexao"),
props.getProperty("usuario"),
props.getProperty("senha"));
pcf = new PoolableConnectionFactory(connFactory, connPool, null, null, false, true);
dataSource = new PoolingDataSource(connPool);
}catch (Exception e) {
e.printStackTrace();
}
}
/**
* Método que fornece uma conexão com o banco de dados
* @return
*/
public Connection getConexaoRAC(){
try{
return dataSource.getConnection();
}catch (SQLException sqle){
sqle.printStackTrace();
}catch (Exception e){
e.printStackTrace();
}
return null;
}
public void showStatusDataSource(){
System.out.println("Conexões ativas: "+this.connPool.getNumActive());
System.out.println("Conexões inativas: "+this.connPool.getNumActive());
}
/**
* Método que fecha os recursos do banco de dados
* @param rs ResultSet
* @param ps PreparedStatement
*/
public static void liberarRecursosBD(ResultSet rs, PreparedStatement ps){
try{
if (ps != null)
ps.close();
if (rs != null)
rs.close();
}catch (SQLException sqle){
sqle.printStackTrace();
}catch (Exception e){
e.printStackTrace();
}
}
/**
* Padrão singleton para essa classe, dessa forma apenas um objeto fornece
* conexões encapsulando a lógica de pool de conexões
* @return
*/
public static synchronized ConexaoDbcp getInstance(){
if (objeto == null)
objeto = new ConexaoDbcp();
return objeto;
}
/**
* Método sobreescrito que impede o objeto de ser clonado
*/
@Override
public Object clone() throws CloneNotSupportedException{
throw new CloneNotSupportedException("Este objeto é único e não pode ser clonado!");
}
}//Fim da classe ConexaoDbcp
Gostaria de saber se essa classe fornece meios de se controlar o pool de conexões para que sempre fique ao menos uma conexão aberta
PS: Isso será usado em aplicações desktop/Swing
Agradeço a atenção de todos
(alias já fiz isso uma vez e não é nada legal…)