JDBC – Java Database Connectivity

Por Edmilson Prata - 2005

Baseado no material do professor Alessandro Cerqueira

1. O que é JDBC

O JDBC (Java Database Connectivity) é uma API Java para acesso a bancos de dados
relacionais através de SQL. Ele é inspirado no ODBC (Open Data Base Connectivity) e vale para
qualquer banco (dependente da disponibilidade de um driver). O pacote padrão é o “java.sql” e é
importante lembrar que para utilizá-lo é preciso conhecer os comandos SQL.

Boa parte da implementação dos recursos presentes no pacote “java.sql” é feita através
das classes presentes nos drivers JDBC. O pacote “java.sql” é um framework que é instanciado
pelos drivers associados a cada banco. Este framework oferece um padrão de comunicação com
as bases de dados, definindo interfaces para serem implementadas por quem queira construir um
driver para um SGBD específico, isto é, o framework dita as regras de “como construir um
driver”.

Para que um programa Java possa acessar um BD Relacional é necessário ter um driver
JDBC (que na realidade é um conjunto de classes disponibilizadas pelo fabricante do SGBD).
Estes drivers podem ser de quatro tipos, a saber:

 O driver de Tipo 1 é o
que utiliza os recursos do
driver ODBC para o
acesso ao BD, este driver
é disponibilizado através
da “Java Runtime
Classes” que vem que
com o JDK;
 O Driver de Tipo 2 é
aquele que acessa
diretamente o BD, mas
utiliza internamente uma
API disponibilizada pelo
SGBD. O código desta
API mistura Java e C Fig 1 - Tipos de Drivers JDBC.
(Código Nativo);
 O driver deTipo 3 é aquele que foi feito totalmente em Java e para acessar o BD
utiliza uma infra-estrutura de middleware para se comunicar com o Servidor;
 O driver de Tipo 4 é aquele que foi feito totalmente em Java e acessa o servidor
diretamente.

Java – JDBC – Edmilson Prata Página 1

2. Padrões da API JDBC

A figura 2 abaixo trás os padrões da API JDBC. O padrão atual para o JDBC é o 4.0.

Fig 2 – A API java.sql.

3. JDBC via ODBC

Para configurar uma

aplicação utilizando o driver Tipo
1, para acesso a um banco de
dados, ou seja, através de ODBC,
siga os seguintes passos:

 Acesse o Painel de
Controle  Ferra-
mentas Administra-
tivas  Fontes de
Dados (ODBC);

 Na guia “Fontes de
Dados de Usuário”,
conforme tela de-
monstrada na figura 3
ao lado, clique no
botão “Adicionar”;
Figura 3 – Tela “Fontes de dados (ODBC)

Java – JDBC – Edmilson Prata Página 2

  Na tela “Criar nova
fonte de dados”
(figura 4 ao lado)
selecione o tipo da
fonte de dados que
você vai utilizar, ou
seja, o driver para a
sua fonte de dados.
Há várias opções
disponíveis;

Figura 4 – Tela de configuração do DSN

 A aplicação irá apresentar a tela demonstrada na figura 5, que solicita algumas

informações sobre a
fonte de dados que
você deseja
adicionar ao
gerenciador ODBC
do sistema. Você
deve informar o
“Nome da fonte de
dados”, que será
uma referencia a
esta fonte que você
deverá utilizar no
código da aplicação
Java que esta
desenvolvendo e,
com o botão Figura 5 – Tela de configuração do DSN
“Selecionar”, você deve localizar e indicar a base de dados propriamente dita, ou seja,
o banco de dados que a aplicação deverá acessar.

Java – JDBC – Edmilson Prata Página 3

4. A URL JDBC

Para o estabelecimento de uma conexão com um BD, a partir da aplicação que você está
desenvolvendo, é necessário indicar qual driver esta aplicação deverá utilizar, a localização do
SGBD e o nome da base a ser utilizada. Para isto, devemos indicar uma URL JDBC com o
seguinte formato:

“jdbc:<subprotocolo>:<dsn>”

Vejamos agora o que significa cada parte desta String:

 A palavra “jdbc” indica que o driver é um JDBC (Java Database Connectivity);

 O subprotocolo indica qual driver iremos utilizar;
 O DSN é a indicação que será utilizada pelo driver especificado para localizar o
