www.fontes.pro.br

 

JDBC: Java Database Connectivity

 

 

O JDBC é um conjunto de classes e interfaces ( API ) escritas em Java para execução e manipulação de resultados de instruções SQL para qualquer banco de dados relacional. Para cada Banco de dados há um driver JDBC.

 

 

Vantagens

 

Visão Geral

A API encapsula

● o estabelecimento da conexão com o BD
● o envio de comandos SQL
● o processamento dos resultados

 

 

Tipo de drivers JDBC para banco de dados:

Tipo 1: Ponte JDBC-ODBC

É o tipo mais simples mas restrito à plataforma Windows . Utiliza ODBC para conectar-se com o banco de dados , convertendo métodos JDBC em chamadas às funções do ODBC. Esta ponte é normalmente usada quando não há um driver puro-Java (tipo 4) para determinado banco de dados , pois seu uso é desencorajado devido à dependência de plataforma.

Tipo 2: Driver API-Nativo

O driver API-Nativo traduz as chamadas JDBC para as chamadas da API cliente do banco de dados usado. Como a Ponte JDBC-ODBC, pode precisar de software extra instalado na máquina cliente.

Tipo 3: Driver de Protocolo de Rede

Traduz a chamada JDBC para um protocolo de rede independente do banco de dados utilizado, que é traduzido para o protocolo do banco de dados por um servidor. Por utilizar um protocolo independente, pode conectar as aplicações clientes Java a vários bancos de dados diferentes. É o modelo mais flexível.

Tipo 4: Driver nativo

Converte as chamadas JDBC diretamente no protocolo do banco de dados. Implementado em Java, normalmente é independente de plataforma e escrito pelos próprios desenvolvedores. É o tipo mais recomendado para ser usado.

 

 

Para realizar a conexão via Tipo 1 que iremos mostrar:

DOWNLOAD (Bom já estou presumendo que você já tenha instalado o banco de dados)

 

 

 

Carga do driver no programa Java

Vários drivers podem ser carregados com o método Class.forName.

Por exemplo:

- Class.forName ("oracle.jdbc.driver.OracleDriver");
- Class.forName ("sun.jdbc.odbc.JdbcOdbcDriver");
- Class.forName ("com.mysql.jdbc.Driver");
- Class.forName ("org.hsqldb.jdbcDriver");

 

No NetBeans

 

Abra a IDE do NetBeans, após aberto vá na opção que fica a esquerda do seu monitor em banco de dados => driver´s clique com o botão direto sobre a opção driver´s e escolha a opção novo driver.

Exemplo do como ficara sua IDE após seguir os passos.

 

Clique no botão adicionar ele ira abrir a tela para buscar o arquivo .jar, lembre-se de que você já tenha descompactado os arquivos do MYSQL -connector-java indique o arquivo MYSQL -connector-java-5.1.5-bin.jar como mostra a figura abaixo.

 

Após clicar no botão abrir você terá um tela igual a esta mostrada a abaixo:

 

Clique no botão ok para finalizar após a instalação você poderá observar que a sua ide agora já esta com o driver jdbc para MYSQL instalado.

 

 

 

 

Exemplo de Aplicação

 

 

Então, onde configuramos qual driver a minha aplicação deve usar? Na verdade, você pode ter vários drivers ao mesmo tempo, e a utilização deles vai de acordo com qual String de conexão você utilizar.

O driver é um jar (se for um driver puro java), e você deve te-lo em seu classpath, caso contrário não conseguirá utilizá-lo. Se preferir, coloque o driver no classpath na hora de chamar o java, atraves da linha de comando, por exemplo:

1 java -classpath diretorio/meudriver.jar MinhaClasse


Você pode pegar o driver do mysql diretamente no site da mysql aqui .

Porém, precisamos antes "carregar" o driver, de tal maneira que o Java saiba que ele existe, e possa usá-lo se necessário. Normalmente, os livros explicam isto de forma muito básica, e não entram em detalhes, já que o código que carrega o driver é do tipo:

1 Class.forName ( "com.mysql.jdbc.Driver" ) ;


Mas o que acontece realmente aqui? Quando você utiliza o método estático Class.forName() , o Class Loader tenta inicializar esta classe. Esta classe (que é o nosso driver jdbc) possui um bloco inicializador estático (não se preocupe caso você não conheça este recurso), que irá registrar essa classe como um driver JDBC, avisando o java.sql.DriverManager , pelo método registerDriver .

Obs: Existem outras maneiras de carregar o driver, como por linha de comando (bootstrap).

Agora que o driver já está registrado, podemos abrir uma conexão com o banco de dados, passando uma String de conexão.

