JDBC - Conexão com Banco de dados

Ver o tópico anterior Ver o tópico seguinte Ir em baixo

JDBC - Conexão com Banco de dados

Mensagem por andreirs em Seg 15 Jul 2013, 5:06 am

study  JDBC - Conexão com Banco de Dados study 
 

ESTE TUTORIAL SERÁ ATUALIZADO EM BREVE.

   Neste tutorial vou ensiná-los a usar o plugin JDBC,
realizando a conexão com o banco de dados, independente de qual seja o banco, e realizando uma consulta simples.
Utilizarei a IDE Eclipse para demonstrar passo a passo e todo o código estará disponível para download no fim do tutorial.

   Primeiro uma breve explicação a respeito do plugin JDBC:
       "O plugin JDBC faz o envio de instruções SQL para qualquer banco de dados relacional, desde que haja um driver que corresponda ao mesmo presente."
Java Database Connectivity ou JDBC é um conjunto de classes e interfaces (API) escritas em Java que fazem o envio de instruções SQL para qualquer
banco de dados relacional.

 
Plugins

   Para cada banco de dados você precisará do seu plugin JDBC específico, então, irei postar os links para download logo abaixo.
Lembre-se de importa-la no seu BuildPath.
Download Plugins JDBC:
    MySQL
 Oracle
   PostgreSQL
   SQLServer
 
Classe Conexão

Para realizarmos a conexão com o banco e o retorno das consultas usufruirmos dos seguintes Objetos em nossa classe:
Connection:
Esta classe representa conexão (sessão) com um banco de dados específico. As instruções SQL
são executadas e os resultados são devolvidos dentro do contexto de uma ligação.
ResultSet:
Basicamente, o ResultSet é uma interface utilizada pra guardar dados vindos de um banco de dados.
Uma tabela de dados representando o resultado de uma consulta no banco de dados.
Durante a leitura das informações em um ResultSet, podemos escolher de qual coluna queremos receber, tanto
pelo número da coluna quanto pelo nome que ela possui na tabela.
.
--- Optativo ---
String (login,senha e url):
Podemos, ou não, manter estas informações em nossa classe.
Login: Este é o login de usuário do banco de dados.
Senha: Esta é a senha do banco.
URL: Este é o caminho do banco de dados. exemplo: "jdbc:mysql:bancoTeste:3306/tabela" <-- Será explicado no decorrer da aula

Então, vamos começar criando a nossa classe Conexao, e declarando seus atributos locais: Connection e as demais Strings (login, senha e url).
A forma de se escrever a URL é a seguinte: "jdbc:nome://caminho:porta/banco"
nome: Nome do banco de dados que estamos utilizando. Utilizarei o mysql.
Exemplo:
MySQL: "jdbc:mysql://caminho:porta/banco"
PostgreSQL: "jdbc:postgresql://caminho:porta/banco"
caminho: Este é o caminho para o banco de dados escolhido. Para o endereço local utilize localhost.
porta: Porta utilizada pelo banco de dados.
banco: Este é o nome do banco, já criado, que queremos utilizar.

Classe Conexao - Atributos Locais criados e inicializados:

Como uma boa prática de programação, podemos inicializar os atributos locais no construtor.

Classe Conexao - Boas Práticas - Inicialização dos atributos no construtor:

Chegou a hora de implementarmos os métodos na classe. Os métodos de base são:
conectar(), desconectar(), consultar(String sql) e atualizar(String sql).
Lembre-se de tratar as exceções que serão lançadas.
Class Conexao - Métodos de Base:
 
VISÃO DETALHADA

Class Conexao - Métodos de Base - Método conectar():
Class Conexao - Métodos de Base - Método desconectar():
Class Conexao - Métodos de Base - Método consultar(String sql):
Class Conexao - Métodos de Base - Método atualizar(String sql):

Bom, é apenas isso aí. A classe Conexao já está realizando todas as tarefas de que
precisamos para realizar qualquer tipo de consulta com o banco de dados. cheers 
 
Testando a nossa aplicação

Bom, agora vamos a parte que nos interessa, fazer o programa funcionar! A ideia é criamos uma tabela
chamada cliente em nosso banco de dados, adicionarmos algumas linhas a ela e, retornarmos estas informações
pelo Java. Então, vamos lá!
As seguintes SQLs foram utilizadas para realizar a criação do banco e a inserção dos valores (o banco utilizado foi o MySQL):
VISUALIZAR CÓDIGO:

Código:

create database java;

create table cliente(nome varchar(45),idade smallint,email varchar(50));

insert into cliente(nome,idade,email) values ('Ândrei Mesquita',21,'andreirs@outlook.com');
insert into cliente(nome,idade,email) values ('Bruno',23,'brunolpw@outlook.com');
insert into cliente(nome,idade,email) values ('Leon Dias',24,'leondias44@gmail.com');

