Java: Conectando-se ao MySQL

Henrique — Fri, 21 Mar 2008 18:47:02 +0000

Olá pessoas,

Aqui estou de novo tentando voltar a postar hehehe. Hoje vou mostrar um exemplo simples de classe em Java para se conectar ao MySQL, para que mais pra frente eu possa mostrar algumas coisas bacanas para se fazer com JSP + TagLibs + MySQL + Servlets :) (Não sou grande fã de usar frameworks quando ainda não conheço bem a linguagem).
Bom, chega de lenga lenga, e vamos ao que interessa :D

Para poder brincar você vai precisar do MyConnector/J instalado. Ele pode ser obtido em: http://dev.mysql.com/downloads/connector/j/5.1.html!
Ao baixar o Connector/J você encontrará dentro do .zip (ou do .tar.gz) um arquivo com o nome parecido com: mysql-connector-java-5.1.5-bin.jar. Certifique-se que você adicionará esse arquivo ao seu CLASSPATH pois ele será necessário para que os exemplos que usaremos funcionem.

Agora vamos criar um banco de dados simples para utilizarmos nos nossos exemplos:

CREATE DATABASE projeto;
USE projeto;
CREATE TABLE usuario (
   id_usuario INT NOT NULL PRIMARY KEY AUTO_INCREMENT
   ,nome VARCHAR(100)
   ,idade INT(3)
);

E aqui inserimos alguns dados, para podermos consulta-los.

INSERT INTO usuario (
   nome
   ,idade
) VALUES (
   "Henrique"
   ,22
);
 
INSERT INTO usuario (
   nome
   ,idade
) VALUES (
   "José"
   ,35
);
 
INSERT INTO usuario (
   nome
   ,idade
) VALUES (
   "Andreia"
   ,21
);

Vou começar com uma classe bem simples, que simplesmente se conecta ao MySQL, e ao longo do texto vamos incrementa-la para que faça mais coisas. Vamos então a primeira classe:

package com.heap.db;
 
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Connection;
 
public class MySQL {
 
    private String host;
    private String user;
    private String pass;
    private String database;
 
    public Connection c;
 
    /**
     * Construtor da classe
     *
     * @param host Host em que se deseja conectar
     * @param database Nome do database em que se deseja conectar
     * @param user Nome do usuário
     * @param pass Senha do usuário
     */
    public MySQL( String host, String database, String user, String pass ) {
        this.pass = pass;
        this.user = user;
        this.host = host;
        this.database = database;
    }
 
    /**
     * Método que estabelece a conexão com o banco de dados
     *
     * @return True se conseguir conectar, falso em caso contrário.
     */
    public boolean connect() {
        boolean isConnected = false;
        String url;
 
        url = "jdbc:mysql://"+this.host+"/"
              +this.database+"?"
              +"user="+this.user
              +"&password="+this.pass;
 
        try {
            Class.forName("com.mysql.jdbc.Driver").newInstance();
            System.out.println(url);
            this.c = DriverManager.getConnection(url);
            isConnected = true;
        } catch( SQLException e ) {
            e.printStackTrace();
            System.out.println(e.getMessage());
            isConnected = false;
        } catch ( ClassNotFoundException e ) {
            e.printStackTrace();
            System.out.println(e.getMessage());
            isConnected = false;
        } catch ( InstantiationException e ) {
            e.printStackTrace();
            System.out.println(e.getMessage());
            isConnected = false;
        } catch ( IllegalAccessException e ) {
            e.printStackTrace();
            System.out.println(e.getMessage());
            isConnected = false;
        }
 
        return isConnected;
    }
}

Código bastante simples como podemos perceber. A primeira linha indica que essa classe pertence ao pacote com.heap.db. É importante ressaltar isso, porque teremos de importar esse código para dentro da nossa classe que será o nosso programa de verdade, que chamará o método de conexão. Perceba também que no código eu não faço nenhum tratamento especial para as exceptions, apenos imprimo o erro. Essa não é uma técnica muito bacana, pois podemos perder informações. Eu gost de criar uma outra classe que faça o handle das exceptions e salve os erros em algum lugar, para que eu possa consulta-los se ncessário, mas em nosso caso aqui é o bastante apenas imprimi-las.

