Aprendendo JAVA com JDBC

Hoje, as aplicações são desenvolvidas através de interfaces amigáveis para que os usuários consigam trabalhar e manipular informações no banco de dados de forma facilitada.

Geralmente, muitos programadores estudam o mecanismo do JDBC - Java Database Connectivity que ajudam nas aplicações com bibliotecas de baixo nível e até mesmo servem de base para as de alto nível. Portanto, abaixo serão explicados os conceitos e práticas necessárias para conseguir começar a desenvolver um sistema baseado no JDBC.

O que é JDBC?

Pode-se dizer que é uma API que reúne conjuntos de classes e interfaces escritas na linguagem Java na qual possibilita se conectar através de um driver específico do banco de dados desejado. Com esse driver pode-se executar instruções SQL de qualquer tipo de banco de dados relacional.

Para fazer a comunicação entre a aplicação e o SGBDs é necessário possuir um driver para a conexão desejada. Geralmente, as empresas de SGBDs oferecem o driver de conexão que seguem a especificação JDBC para caso de algum desenvolvedor querer utilizar.

O que é um Driver?

Além de atuar como uma interface entre os SGBDs e as aplicações, também pode ser considerado como um tradutor que ajuda na definição das mensagens binárias trocadas com um protocolo de um SGBD.

Para desenvolver uma aplicação baseada em uma especificação JDBC é preciso entender algumas das principais classes e interfaces apresentadas abaixo.

Existe um ponto de atenção na importação das classes ou interfaces relacionadas ao pacote a ser usado no momento do desenvolvimento. Na Figura 1, é mostrado de forma correta a importação do pacote referente à classe Connection pertencente ao pacote java.sql. Esse é um fator a ser observado com cautela, pois isso é considerado um dos erros mais comuns justamente pelo fato do desenvolvedor pensar muitas vezes em usar o pacote com.mysql.jdbc sendo que está utilizando o driver JDBC do banco MySQL.

Figura 1: Importação da classe Connection

Pacote java.sql

Esse pacote oferece a biblioteca Java o acesso e processamento de dados em uma fonte de dado. As classes e interfaces mais importantes são:

Classe	Interface
DriverManager	Driver
	Connection
	Statement
	ResultSet
	PreparedStatement

A classe DriverManager

Cada driver que se deseja a usar precisa ser registrado nessa classe, pois oferece métodos estáticos para gerenciar um driver JDBC.

Para a aplicação reconhecer a comunicação com o banco de dados escolhido, é preciso obter um arquivo com a extensão .jar que geralmente se consegue através dos sites das empresas que distribuem o SGBD. Esse arquivo tem o objetivo ajudar no carregamento do driver JDBC. Na prática de um desenvolvimento voltado a web, é criada a pasta “lib” da pasta “WEB-INF” e inserido esse arquivo.

No caso apresentado na Figura 2, apenas foi criado à pasta “lib” por ser um projeto Java puro e adicionado a biblioteca copiada para dentro do projeto.

Figura 2: Adicionando a biblioteca MySQL Connector no projeto.

Listagem 1: Carregando o driver MySQL.

try {
 //Carrega o driver especificado
 Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException e) {
 System.out.println("Driver não encontrado!"+e);
}

Após o driver estar inicializado, pode-se abrir uma conexão através do método getConection da classe DriverManager. Esse método possui três sobrecargas apresentado na Listagem 2.

Listagem 2: Sobrecarga do método getConnection.

public static Connection getConnection(String url)
public static Connection getConnection(String url, Properties info)
public static Connection getConnection(String url, String user, String password)

A interface Connection

Representa uma conexão ao banco de dados. Nessa interface são apresentados os métodos mais utilizados.

Método close

Geralmente é inserido dentro do bloco finally para realizar sempre a sua execução, pois esse método serve para fechar e liberar imediatamente um objeto Connection.

Método isClosed

Serve para verificar se o objeto Connection está fechado.

Método createStatement

É usado para criar um objeto Statement que executa instruções SQL ao banco de dados.

Listagem 3: Método que cria uma conexão com o banco de dados.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class ConnectionFactory {
 
 public static Connection createConnection() throws SQLException{
  String url = "jdbc:mysql://localhost:3306/loja"; //Nome da base de dados
  String user = "root"; //nome do usuário do MySQL
  String password = "root"; //senha do MySQL
  
  Connection conexao = null;
  conexao = DriverManager.getConnection(url, user, password);
  
  return conexao;
 }
}

Método prepareStatement

