Quick Contact

    Hibernate

    Hibernate – Batch Processing

    Consider a situation when you need to upload a large number of records into your database using Hibernate. Following is the code snippet to achieve this using Hibernate −

    Sessionsession=SessionFactory.openSession();
    Transactiontx=session.beginTransaction();
    for(inti=0;i<100000;i++){
    Employeeemployee=newEmployee(.....);
    session.save(employee);
    }
    tx.commit();
    session.close();
    

    By default, Hibernate will cache all the persisted objects in the session-level cache and ultimately your application would fall over with an OutOfMemoryException somewhere around the 50,000th row. You can resolve this problem, if you are using batch processing with Hibernate.

    To use the batch processing feature, first set hibernate.jdbc.batch_size as batch size to a number either at 20 or 50 depending on object size. This will tell the hibernate container that every X rows to be inserted as batch. To implement this in your code, we would need to do little modification as follows −

    Sessionsession=SessionFactory.openSession();
    Transactiontx=session.beginTransaction();
    for(inti=0;i<100000;i++){
    Employeeemployee=newEmployee(.....);
    session.save(employee);
    if(i%50==0){// Same as the JDBC batch size
    //flush a batch of inserts and release memory:
    session.flush();
    session.clear();
    }
    }
    tx.commit();
    session.close();
    

    Above code will work fine for the INSERT operation, but if you are willing to make UPDATE operation, then you can achieve using the following code −

    Sessionsession=sessionFactory.openSession();
    Transactiontx=session.beginTransaction();
    
    ScrollableResultsemployeeCursor=session.createQuery("FROM EMPLOYEE").scroll();
    int count =0;
    
    while(employeeCursor.next()){
    Employeeemployee=(Employee)employeeCursor.get(0);
    employee.updateEmployee();
    seession.update(employee);
    if(++count %50==0){
    session.flush();
    session.clear();
    }
    }
    tx.commit();
    session.close();
    

    Batch Processing Example

    Let us modify the configuration file to add hibernate.jdbc.batch_size property −

    < ?xml version ="1.0" encoding ="utf-8"?>
    < !DOCTYPE hibernate-configuration SYSTEM 
    "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
    
    < hibernate-configuration>
    < session-factory>
    
    < propertyname="hibernate.dialect">
    org.hibernate.dialect.MySQLDialect
    < /property>
    
    < propertyname="hibernate.connection.driver_class">
    com.mysql.jdbc.Driver
    < /property>
    
    < !-- Assume students is the database name -->
    
    < propertyname="hibernate.connection.url">
    jdbc:mysql://localhost/test
    < /property>
    
    < propertyname="hibernate.connection.username">
    root
    < /property>
    
    < propertyname="hibernate.connection.password">
             root123
    < /property>
    
    < propertyname="hibernate.jdbc.batch_size">
             50
    < /property>
    
    < !-- List of XML mapping files -->
    < mappingresource="Employee.hbm.xml"/>
    
    < /session-factory>
    < /hibernate-configuration>
    

    Consider the following POJO Employee class −

    	
    publicclassEmployee{
    privateint id;
    privateStringfirstName;
    privateStringlastName;
    privateint salary;
    
    publicEmployee(){}
    
    publicEmployee(Stringfname,Stringlname,int salary){
    this.firstName=fname;
    this.lastName=lname;
    this.salary= salary;
    }
    
    publicintgetId(){
    return id;
    }
    
    publicvoidsetId(int id ){
    this.id = id;
    }
    
    publicStringgetFirstName(){
    returnfirstName;
    }
    
    publicvoidsetFirstName(Stringfirst_name){
    this.firstName=first_name;
    }
    
    publicStringgetLastName(){
    returnlastName;
    }
    
    publicvoidsetLastName(Stringlast_name){
    this.lastName=last_name;
    }
    
    publicintgetSalary(){
    return salary;
    }
    
    publicvoidsetSalary(int salary ){
    this.salary= salary;
    }
    }
    

    Let us create the following EMPLOYEE table to store the Employee objects −

    	create table EMPLOYEE (
    id INT NOT NULL auto_increment,
    first_name VARCHAR(20)default NULL,
    last_name  VARCHAR(20)default NULL,
    salary     INT  default NULL,
       PRIMARY KEY (id)
    );
    

    Following will be the mapping file to map the Employee objects with EMPLOYEE table −

    < ?xml version ="1.0" encoding ="utf-8"?>
    < !DOCTYPE hibernate-mapping PUBLIC 
    "-//Hibernate/Hibernate Mapping DTD//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
    
    < hibernate-mapping>
    < classname="Employee"table="EMPLOYEE">
    
    < metaattribute="class-description">
             This class contains the employee detail. 
    < /meta>
    
    < idname="id"type="int"column="id">
    < generatorclass="native"/>
    < /id>
    
    < propertyname="firstName"column="first_name"type="string"/>
    < propertyname="lastName"column="last_name"type="string"/>
    < propertyname="salary"column="salary"type="int"/>
    
    < /class>
    < /hibernate-mapping>
    

    Finally, we will create our application class with the main() method to run the application where we will use flush() and clear() methods available with Session object so that Hibernate keeps writing these records into the database instead of caching them in the memory.

    importjava.util.*;
    
    importorg.hibernate.HibernateException;
    importorg.hibernate.Session;
    importorg.hibernate.Transaction;
    importorg.hibernate.SessionFactory;
    importorg.hibernate.cfg.Configuration;
    
    publicclassManageEmployee{
    privatestaticSessionFactory factory;
    publicstaticvoid main(String[]args){
    
    try{
    factory=newConfiguration().configure().buildSessionFactory();
    }catch(Throwable ex){
    System.err.println("Failed to create sessionFactory object."+ex);
    thrownewExceptionInInitializerError(ex);
    }
    ManageEmployee ME =newManageEmployee();
    
    /* Add employee records in batches */
    ME.addEmployees();
    }
    
    /* Method to create employee records in batches */
    publicvoidaddEmployees(){
    Sessionsession=factory.openSession();
    Transactiontx=null;
    IntegeremployeeID=null;
    
    try{
    tx=session.beginTransaction();
    for(inti=0;i<100000;i++){
    Stringfname="First Name "+i;
    Stringlname="Last Name "+i;
    Integer salary =i;
    Employeeemployee=newEmployee(fname,lname, salary);
    session.save(employee);
    	if(i%50==0){
    session.flush();
    session.clear();
    }
    }
    tx.commit();
    }catch(HibernateException e){
    if(tx!=null)tx.rollback();
    e.printStackTrace();
    }finally{
    session.close();
    }
    return;
    }
    }
    

    Compilation and Execution

    Here are the steps to compile and run the above mentioned application. Make sure, you have set PATH and CLASSPATH appropriately before proceeding for the compilation and execution.

    • Create hibernate.cfg.xml configuration file as explained above.
    • Create Employee.hbm.xml mapping file as shown above.
    • Create Employee.java source file as shown above and compile it.
    • Create ManageEmployee.java source file as shown above and compile it.
    • Execute ManageEmployee binary to run the program, which will create 100000 records in EMPLOYEE table.

    Apply now for Advanced Java Training Course

    Copyright 1999- Ducat Creative, All rights reserved.

    Anda bisa mendapatkan server slot online resmi dan terpercaya tentu saja di sini. Sebagai salah satu provider yang menyediakan banyak pilihan permainan.