import com.heap.db.MySQL;
 
public class TesteDB {
 
    public static void main (String [] args) {
        MySQL db = new MySQL("localhost","projeto","root","12345");
        if ( db.connect() ) {
          System.out.println("Conectado!");
        };
      }
 
}

Logo na primeira linha desse código é feito o import da classe que se conecta ao MySQL. No método main() criamos uma instancia da classe MySQL com os parametros para especificar onde estamos conectando, e logo na sequência chamamos o método para conectar.
Agora é hora de testar isso tudo. Então apenas para motivos de esclarecimento, vamos dar uma olhada em como ficou a estrutura do nosso diretório.

C:\Projeto
¦   TesteDB.class
¦   TesteDB.java
¦
+---com
¦   +---heap
¦      +---db
¦               MySQL.class
¦               MySQL.java
¦
+---lib
         mysql-connector-java-5.1.5-bin.jar

No meu caso já se pode ver os arquivos .class pois já compilei o código, mas aqui vai a forma como iremos compilar:

À partir da raiz do projeto (No meu caso aqui C:\Projeto (Sim, estou usando windows porque estou escrevendo isso do computador do trabalho :|))
javac -cp . com\heap\db\MySQL.java
javac -cp . TesteDB.java

Agora que tudo está compilado, basta rodar!

java TesteDB
java.lang.ClassNotFoundException: com.mysql.jdbc.Driver
         at java.net.URLClassLoader$1.run(URLClassLoader.java:200)
         at java.security.AccessController.doPrivileged(Native Method)
         at java.net.URLClassLoader.findClass(URLClassLoader.java:188)
         at java.lang.ClassLoader.loadClass(ClassLoader.java:306)
         at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:276)
         at java.lang.ClassLoader.loadClass(ClassLoader.java:251)
         at java.lang.ClassLoader.loadClassInternal(ClassLoader.java:319)
         at java.lang.Class.forName0(Native Method)
         at java.lang.Class.forName(Class.java:169)
         at com.heap.db.MySQL.connect(MySQL.java:32)
         at TesteDB.main(TesteDB.java:7)
com.mysql.jdbc.Driver

Oops! Algo saiu errado. Lembram-se no começo quando eu disse que precisavamos do Mysql Connector/J e que ele estivesse no CLASSPATH? Bem, como da pra notar na estrutura de diretórios, eu coloquei o Connector/J no diretório lib porém não fiz referência a essa lib quando fui rodar o programa, o que causou o erro. Então vamos rodar o comando correto e ver o que acontece:

java -cp .;lib\mysql-connector-java-5.1.5-bin.jar TesteDB
jdbc:mysql://localhost/projeto?user=root&password=12345
Conectado!

Como pode perceber, agora parece que tudo funcionou! A opção -cp do comando java diz ao interpretador qual o CLASSPATH a utilizar. Nesse caso mandei que utilizasse o diretório atual, e o arquivo .jar do Connector/J.

Muito legal isso tudo, porém uma classe que simplesmente conecta no banco é bastante inútil. Vamos então melhorar a nossa classe MySQL, adicionando algums métodos para que possamos consultar dados.

O primeiro método que irei adicionar é um que recebe uma query como parametro e retorna um ResultSet. O ResultSet nada mais é do que um resource que representa a tabela. Eis o código:

    /**
     * Esse método executa a query dada, e retorna um ResultSet
     * Talvez fosse melhor idéia fazer esse método lançar uma exception
     * a faze-lo retornar null como eu fiz, porém isso é apenas um exemplo
     * para demonstrar a funcionalidade do comando execute
     *
     * @param query String contendo a query que se deseja executar
     * @return ResultSet em caso de estar tudo Ok, null em caso de erro.
     */
    public ResultSet executar( String query ) {
        Statement st;
        ResultSet rs;
 
        try {
            st = this.c.createStatement();
            rs = st.executeQuery(query);
            return rs;
        } catch ( SQLException e ) {
            e.printStackTrace();
        }
 
        return null;
    }

