Guia Hibernate

Manipulando dados com JDBC em Java

Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Para efetuar o download você precisa estar logado. Clique aqui para efetuar o login
Confirmar voto
0
 (9)  (0)

Veja neste artigo como manipular dados com JDBC, iremos ver como acessar e conectar ao banco de dados, além de inserir, editar e deletar dados no banco de dados.

Olá pessoal, nesse artigo vamos aprender a trabalhar um pouco com Java.

O Java é uma das mais poderosas ferramentas de desenvolvimento do mundo, ganhando cada vez mais adeptos e fãs.

Acesso a dados com JDBC

Sem dúvida alguma o acesso a dados é um dos recursos mais utilizados na área de desenvolvimento. Praticamente todo o sistema precisa de um banco de dados, havendo raras exceções.

O Java, diferente de linguagens como PHP, não suporta o acesso a banco de dados diretamente, para isso ele usa uma API (conjunto de classes e interfaces) para fazer o serviço. A JDBC (Java Database Connectivity), faz o envio de instruções SQL para qualquer banco de dados relacional, desde que haja um driver que corresponda ao mesmo presente.

Esquema de funcionamento do JDBC

Figura 1: Esquema de funcionamento do JDBC

Existem quatro tipos de drivers JDBC: 1, 2, 3 e 4, são eles:

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.

Neste artigo vamos usar o tipo 4, por ser o mais recomendado, pois ele converte as chamadas diretamente no protocolo do banco de dados em questão, dando assim uma performance melhor, além, é claro, de ser o mais simples de se usar.

Muitos podem encontrar uma certa semelhança entre JDBC e ODBC; estão absolutamente corretos, podemos dizer a "grosso modo" que as duas seguem a mesma ideia. Ambas funcionam como meio de comunicação Banco X Aplicação, porém, ODBC é uma aplicação Windows restrita apenas a ele, enquanto a JDBC, por ser escrita em Java, é multiplataforma.

Outra das vantagens da JDBC é o fato dela funcionar como uma camada de abstração de dados. Independente do SGBD utilizado, a API será a mesma, facilitando muito a vida dos programadores caso haja a necessidade de uma migração de banco.

Agora vamos ver como se conectar por meio do JDBC a uma base de dados Oracle.

Listagem 1: Conectando a uma base Oracle

Connection connection = null;  
    try {  
        // Load the JDBC driver  
        String driverName = "oracle.jdbc.driver.OracleDriver";  
        Class.forName(driverName);  
      
        // Create a connection to the database  
        String serverName = "127.0.0.1";  
        String portNumber = "1521";  
        String sid = "mydatabase";  
        String url = "jdbc:oracle:thin:@" + serverName + ":" + portNumber + ":" + sid;  
        String username = "username";  
        String password = "password";  
        connection = DriverManager.getConnection(url, username, password);  
    } catch (ClassNotFoundException e) {  
        // Could not find the database driver  
    } catch (SQLException e) {  
        // Could not connect to the database  
    }
 

O código é bem padronizado, colocamos o ip do servidor, número de porta, nome da base de dados, nome de usuário e senha, além de colocar o driver de conexão.

Agora veremos como acessar uma base de dados em MySQL

Listagem 2: Acessando uma base de dados MySQL

Connection connection = null;  
    try {  
        // Load the JDBC driver  
        String driverName = "org.gjt.mm.mysql.Driver"; // MySQL MM JDBC driver  
        Class.forName(driverName);  
      
        // Create a connection to the database  
        String serverName = "localhost";  
        String mydatabase = "mydatabase";  
        String url = "jdbc:mysql://" + serverName +  "/" + mydatabase; // a JDBC url  
        String username = "username";  
        String password = "password";  
        connection = DriverManager.getConnection(url, username, password);  
    } catch (ClassNotFoundException e) {  
        // Could not find the database driver  
    } catch (SQLException e) {  
        // Could not connect to the database  
    } 
 

Note que a diferença do código da listagem 1 para a listagem 2 é apenas o nome do driver que muda de jdbc:oracle para jdbc:mysql e sua aplicação também.

Como fazer o load do driver JDBC

Agora veremos como fazer o load de um driver JDBC, nesse exemplo vamos fazer o load do driver do MySQL.

