Nesta edição iremos aprender a estabelecer uma conexão MYSQL com JAVA e quatro operações básicas: criação (CREATE), consulta (READ), atualização (UPDATE) e destruição (DELETE) para trabalhar com os dados do Banco de Dados, caracterizando o acrônimo CRUD. Acesse o link do GitHub para acesso ao código e melhor acompanhamento da redação.
Para começar, deve ser feito o download e a instalação do MySQL Server bem como a da IDE que se deseja utilizar (NetBeans, Intelij IDEA, Eclipse, etc.). Em seguida, precisamos do driver de conexão entre o Java e o MySQL, o mysqlconnector. Drivers retornam dados consultados em um formato relacional e fornecem conectividade entre banco de dados por meio das interfaces de programa aplicativo (APIs) JDBC disponíveis na plataforma Java. O JDBC (Java Database Connectivity) descreve uma lista de métodos SQL que um programador Java pode usar para acessar um banco de dados relacional. Neste tutorial, estamos utilizando a versão “mysql-connector-java-8.0.17.jar“, bem como o Netbeans IDE 8.2.
Após as instalações, poderemos iniciar nosso projeto. No NetBeans, insira o conector na pasta “Bibliotecas” do seu projeto, como nas figuras a seguir:
Em seguida, crie um pacote em “Pacotes de Códigos-fonte” para onde será colocada a classe da conexão com o banco. Nesse pacote, crie uma nova Classe Java para a sua classe de conexão.
Para ser feita uma conexão com o banco de dados, utilizamos um driver. Assim sendo, utilizamos a classe DriverManager para a comunicação com esses drivers. Com o método getConnection, por sua vez, podemos informar com qual o banco devemos realizar a nossa conexão, o usuário e a senha. O primeiro parâmetro passado por esse método é a URL, uma String, que varia de acordo com o conector que se está utilizando. Neste exemplo, estamos usando o “mysql-connector-java-8.0.17.jar”, logo, essa String possui a seguinte formatação:
URL = jdbc:mysql:// localhost:port/nome_do_banco?useTimezone=true&serverTimezone=UTC
Os próximos parâmetros são o usuário e a senha de acesso ao banco de dados, respectivamente:
DriverManager.getConnection(URL, USER, PASS);
Classe de conexão:
package DatabaseConnection;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class Conexao{
// Informamos qual o Driver que está sendo utilizado
private static final String DRIVER = "com.mysql.cj.jdbc.Driver";
private static final String URL = "jdbc:mysql://localhost:3306/pet?useTimezone=true&serverTimezone=UTC";
private static final String USER = "root";
private static final String PASSWORD = "senha";
public static Connection getConnection() throws SQLException, ClassNotFoundException {
try{
// O método forName carrega e inicia o driver passado por parâmetro
Class.forName(DRIVER);
// Estabelecendo a conexão
return DriverManager.getConnection(URL, USER, PASSWORD);
}catch(ClassNotFoundException | SQLException ex){ // Tratamento de Exceções
System.out.println(ex);
return null;
}
}
}
Agora, com a conexão estabelecida, podemos gerar as classes que irão se relacionar com o banco de dados, buscando, alterando, inserindo e excluindo dados. Assim sendo, precisamos criar mais dois pacotes, um para as classes DAO e um para as classes bean. As classes DAO – Data Access Object – são as classes que fazem o intermédio com o banco de dados, fazendo conexões e transações com o mesmo. Já as classes bean, elas possuem todos os atributos privados (as colunas das tabelas do banco de dados) bem como os métodos getters e setters destes. Exemplo de classe bean:
Criadas as classes bean, podemos nos dirigir à criação das classes DAO. Para a construção dessas classes, é necessário ter um conhecimento prévio na linguagem SQL, uma vez que é através dela que a comunicação é feita com o banco de dados. Primeiramente, precisamos buscar uma conexão com o banco de dados. Isso é feito por meio do método getConnection(). A seguir, utilizamos o PreparedStatement, que é usado para consultas parametrizadas, formatando os valores – inserindo dados de forma mais segura.
Exemplo de um método para inserção de dados no banco de dados:
// O retorno é vazio, e recebe um objeto do tipo Membros
public void Insert(Membros m) throws SQLException, ClassNotFoundException{
Connection con = Conexao.getConnection(); // Busca uma conexão com o banco de dados
PreparedStatement stmt = null;
try{
// Inserindo o comando SQL a ser usado
stmt = con.prepareStatement("INSERT INTO membros VALUES (DEFAULT, ?)");
// O método setString, define que o valor passado será do tipo inteiro
stmt.setString(1, m.getNome());
// Método responsável por fazer a alteração no banco de dados
stmt.executeUpdate();
}catch(SQLException ex){ // Tratamento das exceções
System.out.println(ex);
} finally{ // Encerramento da conexão
Conexao.closeConnection(con, stmt);
}
}
Note que, os valores que são auto-incrementáveis, não são passados através do método get, como é o caso do ID no exemplo.
O método para alteração, bem como para remoção de dados é semelhante ao da inserção, diferindo apenas no comando SQL utilizado.
Agora, desenvolveremos um exemplo de busca de dados no banco de dados. Tendo em vista que, ao ser realizada uma busca (SELECT) em um banco de dados, recebemos como retorno vários itens/linhas. Assim, trataremos esses dados como uma lista de informações, ou seja, o retorno desse método deve ser uma lista.
Exemplo de um método para busca de dados:
// O retorno é uma lista
public List<Membros> Select () throws SQLException, ClassNotFoundException{
Connection con = Conexao.getConnection(); // Busca uma conexão com o banco de dados
PreparedStatement stmt = null;
ResultSet rs = null; // Objeto que armazena o resultado de uma busca em uma estrutura de dados que pode ser percorrida
// Instanciando uma nova lista para receber os valores do banco
List<Membros>membros = new ArrayList<>();
try{
// Inserindo o comando SQL a ser usado
stmt = con.prepareStatement("SELECT * FROM membros");
rs = stmt.executeQuery(); // Executa o comando SQL
/* Loop responsável pela busca dos dados no banco que o repetirá até que não
haja valores */
while(rs.next()){
Membros mem = new Membros();
mem.setId(rs.getInt("id"));
mem.setNome(rs.getString("nome"));
membros.add(mem); // Adiciona o objeto na lista
}
}catch(SQLException ex){ // Tratamento das exceções
Logger.getLogger(MembrosDAO.class.getName()).log(Level.SEVERE, null, ex);
}
return membros; // Retorna a lista
}
Tendo as classes DAO e bean, resta apenas o desenvolvimento de uma interface com o usuário. Dessa forma, pode-se testar a conexão e suas interações com o banco de dados. Esse é um ponto de partida para as aplicações que precisem usar bancos de dados e é extremamente importante sabermos lidar com essa interação e, embora possa parecer complexo, uma vez que se entenda o funcionamento dos métodos necessários, vemos que não é tão complicado assim.
http://www.codeacademy.com/articles/what-is-crud
http://www.linhadecodigo.com.br/artigo/832/overview-de-javabeans.aspx
https://pt.stackoverflow.com/questions/113840/como-funciona-o-padr%C3%A3o-dao
https://www.guj.com.br/t/classe-dao/71523/3
https://www.guj.com.br/t/class-forname/96650/3
https://www.devmedia.com.br/classe-de-conexao-em-java-no-netbeans-driver-mysql/18804
https://www.guj.com.br/t/re-resultset-pra-q-isso-serve/31507
https://www.guj.com.br/t/o-que-e-preparedstatement-e-para-que-serve/86774/2
https://www.javatpoint.com/PreparedStatement-interface