1 Connection conn = DriverManager.getConnection ( "jdbc:mysql://localhost/BANCO_DE_DADOS?user=root&password=root" ) ;

Desta vez, o java.sql.DriverManager vai perguntar para cada Driver registrado, se ele aceita a String de conexão em questão. Se algum deles aceita esta String, a conexão é aberta (pelo Driver), e retornada. Caso contrário, uma exceção é lançada.

Pela própria String de conexão, você pode passar muitos outros parâmetros (além de login, senha e nome do banco de dados, como neste caso), a maioria de interesse do Driver, como por exemplo saber se aquela conexão deve estar em modo de auto reconexão caso ela caia, e muitos outros. Este tipo de informação está na documentação do seu driver.




Vamos agora fazer um SELECT, e pegar os dados que este SELECT devolver, imprimindo-os. Lembre-se que você deve adaptar a String de conexão e o nome do bancod e dados, tabela e campos para um que você já tenha em sua máquina, claro.

1 Connection conn = DriverManager.getConnection ( "jdbc:mysql://localhost/BANCO_DE_DADOS?user=root&password=root" ) ;
2 Statement stm = conn.createStatement () ;
3 ResultSet rs = stm.executeQuery ( "SELECT coluna1, coluna2, coluna3 FROM tabela" ) ;


O método Connection.createStatement() te devolve um objeto java.sql.Statement , que representa uma simples Query ou comando.

Nós utilizamos depois o Statement.executeQuery() , que devolve um java.sql.ResultSet com o resultado. Caso a quey fosse algo que não retornasse nada, tipo um INSERT ou UPDATE, você deve utilizar o Statement.executeUpdate() .

Agora temos um java.sql.ResultSet , que contém o resultado da nossa Query. Vamos iterar sobre ele:

1 while  ( rs.next ()) {
2 String coluna1 = rs.getString ( "coluna1" ) ;
3 int  coluna2 = rs.getInt ( "coluna2" ) ;
4 Date coluna3 = rs.getDate ( "coluna3" ) ;
5 }


Muito intuitivo não? Repare que o java.sql.ResultSet possui uma série de métodos para que você possa pegar o valor da coluna já no tipo desejado, como String, int, Date, etc...




Aqui utilizamos código SQL dentro das classes Java, isto é um péssimo hábito. O interessante é ter as queries dentro de um arquivo de configuração, como um XML ou um arquivo de properties. Desta maneira, caso você mude de banco de dados, pode facilmente mudar as queries que não são compatíveis.

Além disso, apresentamos aqui apenas o java.sql.Statement , mas é altamente recomendável o uso do java.sql.PreparedStatement , onde você pode reutilizar bastante os statements e o seu driver JDBC pode ajudar bastante na hora de você ter de fazer coisas como escape de Strings (colocar \ na frente das aspas de uma String, por exemplo). Fica aqui a recomendação da leitura da api desta classe.

 

Exemplo de Aplicação no NetBeans

 

 

 

Antes de tudo, não esqueça de incorporar a biblioteca connector-java-5.1.5-bin.jar ao seu projeto

 

 

 
package projetojavadiscos;

import java.sql.*;

public class Javadiscos {

  public static void main(String[] args) throws Exception{
    String driver = "org.hsqldb.jdbcDriver";     // para MySQL com.mysql.jdbc.Driver
    String url = "jdbc:hsqldb:hsql://localhost/javadiscos";    // para MySQ jdbc:mysql://localhost/lojadiscos
    String user = "sa";    // para MySQ root
    String password = "";

    // Carrega o driver do BD
    Class.forName(driver);  

    // Faz a conexão com o BD
    Connection conn = DriverManager.getConnection(url, user, password);

    String sql = "SELECT * FROM artista";

    // Instancia a classe PreparedStatement capaz de executar o comando SQL
    PreparedStatement stmt = conn.prepareStatement(sql);

    // Executa o comando SQL e coloca o resultado em rs (objeto responsável por manipular os dados)
    ResultSet rs = stmt.executeQuery();

    // Percorre o ResultSet
     while (rs.next()){
         String id = rs.getString("id");
         String nome = rs.getString("nome");
         String banda = rs.getString("banda");
         String pais = rs.getString("pais");
         System.out.println("ID -> "+ id);
         System.out.println("Nome -> "+ nome);
         System.out.println("Banda -> "+ banda);
         System.out.println("Pais -> "+ pais);
    }

    // Libera recursos
    rs.close();
    stmt.close();
    conn.close();
  }
}

 

Exemplo 2

 

 

package p_banco_de_dados;