É usado para criar um objeto que representa a instrução SQL que será executada, sendo que é invocado através do objeto Connetion.

Listagem 4: Exemplo da execução de uma instrução SQL através do prepareStatement

String sql = "INSERT INTO loja (nome,sobrenome,idade,salario) VALUES ('Mario','Corleone','28','2322.39')";
//Prepara a instrução SQL
PreparedStatement ps = conexao.prepareStatement(sql);
//Executa a instrução SQL
ps.execute();

setAutoCommit

Esse método aceita como parâmetro um valor booleano (true ou false), no qual consegue definir se todas as instruções executadas serão gravadas (comitadas). Por padrão, quando finalizada uma instrução de INSERT, UPDATE ou DELETE a operação de gravação (commit) é executada automaticamente sem a necessidade de invocar o método setAutoCommit. Agora, para instruções de SELECT, a gravação dos dados ocorre quando o conjunto de dados associados é fechado, ou seja, quando invocado o método close.

rollback

Usado para retornar uma transação, sendo muito usado dentro de blocos catch em caso de alguma operação gerar erro.

Listagem 5: Exemplos do método setAutoCommit, rollback e commit.

try {
 conexao.setAutoCommit(false);
 ps = conexao.prepareStatement(sql);
 ps.executeUpdate();
 
 //Grava as informações se caso de problema os dados não são gravados 
 conexao.commit();

} catch (SQLException e ) {
 if (conexao != null) {
  try {
   System.err.print("Rollback efetuado na transação");
   conexao.rollback();
  } catch(SQLException e2) {
   System.err.print("Erro na transação!"+e2);
  }
 }
} finally {
 if (ps != null) {
  ps.close();
 }
 conexao.setAutoCommit(true);
}

A interface Statement

Nesta interface são listados os métodos executeQuery e executeUpdate que são considerados os mais importantes referente a execução de uma query.

• executeQuery - Executa uma instrução SQL que retorna um único objeto ResultSet.
• executeUpdate - Executa uma instrução SQL referente a um INSERT, UPDATE e DELETE. Esse método retorna a quantidade de registros que são afetados pela execução do comando SQL.

Listagem 6: Exemplo do método executeUpdate.

String sql = "UPDATE funcionario SET nome=?, sobrenome=? WHERE codigo=?";
ps = conn.prepareStatement(sql);
ps.setString(1, nome);
ps.setString(2, sobrenome);
ps.setInt(3, codigo);
//Executa a instrução
int retorno = ps.executeUpdate();
if(retorno > 0){
 System.out.printf("Novo registro alterado: %d: %s - %s",codigo, nome,sobrenome);
}else{
 System.out.println("Não foi possível alterar os registros!");
} 

Interface ResultSet

Representa o conjunto de resultados de uma tabela no banco de dados. Esse objeto mantém o cursor apontando para a sua linha atual de dados, sendo que seu início fica posicionado na primeira linha.

Além disso, esse objeto fornece métodos getters referentes aos tipos de dados como: getInt, getString, getDouble, getFloat, getLong entre outros. Com esses métodos são possíveis recuperar valores usando, por exemplo, o nome da coluna ou número do índice.

Figura 3: Visão de como funciona a recuperação de valores através dos índices.

Listagem 7: Exemplo da listagem e recuperação dos valores através do objeto ResultSet.

conn = ConnectionFactory.createConnection();
   
String sql = "SELECT codigo, nome, sobrenome, idade, salario FROM funcionario";
ps = conn.prepareStatement(sql);

//Executa o comando de consulta aonde guarda os dados retornados dentro do ResultSet.
//Pelo fato de gerar uma lista de valores, é necessário percorrer os dados através do laço while 
ResultSet rs = ps.executeQuery();
//Faz a verificação de enquanto conter registros, percorre e resgata os valores
while(rs.next()){
 //Recupera valor referente ao nome da coluna
 int codigo = rs.getInt("codigo");
 //Recupera o índice do campo referente ao campo nome
 String nome = rs.getString(2); 
 String sobreNome = rs.getString("sobrenome");
 String nomeCompleto = nome.concat(" "+sobreNome);
 int idade = rs.getInt("idade");
 Double salario = rs.getDouble("salario");
 System.out.printf("Código %d: %s - %d | Salário: %f \n",codigo, nomeCompleto, idade, salario);
}

Conclusão

Portanto, o objetivo principal foi em obter conhecimentos básicos referentes às principais classes e interfaces do JDBC para que seja possível compreender certas funções quando se deparar a um código similar.