Finalizar conexao e Exception no BAnco

Programação Java
#1

Duvida ao executar sqlException ?

public void incluir(VOCargo pVOCargo) throws SQLException  {

		PreparedStatement prepStatement = null;
String sql = " INSERT INTO CARGO (COD_CARGO , NOME_CARGO ) VALUES (? ,? )";
 
 try {
      		conexao = ControladorConexao.abrirConexao();
		
                prepStatement = conexao.prepareStatement(sql);
		prepStatement.setString(1, pVOCargo.getCodCargo());
		prepStatement.setString(2, pVOCargo.getNomeCargo());
			
			
		prepStatement.executeUpdate();
		prepStatement.close();
		conexao.close();

System.out.println("*--------------------------------------- Cargo Incluido com Sucesso.. ----------------------------------* \n\n");
		}
		catch (SQLException e) 
		{
			throw new SQLException(e.getMessage());
		}
	}

Gente a minha duvida nao é quanto ao codigo , que fike bem claro !!

A duvida é ?

Gente eu gostaria de saber , se no momento que for capturado uma Excecao , a minha conexao com o banco vai seria finalizada !?

POr isso coloquei (conexao.close():wink: dentro do meu try{}catch();

Pois eu gostaria de no momento que a exceção fosse chamada a minha conexoa com o banco fosse finalizada !!

Agradeço a quem ajudar !

#2

não…
assim que que um exceção é lançada, o fluxo do codigo é interrompido.

Neste caso vc poderia usar o finally, assim o conteudo do bloco finally sempre será executado, por exemplo :

[code]
public void incluir(VOCargo pVOCargo) throws SQLException {

  PreparedStatement prepStatement = null;

String sql = " INSERT INTO CARGO (COD_CARGO , NOME_CARGO ) VALUES (? ,? )";

try {
conexao = ControladorConexao.abrirConexao();

            prepStatement = conexao.prepareStatement(sql);
  prepStatement.setString(1, pVOCargo.getCodCargo());
  prepStatement.setString(2, pVOCargo.getNomeCargo());
     
     
  prepStatement.executeUpdate();

System.out.println("--------------------------------------- Cargo Incluido com Sucesso… ---------------------------------- \n\n");
}
catch (SQLException e)
{
throw new SQLException(e.getMessage());
}
finally{
prepStatement.close();
conexao.close();
}
} [/code]

sempre o finall será executado, mesmo que nenhuma exceção seja lançada !

#3

eclipse_lunar, existe um outro esquema pra você garantir o fechamento do teu banco.

No try, além do catch, existe o finally que sempre é chamado, mesmo dando erro ou não.

Então você pode colocar o conexao.close(); dentro do finally.

try { statements; } catch (exceptionType1 identifier1) { // one or multiple statements; } catch (exceptionType2 identifier2) { statements; } ... } finally { // one or none statements; }

Entendido?! E so respondendo a tua pergunta, ele nao vai ser fechado, caso o erro seja causado!

P.S. O unico momento em que o FINALLY não é chamado, é quando você tem o método System.exit() dentro o try ou do catch…

Abraços!

#4

O que voces me indicam ?

Criar uma Connection global ou criar uma Conncection dentro de cada metodo ?

Exemplo .:

 public class Teste {
 
         private Connection conexao = null ;
 
         public void InserirCargo() {
                
        conexao = Conexao.abrirConexao() ; // Chama a classe que abre conexao com o banco ;
        
          }
 }

   public class Teste {
 
         public void InserirCargo() {
                
        Connection conexao = Conexao.abrirConexao() ; // Chama a classe que abre conexao com o banco ;
        
          }
 }

Agradeço novamente !

#5

cara…
no seu exemplo sempre sera criada um nova conexao, a unica diferenca é a referencia. Porem a referencia não é o objeto em si, ela é apenas um “controle remoto”, pra acesso ao objeto.

agora se vc criar a conexao no se construtor, ae sim seria criada apenas uma conexão por instancia.

a implementalção da sua classe Conexao, terá grande influencia em qual implementação seria a ideal.

Post ae o metodo abrirConexao !

#6 
public class ControladorConexao {

	
	public static Connection abrirConexao() throws SQLException {
		
		OracleDataSource conexao = new OracleDataSource();
		conexao.setDriverType(driver);
		conexao.setUser(usuario);
		conexao.setPassword(senha);
		conexao.setURL(url);

        
		return conexao.getConnection();
				
		
		
		  
	}
	
	
}//fim da classe
#7

Sobre sua pergunta se é melhor uma conexão para todas as requisições ou uma conexão para cada requisição:

Criar uma conexão com o banco é um processo extremamente pesado, pois envolve rede, autenticação, etc… Portanto criar uma pra cada requisição não é interessante.

Mas se na sua aplicação há a possibilidade de varias consultas serem realizadas ao mesmo tempo (aplicação web por exemplo) nesse caso usar uma conexão só pode acarretar em uma grande perda de performance pois uma conexão só consegue executar uma consulta de cada vez, então as requisições que forem chegando terão que esperar a consulta que está sendo realizada terminar, e lá se vai o desempenho da sua aplicação.

Pra resolver as duas coisas geralmente é usado um pool de conexões, ele é uma mistura da primeira com a segunda solução, são criadas varias conexões e são mantidas abertas e cada consulta vai pegando uma conexão e usando.

Então, se sua aplicação é desktop e executa uma consulta só por vez, use uma conexão só, se é web ou faz varias consultas simultaneas, use um pool.

#8

POw valeu pela ajuda !

Entao independente da forma que eu faça a conexao com o banco , utilizando pool de conexao quebra o meu galho !?

Valeu

#9

cara, eu dei uma olhada na classe OracleDataSource, e parece que ela não gerencia o pool, sempre é criada uma nova conexao.
Por favor, me corrijam se eu estiver errado, dei uma olhada mto rapida na API.

Agora ja a classe OracleOCIConnectionPool que estende OracleDataSource, da opções de configuracao do pool.

no meu ponto de vista eu alteraria sua classe conexao, onde esta classe seria um singleton http://en.wikipedia.org/wiki/Singleton_pattern, para que so houvesse uma instacia dessa classe, e que so seria necessaria a criacao da conexao uma unica vez.

e criaria um metodo, obterConexao(), onde vc devolveria uma conexao pra as classes que precisam de acesso ao banco.

Ficaria +/- assim:

[code]
public class ControladorConexao {

private static ControladorConexao instance;

private OracleDataSource conexao;

private ControladorConexao()
{
conexao = new OracleDataSource();
conexao.setDriverType(driver);
conexao.setUser(usuario);
conexao.setPassword(senha);
conexao.setURL(url);
}

public static ControladorConexao getControladorConexao(){
if (instance == null)
{
instance = new ControladorConexao();
}
return(instance);
}

public static Connection abrirConexao() throws SQLException {
return conexao.getConnection();
}
}//fim da classe [/code]

public class Teste { public void InserirCargo() { Connection conexao = ControladorConexao.getControladorConexao().abrirConexao() ; // Chama a classe que abre conexao com o banco ; } }

De uma olhada na documentacao das classes OracleOCIConnectionPool,OracleDataSource. Tente usar pool de conexao, pois assim a performance de sua app sera bem melhor.

#10

A conexao que eu quis dizer aqui, e a criacao do dataSource OracleDataSource !

#11