import java.sql.*;

/**
*
* @author Fontes
*/
public class Executa {

static String driver = "com.mysql.jdbc.Driver";
String url = "jdbc:mysql://localhost/bd_aluno";
String user = "root";
String password = "";
Connection conn;

public void carregar(String driver) throws ClassNotFoundException, SQLException {

// Carrega o driver do BD
Class.forName(driver);
// Faz a conexão com o BD
conn = DriverManager.getConnection(url, user, password);

}

public void inserir(String sql) throws SQLException {

PreparedStatement stmt = conn.prepareStatement(sql);
stmt.executeUpdate();
stmt.close();

}

public void alterar(String sql) throws SQLException {

PreparedStatement stmt = conn.prepareStatement(sql);
stmt.executeUpdate();
stmt.close();

}

public void consultar(String sql) throws SQLException {

// Instancia a classe PreparedStatement capaz de executar o comando SQL
PreparedStatement stmt = conn.prepareStatement(sql);
// Executa o comando SQL e coloca o resultado em rs (objeto responsável por manipular os dados)
ResultSet rs = stmt.executeQuery();
// Percorre o ResultSet
while (rs.next()) {

String matricula = rs.getString("matricula");
String nome = rs.getString("nome");
String media = rs.getString("media");

System.out.println("Matrícula -> " + matricula);
System.out.println("Nome -> " + nome);
System.out.println("Média -> " + media);
System.out.println("---------------");

}
// Libera recursos
rs.close();

}

 

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

String sql;
Executa e = new Executa();

//------------ carrega driver
e.carregar(driver);

//------------ consultar

sql = "SELECT * FROM aluno";
e.consultar(sql);

//------------ inserir
// sql = " INSERT INTO `aluno` ( `matricula` , `nome` , `media` ) VALUES ('49', 'Maria', '5.4')";
// e.inserir(sql);

sql = "UPDATE `aluno` SET `media` = '8' WHERE `aluno`.`matricula` = 56";
e.alterar(sql);

}


}


 

Exemplo 3

 


package p_banco_de_dados;

/**
*
* @author Fontes
*/
import java.sql.*;

public class Conexao {

public Connection con;
public Statement stm;
public ResultSet res = null;
private String nome = null;
private int idade = 0;
private String sexo = null;

public Conexao() {

try {

Class.forName("com.mysql.jdbc.Driver");
con = DriverManager.getConnection("jdbc:mysql://localhost/bd_aluno", "root", "");
stm = con.createStatement();

} catch (Exception e) {

System.out.println("não foi possível conectar ao banco" + e.getMessage());

}

}

public void setNome(String nome) {
this.nome = nome;
}

public void setIdade(int idade) {
this.idade = idade;
}

public void setSexo(String sexo) {
this.sexo = sexo;
}

public String getNome() {
return nome;
}

public int getIdade() {
return idade;
}

public String getSexo() {
return sexo;
}

public void inserirDados() {

try {
String query = "insert into pessoa(nome,idade,sexo) values(\"" + nome + "\"," + idade + ",\"" + sexo + "\")";
stm.executeUpdate(query);

} catch (SQLException e) {
System.out.println("Erro na inserção:" + e.getMessage());
}

}

public boolean alterarDados() {

boolean testa = false;

try {
String query = "update pessoa " +
"set idade = " + idade + ", " +
"sexo = \"" + sexo + "\" " +
"where nome = \"" + nome + "\"";

int linhas = stm.executeUpdate(query);

if (linhas > 0) {
testa = true;
} else {
testa = false;
}
} catch (SQLException e) {
System.out.println("Erro na inserção:" + e.getMessage());
}

return testa;

}

public boolean excluirDados() {

boolean testa = false;

try {
String query = "delete from pessoa where nome='" + nome + "'";
int linhas = stm.executeUpdate(query);

if (linhas > 0) {
testa = true;
} else {
testa = false;
}
} catch (SQLException e) {
System.out.println("Erro na exclusão:" + e.getMessage());
}

return testa;


}

public boolean consultarDados() {

boolean testa = false;

try {
String query = "select * from pessoa where nome='" + nome + "'";
res = stm.executeQuery(query);

if (res.next()) {
testa = true;
} else {
testa = false;
}

} catch (SQLException e) {
System.out.println("Erro na inserção:" + e.getMessage());
}

return testa;
}

public void setConsulta() {

try {
res = stm.executeQuery("select * from pessoa");
} catch (SQLException e) {
e.printStackTrace();
}

}

public ResultSet getResultado() {
return res;
}


}

_______________________ MAIN_____________

package p_banco_de_dados;

