Banco de dados com Java

O acesso a dados externos é um dos recursos mais usados e mais úteis na área de desenvolvimento. Quase todos os sistemas desenvolvidos precisam de um banco de dados, havendo raras exceções. Neste post veja banco de dados com Java.

O Java, diferente de linguagens como PHP, não suporta o acesso a banco de dados diretamente, para isso ele usa uma API (conjunto de classes e interfaces) para fazer o serviço.

A JDBC (Java Database Connectivity), faz o envio de instruções SQL para qualquer banco de dados relacional, desde que haja um driver que corresponda ao mesmo presente.

Existem quatro tipos de drivers JDBC: 1, 2, 3 e 4. Aqui usaremos o tipo 4 por ser o mais recomendado.

O tipo 4 converte as chamadas diretamente no protocolo do banco de dados em questão, dando assim uma performance melhor, além, é claro, de ser o mais simples de se usar.

Muitos podem encontrar uma certa semelhança entre JDBC e ODBC; estão absolutamente corretos, podemos dizer a “grosso modo” que as duas seguem a mesma ideia.

Ambas funcionam como meio de comunicação Banco X Aplicação, porém, ODBC é uma aplicação Windows restrito apenas a ele, enquanto a JDBC, por ser escrita em java, é multiplataforma.

Outra das vantagens da JDBC é o fato dela funcionar como uma camada de abstração de dados.

Independente do SGBD utilizado, a API será a mesma, facilitando muito a vida dos programadores caso haja a necessidade de uma migração de banco.

Acessando bancos de dados em JDBC

A primeira coisa a fazer é estabelecer uma conexão com o banco de dados. Fazemos isso em dois passos: primeiro carregamos o driver para o banco de dados na JVM da aplicação.

Uma vez carregado, o driver se registra para o DriverManager e está disponível para a aplicação. Utilizamos então a classe DriverManager para abrir uma conexão com o banco de dados.

A interface Connection designa um objeto, no caso con, para receber a conexão estabelecida:

try
     { //A captura de exceções SQLException em Java é obrigatória para usarmos JDBC 
 
        //Este é um dos meios para registrar um driver 
	Class.forName("sun.jdbc.odbc.JdbcOdbcDriver").getInstance(); 
 
	//Registrado o driver, vamos estabelecer uma conexão 
	Connection con = DriverManager.getConnection("jdbc:odbc:meusCdsDb","conta","senha");
      }	catch(SQLException e) {

		//se houve algum erro, uma exceção é gerada para informar o erro
		e.printStackTrace(); //vejamos que erro foi gerado e quem o gerou  
     }

Estabelecida a conexão, podemos executar comandos SQL para o banco de dados. Vejamos como realizar uma consulta sobre o título, numero de faixas e o artista de cada CD no banco de dados.

Podemos usar 3 interfaces para executar comandos SQL no banco de dados. A primeira delas é a interface Statement, que permite a execução dos comandos fundamentais de SQL (SELECT, INSERT, UPDATE ou DELETE).

A interface PreparedStatement nos permite usufruir de SQL armazenado ou pré-compilado no banco, quando o banco de dados suportar este recurso.

A terceira interface é CallableStatement, e permite executar procedimentos e funções armazenados no banco quando o banco suportar este recurso. Vejamos como utilizar a interface Statement.

File noDiretorioAtual = new File("arquivo.txt");  
File noDiretorioAnterior = new File("../arquivo.txt");

/* Após estabelecermos a conexão com o banco de dados, utilizamos o método 
createStatement de con para criar o Statement */ 
 
Statement stm = con.createStatement();  

// Vamos executar o seguinte comando SQL : 
String SQL = "Select titulo, autor, total_faixas from MeusCDs"; 

A interface ResultSet permite colher os resultados da execução de nossa query no banco de dados. Esta interface apresenta uma série de métodos para prover o acesso aos dados:

// Definido o Statement, executamos a query no banco de dados 
ResultSet rs = stm.executeQuery(SQL); 

/* O método next() informa se houve resultados e posiciona o cursor do banco 
na próxima linha disponível para recuperação. 
Como esperamos várias linhas, utilizamos um laço para recuperar os dados */ 

while(rs.next()) {
	
  // Os métodos getXXX recuperam os dados de acordo com o tipo SQL do dado: 
  String tit = rs.getString("titulo"); 

  String aut = rs.getString("autor"); 
  int totalFaixas = rs.getInt("total_faixas");

   /* As variáveis tit, aut e totalFaixas contém os valores retornados 
      pela query. Vamos imprimí-los */ 
  
  System.out.println("Titulo: "+tit+" Autor: "+aut+" Tot. Faixas: "+totalFaixas); 
} 

E nosso acesso está terminado. O importante agora é liberar os recursos alocados pelo banco de dados para a execução deste código.

Podemos fazer isso fechando o Statement, que libera os recursos associados à execução desta consulta mas deixa a conexão aberta para a execução de uma próxima consulta, ou fechando diretamente a conexão, que encerra a comunicação com o banco de dados.

Para termos certeza de que vamos encerrar esta conexão mesmo que uma exceção ocorra, reservamos o fechamento para a cláusula finally() do tratamento de exceções.

finally 
  {
    try  
    {
      con.close(); 
    }
    catch(SQLException onConClose)  
    {
      System.out.println("Houve erro no fechamento da conexão"); 
      onConClose.printStackTrace(); 
    }
  }

Dúvidas ou sugestões? Deixem nos comentários! Para mais dicas, acesse o nosso canal no YouTube:
https://youtube.com/criandobits

Tags: banco de dados | java | jdbc | odbc