Este artigo descreve o conhecimento e as habilidades básicas de JDBC com exemplos. Compartilhe com todos para sua referência. A análise específica é a seguinte:
1. O que é JDBC?
Em termos leigos, a tecnologia JDBC usa um programa Java para enviar instruções SQL ao banco de dados. O banco de dados executa as instruções SQL após recebê-las e retorna os resultados ao programa Java para gerenciamento.
2. Quais são as condições para utilização do JDBC?
A) O endereço do host do banco de dados de destino
B) O número da porta ocupada pelo software de banco de dados no host
C) Nome de usuário usado para fazer login no banco de dados
D) Senha para esse nome de usuário
E) Conecte-se ao banco de dados
3.Princípios da tecnologia JDBC
Sabemos que existem vários tipos de bancos de dados, e os padrões e especificações de bancos de dados produzidos por diferentes fabricantes são diferentes. Neste momento, se usarmos código JAVA para enviar instruções SQL, teremos que escrever um conjunto após o outro de acordo com diferentes bancos de dados. Um conjunto de códigos de operação, que representa um enorme custo de desenvolvimento para desenvolvedores de programas, então SU Quando a Empresa N desenvolveu a tecnologia JDBC, ela estipulou um conjunto de interfaces padrão. Os fabricantes de bancos de dados devem fornecer um driver para implementar esse conjunto de interfaces. . Para desenvolver, não há necessidade de escrever um conjunto de códigos para se adaptar a diferentes bancos de dados.
4. API principal em JDBC
|- Driver: A interface implementada pela classe do driver.
|-Connection connect(String url, Properties info) --usado para conectar ao banco de dados e obter o objeto de conexão
Parâmetros que precisam ser definidos em Propriedades:
url: string URL da conexão com o banco de dados. Protocolo+banco de dados subprotocolo+host+porta+banco de dados
usuário: nome de usuário do banco de dados
senha: senha do usuário
|-Connection: interface para conectar ao banco de dados
|- Statement createStatement() --Cria um objeto Statement para enviar instruções sql
|- PreparedStatement prepareStatement(String sql) - Cria um objeto PreparedStatement para enviar instruções sql pré-compiladas
|-CallableStatement prepareCall(String sql) --Crie um objeto CallableStatement para chamar procedimentos armazenados.
|-Instrução: usada para executar instruções SQL estáticas
|-int executeUpdate(String sql) --Executa operação de atualização (DDL+DML)
|-ResultSet executeQuery(String sql) --Executa operação de consulta (DQL)
|- PreparedStatement: usado para executar instruções SQL pré-compiladas
|- int executeUpdate() -- executa operação de atualização
|- ResultSet executeQuery() -- Executa operação de consulta
|- CallableStatement: sql usado para executar procedimentos armazenados
|- ResultSet executeQuery() --Chama o procedimento armazenado
|- ResultSet: conjunto de resultados. Usado para encapsular os dados de consulta do banco de dados
|- boolean next() --Move o cursor de registro para a próxima linha
|- Object getObject(int columnIndex) -- Obtém o valor do campo
Depois de entender quais APIs, vamos usar JDBC para enviar instruções SQL ~
5. Use o objeto Statement para operar o banco de dados
Operações DDL e DML
Passo 1
Importe o pacote, pois estou utilizando um banco de dados MySQL, portanto para utilizar a tecnologia JDBC é necessário utilizar o driver de banco de dados fornecido pelo fabricante do banco de dados MySQL. Portanto, o primeiro passo é importar o pacote do driver de banco de dados para o projeto.
Nome do pacote usado: mysql-connector-java-5.1.7-bin.jar
Etapa 2
Crie uma classe comum, adicione um método nela e copie o código no método da seguinte forma: //URL
private String url = "jdbc:mysql://localhost:3306/vmaxtam";
//usuário
string privada usuário = "root";
//senha
senha privada String = "root";
public void testDDL() lança exceção{
//1.Registrar driver
Class.forName("com.mysql.jdbc.Driver");
//2. Obtenha a conexão
Conexão conexão = DriverManager.getConnection(url, usuário, senha);
//3. Criar objeto de instrução
Instrução stmt = conn.createStatement();
//4. Preparar instrução sql
String sql = "CREATE TABLE aluno(sid INT PRIMARY KEY,nome VARCHAR(20),idade INT)";
//5. Envia a instrução sql através do objeto de instrução e retorna o resultado da execução
contagem interna = stmt.executeUpdate(sql);
//6.Imprimir resultados de execução
System.out.println("Registros "+count+" afetados");
}
//7. Fechar recursos
if(declaração!=nulo)
{
instrução.close();
}
if(conn!=nulo)
{
conn.close();
}
Se desejar executar operações DQL e DDL, você pode escrever a instrução SQL e, em seguida, chamar o método executlUpdate da instrução para executar a instrução SQL para o banco de dados. Esse método retorna um valor inteiro indicando quantas linhas no banco de dados são afetadas.
Se não alterarmos o programa acima e quisermos emitir instruções SQL para o banco de dados novamente, teremos que escrever um programa para conectar novamente e, após a operação, teremos que fechar o objeto de instrução e o objeto de conexão, o que é muito complicado . Portanto, geralmente extraímos o processo de conexão e o processo de liberação do objeto em uma classe de ferramenta. O código na classe de ferramenta é o seguinte:
Copie o código da seguinte forma: public class sqlUtil {
string estática privada url = "jdbc:mysql://localhost:3306/vmaxtam";
string estática privada usuário = "root";
private static String senha = "root";
// Obtém conexão
conexão estática pública getconnection() {
Conexão conexão = null;
tentar {
// 1. Registrar driver
Class.forName("com.mysql.jdbc.Driver");
// 2. Obtenha a conexão
conn = DriverManager.getConnection(url, usuário, senha);
// 3. Obtenha o objeto de instrução
Instrução instrução = conn.createStatement();
} catch (Exceção e) {
// TODO Bloco catch gerado automaticamente
e.printStackTrace();
}
conexão de retorno;
}
// 7. Feche o recurso
public static void close(Instrução de instrução, conexão de conexão) {
{
tentar {
if (instrução! = nulo)
instrução.close();
if (conexão! = nulo) {
conexão.close();
}
} catch (SQLException e) {
// TODO Bloco catch gerado automaticamente
e.printStackTrace();
}
}
}
}
As coisas a considerar são:
1) Um usuário só precisa registrar o driver uma vez. Não há necessidade de registrar o driver toda vez que ele se conectar ao banco de dados, então escrevemos o processo de registro do driver em um bloco de código estático.
2) O URL, o nome de usuário, a senha e o nome da classe do driver são codificados no programa. Para poder alterar o banco de dados ou o usuário sem alterar o código, geralmente escrevemos essas informações em um arquivo de configuração.
O arquivo de configuração é escrito no diretório src do projeto e é denominado db.properties
Copie o código da seguinte forma: url=jdbc:mysql://localhost:3306/vmaxtam
usuário = raiz
senha=raiz
driverClass=com.mysql.jdbc.Drive
Em seguida, leia o arquivo de configuração em sqlUtil e, finalmente, otimize-o no código a seguir: public class sqlUtil {.
string estática privada url = null;
string estática privada usuário = null;
private static String senha = null;
string estática privada driverClass = null;
estático{
tentar {
//1. Obtenha o objeto bytecode
Classclazz = sqlUtil.class;
//2. Chame getResourceAsStream para obter o caminho
InputStream inputStream = clazz.getResourceAsStream("/db.properties");
Propriedades pro = new Propriedades();
pro.load(inputStream);
//3. Ler parâmetros
url=pro.getProperty("url");
senha=pro.getProperty("senha");
usuário=pro.getProperty("usuário");
driverClass=pro.getProperty("driverClass");
Class.forName(driverClass);
} catch (Exceção e) {
e.printStackTrace();
System.out.println("Falha no registro!" + e.getMessage());
lançar nova RuntimeException(e);
}
}
// Obtém conexão
conexão estática pública getconnection() {
Conexão conexão = null;
tentar {
// Obtém conexão
conn = DriverManager.getConnection(url, usuário, senha);
// Obtém o objeto instrução
Instrução instrução = conn.createStatement();
} catch (Exceção e) {
e.printStackTrace();
}
conexão de retorno;
}
//Fecha o recurso
public static void close(Instrução de instrução, conexão de conexão) {
{
tentar {
if (instrução! = nulo)
instrução.close();
if (conexão! = nulo) {
conexão.close();
}
} catch (SQLException e) {
// TODO Bloco catch gerado automaticamente
e.printStackTrace();
}
}
}
}
Operação DQL
Então, como usar JDBC para consultar dados no banco de dados?
Copie o código da seguinte forma: @Test
public void testdsl() lança exceção {
//Obter conexão
cnn2=sqlUtil.getconnection();
Instrução instrução = cnn2.createStatement();
//Prepara instrução SQL
String sql = "selecione * do assunto";
//Chama executeQuery para executar a instrução de consulta
ResultSet res = instrução.executeQuery(sql);
//Após a conclusão da consulta, res apontará para o cabeçalho da tabela. Se desejar obter dados, você deve continuar apontando para a próxima linha do resultado da consulta. Quando não houver próxima linha de dados, 0 será retornado.
enquanto(res.next())
{
//Obtenha o valor do campo "sjid" no resultado da consulta e certifique-se de que o tipo esteja claro
int id = res.getInt("sjid");
//Obtém o valor do campo "sjname" no resultado da consulta, e o tipo deve ser claro
String nome = res.getString("sjname");
System.out.println("ID:" + id + "NOME:" + nome);
}
sqlUtil.close (instrução, cnn2);
}
O acima é o uso de objetos Statement para operar o banco de dados ~
6. Use PreparedStatement para operar o banco de dados
O objeto PreparedStatement é na verdade um objeto Statement especial que pode pré-compilar instruções SQL. Ao definir os parâmetros, você pode executar a instrução SQL ~.
O código de cópia da operação DDL e DML é o seguinte: pacote com.vmaxtam.sqltest;
importar java.sql.Connection;
importar java.sql.PreparedStatement;
importar org.junit.Test;
classe pública PreparedStatementTest{
Conexão conexão = null;
@Teste
public void ddldmlTest() lança exceção {
// 1. Obtenha a conexão
conexão = sqlUtil.getconnection();
// 2. Preparar instruções SQL, instruções pré-compiladas e parâmetros? Espaço reservado para número
String sql = "INSERIR EM VALORES DE ASSUNTO (?,?)";
// 3. Obtenha o objeto
PreparedStatement preparadoStatement = connection.prepareStatement(sql);
/*
* 4. Para definir os parâmetros SQL, você precisa saber o número do parâmetro e seu tipo. A primeira frase abaixo indica: o primeiro parâmetro da instrução SQL é do tipo int, e o valor do parâmetro é definido como 3, e assim por diante. sobre.
*/
preparadoStatement.setInt(1, 3);
preparadoStatement.setString(2, "Inglês");
// 5. Entregue ao banco de dados para executar SQL
int num = preparadoStatement.executeUpdate();
System.out.println("Existem" + num + "registros afetados");
sqlUtil.close(preparedStatement, conexão);
}
}
O exemplo acima é usar o objeto PreparedStatement para enviar instruções de inserção. Da mesma forma, instruções DDL e DML podem ser enviadas desta forma.
Benefícios da pré-compilação PreparedStatement:
A pré-compilação de PreparedStatement permite consultar diferentes destinos definindo diferentes parâmetros no lado do banco de dados, apenas uma instrução pré-compilada será salva, mas se você usar Statement para enviar uma instrução, cada vez que uma for enviada, uma será armazenada no. banco de dados , o que pode ocupar muita memória.
O código de cópia da operação DQL é o seguinte: @Test
public void dqlTest() lança exceção {
// 1. Obtenha a conexão
conexão = sqlUtil.getconnection();
// 2. Preparar instruções SQL, instruções pré-compiladas e parâmetros? Espaço reservado para número
String sql = "selecione * do assunto onde sjid=? ou sjname=?";
// 3. Obtenha o objeto
PreparedStatement preparadoStatement = connection.prepareStatement(sql);
/*
* 4. Para definir os parâmetros SQL, você precisa saber o número do parâmetro e seu tipo. A primeira frase abaixo indica: o primeiro parâmetro da instrução SQL é do tipo int, e o valor do parâmetro é definido como 3, e assim por diante. sobre.
*/
preparadoStatement.setInt(1, 2);
preparadoStatement.setString(2, "Chinês");
// 5. Entregue ao banco de dados para executar SQL
ResultSet rst = preparadoStatement.executeQuery();
//6.Iterar o conjunto de resultados
enquanto(rst.next())
{
int id = rst.getInt("sjid");
String nome = rst.getString("sjname");
System.out.println("ID:" + id + "NOME:" + nome);
}
//7.Feche a conexão
sqlUtil.close(preparedStatement, conexão);
}
Você também pode chamar o método executeQuery() e iterar a saída após obter o conjunto de resultados ~;
Como Statement e PreparedStatement são tão semelhantes, vamos comparar suas vantagens e desvantagens ~
A diferença entre Declaração e PreparedStatement:
1. Gramática diferente
A instrução oferece suporte apenas à compilação estática e as instruções SQL são codificadas permanentemente.
PreparedStatement suporta pré-compilação, use? Venha e sente-se.
2. Eficiência diferente
A instrução sempre envia uma instrução SQL, não suporta armazenamento em cache e tem baixa eficiência de execução.
PreparedStatement suporta pré-compilação e é armazenado em cache no banco de dados. Ele só precisa enviar parâmetros e a eficiência de execução é rápida.
3. Segurança diferente
A declaração é facilmente injetada.
Injeção: elementos Crafty podem escrever instruções SQL especiais para comprometer o banco de dados.
Por exemplo: Para consultar as informações de um determinado usuário
Situação geral: SELECT * FROM user_list onde nomedeusuário=xxx e senha=xxx (xxx aqui deve preencher o nome de usuário e senha do próprio usuário)
Situação de injeção: SELECT * FROM user_list where username='abc' ou 1=1 -- password=xxx;
Desta forma, 1=1 é igual, e o sinal “--” é adicionado antes da senha, e o conteúdo a seguir se torna um comentário e não será executado. Em outras palavras, todas as informações do usuário podem ser consultadas sem senhas.
PreparedStatement, porque especifica os parâmetros na instrução SQL, pode impedir a injeção.
Conclusão: Recomenda-se usar PreparedStatement por ser mais rápido e seguro .
7. Use CallableStatement para executar procedimentos armazenados
Usar CallableStatement executa apenas procedimentos armazenados. Para criar procedimentos armazenados, ainda precisamos criá-los no banco de dados.
Passo 1
Agora o banco de dados criou um procedimento armazenado:
Copie o código da seguinte forma: DELIMITER $
CRIAR PROCEDIMENTO pro_add(IN a INT , IN b VARCHAR(20),OUT c INT)
COMEÇAR
SELECIONE * DO ASSUNTO ONDE sjid=a OR sjname=b;
DEFINIR c=a+a+a+a;
FIM $
Etapa 2
Use o código java para executar e obter os parâmetros de saída. Copie o código da seguinte forma: @Test.
public void calaST() lança exceção {
//Obter conexão
conexão=sqlUtil.getconnection();
//Prepara instrução SQL
String sql = "CALL pro_add(?,?,?)";
//Obtém o objeto callableStatement
CallableStatement cbs = connection.prepareCall(sql);
//Definir parâmetros de entrada, iguais a prepareStatement
cbs.setInt(1, 3);
cbs.setString(2, "Matemática");
/*Então, como definir os parâmetros de saída?
* Necessidade de registrar parâmetros de saída!
*/
cbs.registerOutParameter(3, java.sql.Types.INTEGER);//Você precisa usar objetos integrados para definir tipos de parâmetros
//Executa instrução SQL
cbs.executeQuery();
//Use o método getXXX para obter os parâmetros de saída da posição correspondente
Número inteiro = cbs.getInt(3);
System.out.println("a*4 é " + num);
//Fecha o recurso
sqlUtil.close(cbs, conexão);
}
Espero que este artigo seja útil para a programação Java de todos.