批处理

考虑一种情况，你需要使用 Hibernate 将大量的数据上传到你的数据库中。以下是使用 Hibernate 来达到这个的代码片段： 

  1. Session session = SessionFactory.openSession();
  2. Transaction tx = session.beginTransaction();
  3. for ( int i=0; i<100000; i++ ) {
  4.     Employee employee = new Employee(.....);
  5.     session.save(employee);
  6. }
  7. tx.commit();
  8. session.close();

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

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

  1. Session session = SessionFactory.openSession();
  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();

上面的代码将使 INSERT 操作良好运行，但是如果你愿意进行 UPDATE 操作那么你可以使用以下代码达到这一点： 

  1. Session session = sessionFactory.openSession();
  2. Transaction tx = session.beginTransaction();
  4. ScrollableResults employeeCursor = session.createQuery("FROM EMPLOYEE")
  5.                                    .scroll();
  6. int count = 0;
  8. while ( employeeCursor.next() ) {
  9.    Employee employee = (Employee) employeeCursor.get(0);
  10.    employee.updateEmployee();
  11.    seession.update(employee); 
  12.    if ( ++count % 50 == 0 ) {
  13.       session.flush();
  14.       session.clear();
  15.    }
  16. }
  17. tx.commit();
  18. 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>
  21.    <property name="hibernate.connection.password">
  22.       root123
  23.    </property>
  24.    <property name="hibernate.jdbc.batch_size">
  25.       50
  26.    </property>
  28.    <!-- List of XML mapping files -->
  29.    <mapping resource="Employee.hbm.xml"/>
  31. </session-factory>
  32. </hibernate-configuration>

考虑以下 POJO Employee 类： 

  1. public class Employee {
  2.    private int id;
  3.    private String firstName; 
  4.    private String lastName;   
  5.    private int salary;  
  7.    public Employee() {}
  8.    public Employee(String fname, String lname, int salary) {
  9.       this.firstName = fname;
  10.       this.lastName = lname;
  11.       this.salary = salary;
  12.    }
  13.    public int getId() {
  14.       return id;
  15.    }
  16.    public void setId( int id ) {
  17.       this.id = id;
  18.    }
  19.    public String getFirstName() {
  20.       return firstName;
  21.    }
  22.    public void setFirstName( String first_name ) {
  23.       this.firstName = first_name;
  24.    }
  25.    public String getLastName() {
  26.       return lastName;
  27.    }
  28.    public void setLastName( String last_name ) {
  29.       this.lastName = last_name;
  30.    }
  31.    public int getSalary() {
  32.       return salary;
  33.    }
  34.    public void setSalary( int salary ) {
  35.       this.salary = salary;
  36.    }
  37. }

让我们创建以下的 EMPLOYEE 表单来存储 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 表单配对的映射文件。 

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC 
  3.  "-//Hibernate/Hibernate Mapping DTD//EN"
  4.  "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> 
  6. <hibernate-mapping>
  7.    <class name="Employee" table="EMPLOYEE">
  8.       <meta attribute="class-description">
  9.          This class contains the employee detail. 
  10.       </meta>
  11.       <id name="id" type="int" column="id">
  12.          <generator class="native"/>
  13.       </id>
  14.       <property name="firstName" column="first_name" type="string"/>
  15.       <property name="lastName" column="last_name" type="string"/>
  16.       <property name="salary" column="salary" type="int"/>
  17.    </class>
  18. </hibernate-mapping>

最后，我们将用 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); 
  17.       }
  18.       ManageEmployee ME = new ManageEmployee();
  20.       /* Add employee records in batches */
  21.       ME.addEmployees( );
  22.    }
  23.    /* Method to create employee records in batches */
  24.    public void addEmployees( ){
  25.       Session session = factory.openSession();
  26.       Transaction tx = null;
  27.       Integer employeeID = null;
  28.       try{
  29.          tx = session.beginTransaction();
  30.          for ( int i=0; i<100000; i++ ) {
  31.             String fname = "First Name " + i;
  32.             String lname = "Last Name " + i;
  33.             Integer salary = i;
  34.             Employee employee = new Employee(fname, lname, salary);
  35.             session.save(employee);
  36.              if( i % 50 == 0 ) {
  37.                session.flush();
  38.                session.clear();
  39.             }
  40.          }
  41.          tx.commit();
  42.       }catch (HibernateException e) {
  43.          if (tx!=null) tx.rollback();
  44.          e.printStackTrace(); 
  45.       }finally {
  46.          session.close(); 
  47.       }
  48.       return ;
  49.    }
  50. }

编译和执行

这里是编译和运行以上提及的应用程序的步骤。确保你已经在处理编译和运行前已经正确设置了 PATH 和 CLASSPATH。

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