/**
*
* @author Fontes
*/
public class ExecutaConexao {

public static void main(String[] args) {

Conexao c = new Conexao();

// -------------- inclusão
c.setNome("Ana Lúcia");
c.setIdade(25);
c.setSexo("F");
// c.inserirDados();

// -------------- alteração
c.setIdade(15);
// c.alterarDados();

// -------------- exclusão
c.setNome("Adão");
c.excluirDados();

}

}



No LINUX

 

 

 

Na seqüência temos os passos para a criação de uma banco de dados chamado "biblioteca", uma tabela chamada "teste", para o usuário "admin" com senha "123456". 

A parte mais complicada foi determinar a forma de conexão, bem como o lugar onde colocar a biblioteca de conexão (.jar). Vejam a seqüência: 

Colocar o arquivo mysql-connector-java-5.1.5-bin.jar (obtido em: http://www.mysql.com/products/connector/j/)  no diretório   /usr/lib/jvm/java-6-sun-1.6.0.03/jre/lib/ext/.

Criar no MySQL o banco: biblioteca 

# mysql -u root -p
Enter password: 
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 30
Server version: 5.0.45-Debian_1ubuntu3-log Debian etch distribution

Type 'help;' or '\h' for help. Type '\c' to clear the buffer.

mysql> create database biblioteca;
Query OK, 1 row affected (0.01 sec)

mysql> grant all privileges on biblioteca.* to admin identified by "123456";
Query OK, 0 rows affected (0.02 sec)

mysql> create table teste(codigo varchar(10), nome varchar(30));
Query OK, 0 rows affected (0.00 sec)

mysql> insert into teste(codigo,nome) values("123","teste1");
Query OK, 1 row affected (0.00 sec)

mysql> insert into teste(codigo,nome) values("122","teste2");
Query OK, 1 row affected (0.00 sec)

mysql> insert into teste(codigo,nome) values("124","teste4");
Query OK, 1 row affected (0.01 sec)

mysql> select * from teste;

+--------+--------+
| codigo | nome   |
+--------+--------+
| 123    | teste1 | 
| 122    | teste2 | 
| 124    | teste4 | 
+--------+--------+
3 rows in set (0.00 sec)

mysql> quit
Bye 

Crie o arquivo teste4.java com o seguinte conteúdo: 
import java.sql.*;

public class teste4
{
    public static void main(String[] args) 
    {
        String url = "jdbc:mysql://localhost:3306/biblioteca";
      String login = "admin";
      String senha = "123456";

        try 
        {
         Class.forName("com.mysql.jdbc.Driver").newInstance();
            System.out.println("\nDriver carregado com sucesso!\n");
         try
         {
                 Connection conn = DriverManager.getConnection(url, login, senha);
                 try
                 {
                 String sql = "SELECT codigo,nome FROM teste";
                    Statement stm = conn.createStatement();
                    try
                    {
                     ResultSet rs = stm.executeQuery(sql);
                  while (rs.next()) 
                  {
                     String nome = rs.getString("nome");
                     String codigo = rs.getString("codigo");
                     System.out.println("Codigo: " + codigo + "\nNome: " +nome);
                     System.out.println("---------------------------------------");
                  }
                  System.out.println("\nConsulta realizada com sucesso!!!\n");                     
                    }
               catch (Exception ex) 
               {
                  System.out.println("\nErro no resultset!");
               }
                 }
                  catch (Exception ex) 
            {
               System.out.println("\nErro no statement!");
            }
         }
         catch (Exception ex) 
         {
            System.out.println("\nErro no connection!");
         }   
        }
        catch (Exception ex) 
        {
            System.out.println("\nDriver nao pode ser carregado!");
        }
    }
}


Na linha de comando, compilando e executando: 

$ javac teste4.java; java teste4 

Driver carregado com sucesso! 

Codigo: 123
Nome: teste1
---------------------------------------
Codigo: 122
Nome: teste2
---------------------------------------
Codigo: 124
Nome: teste4
--------------------------------------- 
Consulta realizada com sucesso!!! 

 

Código para verificar se o driver está presente e funcionando

  1. public static void main(String[] args)  
  2.     throws ClassNotFoundException {  
  3.           
  4.         try{  
  5.             Class.forName("com.mysql.jdbc.Driver");  
  6.             Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/biblioteca",  "admin", "123456");  
  7.         } catch(SQLException se) {  
  8.             se.printStackTrace(System.err);  
  9.         }  
  10.     }  

Modelo MVC

Artigo do javafree

Apresentando Model-View-Presenter, o MVC focado na visualização

 


 

E aí o que achou?

Fontes