Hibernate（25）Hibernate的批量操作是什么？

Victor3562026-01-06 20:21

Hibernate的批量操作

Hibernate的批量操作是指对大量数据进行插入、更新或删除时，通过减少SQL语句的数量和数据库的交互次数来提高性能的一种操作方式。批量操作可以显著提高大型数据处理任务的性能，特别是在处理成百上千条记录的时候。

主要优化点

  1. JDBC批量操作：减少每次操作提交到数据库的SQL数量。
  2. Session的管理：避免一次性加载过多对象到内存，导致内存溢出。
  3. 使用级联操作（Cascade）：可以批量操作关联的实体。

实现步骤

  1. 配置Hibernate。
  2. 创建实体类。
  3. 实现批量操作方法。

示例代码

配置文件 hibernate.cfg.xml

xml 复制代码 
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <!-- 数据库连接配置 -->
        <property name="hibernate.connection.driver_class">com.mysql.cj.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/your_database</property>
        <property name="hibernate.connection.username">your_username</property>
        <property name="hibernate.connection.password">your_password</property>

        <!-- Hibernate 属性配置 -->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
        <property name="hibernate.show_sql">true</property>
        <property name="hibernate.format_sql">true</property>
        <property name="hibernate.hbm2ddl.auto">update</property>

        <!-- 批量操作配置 -->
        <property name="hibernate.jdbc.batch_size">50</property>
        <property name="hibernate.order_inserts">true</property>
        <property name="hibernate.order_updates">true</property>

        <!-- 映射类 -->
        <mapping class="com.example.domain.Person"/>
    </session-factory>
</hibernate-configuration>

实体类 Person

java 复制代码 
package com.example.domain;

import javax.persistence.*;

@Entity
@Table(name = "person")
public class Person {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "name")
    private String name;

    @Column(name = "age")
    private int age;

    public Person() {}

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // getters 和 setters
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

使用Hibernate进行批量操作

HibernateUtil类
java 复制代码 
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateUtil {
    private static final SessionFactory sessionFactory;

    static {
        try {
            // 从配置文件创建SessionFactory
            sessionFactory = new Configuration().configure("hibernate.cfg.xml").buildSessionFactory();
        } catch (Throwable ex) {
            // 记录启动失败的错误
            System.err.println("Initial SessionFactory creation failed." + ex);
            throw new ExceptionInInitializerError(ex);
        }
    }

    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }
}

批量插入操作示例

java 复制代码 
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;

import java.util.ArrayList;
import java.util.List;

public class HibernateBatchInsertExample {

    private static final int BATCH_SIZE = 50;

    public static void main(String[] args) {
        // 获取SessionFactory
        SessionFactory sessionFactory = HibernateUtil.getSessionFactory();

        // 批量插入数据
        batchInsertPersons(sessionFactory);

        // 关闭SessionFactory
        sessionFactory.close();
    }

    private static void batchInsertPersons(SessionFactory sessionFactory) {
        Session session = sessionFactory.openSession();
        Transaction transaction = session.beginTransaction();
        try {
            List<Person> persons = createPersons(1000);

            for (int i = 0; i < persons.size(); i++) {
                session.save(persons.get(i));
                if (i % BATCH_SIZE == 0 && i > 0) {
                    // 批量插入，清理Session，防止内存溢出
                    session.flush();
                    session.clear();
                }
            }

            transaction.commit();
            System.out.println("Inserted " + persons.size() + " Persons");
        } catch (Exception e) {
            if (transaction != null) {
                transaction.rollback();
            }
            e.printStackTrace();
        } finally {
            if (session != null) {
                session.close();
            }
        }
    }

    private static List<Person> createPersons(int count) {
        List<Person> persons = new ArrayList<>();
        for (int i = 0; i < count; i++) {
            persons.add(new Person("Person " + i, 20 + (i % 30)));
        }
        return persons;
    }
}

批量更新操作示例

java 复制代码 
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;

public class HibernateBatchUpdateExample {

    private static final int BATCH_SIZE = 50;

    public static void main(String[] args) {
        // 获取SessionFactory
        SessionFactory sessionFactory = HibernateUtil.getSessionFactory();

        // 批量更新数据
        batchUpdatePersons(sessionFactory);

        // 关闭SessionFactory
        sessionFactory.close();
    }

