Meny

JDBC Batchbehandling och lagrad procedurhandledning

  • Huvud
  • Övrig
  • JDBC Batchbehandling och lagrad procedurhandledning

jdbc batch processing

Prova Vårt Instrument För Att Eliminera Problem

Denna handledning ger en fullständig förståelse för JDBC Batch Processing och Java Stored Procedure med exempel på Java-exempel:

I JDBC Undantagshantering handledning av JDBC-handledningsserie , vi lärde oss sätt att hantera SQL Undantag med hjälp av programmeringsexempel.

I denna handledning kommer vi att diskutera metoder för att göra batchbehandling i Java med JDBC-drivrutin. Vi lär oss också hur man skapar lagrade procedurer och anropar det från ett Java-program.

Låt oss börja med att förstå batchbearbetning och dess fördelar.

Batchbehandling och lagrad procedurhandledning

Vad du kommer att lära dig:

JDBC batchbehandling

Det är processen att köra flera SQL-satser i en transaktion. Denna process minskar kommunikationstiden och ökar prestandan. Det underlättar behandlingen av en stor mängd data.

Fördelar med batchbehandling

Batch Processing syftar till att förbättra prestanda och datakonsistens.

Prestanda

Tänk på scenariot där flera (säg 5) poster ska läggas till i en tabell från ett JAVA-program. Det enkla tillvägagångssättet är att öppna en anslutning till databasen, skriva INSERT-frågor och utföra varje fråga med hjälp av Statement eller PreparedStatement.

Detta tillvägagångssätt kommer att öka nätverksresorna till databasen och som ett resultat kommer det att leda till dålig prestanda. Med batchbearbetning kan vi utföra denna operation i ett samtal.

Datakonsekvens

I vissa fall måste vi infoga / uppdatera data i flera tabeller. Detta kommer att leda till en sammanhängande transaktion där sekvensen av frågor som infogas eller uppdateras är viktig. Eventuella fel som inträffar under körningen skulle resultera i en återställning av data som infogats av tidigare frågor om någon.

Exempel:

# 1) Tabellen 'EMPLOYEE_DETAILS' har tre kolumner: ID , namn och Den anställdas roll.

statement.execute('INSERT INTO EMPLOYEE_DETAILS(ID, NAME, ROLE) ' + 'VALUES ('1','EMPLOYEE_NAME1','ROLE1')');

#två) Tabellen 'EMPLOYEE_ADDRESS' har två kolumner: EMP-ID och Adress

statement.execute('INSERT INTO EMPLOYEE_ADDRESS( EMP_ID, ADDRESS) ' + 'VALUES ('1','ADDRESS1')');

Ett problem kan uppstå i exemplet ovan när det första uttalandet körs framgångsrikt, men det andra uttalandet misslyckas. I denna situation finns det ingen återställning av data som infogats av det första uttalandet. Detta leder till datainkonsekvens.

Vi kan uppnå datakonsistens genom att begå transaktionen i slutet eller genomföra en återställning vid undantag. Men för att uppnå detta måste DB träffas upprepade gånger för varje uttalande.

Å andra sidan, vid batchbearbetning, endast när alla frågor i en batch körs framgångsrikt, kommer data att göras. Annars gör det inte.

Hur man utför batchbearbetning

Vi kan utföra batchbearbetning med hjälp av addbatch () och executeBatch () -metoderna som finns tillgängliga i klasserna Statement och PreparedStatement.

I denna handledning är alla program skrivna i Java. Vi har använt Java 8-versionen och Oracle DB.

=> Klicka här för att ladda ner Oracle-programvaran

=> Klicka här för att ladda ner Java version 8

I följande exempel ser vi hur man gör batchbearbetning utförligt. Den har den stegvisa Java-installationsprocessen.

Data i ANSTÄLLDA-tabellen innan du infogar data:

Data i ANSTÄLLDA-tabellen innan du infogar data

rotorsak analys exempel programvaruutveckling

Java-program

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();} } }

PRODUKTION:

batchbehandling infoga data

Data i ANSTÄLLDA-tabellen efter införande av uppgifterna:

ANSTÄLLDA Tabell efter infogning av data

Förklaring:

I ovanstående program har vi infogat data om 3 anställda i ett samtal med batchoperation.

  1. Skapa en infogningsfråga för att skicka kolumnvärdena.
  2. Öppna anslutningen och skapa ett prepareratStatement-objekt med hjälp av anslutningsobjektet och ring preparatmetoden.
  3. Ställ sedan in värdena för 1stanställd som använder setXXX-metoder och anropar metoden addBatch () för att lägga till den nya raden i batchen.
  4. Så här lägger du till värdena för 2ndoch 3rdanställda. Efter att ha lagt till frågorna i addBatch () -metoden ska vi anropa metoden executeBatch () med det preparerade objektet.
  5. metoden executeBatch () infogar de tre anställdas data i ett samtal.
  6. Kontrollera tabellen ANSTÄLLDA om uppgifterna har infogats ordentligt eller inte.

Java-lagrade procedurer

En lagrad procedur är en grupp SQL-satser som bildar en enda enhet och utför en specifik uppgift. De kommer att användas för att utföra en uppsättning operationer eller frågor att utföra på en databasserver. Den kan sammanställas och köras med olika parametrar och resultat.

Varje procedur har sitt unika namn att hänvisa till. Denna underprogramenhet lagras som ett databasobjekt i DB.

Ett underprogram är inget annat än ett förfarande, och det ska skapas manuellt som vi vill och lagra det som ett DB-objekt.

Lagrade procedurer är fristående block för ett program som vi kan lagra i DB. Genom att använda namnet på den lagrade proceduren kan vi ringa och utföra den. Den används främst för att utföra en process i PL / SQL. Proceduren kan ha kapslade block eller kan vara kapslade inuti de andra blocken.

Den lagrade proceduren har tre delar:

  1. Deklarationsdel (valfritt): I denna del kan vi deklarera variabler, konstanter, markörer etc. Det är en valfri del. Baserat på kraven kan vi använda den.
  2. Exekveringsdel: Denna del innehåller procedurens huvudsakliga affärslogik. Normalt kommer det att ha ett block med SQL-uttalanden.
  3. Exceptionell hanteringsdel (tillval): I den här delen kan vi hantera undantaget som kan uppstå på grund av exekveringsdelkoden. Det är också valfritt.

Baserat på kraven kan vi skapa ett förfarande. Vi kan skicka eller hämta värdena från parametrarna.

Det finns tre typer av parametrar tillgängliga i lagrade procedurer. Dom är:

  1. I: Den används för att överföra inmatningsvärdet till den lagrade proceduren. Den lagrade proceduren använder ingångsparametern i programmet som en skrivskyddad variabel. Värdet kan inte ändras i underprogrammen. Oracle använder IN som standardläge för parametern. Det är standardparametern.
  2. UT: Den används för att returnera eller hämta värdet från den lagrade proceduren efter körningen. Det är en läs-skriv-variabel i underprogrammen. Värdet kan ändras i underprogrammen.
  3. IN UT: Den används för att skicka inmatningsvärdena till den lagrade proceduren och returnera eller hämta värdena från proceduren också. Det är både läsbart och skrivbart. Vi kan läsa och ändra det.

LÄMNA TILLBAKA

Vi kommer att använda returordet för att ge kontrollen tillbaka till huvudprogrammet, till exempel Java-programmet. När proceduren hittar RETURN-nyckelordet kommer det att avslutas från körningen och hoppa över koden eller uttalandet efter det.

Hur man ringer lagrad procedur från Java

Vi har ett CallableStatement-gränssnitt i Java för att ringa lagrad procedur. CallableStatement-gränssnittsobjekt kan skapas med preparatCall () -metoden i anslutningsgränssnittet och efter det bör vi anropa executeQuery () -metoden för att utföra den lagrade proceduren i Java-programmet.

Innan vi skriver Java-programmet för att implementera detta bör vi skapa lagrade procedurer för att använda det i programmet.

Följande är syntaxen för att anropa lagrade procedurer i Java-programmet:

SyntaxAntal parametrar
{samtal PROCEDURE_NAME ()}Inga ingångsparametrar och inga utmatningsparametrar
{ring PROCEDURE_NAME (?,?,?)}Tre ingångsparametrar och inga utmatningsparametrar
{? = ring PROCEDURE_NAME ()}Inga ingångsparametrar och en utgångsparameter (RETURN-värde)
{? = ring PROCEDURE_NAME (?,?)}Två ingångsparametrar och en utmatningsparameter (RETURN-värde)

Steg för att skapa lagrade procedurer

# 1) Skapa proceduren i DB-servern. Här använder vi Oracle DB.

# 2) Syntax för att skapa fullständig procedur:

Syntax för att skapa fullständig procedur

Vi kan också skriva den lagrade proceduren i Java-kod.

# 3) Skicka parametrarna IN och OUT för att använda det i proceduren.

# 4) AS / IS-nyckelord bör nämnas. Om vi ​​lägger till en annan procedur i den nya proceduren, använd IS-nyckelordet eller annat AS-nyckelord om proceduren är fristående.

# 5) Förklara variablerna, det är inte obligatoriskt, baserat på kravet vi kan skapa.

# 6) BÖRJA sedan proceduren med BEGIN-nyckelordet och skriv sedan de SQL-uttalanden eller frågor som ska utföras i proceduren.

# 7) Därefter kan vi hantera undantaget i undantagsdelen. Det är inte heller obligatoriskt att nämna.

# 8) Avsluta proceduren genom att nämna END-nyckelordet och procedurnamnet.

Vi kan skapa proceduren i Oracle och spara den med ett unikt namn och kalla den proceduren från Java-programmet. Vi kan skapa proceduren och kalla den proceduren också i Java.

Skapa en procedur i Oracle, Spara den och ring proceduren i Java-programmet.

# 1) Öppna databasservern. Här använder vi Oracle DB-servern.

#två) Högerklicka på procedurmappen och klicka på alternativet Ny procedur.

skapa ett nytt förfarande

# 3) Den kommer att be om namnet på proceduren och parameterdetaljer.

procedur och parameterinformation.

Notera: Vi kan också ge parameterdetaljerna medan vi skriver proceduren.

# 4) Skriv proceduren med de steg som vi redan har diskuterat i denna handledning och spara proceduren med det unika namnet.

förfarande med det unika namnet

Proceduren på skärmdumpen visar utdata i DB. Vi kan ändra det för att visa det i Java-programmet också. För det måste vi använda OUT-parametrar.

# 5) Kör proceduren genom att klicka på kör-knappen skapa procedur 4

bästa apparna för att spionera på någon

Ingångsvärde kolumn

# 6) Ange värdet i kolumnen Ingångsvärde. Det visar data för det angivna värdet.

DISPLAY_EMPLOYEE_DETAILS

Hittills har vi sett hur man skapar och utför proceduren i själva DB-konsolen.

Skapa proceduren i DB. Ring det och visa data i Java-konsolen .

Skapa följande procedur med hjälp av stegen ovan och spara den med namnet “DISPLAY_EMPLOYEE_DETAILS”.

procedur i DB-utdata

Java Stored Procedure Exempelprogram

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(); } } }

PRODUKTION:

produktion

Förklaring:

I ovanstående program är vad vi har gjort att vi har skapat en procedur och sparat den i Oracle DB. Ringte sedan den proceduren med CallableStatement och visade data i Java Console.

  1. Skapa proceduren och spara den i Oracle DB.
  2. I Java-programmet öppnar du DB-anslutningen och ringer till PreparCall-metoden med hjälp av anslutningen och CallableStatement-objekten.
  3. Skicka värdet för ingångsparametern med setXXX-metoden.
  4. Hämta utdata-parametervärdena med metoden registerOutParameter. I den här metoden ska vi skicka parameterindexvärdet och datatypen för parametern. Värdena sparas i parameterindex.
  5. Med getXXX-metoderna kan vi hämta data och visa dem i Java-konsolen.

Skapa proceduren och kör den i själva Java-programmet.

Java-program

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(); } } }

PRODUKTION:

Tabellen Employee_details före körningen

