Menu

Didacticiel sur le traitement par lots et les procédures stockées JDBC

  • Principal
  • Autre
  • Didacticiel sur le traitement par lots et les procédures stockées JDBC

jdbc batch processing

Essayez Notre Instrument Pour Éliminer Les Problèmes

Ce didacticiel fournit une compréhension complète du traitement par lots JDBC et de la procédure stockée Java avec des exemples d'exemples Java:

Dans le Gestion des exceptions JDBC tutoriel du Série de didacticiels JDBC , nous avons appris comment gérer les exceptions SQL à l'aide d'exemples de programmation.

Dans ce didacticiel, nous discuterons des méthodes de traitement par lots en Java à l'aide du pilote JDBC. Nous apprendrons également comment créer des procédures stockées et les appeler à partir d'un programme Java.

Commençons par comprendre le traitement par lots et ses avantages.

Tutoriel sur le traitement par lots et la procédure stockée

Ce que vous apprendrez:

Traitement par lots JDBC

C'est le processus d'exécution de plusieurs instructions SQL en une seule transaction. Ce processus réduit le temps de communication et augmente les performances. Cela facilite grandement le traitement d'une grande quantité de données.

Avantages du traitement par lots

Le traitement par lots vise à améliorer les performances et la cohérence des données.

Performance

Considérez le scénario où plusieurs entrées (disons 5) doivent être ajoutées à une table à partir d'un programme JAVA. L'approche simple consiste à ouvrir une connexion à la base de données, à écrire des requêtes INSERT et à exécuter chaque requête à l'aide de Statement ou PreparedStatement.

Cette approche augmentera les déplacements du réseau vers la base de données et, par conséquent, entraînera de mauvaises performances. En utilisant le traitement par lots, nous pouvons effectuer cette opération en un seul appel.

La cohérence des données

Dans certains cas, nous devons insérer / mettre à jour des données dans plusieurs tables. Cela conduira à une transaction interdépendante où la séquence des requêtes insérées ou mises à jour est importante. Toutes les erreurs qui se produisent pendant l'exécution entraîneraient une annulation des données insérées par les requêtes précédentes, le cas échéant.

Exemple:

#1) La table 'EMPLOYEE_DETAILS' comprend 3 colonnes: identifiant , Nom , et Rôle de l'employé.

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

#deux) La table 'EMPLOYEE_ADDRESS' comporte 2 colonnes: ID EMP et Adresse

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

Un problème peut se produire dans l'exemple ci-dessus lorsque la première instruction s'exécute correctement, mais la deuxième instruction échoue. Dans cette situation, il n'y a pas de restauration des données insérées par la première instruction. Cela conduit à une incohérence des données.

Nous pouvons atteindre la cohérence des données en validant la transaction à la fin ou en effectuant une restauration en cas d'exceptions. Mais, pour y parvenir, la base de données doit être frappée à plusieurs reprises pour chaque instruction.

D'autre part, dans le traitement par lots, les données ne seront validées que lorsque toutes les requêtes à l'intérieur d'un lot s'exécutent avec succès. Sinon, ce ne sera pas le cas.

Comment effectuer un traitement par lots

Nous pouvons effectuer un traitement par lots en utilisant les méthodes addbatch () et executeBatch () qui sont disponibles dans les classes Statement et PreparedStatement.

Dans ce didacticiel, tous les programmes sont écrits en Java. Nous avons utilisé la version Java 8 et Oracle DB.

=> Cliquez ici pour télécharger le logiciel Oracle

=> Cliquez ici pour télécharger la version Java 8

Dans l'exemple suivant, nous verrons comment effectuer un traitement par lots de manière élaborée. Il a le processus d'installation Java étape par étape.

Données dans la table EMPLOYEE avant d'insérer les données:

Données dans la table EMPLOYEE avant d

sites de test de produits qui envoient des choses

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

PRODUCTION:

traitement par lots insérer des données

Données dans la table EMPLOYEE après insertion des données:

Tableau EMPLOYÉ après insertion des données

Explication:

Dans le programme ci-dessus, nous avons inséré les données de 3 employés en un seul appel en utilisant l'opération par lots.

  1. Créez une requête d'insertion pour transmettre les valeurs de colonne.
  2. Ouvrez la connexion et créez un objet prepareStatement à l'aide de l'objet connexion et appelez la méthode prepareStatement.
  3. Ensuite, définissez les valeurs pour le 1stemployé à l'aide des méthodes setXXX et appelez la méthode addBatch () pour ajouter la nouvelle ligne dans le lot.
  4. Comme ça, ajoutez les valeurs pour 2ndet 3rddes employés. Après avoir ajouté les requêtes dans la méthode addBatch (), nous devons appeler la méthode executeBatch () en utilisant l'objet prepareStatement.
  5. La méthode executeBatch () insère les données des 3 employés en un seul appel.
  6. Vérifiez dans le tableau EMPLOYEE si les données ont été insérées correctement ou non.

Procédures stockées Java

Une procédure stockée est un groupe d'instructions SQL qui forment une seule unité et exécutent une tâche spécifique. Ils seront utilisés pour effectuer un ensemble d'opérations ou de questions à exécuter sur un serveur de base de données. Il peut être compilé et exécuté avec différents paramètres et résultats.

Chaque procédure a son nom unique auquel faire référence. Cette unité de sous-programme est stockée en tant qu'objet de base de données dans DB.

Un sous-programme n'est rien d'autre qu'une procédure, et il doit être créé manuellement comme nous le souhaitons et le stocker en tant qu'objet DB.

Les procédures stockées sont des blocs autonomes d'un programme que nous pouvons stocker dans DB. En utilisant le nom de la procédure stockée, nous pouvons l'appeler et l'exécuter. Il est principalement utilisé pour exécuter un processus en PL / SQL. La procédure peut avoir des blocs imbriqués ou peut être imbriquée dans les autres blocs.

La procédure stockée comprend 3 parties:

  1. Partie déclaration (facultative): Dans cette partie, nous pouvons déclarer les variables, constantes, curseurs, etc., c'est une partie optionnelle. En fonction des exigences, nous pouvons l'utiliser.
  2. Partie exécution: Cette partie contient la principale logique métier de la procédure. Normalement, il aura un bloc d'instructions SQL.
  3. Pièce de manutention exceptionnelle (en option): Dans cette partie, nous pouvons gérer l'exception qui peut survenir en raison du code de pièce Execution. C'est également facultatif.

En fonction des exigences, nous pouvons créer une procédure. Nous pouvons passer ou récupérer les valeurs des paramètres.

Il existe trois types de paramètres disponibles dans les procédures stockées. Elles sont:

  1. DANS: Il est utilisé pour transmettre la valeur d'entrée à la procédure stockée. La procédure stockée utilisera le paramètre d'entrée dans le programme comme une variable en lecture seule. La valeur ne peut pas être modifiée à l'intérieur des sous-programmes. Oracle utilise IN comme mode par défaut du paramètre. C'est le paramètre par défaut.
  2. EN DEHORS: Il est utilisé pour renvoyer ou obtenir la valeur de la procédure stockée après l'exécution. C'est une variable en lecture-écriture à l'intérieur des sous-programmes. La valeur peut être modifiée à l'intérieur des sous-programmes.
  3. IN / OUT: Il est utilisé pour transmettre les valeurs d'entrée à la procédure stockée et pour renvoyer ou obtenir également les valeurs de la procédure. Il est à la fois lisible et inscriptible. Nous pouvons le lire et le modifier.

REVENIR

Nous utiliserons le mot-clé return pour redonner le contrôle au programme principal, tel que le programme Java. Lorsque la procédure trouve le mot clé RETURN, elle quitte l'exécution et ignore le code ou l'instruction qui suit.

Comment appeler une procédure stockée à partir de Java

Nous avons une interface CallableStatement en Java pour appeler la procédure stockée. L'objet d'interface CallableStatement peut être créé en utilisant la méthode prepareCall () de l'interface Connection et après cela, nous devrions appeler la méthode executeQuery () pour exécuter la procédure stockée dans le programme Java.

Avant d'écrire le programme Java pour l'implémenter, nous devons créer des procédures stockées pour l'utiliser dans le programme.

Voici la syntaxe pour appeler des procédures stockées dans le programme Java:

SyntaxeNo de paramètres
{appeler PROCEDURE_NAME ()}Aucun paramètre d'entrée et aucun paramètre de sortie
{appeler PROCEDURE_NAME (?,?,?)}Trois paramètres d'entrée et aucun paramètre de sortie
{? = appeler PROCEDURE_NAME ()}Aucun paramètre d'entrée et un paramètre de sortie (valeur RETURN)
{? = appeler PROCEDURE_NAME (?,?)}Deux paramètres d'entrée et un paramètre de sortie (valeur RETURN)