    private static void batchUpdatePersons(SessionFactory sessionFactory) {
        Session session = sessionFactory.openSession();
        Transaction transaction = session.beginTransaction();
        try {
            List<Person> persons = session.createQuery("FROM Person", Person.class).list();

            for (int i = 0; i < persons.size(); i++) {
                Person person = persons.get(i);
                person.setAge(person.getAge() + 1);
                session.update(person);
                if (i % BATCH_SIZE == 0 && i > 0) {
                    // 批量更新，清理Session，防止内存溢出
                    session.flush();
                    session.clear();
                }
            }

            transaction.commit();
            System.out.println("Updated " + persons.size() + " Persons");
        } catch (Exception e) {
            if (transaction != null) {
                transaction.rollback();
            }
            e.printStackTrace();
        } finally {
            if (session != null) {
                session.close();
            }
        }
    }
}

批量删除操作示例

java 复制代码 
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;

public class HibernateBatchDeleteExample {

    private static final int BATCH_SIZE = 50;

    public static void main(String[] args) {
        // 获取SessionFactory
        SessionFactory sessionFactory = HibernateUtil.getSessionFactory();

        // 批量删除数据
        batchDeletePersons(sessionFactory);

        // 关闭SessionFactory
        sessionFactory.close();
    }

    private static void batchDeletePersons(SessionFactory sessionFactory) {
        Session session = sessionFactory.openSession();
        Transaction transaction = session.beginTransaction();
        try {
            List<Person> persons = session.createQuery("FROM Person", Person.class).list();

            for (int i = 0; i < persons.size(); i++) {
                session.delete(persons.get(i));
                if (i % BATCH_SIZE == 0 && i > 0) {
                    // 批量删除，清理Session，防止内存溢出
                    session.flush();
                    session.clear();
                }
            }

            transaction.commit();
            System.out.println("Deleted " + persons.size() + " Persons");
        } catch (Exception e) {
            if (transaction != null) {
                transaction.rollback();
            }
            e.printStackTrace();
        } finally {
            if (session != null) {
                session.close();
            }
        }
    }
}

详细解释

  1. 配置文件 hibernate.cfg.xml：定义数据库连接信息、Hibernate属性配置以及批量操作的配置。

    xml 复制代码 
    <property name="hibernate.jdbc.batch_size">50</property>
<property name="hibernate.order_inserts">true</property>
<property name="hibernate.order_updates">true</property>

  2. 实体类 Person：定义实体类及其属性。

    java 复制代码 
    @Entity
@Table(name = "person")
public class Person {
    // 属性和方法
}

  3. HibernateUtil类：创建并管理SessionFactory。

    java 复制代码 
    public class HibernateUtil {
    // 创建SessionFactory的代码
}

  4. 批量插入、更新、删除操作类：演示了如何使用Hibernate进行批量插入、更新和删除操作。

    java 复制代码 
    public class HibernateBatchInsertExample {
    // 插入方法
}

public class HibernateBatchUpdateExample {
    // 更新方法
}

public class HibernateBatchDeleteExample {
    // 删除方法
}
相关推荐
盖世英雄酱581365 小时前
Java 组长年终总结：靠 AI 提效 50%，25 年搞副业只赚 4k？
后端·程序员·trae
+VX:Fegn08955 小时前
计算机毕业设计|基于springboot + vue在线音乐播放系统(源码+数据库+文档)
数据库·vue.js·spring boot·后端·课程设计
code bean6 小时前
Flask图片服务在不同网络接口下的路径解析问题及解决方案
后端·python·flask
+VX:Fegn08956 小时前
计算机毕业设计|基于springboot + vue律师咨询系统(源码+数据库+文档)
java·数据库·vue.js·spring boot·后端·课程设计
努力的小郑6 小时前
2025年度总结：当我在 Cursor 里敲下 Tab 的那一刻，我知道时代变了
前端·后端·ai编程
颜淡慕潇8 小时前
深度解析官方 Spring Boot 稳定版本及 JDK 配套策略
java·后端·架构
Victor3568 小时前
Hibernate（28）Hibernate的级联操作是什么？
后端
Victor3568 小时前
Hibernate（27）Hibernate的查询策略是什么？
后端
superman超哥8 小时前
Rust 内部可变性模式：突破借用规则的受控机制
开发语言·后端·rust·rust内部可变性·借用规则·受控机制
柒.梧.9 小时前
Spring核心知识全解析：从入门实战到进阶
java·后端·spring
热门推荐
01GitHub 镜像站点02安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）03Linux下V2Ray安装配置指南04手把手教你通过Gemini3 pro 学生认证，白用一年，手慢无！05Labelme从安装到标注：零基础完整指南06jdk21下载、安装（Windows、Linux、macOS）07GitLab 零基础入门指南：从安装到项目管理全流程08UV安装并设置国内源09【踩坑笔记】50系显卡适配的 PyTorch 安装102025-04-03 Latex学习1——本地配置Latex + VScode环境