A03 - JDBC

JDBC
Rafael Romualdo Wandresen
Universidade Federal do Paraná – Linguagem Orientada a Objetos – Prof. Rafael Romualdo Wandresen
JDBC
 Introdução
 Conexão
 API JDBC
 Prática
 Operação interativa;
 Operação preparada;
 OO e JDBC
 Exemplo 1
 Exemplo 2
2
Introdução - Linguagens de um
SGBD
 DDL (Data definition language): Define o modelo
dos dados
 DML (Data Manipulation Language): Utilizada para
manipular os dados
 SQL (Structured Query Languege): Combina
recursos de DDL e DML.
4
Introdução - JDBC
 SGBD (Sistema Gerenciador de Banco de Dados) é um
conjunto de dados que pode ser utilizado por intermédio
de um grupo de programas, proporcionando um
ambiente para armazenamento e recuperação de
informações;
 O JDBC (Java Database Conectivity) é a API do Java que
contém os elementos necessários para que uma
aplicação Java possa acessar SGBD relacionais;
 Utiliza extensivamente a SQL (Structured Query Language);
 Esta API é composta pelos pacotes java.sql e javax.sql,
os quais fazem parte do JavaSE;
5
Introdução - Objetivo
 Com JDBC é possível:
 Conectar-se em uma fonte de dados, mais comumente o
banco de dados
 Enviar queries e updates para o banco de dados
 Receber e processar os resultados provenientes de
consultas aos bancos de dados
6
Introdução - Arquitetura JDBC
7
Mapeamento de Tipos
 Com JDBC, cabe ao programador escrever o código
para conectar-se ao banco de dados e, com auxílio
do SQL, deverão ser especificadas as operações de
consulta, inclusão, remoção ou alteração de dados;
 O JDBC faz automaticamente o mapeamento de
tipos de dados existentes no banco de dados para
os tipos do Java (nativos ou classes específicas),
conforme mostrado na tabela a seguir;
9
Introdução - Tabela de Mapeamento
de Tipos
10
Introdução - Componentes do JDBC
 É possível identificar quatro elementos centrais na
arquitetura JDBC:
 Classes e interfaces da sua API (pacotes java.sql e javax.sql);
 Suíte de testes de drivers, disponibilizada no site da Oracle, que
permite avaliar as funcionalidades e a compatibilidade de drivers
JDBC;
 Drivers JDBC, que implementam, de fato, os mecanismos
padronizados de conexão e interação com cada SGBDR;
 Ponte JDBC-ODBC, que possibilita o uso de drivers ODBC com
drivers JDBC, permitindo o uso de bancos de dados acessíveis
exclusivamente por meio do ODBC;
11
Conexão - Classe Driver Manager
 A utilização de um banco de dados requer uma conexão estabelecida
por meio de um driver adequado;
 A classe DriverManager é responsável por administrar e selecionar tal
driver conforme o banco de dados específico, possibilitando efetuar a
conexão;
 A solicitação de conexão com o banco de dados é feita através do
método getConnection (String), que recebe uma URL (Unified
Resource Locator) no padrão JDBC para indicar qual o SGBDR desejado;
try {
Connection con = DriverManager.getConnection
("jdbc:hsqldb:hsql://omega/ssolar");
} catch (SQLException e) {
//conexão não foi possível
}
12
Conexão - URL
 A API JDBC utiliza URLs para especificar qual SGBDR será
utilizado. Tais URLs tem a seguinte forma básica:
jdbc:<subprotocolo>:<subnome>
 O prefixo inicial JDBC indica o uso desta API;

 O subprotocolo é a denominação do SGBDR, a qual deverá ser
reconhecida pelos drivers disponíveis;
 O subnome depende do SGBDR e, geralmente, inclui host e o nome
do banco de dados;
 A documentação fornecida com o driver utilizado usualmente
detalha o formato apropriado da sua URL JDBC;
13
Conexão - Exemplos de URLs JDBC
SGBDR URL
Derby jdbc:derby://hostname:1527/database
Firebird jdbc:firebirdsql://hostname:3050/database
HSQLDB jdbc:hsqldb:hsql://hostname:9001/database
ODBC jdbc:odbc:datasource
Oracle jdbc:oracle:thin@hostname:1526:database
MySQL jdbc:mysql://hostname/database
Postgre jdbc:postgresql://localhost/database
14
Conexão - Driver JDBC
15
Conexão - Carregamento do Driver
 Para que a classe DriverManager possa selecionar o