Étapes de création de procédures stockées

#1) Créez la procédure sur le serveur de base de données. Ici, nous utilisons Oracle DB.

# 2) Syntaxe pour créer une procédure complète:

Syntaxe pour créer une procédure complète

Nous pouvons également écrire la procédure stockée en code Java.

# 3) Passez les paramètres IN et OUT pour l'utiliser dans la procédure.

# 4) Le mot clé AS / IS doit être mentionné. Si nous ajoutons une autre procédure dans la nouvelle procédure, utilisez le mot clé IS ou bien le mot clé AS si la procédure est autonome.

# 5) Déclarez les variables, ce n'est pas obligatoire, en fonction de l'exigence que nous pouvons créer.

# 6) Commencez ensuite la procédure à l'aide du mot clé BEGIN, puis écrivez les instructions ou requêtes SQL à exécuter dans la procédure.

# 7) Ensuite, nous pouvons gérer l'exception dans la partie Exception. Il n'est pas non plus obligatoire de le mentionner.

# 8) Terminez la procédure en mentionnant le mot-clé END et le nom de la procédure.

Nous pouvons créer la procédure dans Oracle et la sauvegarder avec un nom unique et appeler cette procédure à partir du programme Java. Nous pouvons également créer la procédure et appeler cette procédure en Java.

Créez une procédure dans Oracle, enregistrez-la et appelez la procédure dans le programme Java.

#1) Ouvrez le serveur de base de données. Ici, nous utilisons le serveur Oracle DB.

#deux) Cliquez avec le bouton droit sur le dossier Procédure et cliquez sur l'option Nouvelle procédure.

créer une nouvelle procédure

# 3) Il vous demandera le nom de la procédure et les détails des paramètres.

détails de la procédure et des paramètres.

Noter: Nous pouvons également donner des détails sur les paramètres lors de l'écriture de la procédure.

# 4) Écrivez la procédure en utilisant les étapes dont nous avons déjà parlé dans ce tutoriel et enregistrez la procédure avec le nom unique.

procédure avec le nom unique

La procédure de la capture d'écran affichera la sortie dans DB. Nous pouvons le modifier pour l'afficher également dans le programme Java. Pour cela, nous devons utiliser les paramètres OUT.

# 5) Exécutez la procédure en cliquant sur le bouton Exécuter créer la procédure 4

Colonne Valeur d

# 6) Entrez la valeur dans la colonne Valeur d'entrée. Il affichera les données pour la valeur donnée.

DISPLAY_EMPLOYEE_DETAILS

Jusqu'à présent, nous avons vu comment créer et exécuter la procédure dans la console DB elle-même.

Créez la procédure dans DB. Appelez-le et affichez les données dans la console Java .

Créez la procédure suivante en utilisant les étapes ci-dessus et enregistrez-la sous le nom «DISPLAY_EMPLOYEE_DETAILS».

procédure en sortie DB

Programme d'exemple de procédure stockée 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(); } } }

PRODUCTION:

production

Explication:

Dans le programme ci-dessus, nous avons créé une procédure et l'avons sauvegardée dans Oracle DB. Ensuite, j'ai appelé cette procédure à l'aide de CallableStatement et affiché les données dans la console Java.

  1. Créez la procédure et enregistrez-la dans Oracle DB.
  2. Dans le programme Java, ouvrez la connexion DB et appelez la méthode prepareCall à l'aide des objets connection et CallableStatement.
  3. Transmettez la valeur du paramètre d'entrée à l'aide de la méthode setXXX.
  4. Récupérez les valeurs des paramètres de sortie à l'aide de la méthode registerOutParameter. Dans cette méthode, nous devons transmettre la valeur d'index du paramètre et le type de données du paramètre. Il stockera les valeurs dans l'index des paramètres.
  5. En utilisant les méthodes getXXX, nous pouvons récupérer les données et les afficher dans la console Java.

Créez la procédure et exécutez-la dans le programme Java lui-même.

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

PRODUCTION:

Table Employee_details avant l

Données de la table Employee_details avant l'exécution du programme:

Table Employee_details après l

Données de la table Employee_details après l'exécution du programme:

Explication:

Dans le programme ci-dessus, nous stockons le code de procédure sous forme de chaîne.

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. Ouvrez la connexion à la base de données Oracle et créez l'objet instruction à l'aide de l'objet de connexion.
  2. Appelez la méthode createStatement en utilisant un objet instruction, car nous créons la procédure en code Java.
  3. Appelez la procédure en utilisant la syntaxe {appeler UPD_EMPLOYEE_DETAILS (?,?) à la méthode prepareCall de CallableStatement.
  4. Puisque nous créons la procédure en code Java, nous devons exécuter ce «Créer un code de procédure».
  5. Pour exécuter cette procédure, appelez la méthode execute à l'aide de l'objet Statement ' stmt.execute (Stored_Procedure) ». Cela créera temporairement la procédure dans la base de données.
  6. La portée de la procédure est la fin de l'exécution du programme. Après cela, il ne sera plus disponible. À l'aide des méthodes setXXX, définissez les valeurs à mettre à jour dans la table Employee_Details.
  7. Appelez la méthode executeUpdate à l'aide de l'objet callableStatement. Cette méthode mettra à jour les valeurs du conte Empoyee_Details.
  8. Vérifiez la table Employee_details si les données ont été correctement mises à jour.

Points à retenir:

  • Le traitement par lots améliore les performances et maintient la cohérence des données.
  • L'exécution de plusieurs instructions SQL en une seule transaction est appelée traitement par lots.
  • La procédure stockée est le bloc d'instructions SQL utilisé pour exécuter la logique métier.
  • Nous pouvons passer le paramètre d'entrée en utilisant le mot-clé IN à la procédure et le mot-clé OUT pour le paramètre de sortie.
  • Nous pouvons créer une procédure dans le serveur de base de données lui-même et temporairement en utilisant également du code Java.

Questions fréquemment posées

Q # 1) Quelle interface doit être utilisée pour effectuer le traitement par lots dans JDBC?

Répondre: Le package Java a des interfaces Statement et PreparedStatement, qui fournissent les méthodes de traitement par lots.

Q # 2) Comment fonctionnent les mises à jour par lots dans JDBC?

Répondre: Une mise à jour par lots JDBC est un ensemble de mises à jour regroupées et envoyées à la base de données en une seule fois plutôt que d'envoyer les mises à jour une par une. Ainsi, il réduit le trafic réseau dans la base de données.

Q # 3) Comment le traitement par lots augmente-t-il les performances?

Répondre: Le traitement par lots envoie les données à la base de données en une seule fois (un seul aller-retour) plutôt que de les envoyer une par une, et la base de données peut être en mesure d'exécuter certaines instructions en parallèle. Ainsi, il augmente les performances de l'application et gagne du temps.

Q # 4) Quels sont les paramètres acceptés dans les procédures stockées dans JDBC?

convertisseur youtube en mp4 de haute qualité

Répondre: Il existe trois types de paramètres: les paramètres IN, OUT et INOUT. Le paramètre IN sert à obtenir la valeur d'entrée. Le paramètre OUT sert à récupérer la valeur de sortie. Le paramètre INOUT est utilisé à la fois pour l'entrée et la sortie.

Q # 5) Quelles sont les méthodes disponibles pour exécuter une procédure stockée dans JDBC?

Répondre: En utilisant l'interface CallableStatement, nous pouvons appeler la procédure. L'interface CallableStatement fournit trois méthodes pour exécuter les procédures stockées.

Les trois méthodes sont:

  • executeUpdate (): Utilisez cette méthode si la procédure ne renvoie aucune valeur de retour.
  • exécuter l'ordre(): Utilisez cette méthode si la procédure renvoie un seul jeu de résultats.
  • exécuter(): Utilisez cette méthode si la procédure renvoie de nombreux jeux de résultats ou un nombre inconnu de jeux de résultats.

Conclusion

Nous avons couvert le traitement par lots et les procédures stockées dans ce didacticiel. Dans le monde moderne, hautes performances, cohérence des données et réutilisabilité sont les mots à la mode de toute application populaire. Le traitement par lots et les procédures stockées jouent un rôle très important dans la mise en œuvre de ces fonctionnalités. La connaissance de ces derniers est inévitable pour chaque ingénieur logiciel.

<| Tutoriel SUIVANT >>

lecture recommandée

^