Agora, declaramos o método main e criamos uma instância da classe Conexao. Usando da estrutura iTry {} Catch() {},
para o tratamento de exceções, vamos circundar a chamada do método conectar() e logo em seguida, consultar(),
lembrando que o método consultar() retornará um objeto do tipo ResultSet, então, previamente criamos este objeto e o
fazemos receber o ResultSet que nos é concebido. O parâmetro que enviamos no método consultar() será "SELECT * FROM cliente".
Ainda não chamaremos o método desconectar() pois o objeto ResultSet apenas será 'visível' enquanto a conexão estiver ativa, caso
contrário nós teremos uma exceção ao tentarmos ler o arquivo.
Agora a última coisa de que precisamos é realizar a leitura do arquivo, e nós fazemos a leitura de um ResultSet por meio da estrutura de
repetição While(){}. Então, o nosso código deve ficar assim:
CÓDIGO - WHILE():

Código:
while (rs.next()) {}
Para cada interação queremos mostrar na tela os valores que estão no nosso ResultSet. Para isso, temos duas formas de se fazer:

A primeira forma de leitura é usando o método getinfo() (onde está o info devemos definir o tipo de atributo que será
retornado. Ex.: Integer, String, Float, Boolean...)
. Para o primeiro e terceiro campo, que sabemos que são Strings (varchar),
usamos o método getString(). Para o segundo campo devemos usar getInt().
A informação enviada como parâmetro pode ser tanto o número da coluna em que a informação se encontra, quanto o nome da mesma.
como já mencionei anteriormente.


Recebimento das informações enviando a String com o nome de cada coluna.
LER RESULTSET - PRIMEIRA FORMA:
Recebimento das informações enviando o número da coluna como parâmetro. Neste caso, a primeira coluna vale 1.
LER RESULTSET - SEGUNDA FORMA:
Assim ficou a nossa classe com o método Main:
Classe Main:
Compilando o nosso programa, devemos receber a seguinte mensagem no console:
Console:
Vamos testar o nosso método 'atualizar()' enviando as seguintes sqls:
SQL para atualização e remoção:

Código:
"UPDATE cliente SET email = 'nao posseu email' WHERE nome LIKE 'Leon%'"
"DELETE FROM cliente WHERE nome LIKE 'Andrei%'"
Copiamos o nosso método de leitura novamente. Agora, nossa classe deve ter ficado assim:
Classe Main:

Código:
   /**
    * Método main. Executa a aplicação.
    * @param args
    */
   public static void main(String[] args)
   {
      Conexao con = new Conexao();
      try
      {
         // Conectar no banco de dados
         con.conectar();
         // Consultamos as informações presentes na tabela
         ResultSet rs = con.consultar("SELECT * FROM cliente");
         // Início da estrutura de repetição que nos possibilita realizar
         // a leitura dos dados no nosso ResultSet.
         while (rs.next())
         {
            // Apresenta as informações de cada linha, no console
            System.out.println("NOME: " + rs.getString(1) + "\n" +
                                "IDADE: " + rs.getInt(2) + "\n" +
                             "EMAIL: " + rs.getString(3) + "\n");
         }
         // Atualizamos o campo 'email', na tabela, onde o nome
         // possue a palavra 'Leon'
         con.atualizar("UPDATE cliente SET email = 'nao posseu email' WHERE nome LIKE 'Leon%'");
         // Removemos a linha da tabela onde o nome possue a palavra
         // 'Andrei'
         con.atualizar("DELETE FROM cliente WHERE nome LIKE 'Andrei%'");
         
         System.out.println("Informação Deletada:\n");
         // Recebemos novamente as informaçoes da tabela 'cliente'
         rs = con.consultar("SELECT * FROM cliente");
         // Início da estrutura de repetição que nos possibilita realizar
         // a leitura dos dados no nosso ResultSet.
         while (rs.next())
         {
            // Apresenta as informações atualizadas de cada linha, no console
            System.out.println("NOME: " + rs.getString(1) + "\n" +
                                "IDADE: " + rs.getInt(2) + "\n" +
                             "EMAIL: " + rs.getString(3) + "\n");
         }
         // Desconectar no banco de dados
         con.desconectar();
      } catch (SQLException e)
      {
         e.printStackTrace();
      }
}
 
Códigos
Aqui estão os códigos que usamos neste tutorial. Se for copiá-los, lembre-se de mudar a url para onde se encontra o seu banco.
Clase Conexao - COMPLETO:

Código:
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
/**
 *
* @author Ândrei
 * @version 1.0
 * @date 15/07/2013
 */
