Hibernate Blob Data Type using Annotation

In this tutorial I will show you how store and retrieve BLOB object using Hibernate Annotation.

First create a new Java Project and configure it as Maven Project. For Reference, Click Here

Add the following dependencies in pom.xml

<dependencies>
 
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.8.2</version>
        <scope>test</scope>
    </dependency>
 
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.15</version>
    </dependency>
 
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-core</artifactId>
        <version>3.6.3.Final</version>
    </dependency>
 
    <dependency>
        <groupId>javassist</groupId>
        <artifactId>javassist</artifactId>
        <version>3.12.1.GA</version>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-log4j12</artifactId>
        <version>1.6.6</version>
    </dependency>
</dependencies>

1. Sql Script

Use the following Sql Script for creating table.

create table User(
    User_ID int(10) primary key NOT NULL AUTO_INCREMENT,
    Name varchar(50),
    content longblob NOT NULL);

2. Pojo

Now create User class and write the following code.

The @Lob Annotation is used to specify the content datatype of User Table.

package com.kruders.model.bean;

import java.sql.Blob;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Lob;
import javax.persistence.Table;

@Entity
@Table(name = "User")
public class User {
	@Id
    @GeneratedValue
    @Column(name="User_ID")
	private int userId;
	
	@Column(name="Name")
    private String name;
  
    @Column(name="content")
    @Lob
    private Blob content;

	public int getUserId() {
		return userId;
	}

	public void setUserId(int userId) {
		this.userId = userId;
	}

	public String getName() {
		return name;
	}

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

	public Blob getContent() {
		return content;
	}

	public void setContent(Blob content) {
		this.content = content;
	}
}

3. Hibernate Configuration File

Now create the hibernate configuration file and add all the mapping files.

hibernate.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>
<!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.jdbc.Driver</property>
    <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/test</property>
    <property name="hibernate.connection.username">root</property>
    <property name="hibernate.connection.password"></property>
    <property name="connection.pool_size">1</property>
    <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
    <property name="show_sql">true</property>
    <mapping class="com.kruders.model.bean.User" />
</session-factory>
</hibernate-configuration>

4. Hibernate Utility Class

Now create HibernateUtil class. The HibernateUtil class helps in creating the SessionFactory from the Hibernate configuration file. A org.hibernate.SessionFactory is used to obtain org.hibernate.Session instances. A org.hibernate.Session represents a single-threaded unit of work. The org.hibernate.SessionFactory is a thread-safe global object that is instantiated once.

package com.kruders.util;

import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
  
public class HibernateUtil {
  
    private static final SessionFactory sessionFactory = buildSessionFactory();
  
    private static SessionFactory buildSessionFactory() {
        try {
            // Create the SessionFactory from hibernate.cfg.xml
            return new Configuration().configure().buildSessionFactory();
        } catch (Throwable ex) {
            // Make sure you log the exception, as it might be swallowed
            System.err.println("Initial SessionFactory creation failed." + ex);
            throw new ExceptionInInitializerError(ex);
        }
    }
  
    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }
}

5. Run Program

Create Main.java class that stores and retrieves BLOB object and run it as Java Application.

I have used byte array to store the data and then it is converted to BLOB.

package com.kruders.core;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.sql.Blob;
import java.util.Iterator;
import java.util.List;

import org.hibernate.Hibernate;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.Transaction;

import com.kruders.model.bean.User;
import com.kruders.util.HibernateUtil;

public class Main {
   public static void main(String args[]) {
	    Session session = HibernateUtil.getSessionFactory().openSession();
	    Transaction transaction = null;
        try {
           
            transaction = session.beginTransaction();
            File resume = new File("D:\\Resume.doc");
            byte[] fileContent = new byte[(int) resume.length()];
            try {
       	     	FileInputStream fileInputStream = new FileInputStream(resume);
       	     	//convert file into array of bytes
       	     	fileInputStream.read(fileContent);
       	     	fileInputStream.close();
            } catch (Exception e) {
       	     	e.printStackTrace();
            }
            Blob blob = Hibernate.createBlob(fileContent);
            User user = new User();
            user.setName("Puneet");
            user.setContent(blob);
            session.save(user);
            transaction.commit();
        }catch (HibernateException e) {
            transaction.rollback();
            e.printStackTrace();
        } finally {
            session.close();
        }
        readResume(1);
     }
    
    public static void readResume(Integer userId) {
    	Session session = HibernateUtil.getSessionFactory().openSession();
	    Transaction transaction = null;
        try {
             
            transaction = session.beginTransaction();
            List employees = session.createQuery("from User where userId ='" + userId + "'").list();
            for (Iterator iterator = employees.iterator(); iterator.hasNext();) {
                User user = (User) iterator.next();
                Blob blob = user.getContent();
                FileOutputStream fos = new FileOutputStream("D:\\Resume1.doc"); 
                fos.write(blob.getBytes(1, (int)blob.length()));
                fos.close();
            }
            transaction.commit();
        } catch (HibernateException e) {
            transaction.rollback();
            e.printStackTrace();
        } catch (Exception e) {
            transaction.rollback();
            e.printStackTrace();
        } finally {
            session.close();
        }
    }
}

The folder structure of the example is shown below in Figure 21.1

Figure 21.1 Figure 21.1

You can download the source code of this example here.

No comments yet.

Leave a Reply