批处理

    因为默认下，Hibernate 将缓存所有的在会话层缓存中的持久的对象并且最终你的应用程序将和 OutOfMemoryException 在第 50000 行的某处相遇。你可以解决这个问题，如果你在 Hibernate 使用批处理。

    为了使用批处理这个特性，首先设置 hibernate.jdbc.batch_size 作为批处理的尺寸，取一个依赖于对象尺寸的值 20 或 50。这将告诉 hibernate 容器每 X 行为一批插入。为了在你的代码中实现这个我们将需要像以下这样做一些修改： 

    2. Transaction tx = session.beginTransaction();
    3. for ( int i=0; i<100000; i++ ) {
    4.     Employee employee = new Employee(.....);
    5.     session.save(employee);
    6.     if( i % 50 == 0 ) { // Same as the JDBC batch size
    7.         //flush a batch of inserts and release memory:
    8.         session.flush();
    9.         session.clear();
    10.     }
    11. }
    12. tx.commit();
    13. session.close();

    让我们通过添加 hibernate.jdbc.batch_size 属性来修改配置文件： 

    1. <?xml version="1.0" encoding="utf-8"?>
    2. <!DOCTYPE hibernate-configuration SYSTEM 
    3. "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
    5. <hibernate-configuration>
    6.    <session-factory>
    7.    <property name="hibernate.dialect">
    8.       org.hibernate.dialect.MySQLDialect
    9.    </property>
    10.    <property name="hibernate.connection.driver_class">
    11.       com.mysql.jdbc.Driver
    12.    </property>
    14.    <!-- Assume students is the database name -->
    15.    <property name="hibernate.connection.url">
    16.       jdbc:mysql://localhost/test
    17.    </property>
    18.    <property name="hibernate.connection.username">
    19.       root
    20.    </property>
    22.    </property>
    23.    <property name="hibernate.jdbc.batch_size">
    24.       50
    25.    </property>
    27.    <!-- List of XML mapping files -->
    28.    <mapping resource="Employee.hbm.xml"/>
    30. </session-factory>
    31. </hibernate-configuration>

    考虑以下 POJO Employee 类： 

    1. create table EMPLOYEE (
    2.    id INT NOT NULL auto_increment,
    3.    first_name VARCHAR(20) default NULL,
    4.    last_name  VARCHAR(20) default NULL,
    5.    salary     INT  default NULL,
    6.    PRIMARY KEY (id)
    7. );

    以下是将 Employee 对象和 EMPLOYEE 表单配对的映射文件。

    最后，我们将用 main() 方法来创建我们的应用程序类以运行应用程序，我们将使用 Session 对象和可用的 flush() 和 clear() 方法以让 Hibernate 持续将这些记录写入数据库而不是在内存中缓存它们。 

    1. import java.util.*; 
    3. import org.hibernate.HibernateException; 
    4. import org.hibernate.Session; 
    5. import org.hibernate.Transaction;
    6. import org.hibernate.SessionFactory;
    7. import org.hibernate.cfg.Configuration;
    9. public class ManageEmployee {
    10.    private static SessionFactory factory; 
    11.    public static void main(String[] args) {
    12.       try{
    13.          factory = new Configuration().configure().buildSessionFactory();
    14.       }catch (Throwable ex) { 
    15.          System.err.println("Failed to create sessionFactory object." + ex);
    16.          throw new ExceptionInInitializerError(ex); 
    19.       /* Add employee records in batches */
    20.       ME.addEmployees( );
    21.    }
    22.    /* Method to create employee records in batches */
    23.    public void addEmployees( ){
    24.       Session session = factory.openSession();
    25.       Transaction tx = null;
    26.       Integer employeeID = null;
    27.       try{
    28.          tx = session.beginTransaction();
    29.          for ( int i=0; i<100000; i++ ) {
    30.             String fname = "First Name " + i;
    31.             String lname = "Last Name " + i;
    32.             Integer salary = i;
    33.             Employee employee = new Employee(fname, lname, salary);
    34.             session.save(employee);
    35.              if( i % 50 == 0 ) {
    36.                session.flush();
    37.                session.clear();
    38.             }
    39.          }
    40.          tx.commit();
    41.       }catch (HibernateException e) {
    42.          if (tx!=null) tx.rollback();
    43.          e.printStackTrace(); 
    44.       }finally {
    45.          session.close(); 
    46.       }
    47.       return ;
    48.    }
    49. }

    编译和执行

    • 如上面解释的那样创建 hibernate.cfg.xml 配置文件。
    • 如上面显示的那样创建 Employee.hbm.xml 映射文件。
    • 如上面显示的那样创建 Employee.java 源文件并编译。
    • 执行 ManageEmployee 二进制代码来运行可以在 EMPLOYEE 表单中创建 100000 个记录的程序。