JDBC – Trabalhando com banco de dados em Java

JDBC – Trabalhando com banco de dados em Java
Leonardo Heidrich
Universidade do Vale do Rio dos Sinos (Unisinos)
Unisinos 950, São Leopoldo, RS, Brasil
[email protected]
Resumo
Em um primeiro momento, o conceito e a
estrutura JDBC serão apresentados, citando facilidades
do uso desta API e motivos pelo qual ela é tão
freqüentemente
utilizada
pela
maioria
dos
programadores Java.
Em seguida, as principais classes e métodos
serão mostrados juntamente com exemplos de como
acessar registros em um banco de dados.
melhor opção, uma vez que ganha em desempenho e
também é a opção multi-plataforma. Na figura 01, pode
ser visto como é estruturada essa API [1][2]:
1. Introdução
JDBC, ou Java Data Base Connectivity
(Conectividade Java com Banco de Dados), é um
conjunto de interfaces e classes em Java que tem como
objetivo padronizar o modo com que um aplicativo
qualquer se conecte com banco de dados. É inspirado no
padrão Microsoft de acesso a banco de dados, ODBC
(Open DataBase Connectivity), porém tem a vantagem de
ser multi-plataforma. Além da independência da
plataforma, o Java também visa obter independência de
banco de dados, conforme será verificado mais adiante.
Isto significa que ao se trocar de banco de dados, esperase pouca alteração na aplicação, aumentando o reuso de
um aplicativo.
Figura 01 – Estrutura da API
2. Estrutura
A API JDBC permite utilizar caminhos distintos
para acessar a base de dados, ou seja, podem-se escolher
diferentes drivers de diferentes tipos. O primeiro tipo é a
conexão através de uma ponte jdbc-odbc. Levando em
consideração que a ponte jdbc-odbc já vem incorporada
ao JDK, e juntamente com o driver ODBC, esta opção se
torna a mais fácil de se utilizar. No segundo tipo, o driver
é obtido a partir de uma API nativa. Isto significa que o
driver Java faz chamadas nativas à C ou C++ para subrotinas definidas pelo fornecedor do banco de dados. Esta
alternativa exige a instalação de software cliente. O último
tipo se dá através de um driver específico JDBC. Esta é a
3. Instalando o JDBC
Para instalar o JDBC ou componentes
necessários para acessar o banco de dados, deve-se
instalar o JDK e logo em seguida o driver específico do
banco de dados. Vários fabricantes de banco de dados e
terceiros disponibilizam gratuitamente os drivers para
acessar seus respectivos bancos [1].
Há dois passos para se instalar qualquer driver
JDBC. Primeiramente, precisa-se descompactar os
arquivos baixados, e posteriormente, deve-se adicionar o
caminho para as classes desse driver em seu
CLASSPATH. É bom saber que todo driver de banco de
dados nada mais é do que classe(s) que contém métodos
de acesso ao banco de dados.
Outra forma de definir a acessibilidade do driver
para o compilador é gerar o arquivo .jar do driver e
colocar no diretório /jre/lib, diretório onde se encontra o
JDK. A CLASSPATH diz ao interpretador e ao
compilador Java onde encontrar as classes necessárias
para execução. Para fazer com que a Máquina Virtual
Java encontre o driver e possa utilizá-lo, a variável de
ambiente CLASSPATH precisa ser modificada.
4. Conexão
O JDBC usa a classe DriverManager e duas
interfaces Driver e Connection, para se conectar a um
banco de dados. A classe Driver proporciona à JDBC um
ponto de partida para a conectividade de banco de dados
respondendo às requisições de conexão de DriverManager
e fornecendo informações sobre a implementação em
questão. A classe DriverManager tem como principal
responsabilidade manter uma lista de implementações de
drivers. A classe Connection é utilizada para enviar uma
série de dados de instruções SQL ao banco de dados e
controlar o registro ou o aborto dessas instruções. Para
efetuar uma conexão, a primeira ação a ser feita para que
o JDBC funcione é obter um objeto Connection que
representa a conexão de rede para o banco de dados que
contém a informação que se deseja trabalhar. A
classe DriverManager gerencia o estabelecimento de
conexões. O DriverManager precisa ser avisado com qual
drivers JDBC ele deve tentar criar conexões. A forma
mais fácil para fazer isto é usar o método forName() na
classe que implementa a interface Driver. Na figura 02,
pode-se ver um exemplo de como criar uma conexão com
JDBC [2]:
Na imagem anterior, primeiramente o driver é
carregado. Em seguida, a conexão com a base de dados
escolhida é estabilizada passando como parâmetros o
local onde a base está instalada, o usuário e senha de
acesso ao banco. Caso, por algum motivo, a conexão não
tenha sido estabelecida, a exception adequada é chamada.
5. Manipulação de Dados
A API do JDBC disponibiliza classes para
trabalhar com a manipulação de registros de banco de
dados. Statements e PreparedStatement são as classes que
facilitam a manipulação de dados nessa API. São as
instâncias dessas classes que enviam suas declarações
SQL para o banco de dados.
5.1. Statements
Para obter um objeto Statement, deve-se chamar
o método createStatement() no objeto Connection que foi
obtido através do método getConnection(). Na figura 03
pode-se ver como se deve criar um objeto do tipo
Statement [3]:
Figura 03 – Criando uma statement
Para atualizar dados no banco de dados é
utilizado o método executeUpdate(StringSQL). Este
método retorna o número de linhas alteradas pela
sentença. Na figura 04 pode-se ver um exemplo de como
dados
são
atualizados
utilizando
o
método
executeUpdate():
Figura 04 – Atualizando dados utilizando statement
Comandos SQL que criam, alteram ou apagam
tabelas são todos exemplos de declarações DDL e são
executadas com o método executeUpdate. O método
executeUpdate() também deve ser usado em comandos
SQL que atualizam dados de uma tabela.
Figura 02 – Criando uma conexão com JBDC
5.2. PreparedStatements
A classe PreparedStatement herda de Statement,
mas difere do fato que o SQL que se deseja utilizar é
especificado
somente
uma
vez,
no
método preparedStatement(), como pode ser visto no
exemplo da figura 05:
Figura 05 – Atualizando dados utilizando
preparedStatement
Quando um PreparedStatment é criado, utiliza-se
interrogações ("?") como marcadores para parâmetros que
serão utilizados através dos métodos setXXX(). Algumas
vezes é mais conveniente ou mais eficiente usar um objeto
PreparedStatement para enviar sentenças SQL, porque
essa sentença já foi analisada pelo o banco de dados
Quando se deseja executar um objeto Statement
várias vezes, o tempo de execução será reduzido se for
utilizado um objeto PreparedStatement. A principal
característica de um objeto PreparedStatement é que,
diferente do objeto Statement, é dada uma sentença SQL
quando é criado. A vantagem para isto é que na maioria
dos casos, esta sentença SQL será enviada ao banco de
dados sempre, onde será compilada. No entanto, o objeto
PreparedStatement contém não somente uma sentença
SQL, mas uma sentença SQL que foi pré-compilada. Isto
significa que quando o PreparedStatement é executado, o
banco de dados pode simplesmente executar a sentença
sem ter que compilá-la primeiro.
Apesar dos objetos PreparedStatement poderem ser
utilizados com sentenças SQL sem parâmetros, é mais
freqüente a sua utilização com sentenças que adotam
parâmetros. A vantagem disso é que se pode usar o
mesmo parâmetro e supri-los com diferentes valores cada
vez que são executados.
6. ResulSet
ResultSets representam as linhas retomadas como
uma resposta a uma consulta. Uma vez se possui um
ResultSet, pode-se obter valores de qualquer campo na
linha, ou mover para a próxima linha no conjunto.
ResultSets são sempre posicionados antes da primeira
linha (se ela existe), portanto você precisa chamar next() e
verificar se foi retomado true (você está posicionado na
próxima linha) ou false (não há mais linhas).
Com objetos da classe ResultSet é possível
realizar operações no banco de dados, como inserir,
alterar ou deletar um registro. Na figura 06, pode-se ver
um exemplo de como se utiliza um resultSet para atualizar
um registro em um determinada tabela [3]:
Figura 06 – Utilização do resultSet
No exemplo anterior, após a criação de um
objeto do tipo Statement, executa-se um select na tabela
CIDADES para trazer ao ResultSet alguns registros do
banco de dados. Logo em seguida o cursor é posicionado
na primeira registro com o método first(). Com o método
updateInt() o primeiro campo é alterado. O mesmo
acontece com updateString() que altera o segundo campo
da tabela. Os dois métodos seguintes enviam o novo
registro ao banco e posicionam o cursor em uma posição
válida na tabela [3].
Como
foi
visto
anteriormente
o
método next() move o cursor para a próxima linha, na
qual ele poderá operar. Uma vez que o cursor é
inicialmente posicionado antes da primeira linha de um
objeto
ResultSet,
a
primeira
chamada
ao
método next() move o cursor para a primeira linha.
Invocações sucessivas do método next() movem o cursor
adiante uma linha por vez. Este ResultSet só rola num
único sentido, para o próximo registro. Não podemos
movimentar o cursor para uma determina linha, ou
navegar em sentido inverso.
A partir da JDBC 2.0, introduziu-se o conceito
de ResultSet rolável, ou seja, o cursor pode se
movimentar entre as linhas em qualquer sentido ou dando
saltos aleatórios. Além da vantagem de se navegar em
qualquer sentido, esse novo ResultSet também permite
atualizações diretas ao conjunto de valores armazenados
por ele, evitando o uso de chamadas ao método
executeUpdate() para atualizar cada linha de dados a ser
alterada.
Ambas
as
classes
Statements
e
PreparedStatements possuem construtores que aceitam
resultSets roláveis ou atualizáveis [3].
As opções para a criação de um cursor rolável
são definidas através de constantes da classe ResultSet. A
constante TYPE_FORWARD_ONLY é o padrão desde a
JDBC 1.0. Ela não permite cursores roláveis e somente é
possível acessar os dados do ResulSet avançando registro
por registro para frente. Outra constante é a
TYPE_SCROLL_INSENSITIVE. Ela permite cursores
roláveis e é possível navegar pelo ResultSet para frente
para trás, para uma posição específica e para uma posição
relativa à posição atual. A TYPE_SCROLL_SENSITIVE
é rolável da mesma forma que a anterior, porém alterações
em registros no banco de dados são refletidos no
ResultSet.
Já para a criação de um cursor atualizável, outras
constantes são definidas. A CONCUR_READ_ONLY não
é
atualizável,
ao
contrário
da
constante
CONCUR_UPDATABLE que é atualizável [3].
7. Conclusão
Neste artigo foi apresentada uma das maneiras de
como se comunicar com uma base de dados na linguagem
de programação Java.
Algumas facilidades são evidentes quanto à sua
utilização. Uma delas é o fato de não se ficar preso a um
tipo de banco de dados, deixando com que o programador
possa migrar para outras bases de dados apenas com
algumas modificações. Isso também acarreta em uma
grande reusabilidade de código.
Outra facilidade é que os comandos de acesso ao
banco são na linguagem SQL, já muito bem difundida e
de fácil aprendizagem.
8. Referências Bibliográficas.
[1] B. Jepson. “Programando Banco de Dados em Java”.
Afiliada, 1997, pg 27-58.
[2] G. Reese. “Database Programming with JDBC and
Java”. O`Reilly, 2000, pg 25-56.
[3] Revista Mundo Java, “O Futuro do Java Corporativo”.
Mundo, n 31, ano VI, 2008, pg 15-17.