Você está na página 1de 17

JDBC – Características

Objetivos do Capítulo
• Pra que serve JDBC
• Entender sua funcionalidade

Primeiramente, o que devemos saber sobre JDBC é que ele é uma API J Java, faz parte
da biblioteca de classes. Essas classes fornecem para os programadores recursos para
manipularem banco de dados. O JDBC trabalha junto com a linguagem SQL (Structured
Query Language – Linguagem de Consulta Estruturada). Caso você não tenha nenhum
conhecimento em SQL não se preocupe, no capítulo _ abordaremos instruções básicas.
Uma das principais funções da API JDBC é separar programadores Java dos problemas
de banco de dados, ou seja, você pode executar o mesmo código para diferentes bancos
de dados.

Gerenciamento de Transação
Imagine que temos um banco de dados e uma aplicação que se conecte a ele. Todas as
transações que são realizadas entre esses dois elementos podem ser com sucesso ou sem
sucesso. O gerenciamento de transação tem exatamente essa função, de alertar se uma
transação teve sucesso ou não. Podemos optar por duas opções no registro de
transações, pode ser a cada instrução ou esperar por uma série de instrução para
registrar sucesso ou fracasso.

JDBC x Banco de Dados Relacional


A API JDBC é fortemente voltada para banco de dados relacionais, e sua linguagem de
consulta é a SQL. Entretanto Java trabalha orientado a objetos, assim precisamos em
nossa aplicação uma camada que mapeie o mundo relacional do mundo orientado a
objetos. Para exemplificar vamos imaginar um banco de dados relacional sobre carros.

Tab_Carros
Cod Marca Modelo Cor AnoFabr
01 Fiat Uno Cinza 1997
02 Ford Escort Prata 1999
03 Chevrolet Astra Preto 2004

Agora uma classe Carro em Java:

1. class Carro{
2. private int cod;
3. private String marca;
4. private String modelo;
5. private String cor;
6. private String anoFabr;
7.
8. //…
9. //setters e getters…
10. //…
11. }
Agora um código em grosso modo para exemplificar a função da classe de mapeamento
do mundo OO para o relacional.

1. class CarroDAO{
2.
3. public void gravar(Carro car){
4.
5. //conexões ao banco de dados...
6.
7. tab_Carros.cod = car.cod;
8. tab_Carros.marca = car.marca;
9. tab_Carros.modelo = car.modelo;
10. tab_Carros.cor = car.cor;
11. tab_Carros.anoFabr = car.anoFabr;
12.
13. }
14. }

Gostaria de deixar bem claro que o código acima apresentado


na classe CarroDAO não está correto do ponto de vista da
linguagem Java. Ele está sendo usado somente para
exemplificar a função da classe de mapeamento.

Vamos entender então a função da classe CarroDAO.