public class Conexao
{
 Connection con;
 String login;
 String senha;
 String url;
 /**
 * Construtor da classe que inicializa os seus atributos locais.
 */
 public Conexao()
 {
 login = "root";
 senha = "";
 url = "jdbc:mysql://localhost:3306/java";
 }
 /**
 * Método que realiza a conexão com o banco de dados a partir das informações enviadas como parâmetro para o método
 * <i>getConnection(url,login,senha)</i>.
 * @throws SQLException Este método lança a excessão <n>SQLException</n>.
 */
 public void conectar() throws SQLException
 {
 // Realiza a conexão com o banco de dados
// Devemos enviar como parâmetro: a url, o login e a senha.
 con = DriverManager.getConnection(url,login,senha);
 }
 /**
 * Este método fecha a conexão com o banco de dados. <n>Você deve chamar o método <i>conectar()</i> novamente se quiser
* realizar novas consultas ou atualizações no banco de dados.</n>
 * @throws SQLException Este método lança a excessão <n>SQLException</n>.
 */
 public void desconectar() throws SQLException
 {
 // Fecha a conexão
 con.close();
 }
 /**
 * Este método recupera um objeto do tipo <n>ResultSet</n>, representando a tabela da consulta feita.
 * @param sql A sql definida que queremos executar.
 * @return Retorna um objeto do tipo <n>ResultSet</n> com os valores da consulta.
 * @throws SQLException Este método lança a excessão <n>SQLException</n>.
 */
 public ResultSet consultar(String sql) throws SQLException
 {
 // Prepara a SQL para ser executada
 PreparedStatement ps = con.prepareStatement(sql);
 // Realiza a consulta
 ResultSet rs = ps.executeQuery();
 // Retorna o ResultSet com os valores recebidos
 return rs;
 }
 /**
 * Este método realiza as seguintes operações com o banco de dados:
 *     - Inserção
 *     - Atualização
 *     - Remoção
 * @param sql A sql definida que queremos executar.
 * @throws SQLException Este método lança a excessão <n>SQLException</n>.
*/
 public void atualizar(String sql) throws SQLException
 {
 // Prepara a SQL para ser executada
 PreparedStatement ps = con.prepareStatement(sql);
 // Executa a atualização
 ps.executeUpdate();
 }
}
Clase Main - COMPLETO:

Código:
import java.sql.ResultSet;
import java.sql.SQLException;

public class Main
{
 /**
 * Método main. Executa a aplicação.
 * @param args
 */
 public static void main(String[] args)
{
 Conexao con = new Conexao();
 try
 {
 // Conectar no banco de dados
 con.conectar();
 // Consultamos as informações presentes na tabela
 ResultSet rs = con.consultar("SELECT * FROM cliente");
 // Início da estrutura de repetição que nos possibilita realizar
 // a leitura dos dados no nosso ResultSet.
 while (rs.next())
 {
 // Apresenta as informações de cada linha, no console
 System.out.println("NOME: " + rs.getString(1) + "\n" +
                      "IDADE: " + rs.getInt(2) + "\n" +
          "EMAIL: " + rs.getString(3) + "\n");
 }
 // Atualizamos o campo 'email', na tabela, onde o nome
 // possue a palavra 'Leon'
 con.atualizar("UPDATE cliente SET email = 'nao posseu email' WHERE nome LIKE 'Leon%'");
 // Removemos a linha da tabela onde o nome possue a palavra
 // 'Andrei'
 con.atualizar("DELETE FROM cliente WHERE nome LIKE 'Andrei%'");
 
System.out.println("Informação Deletada:\n");
 // Recebemos novamente as informaçoes da tabela 'cliente'
 rs = con.consultar("SELECT * FROM cliente");
 // Início da estrutura de repetição que nos possibilita realizar
 // a leitura dos dados no nosso ResultSet.
 while (rs.next())
 {
 // Apresenta as informações atualizadas de cada linha, no console
 System.out.println("NOME: " + rs.getString(1) + "\n" +
                      "IDADE: " + rs.getInt(2) + "\n" +
          "EMAIL: " + rs.getString(3) + "\n");
 }
 // Desconectar no banco de dados
 con.desconectar();
 } catch (SQLException e)
 {
 e.printStackTrace();
 }
 }
}
 
Conclusão
Por hoje era isso. Aprendemos como implementar a estrutura básica de uma classe que realiza a conexão com qualquer banco de dados.
Espero que tenham gostado da forma como expliquei, e que tenham compreendido.
Abraço, até o próximo tutorial! Sleep


Última edição por andreirs em Ter 18 Fev 2014, 3:44 pm, editado 5 vez(es)

_________________
/**
* @author Ândrei
* @title YottaByte
*/

http://codigomestre.forumbrasil.net/

andreirs
YOTTABYTE
YOTTABYTE

Mensagens : 33
Reputação : 8
Data de inscrição : 14/07/2013
Idade : 24
Localização : Porto Alegre

Voltar ao Topo Ir em baixo

Re: JDBC - Conexão com Banco de dados

Mensagem por brunolpw em Ter 16 Jul 2013, 3:52 pm

Cara, eu fiz aqui e deu bem certinho, gostei, ficou bem explicado Wink 

_________________


/**
* @author Bruno La Porta.
* @title  YottaByte.
* */

/* Life rum on code. */


http://codigomestre.forumbrasil.net/

.:: Amigurumi Life ::.
Por Liz Camargo

brunolpw
YOTTABYTE
YOTTABYTE

Mensagens : 33
Reputação : 14
Data de inscrição : 14/07/2013
Idade : 26
Localização : Brasil - RS - Porto Alegre

http://codigomestre.forumbrasil.net

Voltar ao Topo Ir em baixo

Ver o tópico anterior Ver o tópico seguinte Voltar ao Topo

- Tópicos similares

 
Permissão deste fórum:
Você não pode responder aos tópicos neste fórum