SGBD e a base de dados. Este DSN foi configurado anteriormente no gerenciador
ODBC do sistema operacional.

Exemplos:

a) jdbc:mysql://unigranrio.edu.br/base
b) jdbc:odbc:bdalunos
C) jdbc:oracle:thin:@102.20.34.13:1521:bdcorp
d) jdbc:postgresql://localhost:5432/bdalunos"

5. Estabelecendo uma conexão com o banco de dados

Para se estabelecer uma conexão é preciso, antes de tudo, carregar o driver JDBC que
será responsável pela comunicação com o SGBD. Para isto devemos utilizar a classe Class, que
é uma classe presente no pacote java.lang e possui o objetivo de descrever os metadados de uma
determinada classe (nome, atributos e métodos), e o seu método estático forName, que por sua
vez, serve para solicitar ao Class Loader da JVM a carga antecipada do bytecode de uma
determinada classe. Em outras palavras, utilizando “Class.forName(<nome do
driver>)” você solicita ao compilador que carregue as classes responsáveis por realizar as
operações com o banco de dados, que nada mais é do que o driver JDBC.

Depois de carregado o driver JDBC, podemos solicitar que o “Gerenciador de Drivers”

do Java faça uma conexão com a base de dados. Isto poderá ser feito utilizando-se a classe
DriverManager, que é o Gerenciador de Drivers propriamente dito, e o seu método estático
“getConnection”. A classe DriverManager faz parte da API java.lang.object, como demonstrado
na Figura 02; ela se utilizará das informações contidas na URL JDBC, passadas a ela por
parâmetro, para estabelecer a conexão com o Banco de Dados.

Java – JDBC – Edmilson Prata Página 4

 Vejamos agora um pequeno resumo sobre as descrições de classes que acabamos de ver e
ainda algumas outras que não vimos, mas que são muito importantes:

 Class: Classe do pacote “java.lang” que possui o objetivo de descrever os metadados

de uma determinada classe. Com o seu método estático forName nós carregamos o
driver JDBC que permitirá uma conexão com um SGBD.
Exemplo: Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");

 DriverManager: É o “Gerenciador de Drivers” do Java, pertencente ao JDBC, que

também é responsável pelas conexões com os SGBDs. O método desta classe
utilizado para estabelecer uma conexão com um BD é o “getConnection”. Será
preciso informar ao método a URL JDBC, a conta e a senha de um usuário com
autorização para estabelecer a conexão.
Exemplo:
Connection conexao;
conexao=DriverManager.getConnection("jdbc:odbc:Exemplo", conta,
senha);

 ClassNotFoundException: Classe de exceção que é disparada quando o método

forName, da classe Class, não encontrar o bytecode da classe especificada no
parâmetro, ou seja, quando o driver JDBC não for encontrado.p

 SQLException: É a classe de exceção que indica a ocorrência de algum erro com o

JDBC, que pode ser por exemplo um problema com uma consulta SQL, um problema
com o SGBD, etc. Todos os métodos JDBC podem disparar esta exceção e, por isto,
somos obrigados a colocar as mensagens dentro de um bloco de “try...catch”.

5. Realizando Operações no Banco de Dados

As operações de inserção, alteração e consulta no banco de dados podem ser realizadas

utilizando-se a classe PreparedStatement que é a classe cujas instâncias preparam a execução
de um comando SQL para ser enviado ao SGBD. Ela é geralmente utilizada em consultas pré-
definidas e que apresentam variações apenas nos dados a serem passados como parâmetros.
Estes são identificados pelo caractere de interrogação (?), na String SQL a ser submetida.

Vejamos agora os métodos da classe PreparedStatement:

 <ref PreparedStatement>.set<tipoDado> (<posição numérica>, <valor>): Tem a