driver adequado à conexão solicitada, é necessário que
sua classe tenha sido carregada pela JVM;
 Para isso, utiliza-se o carregamento dinâmico do driver
por meio do método forName(String) da classe Class;
 O nome da classe do driver é passada como argumento
para Class.forName(String), que realiza o carregamento
dinâmico do driver;
try {
//carregamento dinâmico da classe do driver
Class.forName("com.mysql.jdbc.Driver"); A classe do
Driver deve
} catch (ClassNotFoundException e) {
estar
System.out.println ("Driver não encontrado!"); acessível
System.exit(-1); por meio do
} classpath.
Este passo é necessário somente se
JVM for inferior a versão 6. Na versão
6 ou superior não é mais necessário.
16
API JDBC
 Uma aplicação que necessita acessar um SGBDR deve utilizar várias
classes e interfaces da API JDBC par realizar as tarefas desejadas:
17
Prática
 Veremos como fazer:
 Conexão;
 Operação interativa;
 Operação preparada;
 Orientação a objetos e JDBC;
18
Prática - Conexão
 Considerando que o driver necessário para acessar o SGBDR
encontra-se carregado, é utilizada uma das versões do
método DriverManager.getConnection ();
 Connection con = DriverManager.getConnection (url, user, pwd);
 Uma aplicação pode possuir uma ou mais conexões com o
mesmo ou com diferentes bancos de dados;
 O objeto retornado por DriverManager.getConnection ()
possui uma implementação dependente do driver e do banco
de dados, mas que realiza a interface java.sql.Connection;
Conexão Operação interativa Operação preparada OO e JDBC
19
Prática - Conexão
 Por padrão, a conexão é estabelecida no modo
auto-commit;
 Para reverter, definir setAutoCommit(false). Neste caso, é
preciso usar explicitamente commit() ou rollback();
 Uma vez que a conexão foi estabelecida com o
banco de dados, as operações sobre ele podem ser
realizadas de quatro formas diferentes: interativa,
em lote, preparada ou por procedimentos
armazenados;
Conexão Operação interativa Operação preparada Tabela de Dados
20
Prática - Exercício: Instalação e
conexão com MySQL
 1º Passo: Baixar e instalar MySQL ou outro BD:
http://www.mysql.com/downloads/mysql/
(Community Edition)
 2º Passo: Iniciar o cliente do MySQL
 mysql –u root -p
 3º Passo: Criar uma Database (Nome = exercicio)
 create database exercicio
 4º Passo: Criar uma tabela no Database e usá-la:
 use exercicio
 create table cliente (nome varchar(30), sobrenome
varchar(30));
Conexão Operação interativa Operação preparada OO e JDBC 21
Prática - Exercício: Passos para instalação
e configuração de um SGBD
Não necessário na
usuário
 5º Passo: Criar aplicação de exemplo Versão 6 do Java
public class JDBCExemplo1 {
public static void main(String[] args) throws SQLException,

ClassNotFoundException {
Class.forName("com.mysql.jdbc.Driver");
Connection conexao =
DriverManager.getConnection("jdbc:mysql://localhost/exercicio?us
er=root&password=senha");
System.out.println("Conectado!");
conexao.close();
}
}
Nome da Máquina Nome do Banco

senha

22
 6º Passo: Execute o programa. O que aconteceu?

Exception in thread "main" java.lang.ClassNotFoundException:
com.mysql.jdbc.Driver
at java.net.URLClassLoader$1.run(URLClassLoader.java:202)
at java.security.AccessController.doPrivileged(Native Method)
at java.net.URLClassLoader.findClass(URLClassLoader.java:190)
at java.lang.ClassLoader.loadClass(ClassLoader.java:307)
at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:301)
at java.lang.ClassLoader.loadClass(ClassLoader.java:248)
at java.lang.Class.forName0(Native Method)
at java.lang.Class.forName(Class.java:169)
at exerciciosloo.bancodados.JDBCExemplo.main(JDBCExemplo.java:19)
23
 7º Passo: Faltou adicionar o driver do mysql ao

