trabalhando com banco de dados
Objetivo
Esperamos que, ao final desta aula, você seja capaz de:
compreender os conceitos relacionados à conexão de aplicações grá- •
ficas com banco de dados.
Pré-requisitos
Para iniciarmos esta aula, é importante ter concluído a disciplina de ban- co de dados já apresentada e, além disso, ter assimilado todo conhecimento referente às aulas anteriores. Sendo mais específico: serão necessários, co- nhecimento básico de SQL (Structured Query Language), além de dominar os conceitos quantos aos componentes da linguagem de programação Java para aplicações visuais.
introdução
Uma funcionalidade primordial em qualquer sistema, é a habilidade para comunicar-se com um repositório de dados. A Linguagem Java possui uma Application Programming Interface (API) que possibilita o acesso a repositórios de dados através de um modelo de conexão uniforme, permi- tindo uma padronização no acesso a distintos bancos de dados. Esta API é a Java DataBase Connectivity (JDBC).
4.1 jdbC
A API JDBC consiste em uma biblioteca, implementada em Java, que disponi- biliza classes e interfaces para o acesso ao banco de dados. Para cada banco de dados, deve haver uma implementação (também chamada de driver) dessas inter- faces, levando em consideração as suas particularidades (THOMPSON, 2002).
4.1.1 tipos de drivers jdbC
Conforme mencionado, a API JDBC utiliza-se de diversos tipos de drivers que possibilitam a conexão de aplicações com banco de dados. Os principais
drivers são apresentados a seguir.
4.1.1.1 jdbC-OdbC
Também conhecido como Ponto JDBC-ODBC, é restrito à plataforma Windows, este tipo utiliza ODBC para conectar-se com o banco de dados, convertendo méto- dos JDBC em chamadas às funções do ODBC. Este tipo de conexão geralmente é usado quando não há um driver “puro-java”, que será descrito na seção 4.1.1.4 logo a seguir, para um determinado banco de dados (THOMPSON, 2002).
4.1.1.2 driver APi-nativo
Este é o responsável por traduzir as chamadas realizadas com o JDBC para realizadas com a API cliente do banco de dados utilizado. Assim como o driver JDBC-ODBC, pode ser que sejam necessários que outras soluções e aplicativos estejam instalados nas máquinas clientes, para que a conexão possa ser estabelecida (THOMPSON, 2002).
4.1.1.3 driver de Protocolo de rede
A utilização do driver de protocolo de rede funciona, convertendo a chama- da por meio do JDBC para um protocolo de rede, que independe do banco de dados que está sendo utilizado, fazendo com que os dados sejam traduzidos para o protocolo do banco de dados. Desta forma, devido ao fato de se utilizar de protocolos que não se prendem a um determinado banco de dados, este con- siste no modelo de conexão mais flexível e abrangente (THOMPSON, 2002).
4.1.1.4 driver nativo
Este drive, por sua vez, converte as chamadas JDBC diretamente no pro- tocolo do banco de dados. Este, que é implementado na linguagem Java, nor- malmente independe de plataforma, é escrito pelos próprios desenvolvedores, tornando o muito flexível. É o tipo mais recomendado para ser usado e mais utilizado no mercado (THOMPSON, 2002).
4.1.2 Pacote java.sql
O pacote java.sql é o responsável por fornecer a API para acesso e pro- cessamento de dados armazenados em uma fonte de dados, geralmente em uma base de dados relacional, utilizando a linguagem de programação Java. As principais classes e interfaces do pacote java.sql são (DEITEL, 2005):
DriverManager,
• responsável por criar uma conexão com o banco de dados;
Connection,
• classe responsável por manter uma conexão aberta com o banco;
Statement,
• gerencia e executa instruções SQL;
PreparedStatement,
• gerencia e executa instruções SQL, permitin- do também a passagem de parâmetros em uma instrução;
ResultSet,
• responsável por receber os dados obtidos em uma pesquisa ao banco.
Prosseguindo nos tópicos seguintes, serão descritas e exemplificadas cada uma dessas principais classes e interfaces, que tornam possível o armazena- mento e recuperação de informação em base de dados.
Saiba mais
Conforme mencionado, os drivers são os responsáveis pela maneira como a aplicação realizará a comunicação com o banco de dados. Com isto, é interessante ficar atento aos drivers disponíveis para o banco de dados que estamos utilizando, uma vez que este pode fornercer uma interface que otimize essa comunicação, como por exemplo, com o banco de dados Oracle.
4.1.3 drivermanager
A Classe DriverManager é a responsável pelo gerenciamento de drivers JDBC. Esta classe também proporciona o estabelecimento de conexões a ban- cos de dados (THOMPSON, 2002).
// Carregando um driver em tempo de execução
Class.forName(“org.gjt.mm.mysql.Driver”);
// Tentando estabelecer conexão com o Banco de Dados
Connection conn =
DriverManager.getConnection(“jdbc:mysql://localhost/ aula04?autoReconnect=true”, “conta”, “senha”);
No código apresentado, primeiramente um driver é carregado em tem- po de execução para que seja possível a tentativa de estabelecer conexão com o banco de dados, por meio do método getConnection() da classe DriverManager. Este método retorna uma implementação para a interface
Connection, então vamos a ela?
4.1.4 Connection
A interface Connection representa a conexão com o banco de dados. Todas as operações executadas entre a aplicação Java e o banco de dados ocorrem dentro do contexto desta interface (SUN, 2007).
No código exibido no tópico anterior, um objeto da interface Connection
(conn) recebe a conexão estabelecida com o banco de dados através da
classe DriverManager. Tal objeto é capaz de proporcionar informações sobre as tabelas do banco, capacidades de sua conexão, quais gramáticas de SQL são suportadas pelo banco, entre outros. Estes são métodos desta interface freqüentemente utilizados (SUN, 2007):
commit()
• , executa todas as alterações feitas com o banco de dados pela atual transação.
rollback()
• , desfaz qualquer alteração feita com o banco de dados pela atual transação.
close()
Note, porém que os métodos fornecidos pela interface Connection não trabalham diretamente com os dados, lidando somente com características de como o banco irá se comportar.
4.1.5 Statement
O objeto desta interface fornece métodos para executar uma instru- ção SQL estática, sem passagem de parâmetros. Os principais métodos da Interface Statement são (SUN, 2007):
executeUpdate()
• , executa instruções SQL do tipo: INSERT, UPDATE e DELETE;
execute()
• , executa instruções SQL de busca de dados do tipo SELECT;
close()
• , libera o recurso que estava sendo utilizado pelo objeto.
// Instanciando o objeto statement (stmt)
Statement stmt = conn.createStatement();
// Executando uma instrução SQL.
stmt.executeUpdate(“INSERT INTO ALUNO VALUES (1, ‘Pedro da Silva’)”);
O código acima mostra a instância de um objeto do tipo Statement (stmt) através do método createStatement(), do objeto conn da interface
Connection. Após a instância do objeto stmt, é executada uma instrução
SQL de inserção em uma tabela de um banco de dados, a partir do método
executeUpdate().
4.1.6 PreparedStatement
A interface PreparedStatement possui todos os recursos da interface Sta- tement, acrescentando a utilização de parâmetros em uma instrução SQL. Os principais métodos da interface PreparedStatement são (SUN, 2007):
execute()
• , consolida a instrução SQL informada;
setDate()
• , método utilizado para atribuir um valor do tipo Data;
setInt()
• , utilizado para atribuir valores do tipo inteiro;
setString()
// Instanciando o objeto preparedStatement (pstmt)
PreparedStatement pstmt = conn.prepareStatement(“UPDATE ALUNO SET NOME = ?”);
// Setando o valor ao parâmetro
pstmt.setString(1, “MARIA RITA”);
O código acima apresenta a instância do objeto pstmt da classe Prepare- dStatement, através do método prepareStatement(), do objeto conn da classe Connection. Após a instância, o objeto pstmt utiliza o método setString() para passar o valor do parâmetro criado na instrução SQL anteriormente.
4.1.7 resultSet
Esta interface permite o recebimento e gerenciamento do conjunto de da- dos resultante de uma consulta SQL, realizada ao banco de dados. Ela propor- ciona métodos capazes de acessar os dados provenientes da consulta SQL. Alguns dos métodos desta interface frequentemente utilizados (SUN, 2007):
next()
• , move o cursor para a próxima linha de dados, já que o conjunto de dados retornados pela consulta SQL é armazenado como em uma lista.
close()
• , libera o recurso que estava sendo utilizado pelo objeto.
getString(String columnName)
• , recupera o valor da coluna informada
como parâmetro, da linha atual do conjunto de dados recebidos pelo objeto ResultSet.
//Recebendo o conjunto de dados da consulta SQL
ResultSet rs = stmt.executeQuery(“SELECT id, nome FROM ALUNO”);
// Se houver resultados, posiciona-se o cursor na próxima linha de dados while (rs.next()) {
// Recuperando os dados retornados pela consulta SQL
int id = rs.getInt(“id”);
String nome = rs.getString(“nome”); }
Este código exibe uma instância da interface ResultSet (rs), recebendo um conjunto de dados retornados pela consulta SQL, caso esta retorne algo. Esta consulta contém a seleção de dois campos: id e nome. Com o método
next(), caso haja resultados, o cursor que indica qual linha de dados do con-
junto está em evidência, é apontado para a próxima linha. Assim, é possível recuperar os valores dos campos selecionados com métodos como o getInt(),
4.2 Exemplo de uma aplicação
O exemplo contido nesta seção apresenta uma aplicação com uma base de dados MySQL. Essa aplicação contém tudo o que foi mostrado nos tópicos anteriores. O código abaixo mostra o início de uma classe chamada Aula04. java, mostrando as importações necessárias para a aplicação funcionar. En- tão, mãos à obra, transcreva o código a seguir.
import java.awt.Frame; import java.awt.List; import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; public class Aula04 {
private Connection conn;
private PreparedStatement pstmt; private Statement stmt;
private ResultSet rs;
Após as importações, foram declarados quatro atributos, os quais serão necessários para a interação com o banco. Além desses atributos, esta aplica- ção contém sete métodos apresentados logo a seguir.
public void open() { try { Class.forName(“org.gjt.mm.mysql.Driver”); conn = DriverManager.getConnection( “jdbc:mysql://localhost/aula04?autoReconnect=true”, “root”, “”); } catch (ClassNotFoundException e) { e.printStackTrace(); } catch (SQLException e) { e.printStackTrace(); } }
public void close() { try { if (stmt != null) stmt.close(); conn.close(); } catch (SQLException e) { e.printStackTrace(); } }
Para esta aplicação, foi utilizado o Tipo de driver 4 (drive nativo). O método
open() atribui a string de conexão do banco em questão (MySQL). Logo a seguir é
instanciado um objeto conn da interface Connection, passando como parâmetro o tipo de driver, o local do servidor, o usuário e senha. A intenção deste método é ape- nas abrir uma conexão com o banco. O próximo método, close(), faz exatamente o contrário do método open(), ou seja, somente fecha a conexão com o banco.
public void inserir(){ try {
// Abrindo a conexão com o banco
open();
// Instanciando o objeto statement (stmt)
stmt = conn.createStatement();
// Executando uma instrução SQL.
stmt.executeUpdate(
“INSERT INTO ALUNO VALUES (1, ‘Pedro da Silva’)”);
// Fechando a conexão com o banco
close();
} catch (SQLException e) {
// Fechando a conexão com o banco
close();
e.printStackTrace(); }
}
O método inserir() utilizou a interface Statement para adicionar um aluno ao banco. Observe que para rodar esta aplicação, teremos que possuir uma tabela Aluno, contendo duas colunas, id e nome. Neste método foi aberta uma conexão com o banco, através do método open(), logo após criou-se uma ins- tância da interface Statement (stmt). Este objeto executou um método chamado
executeUpdate(), passando como parâmetro uma instrução SQL de inserção
de dados. Ao final foi fechada a conexão com o banco.
public void alterar(){ try {
// Abrindo a conexão com o banco
open();
// Instanciando o objeto preparedStatement (pstmt)
pstmt = conn.prepareStatement(“UPDATE ALUNO SET NOME = ? Where id = 1”);
// Setando o valor ao parâmetro
pstmt.setString(1, “MARIA RITA”);
// Fechando a conexão com o banco
pstmt.execute(); close();
} catch (SQLException e) {
// Fechando a conexão com o banco
close();
e.printStackTrace(); }
O método alterar() é bem parecido com o inserir(). Apenas foi utilizada ou- tra classe para a execução da instrução SQL. Neste caso, utilizamos a interface PreparedStatement, que funciona de forma semelhante à interface Statement, mas possui a grande vantagem de se passar parâmetros a uma instrução SQL. Na instância da interface PreparedStatement (pstmt), é informada a instrução SQL. Nesta instrução, espera-se alterar o nome de um aluno que possui o id igual a “1”, inserido no método anterior. Nesta mesma instrução, logo após o nome, foi utilizado o caractere “?”, que significa a criação de um parâmetro. Na próxima linha, o objeto pstmt utiliza o método setString() para atribuir o va- lor ao parâmetro em questão. Repare que são informados dois valores: qual o parâmetro e o seu devido valor. Neste caso, como só existe um parâmetro, foi informado o número “1”. Se houvesse mais parâmetros, seriam informados na seqüência: “2”, “3” etc. Logo após informar o valor do parâmetro, é executado o método execute() do objeto pstmt, consolidando a alteração no banco.
public ResultSet buscarAlunos(){ try {
open();
stmt = conn.createStatement();
rs = stmt.executeQuery(“SELECT id, nome FROM ALUNO”); return rs; } catch (SQLException e) { close(); e.printStackTrace(); } return null; }
O método seguinte, buscarAlunos(), utiliza o Statement, para fazer uma pesquisa ao banco, através do método executeQuery(). Este retorna um objeto do tipo ResultSet ao objeto rs, contendo os dados selecionados da tabela Alu- no. Este método será utilizado logo a seguir para imprimir os dados na tela.
public void imprimirAlunos() throws SQLException{
List listAlunos = new List(); Aula04 aula = new Aula04(); aula.rs = aula.buscarAlunos();
while (aula.rs.next())
listAlunos.add(“Id: “ + aula.rs.getInt(“id”) + “ - “ + “Nome: “ + aula.rs.getString(“nome”)); Frame janela = new Frame(“Janela”);
janela.setLocation(300, 300); janela.setSize(300, 300); janela.add(listAlunos); janela.setVisible(true); }
O método imprimirAlunos() utilizou componentes do pacote AWT para a impressão dos alunos na tela. Foram feitas instâncias das classes List e Aula04. O objeto aula faz uma pesquisa no banco, através de seu método buscarA-
lunos(), explicado anteriormente, e logo a seguir é feito um laço de repetição
para adicionar os valores ao objeto listAlunos. Logo após, é criado o objeto janela do tipo Frame, atribuindo valores de posição e tamanho. Depois disso, é adicionada a lista de alunos à janela, a qual é exibida na tela.
Pensando sobre o assunto
Assim como foi utilizado um objeto do tipo List para a exibição dos valores obtidos junto ao banco de dados, diversos outros componentes poderiam ter sido utilizados. Dentre esses podemos citar o componete Jtable da biblioteca Swing. Com isto, sugerimos testes e uma leitura mais detalhada sobre quais componentes podem receber valores de uma consulta a um banco de dados.
public static void main(String[] args ){
Aula04 aula = new Aula04(); aula.inserir(); aula.alterar(); aula.rs = aula.buscarAlunos(); try { aula.imprimirAlunos(); } catch (SQLException e) { e.printStackTrace(); } }
Finalmente, o código acima apresenta o método main(), de execução pa- drão de uma classe Java. Nele, apenas se instância o objeto da classe Aula04 e executa os métodos explicados anteriormente. Assim finalizamos nossa 4ª aula, refaçam todos os exemplos para um melhor aproveitamento dela.
Síntese da aula
Nesta aula, foram apresentados os conceitos relacionados à conexão de aplicações Java com banco de dados. Inicialmente foram apresentados os tipos de conexão JDBC possíveis, além de detalhar cada um destes. Depois, foram consideradas as classes que fazem parte de uma conexão nativa do Java, apresentado sua utilização. Finalmente, foi criado um exemplo que fizes- se uso de todos os conceitos vistos anteriormente.
Atividades
1. Levando em consideração os tópicos apresentados nesta aula, quais são os
métodos implementados pela Interface Connection, para controle da conexão com um banco de dados e qual o objetivo destes?
2. Qual a diferença entre as interfaces Statement e PreparedStatement?
Comentário das atividades
Na atividade 1, os métodos que são implementados pela interface Con- nection, constem em: commit(), que executa todas as alterações feitas pela atual transação; rollback(), que desfaz qualquer alteração feita pela atual transação; close(), que libera o recurso que estava sendo utilizado pelo obje- to. Já na atividade 2, a primeira consiste em uma interface que disponibiliza métodos para a execução de claúsulas SQL, sem a passagem de parâmetros, no caso estáticos. Já a interface PreparedStatement, além de possuir todos os métodos disponibilizados pela primeira interface, fornece suporte à passagem de parâmetros para as claúsulas que esta executa.
referências
DEITEL, Harvey M. Java: como programar. 6 ed. São Paulo: Pearson Prentice Hall, 2005.
THOMPSON, Marco Aurélio. Java 2 & banco de dados. São Paulo: Éri- ca, 2002.
SUN, MicroSystem. Java Technology. Disponivel em http://java.sun.com. Acessado em 12 out. 2007.
na próxima aula
Serão apresentados os conceitos relacionados a construção de aplica- ções utilizando a classe Applets Java, fornecendo suporte para que possamos disponibilizar aplicações visuais Java para a WEB.