Nesse trecho de código, criamos um Statement a partir da nossa conexão. O objeto Statement nos permite executar comando no nosso banco de dados.
E para testar esse código, nós iremos rodar uma query contra o nosso banco de dados que criamos no começo desse texto. O nosso código da classe TesteDB vai ficar dessa maneira:

import java.sql.ResultSet;
import java.sql.SQLException;
 
import com.heap.db.MySQL;
 
public class TesteDB {
 
    public static void main (String [] args) {
        MySQL db = new MySQL("localhost","projeto","root","12345");
        String query;
 
        if ( db.connect() ) {
            System.out.println("Conectado!");
            System.out.println("Rodando uma query contra o banco");
 
            query = "select * from usuario";
            ResultSet rs = db.executar(query);
            try {
                if ( rs != null ) { // Verifica se a query retornou algo
                    while ( rs.next() ) {
                        // Podemos referenciar a coluna pelo índice
                        System.out.println("Id: " + rs.getInt(1));
 
                        // Ou pelo seu nome
                        System.out.println("Nome: " + rs.getString("nome"));
                        System.out.println("Idade: " + rs.getInt("idade"));
                        System.out.println("----------------------------");
                    }
                }
          } catch ( SQLException e ) {
              e.printStackTrace();
          }
 
        };
      }
 
}

Recompile e rode esse código da mesma forma que fizemos lá em cima, você deve ter uma saída como essa:

jdbc:mysql://localhost/projeto?user=root&password=12345
Conectado!
Rodando uma query contra o banco
Id: 1
Nome: Henrique
Idade: 22
----------------------------
Id: 2
Nome: Jos‚
Idade: 35
----------------------------
Id: 3
Nome: Andreia
Idade: 21
----------------------------

No código você pode reparar que eu referenciei as colunas tanto utilizando um índice (cada coluna tem um índice numérico que vai de 1, representando a primeira coluna da tabela, até N onde N é o número de colunas na tabela). Repare também que para cada tipo de dados que a tabela possui utilizamos um método get distinto. Para a lista de métodos get que se pode utilizar, consulte a documentação do ResultSet .
Já melhoramso bastante! Agora nossa classe já tem uma função, ela consulta dados na nossa base! Vamos ver então como podemos ecrever um método para inserir dados em nossa tabela. De volta na classe MySQL adicione o seguinte método:

    /**
     * Executa uma query como update, delete ou insert.
     * Retorna o número de registros afetados quando falamos de um update ou delete
     * ou retorna 1 quando o insert é bem sucedido. Em outros casos retorna -1
     *
     * @param query A query que se deseja executar
     * @return 0 para um insert bem sucedido. -1 para erro
     */
    public int inserir( String query ) {
        Statement st;
        int result = -1;
 
        try {
            st = this.c.createStatement();
            result = st.executeUpdate(query);
        } catch ( SQLException e ) {
            e.printStackTrace();
        }
 
        return result;
    }

Esse método poderá ser utilizado tanto para inserir dados, como para apagar ou atualizar. Novamente criamos um Statement e chamamos um método para executar a nossa query. Para maiores informações sobre os métodos da classe Statement consulte a documentação.

Vejamos então como ficou a nossa classe MySQL completa, e um programa de exemplo que a utiliza.

MySQL.java

package com.heap.db;
 
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Connection;
import java.sql.Statement;
 
public class MySQL {
 
    private String host;
    private String user;
    private String pass;
    private String database;
 
    public Connection c;
 
    /**
     * Construtor da classe
     *
     * @param host Host em que se deseja conectar
     * @param database Nome do database em que se deseja conectar
     * @param user Nome do usuário
     * @param pass Senha do usuário
     */
    public MySQL( String host, String database, String user, String pass ) {
        this.pass = pass;
        this.user = user;
        this.host = host;
        this.database = database;
    }
 