classpath! Baixar e importar o driver do MySQL no
NetBeans
 http://dev.mysql.com/downloads/mirror.php?id=390509
 Descompactar e localizar o arquivo mysql-connector-java-
5.1.13-bin.jar
 No NetBeans, com o botão direito sobre o projeto, clicar
em Properties.
 No menu Bibliotecas clicar em “Adicionar JAR/pasta” e
incluir o arquivo mysql-connector-java-5.1.13-bin.jar
24
Prática - Padronizando a obtenção da
conexão
 Não é desejável que façamos a conexão ao banco de dados
no meio do código, como no exemplo anterior.
 É um processo repetitivo. Portanto vamos utilizar um Design
Pattern para isso chamado Factory:
public class ConnectionFactory {
public Connection getConnection() {

try {
return
DriverManager.getConnection("jdbc:mysql://localhost/exercicio",
"root", "senha");
throw new RuntimeException(e);
}
}
} 25
Conexão
Universidade FederalOperação
do Paraná –interativa Operação
Linguagem Orientada a Objetospreparada OO e JDBC
– Prof. Rafael Romualdo Wandresen
conexão
public class JDBCExemploComConnectionFactory {
public static void main(String[] args) throws SQLException {

Connection conexao = new ConnectionFactory().getConnection();
conexao.close();
}
}
 Por que criar uma ConnectionFactory?

 Poderíamos controlar o número de conexões requeridos
pela aplicação.
 Podemos criar um pool de conexões controladas.
 Podemos controlar melhor as exceções de conexão com o
banco dados.
26
Conexão Operação
Universidade Federal do Paraná –interativa Operação
conexão
 É desejável configurar a conexão com o banco de
dados externamente ao código
 Para isso podemos utilizar arquivos de configuração.
 No NetBeans:
 clique com o botão direito no pacote: Novo – Outro
 Em Categorias: Clique em Outro. Clique em “Arquivo de
Propriedades”
 Clique em Próximo
 Preencha o nome do arquivo como
“bancoDeDados.properties”
27
Conexão Operação
conexão
 As informações neste arquivo são definidas na forma nome=valor;
 A recuperação das propriedades é feita por meio da classe
java.util.Properties;
 Conteúdo do Arquivo DB.properties:
db.driver=com.mysql.jdbc.Driver
db.url=jdbc:mysql://localhost/exercicio
db.user=root
db.pwd=senha
 Leitura das propriedades:
Properties prop = new Properties ();
prop.load (new
FileInputStream(getClass().getResourceAsStream("/exerciciosloo/bancodados/banc
oDeDados.properties")));
String dbDriver = prop.getProperty("db.driver");
String dbUrl = prop.getProperty("db.url");
String dbUser = prop.getProperty("db.user");
String dbPwd = prop.getProperty("db.pwd");
28
Conexão Operação
conexão
public class ConnectionFactoryComProperties {
public Connection getConnection() {
try {
Properties prop = new Properties();
prop.load(getClass().getResourceAsStream("/exerciciosloo/banc
odados/bancoDeDados.properties"));
String dbDriver = prop.getProperty("db.driver");
String dbUrl = prop.getProperty("db.url");
String dbUser = prop.getProperty("db.user");
String dbPwd = prop.getProperty("db.pwd");
Class.forName(dbDriver);
return DriverManager.getConnection(dbUrl, dbUser,
dbPwd);
} catch (ClassNotFoundException ex) {
throw new RuntimeException(ex);
} catch (IOException ex) {
} catch (SQLException ex) {
}}} Universidade Federal do Paraná – Linguagem Orientada a Objetos – Prof. Rafael Romualdo Wandresen 29
conexão
public class JDBCExemploComConnectionFactory1 {
public static void main(String[] args) throws SQLException

{
Connection conexao = new
ConnectionFactoryComProperties().getConnection();
conexao.close();
}
}
 É importante:
 o driver do banco de dados deve estar disponível via classpath no
momento da execução do programa;
 o servidor do banco de dados deve estar em execução;
 o banco de dados designado do arquivo Db.Properties deve existir;
30
Conexão Operação
Padronizando a obtenção da conexão
 Por que ler os atributos de um arquivo .properties?
 Se houver modificação na URL de conexão, no dirver, no
usuário do banco de dados, na senha, você não precisará
recompilar o código.
 É uma boa prática de programação deixar as
configurações em um arquivo e não dentro do código.
 Importante:
 Nossa classe ConnectionFactory ainda não está preparada
para uso em uma aplicação comercial.
 Teríamos que implementar métodos para controlar um
pool de conexões.
 Existem drivers que contém métodos prontos para isso.
31
Conexão Operação
Prática - Operação interativa
 A operação interativa sobre o banco de dados
se faz por meio da interface
java.sql.Statement, que permite o envio de
comandos SQL estáticos;
 Por meio do método createStatement()
disponível na interface Connection, é possível
obter um objeto que implementa esta
interface;
 Statement stmt = con.createStatement();
32
Comandos de Atualização
 Quando os comandos SQL enviados ao banco de dados
através de objetos Statement são capazes de produzir
alterações (INSERT, UPDATE, DELETE, ou outros
comandos DDL), deve-se utilizar o método
executeUpdate(String):
String cmd = “INSERT INTO elementos VALUES (‘He’, ‘Hélio’, 2,
4.003, 0.179)”;
int result = stmt.executeUpdate(cmd);
String cmd = “DELETE FROM pedidos WHERE idCliente=19640115”;

int result = stmt.executeUpdate(cmd);
 O valor inteiro retornado por ExecuteUpdate permite

conhecer o número de linhas afetadas;
33
Conexão
Universidade Federal Operação
Prática - Exemplo de Operação Interativa
- Comandos de Atualização
public static void main(String[] args) throws SQLException

{
Statement stmt = conexao.createStatement();
stmt.executeUpdate("INSERT INTO CLIENTE
(NOME,SOBRENOME)
VALUES
(\"Maria\",\"Silva\")");
conexao.close();
}
}
 Executar o programa e verificar se a linha foi

incluida na base dados.
34
Consultas
 Quando é realizada uma consulta com SELECT, deve
utilizar-se o método executeQuery(String), que sempre
retornará um objeto que implementa a interface
ResultSet:
 ResultSet rs = stmt.executeQuery(“SELECT posicao, nome FROM
planetas”);
 Um objeto ResultSet representa uma espécie de tabela
dinâmica, dotada de um cursor que pode navegar por
suas linhas;
 Por meio do cursor, é possível percorrer o conjunto de
dados, obtendo valores específicos para cada campo
indicado;
35
Prática - Exemplo de Operação
interativa Consultas
java.sql.Statement stmt = conexao.createStatement();
ResultSet rs = stmt.executeQuery("SELECT * FROM CLIENTE
WHERE SOBRENOME=\"Wandresen\"");
while(rs.next()){
System.out.println("------");
System.out.println(rs.getString(“nome"));
System.out.println(rs.getString(2));
}
System.out.println("Fim Lista!");
conexao.close();
}
}
36
Consultas
 Como padrão, ResultSet não é atualizável e só pode ser
navegado à frente;
 O método next() avança para o próximo registro;
 Em qualquer linha válida, podem ser usados os métodos
de acesso para leitura dos valores das colunas do
ResultSet:
while(rs.next()){
System.out.println(rs.getString(“nome"));
}
 Quando os registros não forem mais necessários, o

Statement e o ResultSet devem ser liberados através do
método close();
37
Conexão
Universidade FederalOperação
Prática - Operação Interativa
Métodos de Acesso
 O conteúdo das colunas do registro em que está
posicionado o cursor pode ser recuperado por meio de
um método de acesso específico, conforme seu tipo:
 getInt para INT ou INTEGER;
 getDouble para DOUBLE ou FLOAT;
 getFloat para REAL;
 getTime para TIME;
 O método getObject pode ser usado sem qualquer restrição;
 O método getString converte o conteúdo da coluna em um
objeto String;
 Todos eles podem ser utilizados enviando-se como
argumento o índice da coluna (iniciado em 1) ou o
nome da coluna (String);
 String nomePlaneta = rs.getString(“NOME”);
 String nomePlaneta = rs.getString(2);
38
Conexão Operação
Universidade Federal do Paraná – interativa Operação
Linguagem Orientada a Objetos preparada OO e JDBC
Métodos de Acesso
39
Conexão Operação
Consultas Navegáveis
 Também é possível solicitar a criação de um objeto ResultSet navegável
(scrollable), informando as características desejadas na criação do
objeto Statement:
Statement stmt = con.createStatement (ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_READ_ONLY);
ResultSet rs = stmt.executeQuery (“SELECT nome, telefone FROM clientes”);
 Os tipos de navegação possíveis são:

 TYPE_FORWARD_ONLY: navegação do primeiro ao último, uma
única vez;
 TYPE_SCROLL_INSENSITIVE: navegação livre;
 Métodos next(), previous(), first(), beforeFirst(), last(), afterLast();

 TYPE_SCROLL_SENSITIVE: idem ao anterior e sensível às
alterações feitas no banco;
 Atenção: nem todos os drivers suportam ResultSets navegáveis ou
atualizáveis;
40
Conexão
Universidade Federal Operação
Linguagem Orientada a Objetospreparada Tabela
– Prof. Rafael Romualdo de Dados
Wandresen
Exemplo Consultas Navegáveis
java.sql.Statement stmt =
conexao.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_READ_ONLY);
ResultSet rs = stmt.executeQuery("SELECT * FROM CLIENTE WHERE
SOBRENOME=\"Wandresen\"");
while(rs.next()){
System.out.println(rs.getString("nome"));
}
//Volta ao primeiro da lista
rs.first();
System.out.println("Nome do Primeiro da
lista:"+rs.getString(1)+" " +rs.getString(2));
conexao.close();
} 41
} Universidade Federal do Paraná – Linguagem Orientada a Objetos – Prof. Rafael Romualdo Wandresen
Consultas Atualizáveis
 Um objeto ResultSet pode ser atualizável, permitindo
que alterações realizadas em seus resultados sejam
refletidas nas tabelas de origem dos dados;
 A seleção do método de escrita deve ser apropriada ao
tipo da coluna:
 updateInt, updateFloat, updateString...
 Após a chamada do método de escrita, deve-se chamar
updateRow() para efetivar as alterações no banco de
dados;
 cancelRowUpdates() cancela as alterações;
 Registros podem ser eliminados e incluídos através de
chamadas a deleteRow() e
moveToInsertRow()/insertRow();
42
Consultas Atualizáveis
Statement stmt = conexao.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
ResultSet rs = stmt.executeQuery("SELECT * FROM CLIENTE2 WHERE
SOBRENOME=\"Wandresen\"");
while(rs.next()){
System.out.println(rs.getString("nome"));
}
//Volta ao primeiro da lista
rs.first();
//Atualiza o primeiro da lista
rs.updateString(2, "Rafael Romualdo");
rs.updateRow();
//Imprime o primeiro da lista
System.out.println("Nome do Primeiro da lista:"+rs.getString(1)+" "
+rs.getString(2));
conexao.close();
}} 43
Prática - Operação Preparada
 Um objeto do tipo PreparedStatement permite
definir um comando SQL que será pré-compilado no
SGBDR, permitindo sua execução eficiente;
 O comando SQL preparado pode conter um ou mais
parâmetros de entrada, representados pelo símbolo
de ? (interrogação);
 Os parâmetros de entrada devem ser fornecidos
antes de cada execução do comando SQL
preparado;
44
 O comando a ser preparado deve ser fornecido
na criação do objeto PreparedStatement:
String sql = “INSERT INTO contatos (nome, re, prof)
VALUES (?, ?,?)”
PreparedStatement pstmt = con.prepareStatement(sql);
 Neste exemplo, o comando SQL possui três

parâmetros de entrada, os quais devem ser
ajustados separadamente antes da sua
execução:
pstmt.setString(1, “Joãozinho”);
pstmt.setInt (2, 1105);
pstmt.setBoolean(3, true);
45
Conexão Operação
 Cada tipo de parâmetro dispõe de um
método específico para ajuste, de prefixo set,
que recebe o número do parâmetro e o seu
valor;
 A execução do comando preparado deve ser
realizada de acordo com a operação:
int re = pstmt.executeUpdate();
ResultSet rs = pstmt.executeQuery();
46
Conexão Operação
Prática - Exemplo Operação
Preparada
public class JDBCPreparedStatement {
PreparedStatement pstmt = conexao.prepareStatement("INSERT INTO
CLIENTE2 (NUMERO,NOME,SOBRENOME) VALUES(?,?,?)");
Scanner sc = new Scanner(System.in);
while(true){
System.out.println("Insira numero, nome e sobrenome (Para
encerrar digite \"S\" no nome ou sobrenome:");
int numero = sc.nextInt();
String nome = sc.next();
String sobrenome = sc.next();
if(nome.equals("S")||sobrenome.equals("S"))
break;
pstmt.setInt(1, numero);
pstmt.setString(2, nome);
pstmt.setString(3, sobrenome);
pstmt.executeUpdate();
}
pstmt.close();
System.out.println("Fim da inclusão");
conexao.close();
}
} 47
OO e JDBC
 Os comandos SQL até agora estão misturados na
lógica de negócio
 Isto não é desejável. O ideal é separarmos a lógica
e o acesso ao banco de dados em classes
diferentes.
 Como fazemos isso?
 JavaBeans: São classes que possuem o construtor sem
argumentos e métodos de acesso do tipo get e set para
acesso aos seus atributos. (Não confundir com Enterprise
JavaBeans)
 DAO (Data Access Objects): Pattern que separa o acesso
ao banco de dados da lógica de negócios.
48
Conexão Operação
OO e JDBC – Exemplo 1
 Preparação
 Criar uma classe
create table contatos (
id BIGINT NOT NULL AUTO_INCREMENT,
nome VARCHAR(255),
email VARCHAR(255),
endereco VARCHAR(255),
dataNascimento DATE,
primary key (id)
);
49
Conexão Operação
 Preparação: Criar a classe para representar a entidade de negócio
public class Contato {
private Long id;
private String nome;
private String email;
private String endereco;
private Calendar dataNascimento;
public Contato() {
}
public Calendar getDataNascimento() {
return dataNascimento;
}
public void setDataNascimento(Calendar dataNascimento) {
this.dataNascimento = dataNascimento;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}....
}
50
Conexão Operação
public class ContatoDAO {
private String sql = "insert into contatos
(nome,email,endereco,dataNascimento) values
(?,?,?,?)";
public void adiciona(Contato contato) {

Connection connection = null;
PreparedStatement stmt = null;
try {
connection = new
stmt = connection.prepareStatement(sql);
stmt.setString(1, contato.getNome());
stmt.setString(2, contato.getEmail());
stmt.setString(3, contato.getEndereco());
stmt.setDate(4, new
Date(contato.getDataNascimento().getTimeInMillis()));
stmt.execute();
throw new RuntimeException(e);
} finally {
stmt.close();
conncetion.close();
}
} 51
 Uso da ContatoDAO
 Aplicação Autor/Livro
 Uma biblioteca possui um sistema para gerenciar
seus livros. Os livros e autores são entidades
separadas. Um livro pode ser escrito por diversos
autores e um autor pode escrever diversos livros. A
relação no banco de dados é muitos para muitos.
53
OO e JDBC- Exemplo 2
 O mapeamento para o diagrama de classes fica
assim:
54

A03 - JDBC

Enviado por

Dados do documento

Descrição original:

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

A03 - JDBC

Enviado por

Direitos autorais:

Formatos disponíveis

JDBC

Rafael Romualdo Wandresen

 O prefixo inicial JDBC indica o uso desta API;

Conexão Operação interativa Operação preparada OO e JDBC

Conexão Operação interativa Operação preparada Tabela de Dados

public static void main(String[] args) throws SQLException,

Nome da Máquina Nome do Banco

Conexão Operação interativa Operação preparada OO e JDBC

 6º Passo: Execute o programa. O que aconteceu?

Conexão Operação interativa Operação preparada OO e JDBC

 7º Passo: Faltou adicionar o driver do mysql ao

public class ConnectionFactory {

public Connection getConnection() {

public static void main(String[] args) throws SQLException {

 Por que criar uma ConnectionFactory?

public static void main(String[] args) throws SQLException

String cmd = “DELETE FROM pedidos WHERE idCliente=19640115”;

 O valor inteiro retornado por ExecuteUpdate permite

public static void main(String[] args) throws SQLException

 Executar o programa e verificar se a linha foi

Conexão Operação interativa Operação preparada OO e JDBC

 Quando os registros não forem mais necessários, o

 Os tipos de navegação possíveis são:

 Métodos next(), previous(), first(), beforeFirst(), last(), afterLast();

Conexão Operação interativa Operação preparada OO e JDBC

 Neste exemplo, o comando SQL possui três

public void adiciona(Contato contato) {

Você também pode gostar