jdbc batch processing
Este tutorial fornece uma compreensão completa do JDBC Batch Processing e Java Stored Procedure com exemplos de exemplos de Java:
No Tratamento de exceções JDBC tutorial do Série de tutoriais JDBC , aprendemos maneiras de lidar com exceções SQL com a ajuda de exemplos de programação.
Neste tutorial, discutiremos métodos para fazer processamento em lote em Java usando o driver JDBC. Também aprenderemos como criar procedimentos armazenados e chamá-los de um programa Java.
Vamos começar entendendo o processamento em lote e suas vantagens.
O que você aprenderá:
Processamento de lote JDBC
É o processo de execução de várias instruções SQL em uma transação. Este processo reduz o tempo de comunicação e aumenta o desempenho. Isso torna o processamento de uma grande quantidade de dados muito mais fácil.
Vantagens do processamento em lote
O processamento em lote visa melhorar o desempenho e a consistência dos dados.
atuação
Considere o cenário em que várias entradas (digamos 5) devem ser adicionadas a uma tabela a partir de um programa JAVA. A abordagem direta será abrir uma conexão com o banco de dados, escrever consultas INSERT e executar cada consulta usando Statement ou PreparedStatement.
Essa abordagem aumentará as viagens da rede ao banco de dados e, como resultado, levará a um desempenho ruim. Usando o processamento em lote, podemos realizar essa operação em uma chamada.
A consistência dos dados
Em alguns casos, precisamos inserir / atualizar dados em várias tabelas. Isso levará a uma transação inter-relacionada em que a sequência de consultas inseridas ou atualizadas é importante. Quaisquer erros que ocorram durante a execução resultariam em uma reversão dos dados inseridos por consultas anteriores, se houver.
Exemplo:
# 1) A tabela ‘EMPLOYEE_DETAILS’ tem 3 colunas: EU IRIA , Nome , e Papel do funcionário.
statement.execute('INSERT INTO EMPLOYEE_DETAILS(ID, NAME, ROLE) ' + 'VALUES ('1','EMPLOYEE_NAME1','ROLE1')');
#dois) A tabela ‘EMPLOYEE_ADDRESS’ tem 2 colunas: EMP ID e Endereço
statement.execute('INSERT INTO EMPLOYEE_ADDRESS( EMP_ID, ADDRESS) ' + 'VALUES ('1','ADDRESS1')');
Um problema pode ocorrer no exemplo acima quando a primeira instrução é executada com êxito, mas a segunda instrução falha. Nessa situação, não há rollback dos dados inseridos pela primeira instrução. Isso leva à inconsistência de dados.
Podemos alcançar a consistência dos dados, confirmando a transação no final ou executando uma reversão no caso de quaisquer exceções. Mas, para conseguir isso, o DB deve ser atingido repetidamente para cada instrução.
Por outro lado, no processamento em lote, apenas quando todas as consultas dentro de um lote são executadas com êxito, os dados são confirmados. Caso contrário, não vai.
Como realizar o processamento em lote
Podemos realizar o processamento em lote usando os métodos addbatch () e executeBatch (), que estão disponíveis nas classes Statement e PreparedStatement.
Neste tutorial, todos os programas são escritos em Java. Usamos a versão Java 8 e Oracle DB.
=> Clique aqui para baixar o software Oracle
=> Clique aqui para baixar o Java versão 8
No exemplo a seguir, veremos como fazer o processamento em lote de forma elaborada. Possui o processo de instalação do Java passo a passo.
Dados na tabela EMPLOYEE antes de inserir dados:
melhor software de recuperação de arquivos windows 10
Programa Java
package com.STH.JDBC; import java.sql.BatchUpdateException; import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; public class ExecuteBatch_Example { public static void main(String[] args) throws ClassNotFoundException, SQLException { //Inserting the data in EMPLOYEE Table using the following query String insert_query1 = 'insert into employee values(?,?,?)'; Class.forName('oracle.jdbc.driver.OracleDriver'); Try(Connection conn = DriverManager.getConnection('jdbc:oracle:thin:system/pass123@localhost:1521:XE')) { PreparedStatement pstatemnt1 = conn.prepareStatement(insert_query1); //Setting values for the 1st person in EMPLOYEE Table pstatemnt1.setInt(1,10001); pstatemnt1.setString(2, 'Bush'); pstatemnt1.setString(3, 'William '); //Adding the 1st insert query into batch pstatemnt1.addBatch(); //Setting values for the 2nd person in EMPLOYEE Table pstatemnt1.setInt(1,10002); pstatemnt1.setString(2, “Bush'); pstatemnt1.setString(3, 'George'); //Adding the 2nd insert query into batch pstatemnt1.addBatch(); //Setting values for the 3rd person in EMPLOYEE Table pstatemnt1.setInt(1,10003); pstatemnt1.setString(2, 'Bond'); pstatemnt1.setString(3, 'James'); //Adding the 3rd insert query into batch pstatemnt1.addBatch(); //Executing the executeBatch method int No_of_Afffected_Rows[]= pstatemnt1.executeBatch(); //After inserting the data, displaying no. of rows affected System.out.println('No of rows affected = ' +No_of_Afffected_Rows.length);} catch (SQLException e) { e.printStackTrace();} } }
RESULTADO:
Dados na tabela EMPLOYEE após inserção dos dados:
Explicação:
No programa acima, inserimos dados de 3 funcionários em uma chamada usando operação em lote.
- Crie uma consulta de inserção para passar os valores da coluna.
- Abra a conexão e crie um objeto createdStatement usando o objeto de conexão e chame o método prepareStatement.
- Em seguida, defina os valores para 1stfuncionário usando métodos setXXX e chame o método addBatch () para adicionar a nova linha ao lote.
- Assim, adicione os valores para 2nde 3rdfuncionários. Depois de adicionar as consultas ao método addBatch (), devemos chamar o método executeBatch () usando o objeto readyStatement.
- O método executeBatch () insere os 3 dados do funcionário em uma chamada.
- Verifique na tabela EMPLOYEE se os dados foram inseridos corretamente ou não.
Procedimentos armazenados Java
Um procedimento armazenado é um grupo de instruções SQL que formam uma única unidade e executam uma tarefa específica. Eles serão usados para realizar um conjunto de operações ou perguntas a serem executadas em um servidor de banco de dados. Pode ser compilado e executado com diferentes parâmetros e resultados.
Cada procedimento tem seu nome exclusivo para ser referido. Esta unidade de subprograma é armazenada como um objeto Banco de Dados no BD.
Um subprograma nada mais é que um procedimento, e deve ser criado manualmente como desejamos e armazená-lo como um objeto DB.
Procedimentos armazenados são blocos autônomos de um programa que podemos armazenar no banco de dados. Usando o nome do procedimento armazenado, podemos chamá-lo e executá-lo. É usado principalmente para executar um processo em PL / SQL. O procedimento pode ter blocos aninhados ou pode estar aninhado dentro de outros blocos.
O procedimento armazenado tem 3 partes:
- Parte da declaração (opcional): Nesta parte, podemos declarar as variáveis, constantes, cursores, etc., é uma parte opcional. Com base nos requisitos, podemos usá-lo.
- Parte de execução: Esta parte contém a principal lógica de negócios do procedimento. Normalmente, ele terá um bloco de instruções SQL.
- Parte de manuseio excepcional (opcional): Nesta parte, podemos tratar a exceção que pode ocorrer devido ao código da parte de execução. Também é opcional.
Com base nos requisitos, podemos criar um procedimento. Podemos passar ou recuperar os valores dos parâmetros.
Existem três tipos de parâmetros disponíveis em procedimentos armazenados. Eles são:
- NO: É usado para passar o valor de entrada para o procedimento armazenado. O procedimento armazenado usará o parâmetro de entrada no programa como uma variável somente leitura. O valor não pode ser alterado dentro dos subprogramas. O Oracle usa IN como o modo padrão do parâmetro. É o parâmetro padrão.
- FORA: É usado para retornar ou obter o valor do Stored Procedure após a execução. É uma variável de leitura e escrita dentro dos subprogramas. O valor pode ser alterado dentro dos subprogramas.
- IN / OUT: É usado para passar os valores de entrada para o procedimento armazenado e retornar ou obter os valores do procedimento também. É legível e gravável. Podemos ler e modificar.
RETORNA
Usaremos a palavra-chave return para devolver o controle ao programa principal, como o programa Java. Quando o procedimento encontra a palavra-chave RETURN, ele sai da execução e pula o código ou instrução depois dela.
Como chamar o procedimento armazenado de Java
Temos uma interface CallableStatement em Java para chamar o procedimento armazenado. O objeto de interface CallableStatement pode ser criado usando o método prepareCall () da interface Connection e, em seguida, devemos chamar o método executeQuery () para executar o Stored Procedure no programa Java.
Antes de escrever o programa Java para implementar isso, devemos criar procedimentos armazenados para usá-lo no programa.
A seguir está a sintaxe para chamar procedimentos armazenados no programa Java:
Sintaxe | Nº de parâmetros |
---|---|
{ligar para PROCEDURE_NAME ()} | Sem parâmetros de entrada e sem parâmetros de saída |
{ligar para PROCEDURE_NAME (?,?,?)} | Três parâmetros de entrada e nenhum parâmetro de saída |
{? = ligar para PROCEDURE_NAME ()} | Sem parâmetros de entrada e um parâmetro de saída (valor RETURN) |
{? = ligar para PROCEDURE_NAME (?,?)} | Dois parâmetros de entrada e um parâmetro de saída (valor RETURN) |
Etapas para criar procedimentos armazenados
# 1) Crie o procedimento no servidor de banco de dados. Aqui, estamos usando o banco de dados Oracle.
# 2) Sintaxe para criar o procedimento completo:
Também podemos escrever o procedimento armazenado em código Java.
# 3) Passe os parâmetros IN e OUT para usar no procedimento.
# 4) A palavra-chave AS / IS deve ser mencionada. Se estivermos adicionando outro procedimento no novo procedimento, use a palavra-chave IS ou a palavra-chave AS se o procedimento for autônomo.
# 5) Declare as variáveis, não é obrigatório, com base no requisito que podemos criar.
# 6) Em seguida, BEGIN o procedimento usando a palavra-chave BEGIN e, a seguir, escreva as instruções ou consultas SQL a serem executadas no procedimento.
# 7) A seguir, podemos tratar a exceção na parte Exceção. Também não é obrigatório mencionar.
# 8) Termine o procedimento mencionando a palavra-chave END e o nome do procedimento.
Podemos criar o procedimento no Oracle e salvá-lo com um nome exclusivo e chamar esse procedimento do programa Java. Podemos criar o procedimento e chamar esse procedimento em Java também.
Crie um procedimento no Oracle, salve-o e chame o procedimento no Programa Java.
# 1) Abra o servidor de banco de dados. Aqui, estamos usando o servidor Oracle DB.
#dois) Clique com o botão direito na pasta Procedimento e clique na opção Novo Procedimento.
# 3) Ele pedirá o nome do procedimento e detalhes do parâmetro.
Nota: Também podemos fornecer os detalhes dos parâmetros ao escrever o procedimento.
# 4) Escreva o procedimento usando as etapas que já discutimos neste tutorial e salve o procedimento com o nome exclusivo.
melhor aplicativo espião móvel para iphone
O procedimento na captura de tela exibirá a saída em DB. Podemos alterá-lo para exibi-lo também no programa Java. Para isso, precisamos usar os parâmetros OUT.
# 5) Execute o procedimento clicando no botão Executar
# 6) Insira o valor na coluna Valor de entrada. Ele exibirá os dados para o valor fornecido.
Até agora, vimos como criar e executar o procedimento no próprio console do banco de dados.
Crie o procedimento em DB. Chame-o e exiba os dados no console Java .
Crie o seguinte procedimento usando as etapas acima e salve-o com o nome “DISPLAY_EMPLOYEE_DETAILS”.
Programa de exemplo de procedimento armazenado Java
package com.STH.JDBC; import java.sql.CallableStatement; import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.SQLException; public class StoredProcedureExample { public static void main(String[] args) throws ClassNotFoundException { Class.forName('oracle.jdbc.driver.OracleDriver'); //Connecting to Oracle DB Try (Connection conn = DriverManager.getConnection('jdbc:oracle:thin:system/pass123@localhost:1521:XE')) { // Creating prepared Statement CallableStatementCallStmt = conn.prepareCall('{call DISPLAY_EMPLOYEE_DETAILS(?,?,?,?)}'); //Passing Input Parameter CallStmt.setInt(1,1001); //Retrieving the Output Parameters values CallStmt.registerOutParameter(2, java.sql.Types.VARCHAR); CallStmt.registerOutParameter(3, java.sql.Types.VARCHAR); CallStmt.registerOutParameter(4, java.sql.Types.VARCHAR); //Calling the execute to execute the procedure and retrieve the data CallStmt.execute(); System.out.println('First Name: '+ CallStmt.getString(2)+'
Last Name: '+ CallStmt.getString(3) + '
Email: ' + CallStmt.getString(4)); }catch (SQLException e) { e.printStackTrace(); } } }
RESULTADO:
Explicação:
No programa acima, o que fizemos foi criar um procedimento e salvá-lo no banco de dados Oracle. Em seguida, chamou esse procedimento usando CallableStatement e exibiu os dados no Java Console.
- Crie o procedimento e salve-o no banco de dados Oracle.
- No programa Java, abra a conexão de banco de dados e chame o método prepareCall usando os objetos de conexão e CallableStatement.
- Passe o valor do parâmetro de entrada usando o método setXXX.
- Recupere os valores do parâmetro de saída usando o método registerOutParameter. Neste método, devemos passar o valor do índice do parâmetro e o tipo de dado do parâmetro. Ele armazenará os valores no índice do parâmetro.
- Usando os métodos getXXX, podemos recuperar os dados e exibi-los no console Java.
Crie o procedimento e execute-o no próprio programa Java.
Programa Java
package com.STH.JDBC; import java.sql.CallableStatement; import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.SQLException; import java.sql.Statement; public class StoredProcedureExample1 { public static void main(String[] args) throws ClassNotFoundException { String Stored_Procedure = 'CREATE OR REPLACE PROCEDURE UPD_EMPLOYEE_DETAILS
' +'(
' + ' PARAM1 IN NUMBER,
' + ' PARAM2 IN NUMBER
'+ ') IS
'+ ' BEGIN
'+ 'UPDATE EMPLOYEE_DETAILS SET EMPNUM= PARAM2 WHERE EMPNUM = PARAM1;
'+ 'COMMIT;
'+ 'END UPD_EMPLOYEE_DETAILS;
'; Class.forName('oracle.jdbc.driver.OracleDriver'); //Connecting to Oracle DB try(Connection conn = DriverManager.getConnection('jdbc:oracle:thin:system/pass123@localhost:1521:XE')) {// Creating prepared Statement Statement stmt = conn.createStatement(); CallableStatementCallStmt = conn.prepareCall('{call UPD_EMPLOYEE_DETAILS(?,?)}'); stmt.execute(Stored_Procedure); //Setting the values to pass the procedure CallStmt.setInt(1,1010); CallStmt.setInt(2, 10010); //Calling executeUpdate method to update the values using Procedure CallStmt.executeUpdate(); System.out.println(' Successfully Updated ' ); } catch (SQLException e) { e.printStackTrace(); } } }
RESULTADO:
Dados na tabela Employee_details antes da execução do programa:
Dados na tabela Employee_details após a execução do programa:
Explicação:
No programa acima, armazenamos o código do procedimento como uma string.
String Stored_Procedure = 'CREATE OR REPLACE PROCEDURE UPD_EMPLOYEE_DETAILS
' +'(
' +' PARAM1 IN NUMBER,
' +' PARAM2 IN NUMBER
'+ ') IS
'+' BEGIN
'+'UPDATE EMPLOYEE_DETAILS SET EMPNUM= PARAM2 WHERE EMPNUM = PARAM1;
'+'COMMIT;
'+'END UPD_EMPLOYEE_DETAILS;
';
- Abra o Oracle DB Connection e crie o objeto de instrução usando o objeto de conexão.
- Chame o método createStatement usando o objeto de instrução, porque estamos criando o procedimento em código Java.
- Chame o procedimento usando a sintaxe {ligar para UPD_EMPLOYEE_DETAILS (?,?) para preparar o método CallableStatement.
- Como estamos criando o procedimento em código Java, temos que executar aquele “Criar código de procedimento”.
- Para executar esse procedimento, chame o método execute usando o objeto Statement “ stmt.execute (Stored_Procedure) ”. Isso criará o procedimento temporariamente no banco de dados.
- O escopo do procedimento é o fim da execução do programa. Depois disso, ele não estará mais disponível. Usando os métodos setXXX, defina os valores a serem atualizados na tabela Employee_Details.
- Chame o método executeUpdate usando o objeto callableStatement. Este método irá atualizar os valores no conto Empoyee_Details.
- Verifique na tabela Employee_details se os dados foram atualizados corretamente.
Pontos para lembrar:
- O processamento em lote melhora o desempenho e mantém a consistência dos dados.
- A execução de várias instruções SQL em uma transação é conhecida como processamento em lote.
- Procedimento armazenado é o bloco de instruções SQL usado para realizar a lógica de negócios.
- Podemos passar o parâmetro de entrada usando a palavra-chave IN para o procedimento e a palavra-chave OUT para o parâmetro de saída.
- Podemos criar um procedimento no próprio servidor de banco de dados e também temporariamente usando código Java.
perguntas frequentes
P # 1) Qual interface deve ser usada para executar o processamento em lote em JDBC?
Responda: O pacote Java possui interfaces Statement e PreparedStatement, que fornecem os métodos para fazer o processamento em lote.
P # 2) Como as atualizações em lote funcionam no JDBC?
Responda: Uma atualização em lote JDBC é um grupo de atualizações agrupadas e enviadas ao banco de dados de uma só vez, em vez de enviar as atualizações uma por uma. Assim, reduz o tráfego da rede no Banco de Dados.
P # 3) Como o processamento em lote aumenta o desempenho?
Responda: O processamento em lote envia os dados para o banco de dados de uma vez (apenas 1 ida e volta) em vez de enviar um por um, e o banco de dados pode ser capaz de executar algumas instruções em paralelo. Assim, está aumentando o desempenho do aplicativo e economizando tempo.
P # 4) Quais são os parâmetros aceitos em procedimentos armazenados em JDBC?
Responda: Existem três tipos de parâmetros - parâmetros IN, OUT e INOUT. O parâmetro IN é para obter o valor de entrada. O parâmetro OUT é para recuperar o valor de saída. O parâmetro INOUT é usado para entrada e saída.
P # 5) Quais são os métodos disponíveis para executar um procedimento armazenado em JDBC?
Responda: Usando a interface CallableStatement, podemos chamar o procedimento. A interface CallableStatement fornece três métodos para executar os procedimentos armazenados.
Os três métodos são:
- executeUpdate (): Use este método se o procedimento não retornar nenhum valor de retorno.
- executeQuery (): Use este método se o procedimento retornar apenas um conjunto de resultados.
- executar(): Use este método se o procedimento retornar muitos conjuntos de resultados ou um número desconhecido de conjuntos de resultados.
Conclusão
Abordamos o processamento em lote e procedimentos armazenados neste tutorial. No mundo moderno, alto desempenho, consistência de dados e capacidade de reutilização são as palavras-chave de qualquer aplicativo popular. Tanto o processamento em lote quanto os procedimentos armazenados desempenham um papel muito importante na implementação desses recursos. O conhecimento deles é inevitável para todo engenheiro de software.
Leitura recomendada
- Tutorial Java JDBC: O que é JDBC (Java Database Connectivity)
- Tutorial de conexão Java JDBC com exemplo de programação
- Gerenciamento de transações Java JDBC com exemplo
- ResultSet JDBC: como usar o ResultSet Java para recuperar dados
- Tratamento de exceções JDBC - Como tratar exceções SQL
- JDBC DriverManager, JDBC PreparedStatement And Statement
- Tutorial JAVA para iniciantes: mais de 100 tutoriais práticos em vídeo Java