Listagem 3: Load no driver JDBC

  try {  
        // Load the JDBC driver  
        String driverName = "org.gjt.mm.mysql.Driver";  
        Class.forName(driverName);  
    } catch (ClassNotFoundException e) {  
        // Could not find the driver  
    }  
 

Vamos entender melhor agora o que cada comando quer dizer.

Class.forName - Esse sem dúvida é o comando principal. É através dele que estamos chamando o driver JDBC.

Connection - Aqui estamos criando um objeto do tipo "Connection". É nele que ficam armazenadas as informações da sua conexão com o banco. Para ser mais direto, usamos o método "getConnection" do objeto "DriverManager" contido no "java.sql" ao invés do construtor padrão, isso faz com que a conexão seja estabelecida imediatamente. Repare na string passada como parâmetro, nela estão contidas as informações da nossa conexão, são elas respectivamente: driver JDBC, host, caminho do banco, usuário e por ultimo a senha.

Statement - É uma declaração simples, porém vital para qualquer projeto. O objeto "Statement" é o responsável por receber os comandos SQL e fazer o envio das informações, assim como o retorno.

Agora que já sabemos como criar a conexão e como carregar o driver, o que acham de vermos algumas operações básicas ?

Excluindo todos os registros da tabela

Veremos agora como excluir todos os registros de uma tabela. Muito cuidado com esse código, pois ele irá limpar todos os registros de sua tabela.

Listagem 4: Excluindo todos os registros com JDBC

try {  
        Statement stmt = connection.createStatement();  
      
        // Use TRUNCATE  
        String sql = "TRUNCATE my_table";  
      
        // Use DELETE  
        sql = "DELETE FROM my_table";  
      
        // Execute deletion  
        stmt.executeUpdate(sql);  
    } catch (SQLException e) {  
    }  

Como sabemos, excluir todos os registros é muito perigoso e pouco usado, na próxima listagem iremos ver como excluir apenas um registro.

Listagem 5: Excluindo apenas um registro com JDBC

try {  
        // Create a statement  
        Statement stmt = connection.createStatement();  
      
        // Prepare a statement to insert a record  
        String sql = "DELETE FROM my_table WHERE col_string='a string'";  
      
        // Execute the delete statement  
        int deleteCount = stmt.executeUpdate(sql);  
        // deleteCount contains the number of deleted rows  
      
        // Use a prepared statement to delete  
      
        // Prepare a statement to delete a record  
        sql = "DELETE FROM my_table WHERE col_string=?";  
        PreparedStatement pstmt = connection.prepareStatement(sql);  
        // Set the value  
        pstmt.setString(1, "a string");  
        deleteCount = pstmt.executeUpdate();  
        System.err.println(e.getMessage()); 
} catch (SQLException e) {  
    } 

 

Dessa forma nós conseguimos excluir apenas um registro, aquele que passamos por parâmetro.

Inserindo registros com JDBC

Se quisermos inserir um registro em uma tabela de banco de dados é muito simples, basta inserir o código a seguir.

Listagem 6: Inserindo dados no banco

try {  
        Statement stmt = connection.createStatement();  
      
        // Prepare a statement to insert a record  
        String sql = "INSERT INTO my_table (col_string) VALUES('a string')";  
      
        // Execute the insert statement  
        stmt.executeUpdate(sql);  
    } catch (SQLException e) {  
    } 

Alterando registros

Caso queira editar ou alterar um registro da tabela, também é muito simples, basta usarmos o código da listagem 7.

Listagem 7: Alterando registros

try {  
        Statement stmt = connection.createStatement();  
      
        // Prepare a statement to update a record  
        String sql = "UPDATE my_table SET col_string='a new string' WHERE col_string = 'a string'";  
      
        // Execute the insert statement  
        int updateCount = stmt.executeUpdate(sql);  
        // updateCount contains the number of updated rows  
    } catch (SQLException e) {  
    }
 

Conclusão

Acredito que qualquer desenvolvedor Java Web, antes mesmo de saber qualquer framework como Hibernate, Struts, JSF, etc, deve saber primeiro o JDBC. Esse é o ponto de partida para o desenvolvimento web em Java.

Espero que tenham gostado do artigo e até a próxima vez.

 
Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Receba nossas novidades
Ficou com alguma dúvida?