No contexto da programação orientada a objetos e banco de dados, CRUD é um acrônimo para as operações básicas que podem ser realizadas em relação aos dados em um sistema.
Cada letra em CRUD representa uma operação específica:
Create (Criar): Envolve a criação de novos registros ou objetos no banco de dados. Isso geralmente é feito por meio da inserção de novos dados em uma tabela ou coleção de dados.
Read (Ler): Envolve a recuperação de registros ou objetos existentes do banco de dados. Isso é feito por meio de consultas ou pesquisas que permitem acessar os dados armazenados.
Update (Atualizar): Envolve a modificação de registros ou objetos existentes no banco de dados. Isso pode incluir a alteração de valores de campos específicos, a atualização de informações relacionadas ou a edição de propriedades de um objeto.
Delete (Excluir): Envolve a remoção de registros ou objetos existentes do banco de dados. Isso é feito por meio da exclusão dos dados correspondentes da tabela ou coleção.
Essas operações básicas formam a base do controle e manipulação dos dados em um sistema.
Ao implementar um sistema com recursos CRUD, você pode criar, ler, atualizar e excluir dados de forma consistente e estruturada. Entretanto, o nível de estrutura pode variar de acordo com a necessidade e a arquitetura do sistema.
Nesta página, veremos como fazer um CRUD para uma tabela de Estudantes usando JDBC para conectar ao banco de dados MySQL, em um projeto com pouca estrutura em uma arquitetura de classe única.
Na página Padrão MVC e Padrão DAO você irá encontrar exemplos de como fazer o mesmo CRUD em projetos com mais estrutura, usando o padrão DAO e o padrão MVC na arquitetura do sistema.
No contexto do JDBC (Java Database Connectivity), existem duas principais interfaces para executar instruções SQL em um banco de dados: PreparedStatement e Statement.
A principal diferença entre elas é a forma como lidam com a execução de consultas parametrizadas e a prevenção de ataques de injeção de SQL.
a PreparedStatement é recomendada quando você precisa executar consultas parametrizadas de forma segura e eficiente, evitando ataques de injeção de SQL e permitindo a reutilização de consultas;
a Statement pode ser adequada para consultas simples e diretas, mas é importante estar ciente dos riscos de segurança e desempenho ao usar concatenação direta de valores nas consultas. Assim, esta opção é mais apropriada para consultas estáticas, ou seja, que não fazem alterações no banco de dados.
public static void inserir(Connection conexao, String nome, String rga) {
String inserirRegistro = "INSERT INTO estudantes (estudanteNome, estudanteRGA) values (?,?)";
try {
PreparedStatement prepararConsulta = conexao.prepareStatement(inserirRegistro);
prepararConsulta.setString(1, nome);
prepararConsulta.setString(2, rga);
int linhasInseridas = prepararConsulta.executeUpdate();
if (linhasInseridas > 0) {
System.out.println("Registro inserido com sucesso!");
}
} catch (SQLException ex) {
ex.printStackTrace();
}
}
Criamos uma instância da classe PreparedStatement usando o método prepareStatement() da conexão com o banco de dados.
A consulta SQL contém dois placeholders (?) para os valores do nome e rga.
Em seguida, definimos os valores dos parâmetros usando os métodos setString() e setInt() da PreparedStatement. Os valores são atribuídos aos placeholders de acordo com a ordem numérica especificada.
Finalmente, executamos a consulta usando o método executeUpdate(), que é adequado para consultas INSERT, UPDATE ou DELETE. O método retorna o número de linhas afetadas pela consulta.
public static void mostrarEstudantes(Connection conexao) {
String mostrarEstudantes = "SELECT * FROM estudantes";
try {
Statement statementMostrarEstudantes = conexao.createStatement();
ResultSet registros = statementMostrarEstudantes.executeQuery(mostrarEstudantes);
while (registros.next()) {
int id = registros.getInt("estudanteID");
String nome = registros.getString("estudanteNome");
String rga = registros.getString("estudanteRGA");
System.out.println(id + ", " + nome + ", " + rga);
}
} catch (SQLException ex) {
ex.printStackTrace();
}
}
Criamos uma instância da classe Statement com o método createStatement() da conexão com o banco de dados.
Em seguida, executamos uma consulta SELECT simples usando o método executeQuery(), passando a consulta SQL como parâmetro.
Os resultados são processados iterando sobre o ResultSet retornado e exibidos na console.
Use Statement para consultas SQL estáticas;
Use PreparedStatement para consultas SQL parametrizadas;
Use métodos setTipo() para atribuir valores aos parâmetros - Ex: setString(), setInt();
Use o método execute() para executar consultas SQL em geral;
Use o método executeUpdate() para executar consultas SQL do tipo INSERT, UPDATE ou DELETE;
Use o método executeQuery() para executar consultas SQL do tipo SELECT;
Use ResultSet para iterar as linhas de retorno de uma consulta do tipo SELECT;
Use o método next() para avançar as linhas;
Use métodos getTipo() para obter valores dos parâmetros - Ex: getString(), getInt();
Acesse o exemplo de projeto que contém a classe principal a seguir e faz as operações CRUD na tabela Estudante em banco de dados MySQL via JDBC.
// Este projeto realiza o CRUD da tabela Estudante usando JDBC sem nenhuma classe conceitual ou padrão. Ou seja, funciona, mas não é o recomendado.
import java.sql.*;
public class App {
public static void main(String[] args) throws Exception {
System.out.println("Hello, meu projeto CRUD Estudante JDBC!");
// organizar seus dados de conexão em strings é uma boa ideia!
String mySQLURL = "jdbc:mysql://localhost:3306/BDalg3"; // Informar o nome do banco no final da URL é opcional
String usuario = "root";
String senha = "123456";
// realiza a conexão com o banco
try (Connection conexao = DriverManager.getConnection(mySQLURL, usuario, senha)) {
if (conexao != null) {
System.out.println("Conectado com sucesso à instância MySQL!");
}
// Testando os métodos CRUD...
mostrarEstudantes(conexao);
inserir(conexao, "Ada Lovelace da Silva", "202311310001");
inserir(conexao, "Grace Santos", "202311310002");
mostrarEstudantes(conexao);
atualizar(conexao, 2, "Grace Hopper Santos", "202311310002");
mostrarEstudantes(conexao);
excluir(conexao, 1);
mostrarEstudantes(conexao);
conexao.close(); // fecha a conexão com o banco - sempre fechar após o uso!
} catch (SQLException ex) {
ex.printStackTrace();
}
}
// métodos CRUD da tabela Estudante
public static void inserir(Connection conexao, String nome, String rga) {
String inserirRegistro = "INSERT INTO estudantes (estudanteNome, estudanteRGA) values (?,?)";
try {
PreparedStatement prepararConsulta = conexao.prepareStatement(inserirRegistro);
prepararConsulta.setString(1, nome);
prepararConsulta.setString(2, rga);
int linhasInseridas = prepararConsulta.executeUpdate();
if (linhasInseridas > 0) {
System.out.println("Registro inserido com sucesso!");
}
} catch (SQLException ex) {
ex.printStackTrace();
}
}
public static void atualizar(Connection conexao, int id, String nome, String rga) {
String atualizar = "UPDATE estudantes SET estudanteNome=?, estudanteRGA=? WHERE estudanteID=?";
try {
PreparedStatement statementAtualizar = conexao.prepareStatement(atualizar);
statementAtualizar.setString(1, nome);
statementAtualizar.setString(2, rga);
statementAtualizar.setInt(3, id);
int linhasAtualizadas = statementAtualizar.executeUpdate();
if (linhasAtualizadas > 0) {
System.out.println("Registro atualizado com sucesso!");
}
} catch (SQLException ex) {
ex.printStackTrace();
}
}
public static void excluir(Connection conexao, int id) {
String excluir = "DELETE FROM estudantes WHERE estudanteID=?";
try {
PreparedStatement statementExcluir = conexao.prepareStatement(excluir);
statementExcluir.setInt(1, id);
int linhasExcluidas = statementExcluir.executeUpdate();
if (linhasExcluidas > 0) {
System.out.println("Registro excluído com sucesso!");
}
} catch (SQLException ex) {
ex.printStackTrace();
}
}
public static void mostrarEstudantes(Connection conexao) {
String mostrarEstudantes = "SELECT * FROM estudantes";
try {
Statement statementMostrarEstudantes = conexao.createStatement();
ResultSet registros = statementMostrarEstudantes.executeQuery(mostrarEstudantes);
while (registros.next()) {
int id = registros.getInt("estudanteID");
String nome = registros.getString("estudanteNome");
String rga = registros.getString("estudanteRGA");
System.out.println(id + ", " + nome + ", " + rga);
}
} catch (SQLException ex) {
ex.printStackTrace();
}
}
}