


Comment effectuer des opérations de mise à jour d'insertion groupée dans Hibernate ?
在本文中,我们将看到如何在Hibernate中执行批量插入/更新。
每当我们执行一条sql语句时,我们都是通过对数据库进行网络调用来完成的。现在,如果我们必须向数据库表中插入 10 个条目,那么我们必须进行 10 次网络调用。相反,我们可以通过使用批处理来优化网络调用。批处理允许我们在单个网络调用中执行一组 SQL 语句。
为了理解和实施这一点,让我们定义我们的实体−
@Entity public class Parent { @Id @GeneratedValue(strategy = GenerationType.AUTO) private long id; private String name; // Getters //Setters }
为了在Hibernate中启用批处理,我们需要向我们的应用程序添加一个属性
properties文件:spring.jpa.properties.hibernate.jdbc.batch_size=3
现在,我们需要执行EntityManager的persist函数将数据插入数据库
示例
@Autowired private EntityManager entityManager; @Test Public void InsertInBatch(){ for (int i = 0; i < 6; i++) { Parent parent = Parent[i]; entityManager.persist(parent); } }
输出
"batch":true, "querySize":1, "batchSize":3, "query":["insert into parent (name, id) values (?, ?)"], "params":[["P1","1"],["P2","2"],["P3","3"]] "batch":true, "querySize":1, "batchSize":3, "query":["insert into parent (name, id) values (?, ?)"], "params":[["P4","4"],["P5","5"],["P6","6"]]
从控制台我们可以看到,插入父表的操作是在批量大小为3的情况下进行的。
在持久化实体时,可能会发生OutOfMemoryException,因为Hibernate将实体存储在持久化上下文中。因此,出于优化目的,我们可以在每批之后使用实体管理器的flush()和clear()。
批量更新意味着在一次网络调用中更新大量数据。
对于批量更新,流程是相同的。我们需要在应用程序属性文件中添加以下两个语句,然后执行更新过程。
spring.jpa.properties.hibernate.order_updates=true spring.jpa.properties.hibernate.batch_versioned_data=true
示例
更新数据的代码−
@Autowired private EntityManager entityManager; @Test public void UpdateInBatch() { TypedQuery<Parent> query = entityManager.createQuery("SELECT p from Parent p", Parent.class); List<Parent> Parents = query.getResultList(); int i=1; for (Parent parent : Parents) { String s="Parent"+Integer.toString(i); i++; parent.setName(s); } }
Hibernate 现在会将这些语句绑定在一个批处理中并执行它们。
输出
"batch":true, "querySize":1, "batchSize":3, "query":["update parent set name=? where id=?"], "params":[["Parent1","1"],[" Parent2","2"],[" Parent3","3"]] "batch":true, "querySize":1, "batchSize":3, "query":["update parent set name=? where id=?"], "params":[["Parent4","4"],["Parent5","5"],["Parent6","6"]]
从控制台可以看到,父表中的数据更新是在批量大小为3的情况下进行的。
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!

Outils d'IA chauds

Undresser.AI Undress
Application basée sur l'IA pour créer des photos de nu réalistes

AI Clothes Remover
Outil d'IA en ligne pour supprimer les vêtements des photos.

Undress AI Tool
Images de déshabillage gratuites

Clothoff.io
Dissolvant de vêtements AI

AI Hentai Generator
Générez AI Hentai gratuitement.

Article chaud

Outils chauds

Bloc-notes++7.3.1
Éditeur de code facile à utiliser et gratuit

SublimeText3 version chinoise
Version chinoise, très simple à utiliser

Envoyer Studio 13.0.1
Puissant environnement de développement intégré PHP

Dreamweaver CS6
Outils de développement Web visuel

SublimeText3 version Mac
Logiciel d'édition de code au niveau de Dieu (SublimeText3)

Titre : Étapes et précautions d'implémentation des mises à jour par lots par les procédures stockées Oracle Dans la base de données Oracle, les procédures stockées sont un ensemble d'instructions SQL conçues pour améliorer les performances de la base de données, réutiliser le code et renforcer la sécurité. Les procédures stockées peuvent être utilisées pour mettre à jour les données par lots. Cet article explique comment utiliser les procédures stockées Oracle pour implémenter des mises à jour par lots et fournit des exemples de code spécifiques. Étape 1 : Créer une procédure stockée Tout d’abord, nous devons créer une procédure stockée pour implémenter les opérations de mise à jour par lots. Voici comment créer une procédure stockée

Intégration d'Hibernate dans le projet SpringBoot Préface Hibernate est un framework ORM (Object Relational Mapping) populaire qui peut mapper des objets Java à des tables de base de données pour faciliter les opérations de persistance. Dans le projet SpringBoot, l'intégration d'Hibernate peut nous aider à effectuer plus facilement des opérations de base de données. Cet article présentera comment intégrer Hibernate dans le projet SpringBoot et fournira des exemples correspondants. 1.Introduire les dépendancesIntroduire les dépendances suivantes dans le fichier pom.xml : org.springframework.bootspring-boot-starter-data-jpam

Java est un langage de programmation orienté objet largement utilisé dans le domaine du développement de logiciels. Hibernate est un framework de persistance Java populaire qui fournit un moyen simple et efficace de gérer la persistance des objets Java. Cependant, des erreurs Hibernate sont souvent rencontrées au cours du processus de développement, et ces erreurs peuvent entraîner une fin anormale du programme ou devenir instable. Comment gérer et éviter les erreurs Hibernate est devenu une compétence que les développeurs Java doivent maîtriser. Cet article présentera quelques Hib courants

Les différences entre hibernate et mybatis : 1. Méthode de mise en œuvre ; 2. Performances 3. Comparaison de la gestion des objets ; Introduction détaillée : 1. Méthode d'implémentation, Hibernate est une solution complète de mappage objet/relationnel qui mappe les objets aux tables de base de données, tandis que MyBatis oblige les développeurs à écrire manuellement des instructions SQL et ResultMap 2. Performances, Hibernate est possible en termes de vitesse de développement Plus rapide que ; MyBatis car Hibernate simplifie la couche DAO et ainsi de suite.

Hibernate un-à-plusieurs et plusieurs-à-plusieurs d'Hibernate est un excellent framework ORM qui simplifie l'accès aux données entre les applications Java et les bases de données relationnelles. Dans Hibernate, nous pouvons utiliser des relations un-à-plusieurs et plusieurs-à-plusieurs pour gérer des modèles de données complexes. Le un-à-plusieurs d'Hibernate Dans Hibernate, une relation un-à-plusieurs signifie qu'une classe d'entité correspond à plusieurs autres classes d'entités. Par exemple, une commande peut correspondre à plusieurs articles de commande (OrderItem), et un utilisateur (User) peut correspondre à plusieurs commandes (Order). Pour implémenter une relation un-à-plusieurs dans Hibernate, vous devez définir un attribut de collection dans la classe d'entité à stocker

Résumé des questions fréquemment posées sur l'importation de données Excel dans MySQL : Comment résoudre le problème de l'insertion de lots volumineux lors de l'importation de données ? L'importation de données Excel dans MySQL est l'une des tâches souvent rencontrées dans le développement quotidien. Pour importer une petite quantité de données, vous pouvez utiliser des outils clients de base de données ou des lignes de commande pour effectuer des opérations d'insertion. Mais face à de gros lots d'importation de données, une simple opération d'insertion entraînera sans aucun doute de sérieux problèmes de performances. Cet article décrira comment résoudre ce problème et donnera des exemples de code correspondants. Description du problème : en utilisation réelle,

Cas d'application de la mise à jour par lots de procédures stockées Oracle dans le traitement des données Dans le traitement réel des données, nous avons souvent besoin de mettre à jour une grande quantité de données dans la base de données. La base de données Oracle fournit la fonction de procédures stockées, qui peuvent gérer efficacement ces opérations de mise à jour de données par lots volumineux et améliorer l'efficacité et les performances du traitement des données. Dans cet article, nous présenterons le cas d'application de la mise à jour par lots des procédures stockées Oracle et fournirons des exemples de code spécifiques pour aider les lecteurs à mieux comprendre et utiliser cette fonction. Contexte du cas Supposons que nous ayons un

Hibernate est un framework ORM open source qui lie le mappage des données entre les bases de données relationnelles et les programmes Java, facilitant ainsi l'accès des développeurs aux données de la base de données. L'utilisation du framework Hibernate peut réduire considérablement le travail d'écriture des instructions SQL et améliorer l'efficacité du développement et la réutilisabilité des applications. Présentons le framework Hibernate sous les aspects suivants. 1. Avantages du framework Hibernate : mappage objet-relationnel, masquage des détails d'accès à la base de données, réalisation du développement