Linha 1:
class CarroDAO{

Declaramos a aqui a classe CarroDAO. No nome da classe fazemos referência a classe


na qual mapearemos para o mundo relacional junto a abreviação de Data Acess Objetc
(DAO – Objeto de Acesso a Dados) .

Linha 3:
public void gravar(Carro car){

Declaramos o método gravar, que recebe como argumento um objeto tipo Carro, e
armazena sua referência em car.

Linha 5:
//conexões ao banco de dados...

Aqui temos em forma de comentário a simulação da conexão ao banco de dados, que


para o nosso exemplo não é necessário. Mais adiante veremos em detalhes em vista do
JDBC como realizar a conexão ao banco de dados e executar comandos SQL como
INSERT, UPDATE, DELETE e SELECT.

Linha 7 a 11:
tab_Carros.cod = car.cod;
tab_Carros.marca = car.marca;
tab_Carros.modelo = car.modelo;
tab_Carros.cor = car.cor;
tab_Carros.anoFabr = car.anoFabr;

Temos em grosso modo referência à nossa tabela de carros e atribuímos a cada campo
valores respectivos do objeto car, que foi recebido através de argumento pelo método
gravar. Dessa forma temos a conversão dos valores de um objeto para uma tabela
relacional.
Como mencionado anteriormente, o código usado na classe CarroDAO não é correto ao
ponto de vista da linguagem Java. No capítulo _ teremos em detalhe o código Java para
realizar a mesma operação.

SQL Básico
Para nossos exemplos usaremos o banco de dados MySql v.5.0.45. Assim em outros
bancos de dados os comandos podem ser diferentes dos apresentados aqui.
Para efetuarmos consultas, inserções, exclusões ou alterações nos dados usamos a
linguagem SQL (Structured Query Language – Linguagem de Consulta Estruturada).
Dentro da linguagem SQL temos seus comandos divididos em grupos:
DML (Data Manipulation Language – Language de Manipulação de Dados)
DDL (Data Definition Language – Linguagem de Definição de Dados)
DCL (Data Control Language – Linguagem de Controle de Dados)
DQL (Data Query language – Linguagem de Consulta a Dados)

Para o foco da apostila explicaremos somente o grupo DML e alguns comandos a parte
de outros grupos.

CREATE – Grupo DDL

Para iniciarmos nossos exemplos precisamos ter um banco de dados, fazemos isso
digitando:

CREATE DATABASE nome_do_banco_de_dados;

Exemplo:

CREATE DATABASE apostila_java;

Para visualizarmos os bancos de dados existentes digitamos:

SHOW DATABASES;

E para saber o banco de dados que está em uso no momento usamos:

SELECT DATABASE();

Após criado o banco de dados devemos selecioná-lo como em uso. Para isso usamos:

USE nome_do_banco_de_dados
Exemplo:
USE apostila_java

O comando USE não necessitada de ponto-e-vírgula ao seu final, mas caso você o use
não fará diferença.
Após de criado o bando de dados e colocá-lo em uso devemos criar sua(s) tabela(s).
Para isso usamos:

CREATE TABLE nome_da_tabela(


nome_coluna tipo_coluna modificadores_coluna,
nome_coluna tipo_coluna modificadores_coluna,
....,
nome_coluna tipo_coluna modificadores_coluna)

Alguns modificadores importantes são:


PRIMARY KEY – Define uma coluna como chave primária
NOT NULL - Define que uma coluna não pode ser nula ( precisa inserir o dado)
UNIQUE - Define que o valor de uma coluna deve ser único
REFERENCES nome_tabela - Define que uma coluna é chave estrangeira

Exemplo – Criando tabela carros

CREATE TABLE tab_carros(


cod INT PRIMARY KEY,
marca CHAR(35),
modelo CHAR(35),
cor CHAR(25),
anoFabr CHAR(4))

Tab_Carros
Cod Marca Modelo Cor AnoFabr
01 Fiat Uno Cinza 1997
02 Ford Escort Prata 1999
03 Chevrolet Astra Preto 2004

Para visualizar se criamos a tabela conforme esperado digite:

DESCRIBE nome_da_tabela;

Exemplo:

DESCRIBE tab_carros;

Se por algum motivo precisar excluir uma tabela usamos o seguinte comando:

DROP TABLE nome_tabela;


Grupo DML
Nesse grupo temos os comandos INSERT, DELETE, UPDATE E SELECT (SELECT
pode ser encaixado também no grupo DQL – Data Query Language – Linguagem de
Consulta a Dados).

INSERT
Criamos uma tabela com propósito de armazenar dados. Quando desejamos inserir
algum dado na tabela usamos o comando INSERT que segue a sintaxe:

INSERT INTO nome_tabela VALUES ();

Exemplos:

INSERT INTO tab_carros VALUES (01, ‘Fiat’, ‘Uno’, ‘Cinza’,


‘1987’);

Caso deseje não inserir valor em todas as colunas pode ser feito da seguinte maneira:

INSERT INTO tab_carros VALUES (01, NULL, ‘Astra’,


‘Vermelho’, NULL);

Perceba o uso da palavra NULL, indica para o banco de dados a ausência de valor. No
lugar referente a coluna que desejamos não inserir valor colocamos a palavra NULL.
Permitido apenas quando a coluna não foi definida como NOT NULL.

Ou você pode especificar as colunas nas quais você deseja inserir os valores, ficando
dessa forma:

INSERT INTO nome_tabela ( coluna1, coluna2, ..., colunaN)


VALUES (valor1, valor2,..., valorN);

Observe que o valor1 é referente a coluna1, valor2 a coluna2 e assim respectivamente.


Da mesma forma devem ser seguidas as regras referentes aos modificadores da coluna.

Exemplo:

INSERT INTO tab_carros(cod, modelo, anoFabr) VALUES (04,


‘Ford’, ‘1998’);

UPDATE
A instrução UPDATE permite modificar dados já inseridos no banco de dados.

UPDATE nome_tabela SET nome_coluna = novo_valor WHERE


condição

Exemplo:

UPDATE tab_carros SET anoFabr = 2000 where cod = 01;


No nosso exemplo redefinimos o campo anoFabr para 2000 mas somente para a linha
que possui cod = 01. Nota, a saber, que se não usássemos a cláusula where todas as
linhas seriam modificadas para 2000.

DELETE
A instrução DELETE é usada quando desejamos excluir o conteúdo de uma linha
inteira.

DELETE FROM nome_tabela WHERE nome_coluna = valor;

Exemplo:

DELETE FROM tab_carros WHERE cod = 01;

Nessa situação excluiríamos a linha que possui o cod =1. Novamente, se não
possuíssemos a cláusula where todas as linhas seriam excluídas.

SELECT

Um dos mais importantes comandos da linguagem SQL. Possui umas das sintaxes mais
compridas. O select nos fornece suporte para pesquisas em nosso banco de dados. Sua
sintaxe de forma mais básica:

SELECT nome_coluna1, nome_coluna2, ...., nome_colunaN


FROM nome_tabela
WHERE nome_coluna = valor;
ORDER BY nome_coluna;

Exemplo:

SELECT modelo FROM tab_carros where cod <= 2 ORDER BY


modelo;

Nesse código seria selecionada a coluna modelo na qual o cod é menor igual que 2, e
seria mostrado para nós, ordenado em ordem alfabética, pelos nomes da coluna modelo.

Apresentamos nesse capítulo as formas mais básicas do comando SQL, a saber, sintaxes
mais avançadas a respeito, uma boa indicação é o site do MySQL:

http://dev.mysql.com/doc/refman/4.1/pt/index.html

JDBC – Estrutura
Objetivos do Capítulo
• Estrutura JDBC
• Drivers JDBC
Estrutura JDBC
Como dito anteriormente a função da API JDBC é fornecer aos programadores Java
conexão a diversos bancos de dados e traduzir o mundo relacional para o mundo
Orientado a Objetos e vice-versa. Essa API também fornece suporte para que
independente da linguagem usada na aplicação, você possa ter acesso a uma grande
quantidade de base de dados sem precisar programar métodos de acesso específicos.
Obviamente para acessar a uma determinada base de dados você precisa de um driver
específico da base de dados.

Existem 4 distintos grupos de Drivers:

Tipo 1 – Ponte JDBC-ODBC


Inicialmente, para que possamos entender esse conceito de ponte, temos que ter
claramente na mente o papel da API ODBC.
Muitos servidores de banco de dados usam seu protocolo próprio para comunicação
com o exterior. Dessa forma, para implementar uma aplicação que acesse a uma
determinada base de dados, é necessário que você aprenda primeiramente os métodos de
acesso da mesma, ou seja, um trabalho e tanto. Imagine agora uma aplicação que
necessite acessar vários tipos de bases de dados, o programador ficaria loco. Para
minimizar esse problema, a Microsoft elaborou uma API chamada ODBC. Sua principal
função é fazer com que o acesso à base de dados seja independente, o programador não
precisa saber os métodos de acesso específico das suas bases de dados, ele apenas
implementa métodos de acesso para a ODBC e assim a mesma faz a chamada na base
de dados. Porém para que a ODBC consiga acesso é necessário o Drive da determinada
base de dados.
Temos até aqui então a seguinte situação:

Na imagem percebemos que uma mesma aplicação tem acesso a duas base de dados,
isso é possível graças a ODBC, que através do Drive específico da consegue fazer
acesso. Dessa maneira é possível realizarmos acesso a quanta base de dados nos fosse
necessária.
Agora podemos entender como funciona a ponte JDBC – ODBC. Que nada mais é do
que uma ligação da API JDBC para a API ODBC. A função da ponte é apenas converter
chamadas tipo JDBC para ODBC, e quanto o retorno do banco de dados são várias
linhas de uma tabela, nos da suporte oferecendo objetos como ResultSet (visto adiante),
que possui métodos para manipulação.
Tipo 2 – JNMI

São construídos através do protocolo nativo da base de dados usada, ou seja, você tem
que saber como funcionam os controles de acesso da base de dados que você deseja
utilizar.

Tipo 3 – JDBC-Net Driver

Esta categoria consiste de drivers que conversam com servidores de acesso a banco de
dados através de um protocolo de rede padrão (como por exemplo, HTTP). Estes
servidores de acesso a banco de dados por sua vez ficam responsáveis em traduzir o
protocolo de rede em um protocolo nativo do sistema de banco de dados, possivelmente
utilizando ODBC.

Tipo 4 – Driver Nativo

Funciona como o tipo 2 de driver, a diferença está que esse é totalmente escrito em
Java. Não é preciso que saibamos sequer um comando da linguagem nativa da base de
dados.

Agora para exemplificarmos de uma melhor forma irei mostrar um exercício que faz
todas as etapas necessárias para realizar uma conexão com o banco de dados. Como já
citado usaremos o banco de dados MySql, que é possível fazer o download na página
http://dev.mysql.com/downloads/
Depois de instalado e configurado o servidor MySql precisaremos também do seu Drive
que usaremos em nossa aplicação Java. Esse Drive que iremos usar é tipo 4, assim
obvio saber que não usaremos ponte com a ODBC.
Download drive tipo 4 para MySql:
http://dev.mysql.com/downloads/connector/j/5.1.html
Uma das partes que há bastantes dúvidas é na hora de inserir o Drive em nossa
aplicação. Para isso precisamos indicar ao classpath onde está o nosso arquivo .jar.
Veja a imagem:

Depois de baixado, dentro do arquivo “mysql-connector-java-5.1.5.zip” teremos o


mostrado acima. Nosso arquivo .jar é o selecionada na imagem, para facilitar o
copiaremos para o local C:
Imagine agora a seguinte situação:

Temos na unidade c:\ a classe Ex_01.class que contem o nosso código de acesso ao
banco de dados, e temos também nosso drive MySQl, ambos selecionados na imagem.
Assim:
Perceba o uso de aspas ao indicar o classpath, e ao seu final ‘;.’ e então o nome da
classe. A mensagem retornada é devido ao nosso banco de dados não estar em
execução. Essa é apenas umas das maneiras de executar nossa classe Ex_01. É possível
que você adicione à sua IDE o local do Drive MySql, assim podendo ser compilado
através da mesma.
Chega de enrrolação, vamos para o código propriamente dito, vejamos:

Exercício_01

1. import java.sql.*;
2.
3. public class Ex_01{
4.
5. public static void main(String args[]){
6. String url =
7. +"jdbc:mysql://localhost/apostila_java?user=root&pass”
8. +”word=123";
9.
10. Connection con = null;
11.
12. try {
13. String driver = "com.mysql.jdbc.Driver";
14. Class.forName(driver).newInstance();
15. }
16.
17. catch(Exception ex){
18. System.out.println("Failed to load MySql Driver.");
19. return;
20. }
21.
22.
23. try{
24. con = DriverManager.getConnection(url);
25. Statement stmt = con.createStatement();
26. ResultSet result = stmt.executeQuery("SELECT * from"
27. +"tab_carros;");
28.
29. if(!result.next()){
30. System.out.print("Não Há Dados Na Tabela.");
31. }
32. else{
33. System.out.print("Há Dados Na Tabela.");
34. }
35.
36. }
37. catch(SQLException ex){
38. System.out.println("SQLException: " +
39. ex.getMessage());
40. System.out.println("SQLState: " + ex.getSQLState());
41. System.out.println("VendorError: " +
42. x.getErrorCode());
43. }
44.
45. }//Main
46.
47. }//Class

Na Linha 1:
import java.sql.*;

temos a instrução import para todas a classes que estão em java.sql, essas fornecendo
um grande leque para a manipulação com base de dados.

Na Linha 6 à 8:
String url =
+"jdbc:mysql://localhost/apostila_java?
user=root&pass”
+”word=123";

Temos a declaração de uma variável String que contém o endereço de nossa base de
dados. A sintaxe para o endereço URL de uma base de dados é:
jdbc:subprotocolo:subnome, onde subprotocolo identifica qual driver será usada para
conexão e subnome fornece ao driver qualquer informação referente a conexão, com
local, usuário e senha. Importante lembrar que a sintaxe de uma URL varia de driver
para driver.

Linha 10:
Connection con = null;

Aqui se cria uma variável tipo referência para um objeto que for instanciado da classe
Connection. Esse objeto é a conexão propriamente dita.
Até agora temos a seguinte situação
Vemos na imagem que nossa conexão não aponta para nenhum banco de dados.

Linha 12 à 15:
try {
String driver = "com.mysql.jdbc.Driver";
Class.forName(driver).newInstance();
}

Nesse bloco try temos inicialmente uma String chamada driver, que armazena o local
do driver mysql, e como já dito, em caso do uso de outro driver, é necessário ver na
especificação do mesmo o local em que ele se encontra..
Na linha Class.forName o que estamos fazendo nada mais é do que falar para a classe
DriverManager, que se necessário temos o driver MySql para uso. Em outras palavras,
estamos registrando o driver.

Linha 17 à 20:
catch(Exception ex){
System.out.println("Failed to load MySql Driver.");
return;
}
Temos uma exceção caso ocorra um erro ao registrar o driver. O erro mais comum que
ocorre nessa fase, é a falta do caminho do driver no classpath da aplicação.

Linha 23 e 24:
try{
con = DriverManager.getConnection(url);

Aqui criamos a conexão com a base de dados. Observe a classe DriverManager criar
uma conexão para a variável con, usando como parâmetro a variável URL, que segue
com endereço, usuário e senha da base de dados.
Temos então nessa fase a seguinte situação:
Como o próprio nome diz, a classe DriverManager é o gerente de drives. Para devolver
à variável con uma conexão com o banco de dados, ela tenta uma implementação com
todos os drivers registrado em sua lista, caso não consiga uma conexão, uma exceção é
gerada.

Na linha 25:
Statement stmt = con.createStatement();

Uma instância da classe Statement permite a nós realizar comandos básicos do SQL.
Para executarmos uma consulta através de um objeto Statement usamos seu método
chamado executeQuery(String Sql), assim nos retorna um objeto da classe ResultSet,
que contêm métodos para manipular as linhas que foram selecionadas. Caso queiramos
executar um UPDATE, INSERT ou DELETE usamos o método executeUpdate(String
Sql) que nos retorna apenas a quantidade de linhas que foram afetadas.
Vemos então a criação de um objeto Statement para a conexão con.

Linha 26:
ResultSet result = stmt.executeQuery("SELECT * from"
+"tab_carros;");

Temos aqui um objeto ResultSet, como dito anteriormente, usado para manipulação de
consultas SQL. Veja o uso do objeto Statement com seu método executeQuery para
consultas, e como parâmetro a String SQL.

Linha 29 à 34:
if(!result.next()){
System.out.print("Não Há Dados Na Tabela.");
}
else{
System.out.print("Há Dados Na Tabela.");
}

Temos um exemplo de como podemos manipular os dados que foram selecionados,


usando o objeto de ResultSet. Um dos métodos da classe ResultSet é o next(), que não
recebe nada como parâmetro, porém nos retorna true se há linhas para serem
manipuladas, ou retorna false, se não há mais linhas. Na ocasião, caso ele retorne true
(sim a linhas), imprimimos a mensagem que há dados na tabela, caso contrário,
imprimimos a mensagem que não há dados na tabela.
Linha 37 à 43:
catch(SQLException ex){
System.out.println("SQLException: " +
ex.getMessage());
System.out.println("SQLState: " + ex.getSQLState());
System.out.println("VendorError: " +
x.getErrorCode());
}
Aqui apenas temos uma exceção para possíveis erros na consulta ou qualquer outra
instrução. Usamos aqui alguns métodos da classe SQLException para mostrar
informações sobre o erro que ocorreu.

Vamos agora criar uma aplicação completa, que faça inicialmente INSERT’s, depois
um SELECT, em seguida UPDATE e DELETE.

A seguir um script usado no MySql, para criação da base de dados, tabelas e inserções
de alguns dados.

Script Exercício_02

*----------------------------------Script---------------------------*

--* Script Exemplo para apostila Java & JDBC.


--* Criado por Felipe Alvares Nemeth
--* Instituição: Universidade de Sorocaba
--* Em 31/01/2008

CREATE DATABASE apostila_java;


USE apostila_java

CREATE TABLE tab_carros(


cod INT(4) PRIMARY KEY AUTO_INCREMENT,
marca VARCHAR(30) NOT NULL,
modelo VARCHAR(30) NOT NULL,
cor VARCHAR(15) NOT NULL,
anoFabr VARCHAR(4) NOT NULL);

INSERT INTO tab_carros(marca, modelo, cor, anoFabr) VALUES


('Fiat', 'Uno', 'Cinza', '1997');
INSERT INTO tab_carros(marca, modelo, cor, anoFabr) VALUES
('Ford', 'Escort', 'Prata', '1998');

*------------------Fim do Script-----------*

Para usar esse Script, basta você copiar seu conteúdo para um arquivo .txt, e dentro do
MySql digitar ‘source [diretório][arquivo];
Exemplo: source c:\criaBd.txt;
Exercício_02

1. import java.sql.*;

2. public class Ex_02{

3. public static void main(String args[]){


4. String url =
5. "jdbc:mysql://localhost/apostila_java?user=root&passwo
6. rd=123";
7.
8. Connection con = null;
9.
10. try {
11. String driver = "com.mysql.jdbc.Driver";
12. Class.forName(driver).newInstance();
13. }
14.
15. catch(Exception ex){
16. System.out.println("Failed to load MySql Driver.");
17. return;
18. }
19.
20. //Criando a conexão
21. try{
22. con = DriverManager.getConnection(url);
23. Statement stmt = con.createStatement();
24.
25. //Usando INSERT
26. int linhasAfetadas=0;
27. linhasAfetadas = stmt.executeUpdate("INSERT INTO
28. tab_carros(marca, modelo, cor, anoFabr) VALUES
29. ('Chevrolet', 'Prisma', 'Prata', '2006')");
30.
31. //Usando SELECT
32. ResultSet rs = stmt.executeQuery("SELECT * from
33. tab_carros");
34. //Tratanto dados do ResultSet
35. while(rs.next()){
36. System.out.println("Cod: "+ rs.getInt(1));
37. System.out.println("Marca: "+ rs.getString(2));
38. System.out.println("Modelo: "+ rs.getString(3));
39. System.out.println("Cor: "+ rs.getString(4));
40. System.out.println("Ano Fabricação: "+
41. s.getString(5));
42. System.out.println("*------------------------------
43. ");
44. }
45. //Usando DELETE
46. stmt.executeUpdate("DELETE FROM tab_carros where
47. noFabr = 2006");
48. rs = stmt.executeQuery("Select * from tab_carros");
49. while(rs.next()){
50. System.out.println("Cod: "+ rs.getInt(1));
51. System.out.println("Marca: "+ rs.getString(2));
52. System.out.println("Modelo: "+ rs.getString(3));
53. System.out.println("Cor: "+ rs.getString(4));
54. System.out.println("Ano Fabricação: "+
55. s.getString(5));
56. System.out.println("*------------------------------
57. ");
58. }
59.
60. //Usando UPDATE
61. stmt.executeUpdate("UPDATE tab_carros SET cor =
62. Vermelho' WHERE cod = 1");
63.
64. }
65.
66. catch(SQLException ex){
67. System.out.println("Erro em INSERT");
68. System.out.println("SQLException: " +
69. ex.getMessage());
70. System.out.println("SQLState: " + ex.getSQLState());
71. System.out.println("VendorError: " +
72. x.getErrorCode());
73. }
74.
75. }//Main
76.
77. }//Class

Esse exercício foi implementado pelo único motivo de mostrar o uso de comandos SQL
dentro da linguagem Java. Como explicado anteriormente temos nossa String url, onde
armazena o ‘endereço’ do banco, pode ser ele local (nosso caso) ou ser externo.
Na linha 8 criamos uma variável tipo Connection que será nossa conexão propriamente
dita com a base de dados.
Na linha 10 até a linha 13 temos um try, que em seu corpo possui uma String chamada
driver que possui o endereço da classe drive, que está dentro do nosso pacote Jar
baixado do site do MySql. Logo após fazemos o registro do nosso drive na lista de
DriverManager. Ele que irá criar a conexão para nós e atribuí-la à variável con de
Connection, mas para isso é preciso registrar o drive que será usado. Após isso, nas
linhas 15 a 18 temos um catch(Exception ) para eventuais erros.
Na linha 21 começamos, com o bloco try, começamos o processo de conexão com a
base de dados. Perceba a sintaxe:
con = DriverManager.getConnection(url);
a classe DriverManager com o método getConnection, que recebe como parâmetro a
string url (endereço do banco), assim é criada uma conexão para a variável con. Em
seguinte temos a seguinte declaração:
Statement stmt = con.createStatement();

Aqui criamos uma variável tipo Statement, será nela que iremos inserir os comandos
SQL. Na linha 26 a 29 temos o uso do método executeUpdate(), e seu retorno para nós é
a quantidade de linhas que foram afetadas com o nosso comando. Vale lembrar que para
usar select, usamos o comando executeQuery(), porém, o nosso retorno será as linhas
selecionadas pela nossa instrução, e para manipulação das mesmas, usamos um objeto
chamado ResultSet. Veja a sintaxe:
ResultSet rs = stmt.executeQuery("SELECT * from"
+"tab_carros");

A partir de agora podemos manipular as linhas selecionadas como exemplo nas linhas
35 a 43:
while(rs.next()){
System.out.println("Cod: "+ rs.getInt(1));
System.out.println("Marca: "+ rs.getString(2));
System.out.println("Modelo: "+ rs.getString(3));
System.out.println("Cor: "+ rs.getString(4));
System.out.println("Ano Fabricação: "+
s.getString(5));
System.out.println("*------------------------------
");
}
Vemos o uso da estrutura while, ela nos permite fazer a verificação antes de entrar em
seu corpo, diferente de outras estruturas. Na condição do while, foi usado rs.next(). O
Objeto rs possui um método chamado next(), ele nos retorna true caso haja mais linhas
para serem manipuladas, assim o while sairá de sua iteração quando não houver mais
linhas para manipulação.
Nas linhas seguintes temos as mesmas instruções com diferença apenas nos comandos
SQL.