    /**
     * Método que estabelece a conexão com o banco de dados
     *
     * @return True se conseguir conectar, falso em caso contrário.
     */
    public boolean connect() {
        boolean isConnected = false;
        String url;
 
        url = "jdbc:mysql://"+this.host+"/"
              +this.database+"?"
              +"user="+this.user
              +"&password="+this.pass;
 
        try {
            Class.forName("com.mysql.jdbc.Driver").newInstance();
            System.out.println(url);
            this.c = DriverManager.getConnection(url);
            isConnected = true;
        } catch( SQLException e ) {
            e.printStackTrace();
            System.out.println(e.getMessage());
            isConnected = false;
        } catch ( ClassNotFoundException e ) {
            e.printStackTrace();
            System.out.println(e.getMessage());
            isConnected = false;
        } catch ( InstantiationException e ) {
            e.printStackTrace();
            System.out.println(e.getMessage());
            isConnected = false;
        } catch ( IllegalAccessException e ) {
            e.printStackTrace();
            System.out.println(e.getMessage());
            isConnected = false;
        }
 
        return isConnected;
    }
 
    /**
     * Esse método executa a query dada, e retorna um ResultSet
     * Talvez fosse melhor idéia fazer esse método lançar uma exception
     * a faze-lo retornar null como eu fiz, porém isso é apenas um exemplo
     * para demonstrar a funcionalidade do comando execute
     *
     * @param query String contendo a query que se deseja executar
     * @return ResultSet em caso de estar tudo Ok, null em caso de erro.
     */
    public ResultSet executar( String query ) {
        Statement st;
        ResultSet rs;
 
        try {
            st = this.c.createStatement();
            rs = st.executeQuery(query);
            return rs;
        } catch ( SQLException e ) {
            e.printStackTrace();
        }
 
        return null;
    }
 
    /**
     * Executa uma query como update, delete ou insert.
     * Retorna o número de registros afetados quando falamos de um update ou delete
     * ou retorna 1 quando o insert é bem sucedido. Em outros casos retorna -1
     *
     * @param query A query que se deseja executar
     * @return 0 para um insert bem sucedido. -1 para erro
     */
    public int inserir( String query ) {
        Statement st;
        int result = -1;
 
        try {
            st = this.c.createStatement();
            result = st.executeUpdate(query);
        } catch ( SQLException e ) {
            e.printStackTrace();
        }
 
        return result;
    }
}

TesteDB.java

import java.sql.ResultSet;
import java.sql.SQLException;
 
import com.heap.db.MySQL;
 
public class TesteDB {
 
    public static void main (String [] args) {
        MySQL db = new MySQL("localhost","projeto","root","12345");
        String query;
        int result;
 
        if ( db.connect() ) {
            System.out.println("Conectado!");
            System.out.println("Rodando uma query contra o banco");
 
            query = "select * from usuario";
            ResultSet rs = db.executar(query);
            try {
                if ( rs != null ) { // Verifica se a query retornou algo
                    while ( rs.next() ) {
                        // Podemos referenciar a coluna pelo índice
                        System.out.println("Id: " + rs.getInt(1));
 
                        // Ou pelo seu nome
                        System.out.println("Nome: " + rs.getString("nome"));
                        System.out.println("Idade: " + rs.getInt("idade"));
                        System.out.println("----------------------------");
                    }
                }
          } catch ( SQLException e ) {
              e.printStackTrace();
          }
 
          System.out.println("Inserindo dados na tabela");
          query = "insert into usuario (nome, idade) values ('Maria',23)";
          result = db.inserir(query);
          if (  result > -1 ) {
              System.out.println("Dado inserido com sucesso! Resutlt = " + result);
          } else {
              System.out.println("Erro inserindo dado.");
          }
 
          query = "update usuario set idade = 99";
          result = db.inserir(query);
          if (  result > -1 ) {
              System.out.println("Dado inserido com sucesso! Resutlt = " + result);
          } else {
              System.out.println("Erro inserindo dado.");
          }
 
        };
      }
 
}

O procedimento para compilar e rodar é o mesmo que seguimos lá no começo.
Bom, por hoje é só pessoas! Espero que esse pequeno tutorial possa ajudar aqueles que como eu estão começando! Continuem estudando e boa sorte!
No próximo vamos falar de coisas pouco mais avançadas e ainda mais divertidas.

Para maiores informações consulte os links:
MySQL AB: Basic JDBC Concepts
Java Documentation
Google

GilgaLab » MySQL

Java: Conectando-se ao MySQL