Data i tabellen Employee_details före genomförandet av programmet:

Tabellen Employee_details efter körningen

Data i tabellen Employee_details efter genomförandet av programmet:

Förklaring:

I ovanstående program lagrar vi procedurkoden som en sträng.

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; ';
  1. Öppna Oracle DB Connection och skapa uttalandeobjektet med hjälp av anslutningsobjektet.
  2. Ring metoden createStatement med uttalandeobjekt, eftersom vi skapar proceduren i Java-kod.
  3. Ring proceduren med syntaxen {ring UPD_EMPLOYEE_DETAILS (?,?) att preparera Call-metoden för CallableStatement.
  4. Eftersom vi skapar proceduren i Java-kod måste vi utföra den 'Skapa procedurkod'.
  5. För att utföra proceduren, anropa execute-metoden med hjälp av Statement-objektet “ stmt.execute (Stored_Procedure) ”. Detta skapar tillfälligt proceduren i DB.
  6. Procedurens omfattning är slutet på genomförandet av programmet. Därefter är det inte tillgängligt. Använd setXXX-metoder och ställ in värdena som ska uppdateras i tabellen Employee_Details.
  7. Ring metoden executeUpdate med callableStatement-objektet. Denna metod uppdaterar värdena i Empoyee_Details-berättelsen.
  8. Kontrollera tabellen Employee_details om data har uppdaterats ordentligt.

Poäng att komma ihåg:

  • Batchbehandling förbättrar prestanda och bibehåller datakonsistens.
  • Att köra flera SQL-satser i en transaktion kallas batch-bearbetning.
  • Stored Procedure är blocket med SQL-uttalanden som används för att utföra affärslogik.
  • Vi kan skicka inmatningsparametern med hjälp av IN-nyckelordet till proceduren och OUT-nyckelordet för utdata-parametern.
  • Vi kan skapa en procedur i själva DB-servern och tillfälligt använda Java-kod också.

Vanliga frågor

F # 1) Vilket gränssnitt ska användas för att utföra batchbehandling i JDBC?

Svar: Java-paketet har uttalanden och PreparedStatement-gränssnitt, som ger metoder för att göra batchbearbetning.

F # 2) Hur fungerar batchuppdateringar i JDBC?

Svar: En JDBC-batchuppdatering är en massa uppdateringar grupperade och skickade till databasen på en gång snarare än att skicka uppdateringarna en efter en. Således minskar det nätverkstrafiken i databasen.

F # 3) Hur ökar batchbearbetningen prestandan?

Svar: Batchbehandling skickar data till databasen åt gången (endast 1 tur och retur) snarare än att skicka en efter en, och databasen kan kanske utföra vissa uttalanden parallellt. Så här ökar applikationens prestanda och sparar tid.

F # 4) Vilka parametrar accepteras i lagrade procedurer i JDBC?

Svar: Det finns tre typer av parametrar – IN-, OUT- och INOUT-parametrar. IN-parametern är att få inmatningsvärdet. Parametern OUT är för att hämta utgångsvärdet. INOUT-parametern används för både ingång och utgång.

F # 5) Vilka metoder finns tillgängliga för att utföra en lagrad procedur i JDBC?

Svar: Med CallableStatement Interface kan vi anropa proceduren. CallableStatement-gränssnittet ger tre metoder för att utföra de lagrade procedurerna.

De tre metoderna är:

  • executeUpdate (): Använd den här metoden om proceduren inte returnerar några returvärden.
  • executeQuery (): Använd den här metoden om proceduren bara returnerar ett resultat.
  • Kör(): Använd den här metoden om proceduren returnerar många resultatmängder eller ett okänt antal resultatmängder.

Slutsats

Vi har täckt batchbearbetning och lagrade procedurer i denna handledning. I den moderna världen är högpresterande, datakonsistens och återanvändbarhet slagord för alla populära applikationer. Både batchbehandling och lagrade procedurer spelar en mycket viktig roll för att implementera dessa funktioner. Kunskap om dessa är oundviklig för alla programvarutekniker.

<| NÄSTA självstudie >>

Rekommenderad läsning

^