função de definir (setar) os valores dos parâmetros do comando SQL a ser submetido.
Exemplo: PreparedStatement comando = conexao.prepareStatement(”INSERT
INTO ESTADO VALUES (?, ?, ?, ? ");
 <ref PreparedStatement>.executeUpdate(): Solicita a execução do comando SQL que
foi definido para a instância em referência;
Exemplo: comando.executeUpdate();
 <ref Connection>.commit(): Solicita o commit da transação, ou seja, efetivação da
operação no banco.
Exemplo: comando.commit();

Java – JDBC – Edmilson Prata Página 5

 Outra forma de realizar as operações no banco de dados é utilizando a classe Statement,
que é uma generalização de PreparedStatement. Neste caso, ao executar o comando deveremos
sempre passar a uma String pronta com o comando SQL.

Para submeter às operações ao SGBD basta utilizar o método executeQuery, escrito na

forma: <ref Statement>.executeQuery(stringSQL). Se fosse um PreparedStatement, não haveria
necessidade do parâmetro “stringSQL” pois o comando teria sido preparado previamente. Este
método devolve uma referência para um ResultSet.

O ResultSet é a classe cujas instâncias representam o resultado de uma consulta. Ela

funciona como um cursor sobre as tuplas retornadas pela consulta realizada no banco. Para a
navegação podemos utilizar os métodos: boolean next(), boolean first(), boolean last(), boolean
absolute(posição), entre outros (ver Javadoc).

Vejamos algumas formas para a recuperação de dados de um ResultSet:

 <ref ResultSet>.get_____(posição): Retorna o campo da tupla referenciada

correntemente pelo ResultSet dada a sua posição;
 <ref_ResultSet>.get_____(nomeCampo): Retorna o campo da tupla utilizando como
referencia o nome do campo ao invés de sua posição na tupla;
 <ref ResultSet>.close( ): Libera recursos no banco associados ao ResultSet.

A seguir alguns Parâmetros Avançados para a Criação de Statements:

 CONCUR_READ_ONLY: Indica que modo de concorrência para o ResultSet não

pode ser atualizado;
 CONCUR_UPDATABLE: Indica que modo de concorrência para o ResultSet pode
ser atualizado;
 FETCH_FORWARD: Indica que as tuplas no ResultSet serão processadas da
primeira para a última;
 FETCH_REVERSE: Indica que as tuplas no ResultSet serão processadas da última
para a primeira;
 FETCH_UNKNOWN: Indica que as tuplas no ResultSet serão processadas em um
modo desconhecido;
 TYPE_FORWARD_ONLY: Indica que o processo de navegação sobre as tuplas será
sempre para frente;
 TYPE_SCROLL_INSENSITIVE: Indica que o ResultSet é rolável mas não é sensível
às mudanças de outros usuários;
 TYPE_SCROLL_SENSITIVE: Indica que o ResultSet é rolável e sensível às
mudanças de outros usuários.

Java – JDBC – Edmilson Prata Página 6

6. Mapeamento dos Tipos ANSI SQL para Java:

 CHAR  String  TIME  java.sql.Time

 VARCHAR  String  TIMESTAMP  java.sql.Timestamp
 LONGVARCHAR  String  String  VARCHAR or
 NUMERIC  java.math.BigDecimal LONGVARCHAR
 DECIMAL  java.math.BigDecimal  java.math.BigDecimal NUMERIC
 BIT boolean  boolean BIT
 TINYINT byte  byte  TINYINT
 SMALLINT short  short  SMALLINT
 INTEGER  int  int  INTEGER
 BIGINT long  long  BIGINT
 REAL  float  float  REAL
 FLOAT double  double  DOUBLE
 DOUBLE  double  byte[] VARBINARY ou
 BINARY byte[] LONGVARBINARY
 VARBINARY byte[]  java.sql.Date  DATE
 LONGVARBINARY byte[]  java.sql.Time  TIME
 DATE  java.sql.Date  java.sql.Timestamp  TIMESTAMP

Exemplos:

A partir de agora veremos alguns exemplos demonstrando operações de estabelecimento

de conexão, liberação de conexão, inserção e alteração de dados na base de dados para
exemplificar o que vimos até aqui sobre o assunto JDBC. Vejamos a seguir um exemplo que
demonstra o estabelecimento de uma conexão:

import java.sql.*;
…
Connection conexao;
try{
// Carregando driver ODBC-JDBC
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
// Abrindo uma conexão com o via ODBC
conexao=DriverManager.getConnection("jdbc:odbc:Teste", conta,
senha);
// As transações serão efetivadas apenas após o commit
conexao.setAutoCommit(false);
}
Catch (ClassNotFoundException cnfe) {
System.out.println(“Não encontrado o driver JDBC-ODBC:"+
cnfe.getMessage( ) );
}
Catch (SQLExceptionsql e) {
System.out.println(“Erro na conexão: " + sqle.getMessage( ) );
}

Java – JDBC – Edmilson Prata Página 7

 O código abaixo demonstra a liberação de uma conexão aberta, isto é muito importante
quando não formos mais utilizar a conexão para que a aplicação não consuma recursos do SGBD
desnecessariamente.

Connection conexao;
...
try {
// Fechando a conexão
conexao.close( );
}
catch (SQLException sqle) {
System.out.println(“Erro no fechamento da conexão: "+
sqle.getMessage( ) );
}

O próximo exemplo demonstra uma operação de inserção de dados utilizando um objeto

do tipo PreperedStatement, que permite trabalhar com operações pré-definidas (e por isso pré-
compiladas) no código, dependendo apenas do envio dos dados necessários a esta operação.

import java.sql.*;
...
Connection conexao;
try{
// Criando o Comando SQL
PreparedStatement comando = conexao.prepareStatement(”INSERT
INTO ESTADO VALUES (?, ?, ?, ? ");
// Definindo os dados para a operação
comando.setString(1, “RJ”);
comando.setString(2, “Rio de Janeiro”);
comando.setString(3, “Rio de Janeiro”);
comando.setBigDecimal(4, new BigDecimal(10000000L));
// Executando a operação
comando.executeUpdate();
// Solicitando o Commit para efetivar a operação no BD
conexao.commit();
// Fechando o PreparedStatement e liberando recursos no banco
comando.close();
}
catch (SQLException sqle) {
System.out.println(“Erro na inserção:" + sqle.getMessage() );
}

Este exemplo realiza uma operação de atualização na base de dados:

import java.sql.*;
...
Connection conexao;
try{
// Criando o Comando
PreparedStatement comando = conexao.prepareStatement("UPDATE
ESTADO SET POPULACAO = ? WHERE SIGLA = ?");
// Definindo os parâmetros (dados) para a execução
comando.setBigDecimal(1, new BigDecimal(12500000L));
comando.setString(2, “RJ”);
// Executando
comando.executeUpdate();
// Solicitando o Commit
conexao.commit();

Java – JDBC – Edmilson Prata Página 8

 // Fechando o PreparedStatement e liberando recursos no banco
comando.close();
}
Catch (SQLException sqle) {
System.out.println(“Erro na inserção: " + sqle.getMessage( ) );
}

Este exemplo realiza uma operação de remoção na base de dados:

import java.sql.*;
…
Connection conexao;
try{
// Criando o Comando
PreparedStatement comando = conexao.prepareStatement(“DELETE FROM
ESTADO WHERE SIGLA = ?");
// Definindo os parâmetros
comando.setString(1, “GB”);
// Executando
comando.executeUpdate();
// Solicitando o Commit
conexao.commit();
// Fechando o PreparedStatement e liberando recursos no banco
comando.close();
}
catch(SQLException sqle) {
System.out.println(“Erro na inserção: " + sqle.getMessage( ) );
}

Este exemplo realiza uma operação de consulta na base de dados:

import java.sql.*;
…
Connection conexao;
try{
// Criando o Comando
Statement comando = conexao.createStatement( );
// Executando a consulta
ResultSet rs = comando.executeQuery(“SELECT * FROM ESTADO");
// Recuperando os dados
while(rs.next( ) ) {
System.out.println(“Sigla: “+ rs.getString(1));
System.out.println(“Nome: “+ rs.getString(2));
System.out.println(“Capital: “+ rs.getString(3));
System.out.println(“População: “l+ rs.getBigDecimal(4));
}
// Fechando o ResultSet e liberando recursos no banco ti
rs.close();
// Fechando o PreparedStatement e liberando recursos no banco
comando.close();
}
catch(SQLException sqle) {
System.out.println(“Erro na consulta: "+ sqle.getMessage( ) );
}

Java – JDBC – Edmilson Prata Página 9