Hibernate Framework In Java | Application Programming Interface[Edit]

By Pankaj

While we believe that this content benefits our community, we have not yet thoroughly reviewed it. If you have any suggestions for improvements, please let us know by clicking the “report an issue“ button at the bottom of the tutorial.

Welcome to the Hibernate tutorial for Beginners. Hibernate is one of the most widely used Java ORM tool. Most of the applications use relational databases to store application information and at the low level we use JDBC API for connecting to databases and perform CRUD operations.

If you look at the JDBC code, there is so much of boiler plate code and there are chances of resource leak and data inconsistency because all the work needs to be done by the developer. This is where an ORM tool comes handy. Object-relational mapping or ORM is the programming technique to map application domain model objects to the relational database tables. Hibernate is java based ORM tool that provides framework for mapping application domain objects to the relational database tables and vice versa. Some of the benefits of using Hibernate as ORM tool are:

I hope all the above benefits will convince you that Hibernate is the best choice for your application object-relational mapping requirements. Let’s look at the Hibernate Framework architecture now and then we will jump into sample project where we will look into different ways to configure Hibernate in standalone java application and use it.

Below image shows the Hibernate architecture and how it works as an abstraction layer between application classes and JDBC/JTA APIs for database operations. It’s clear that Hibernate is built on top of JDBC and JTA APIs. Let’s look at the core components of hibernate architecture one by one.


org.hibernate.Sessionusing


SessionFactory.


java.sql.Connectionand works as a factory for


org.hibernate.Transaction.


org.hibernate.Session.


org.hibernate.Session. They may have been instantiated by the application and not yet persisted, or they may have been instantiated by a closed


org.hibernate.Session.


org.hibernate.Sessionmight span multiple


org.hibernate.Transactionin some cases.


javax.sql.DataSourceor


java.sql.DriverManager. It is not exposed to application, but it can be extended by the developer.


org.hibernate.Transactioninstances.


Hibernate provides implementation of Java Persistence API, so we can use JPA annotations with model beans and hibernate will take care of configuring it to be used in CRUD operations. We will look into this with annotations example.

When developing hibernate applications, we need to provide two set of configuration. First set of configuration contains database specific properties that will be used to create Database connection and Session objects. Second set of configurations contains mapping between model classes and database tables. We can use XML based or properties based configuration for database connection related configurations. We can use XML based or annotation based configurations for providing model classes and database tables mapping. We will use JPA annotations from

javax.persistence

for annotation based mappings. Our final project will look like below image. Create a Maven project in Eclipse or your favorite IDE, you can keep any name of your choice. Before we move on to the different components of the project, we will have to do the database setup.

For my example, I am using MySQL database and below script is used to create necessary table.


CREATE TABLE `Employee` ( `id` int(11) unsigned NOT NULL AUTO_INCREMENT, `name` varchar(20) DEFAULT NULL, `role` varchar(20) DEFAULT NULL, `insert_time` datetime DEFAULT NULL, PRIMARY KEY (`id`) ) ENGINE=InnoDB AUTO_INCREMENT=19 DEFAULT CHARSET=utf8;


Notice that Employee table “id” column is automatically generated by MySQL, so we don’t need to insert it.

Our final pom.xml file looks like below.


4.0.0


com.journaldev.hibernate


HibernateExample


0.0.1-SNAPSHOT


HibernateExample




org.hibernate


hibernate-core


4.3.5.Final





org.slf4j


slf4j-simple


1.7.5




mysql


mysql-connector-java


5.0.5





${project.artifactId}



hibernate-core artifact contains all the core hibernate classes, so we will get all the necessary features by including it in the project. Note that I am using latest Hibernate version (4.3.5.Final) for my sample project and Hibernate is still evolving and I have seen that a lot of core classes change between every major release. So if you are using any other version, there is a small chance that you will have to modify the Hibernate configurations for it to work. However, I am sure that it will work fine for all the 4.x.x releases. Hibernate 4 uses JBoss logging but older versions uses slf4j for logging purposes, so I have included slf4j-simple artifact in my project, although not needed because I am using Hibernate 4. mysql-connector-java is the MySQL driver for connecting to MySQL databases, if you are using any other database then add corresponding driver artifact.

As you can see in above image that we have two model classes,

Employee

and

Employee1

. Employee is a simple Java Bean class and we will use XML based configuration for providing it’s mapping details. Employee1 is a java bean where fields are annotated with JPA annotations, so that we don’t need to provide mapping in separate XML file.


package com.journaldev.hibernate.model; import java.util.Date; public class Employee { private int id; private String name; private String role; private Date insertTime; public int getId() { return id; } public void setId(int id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getRole() { return role; } public void setRole(String role) { this.role = role; } public Date getInsertTime() { return insertTime; } public void setInsertTime(Date insertTime) { this.insertTime = insertTime; } }


Employee class is simple java bean, there is nothing specific to discuss here.


package com.journaldev.hibernate.model; import java.util.Date; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id; import javax.persistence.Table; import javax.persistence.UniqueConstraint; @Entity @Table(name="Employee", uniqueConstraints={@UniqueConstraint(columnNames={"ID"})}) public class Employee1 { @Id @GeneratedValue(strategy=GenerationType.IDENTITY) @Column(name="ID", nullable=false, unique=true, length=11) private int id; @Column(name="NAME", length=20, nullable=true) private String name; @Column(name="ROLE", length=20, nullable=true) private String role; @Column(name="insert_time", nullable=true) private Date insertTime; public int getId() { return id; } public void setId(int id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getRole() { return role; } public void setRole(String role) { this.role = role; } public Date getInsertTime() { return insertTime; } public void setInsertTime(Date insertTime) { this.insertTime = insertTime; } }



javax.persistence.Entity

annotation is used to mark a class as Entity bean that can be persisted by hibernate, since hibernate provides JPA implementation.

javax.persistence.Table

annotation is used to define the table mapping and unique constraints for the columns.

javax.persistence.Id

annotation is used to define the primary key for the table.

javax.persistence.GeneratedValue

is used to define that the field will be auto generated and GenerationType.IDENTITY strategy is used so that the generated “id” value is mapped to the bean and can be retrieved in the java program.

javax.persistence.Column

is used to map the field with table column, we can also specify length, nullable and uniqueness for the bean properties.

As stated above, we will use XML based configuration for Employee class mapping. We can choose any name, but it’s good to choose with table or java bean name for clarity. Our hibernate mapping file for Employee bean looks like below. employee.hbm.xml

The xml configuration is simple and does the same thing as annotation based configuration.

We will create two hibernate configuration xml files – one for xml based configuration and another for annotation based configuration. hibernate.cfg.xml







com.mysql.jdbc.Driver jdbc:mysql://localhost/TestDB pankaj pankaj123
thread true org.hibernate.dialect.MySQLDialect




Most of the properties are related to database configurations, other properties details are given in comment. Note the configuration for hibernate mapping file, we can define multiple hibernate mapping files and configure them here. Also note that mapping is specific to session factory. hibernate-annotation.cfg.xml







com.mysql.jdbc.Driver jdbc:mysql://localhost/TestDB pankaj pankaj123 thread




Most of the configuration is same as XML based configuration, the only difference is the mapping configuration. We can provide mapping configuration for classes as well as packages.

I have created a utility class where I am creating

SessionFactory

from XML based configuration as well as property based configuration. For property based configuration, we could have a property file and read it in the class, but for simplicity I am creating Properties instance in the class itself.


package com.journaldev.hibernate.util; import java.util.Properties; import org.hibernate.SessionFactory; import org.hibernate.boot.registry.StandardServiceRegistryBuilder; import org.hibernate.cfg.Configuration; import org.hibernate.service.ServiceRegistry; import com.journaldev.hibernate.model.Employee1; public class HibernateUtil { //XML based configuration private static SessionFactory sessionFactory; //Annotation based configuration private static SessionFactory sessionAnnotationFactory; //Property based configuration private static SessionFactory sessionJavaConfigFactory; private static SessionFactory buildSessionFactory() { try { // Create the SessionFactory from hibernate.cfg.xml Configuration configuration = new Configuration(); configuration.configure("hibernate.cfg.xml"); System.out.println("Hibernate Configuration loaded"); ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder().applySettings(configuration.getProperties()).build(); System.out.println("Hibernate serviceRegistry created"); SessionFactory sessionFactory = configuration.buildSessionFactory(serviceRegistry); return sessionFactory; } 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); } } private static SessionFactory buildSessionAnnotationFactory() { try { // Create the SessionFactory from hibernate.cfg.xml Configuration configuration = new Configuration(); configuration.configure("hibernate-annotation.cfg.xml"); System.out.println("Hibernate Annotation Configuration loaded"); ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder().applySettings(configuration.getProperties()).build(); System.out.println("Hibernate Annotation serviceRegistry created"); SessionFactory sessionFactory = configuration.buildSessionFactory(serviceRegistry); return sessionFactory; } 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); } } private static SessionFactory buildSessionJavaConfigFactory() { try { Configuration configuration = new Configuration(); //Create Properties, can be read from property files too Properties props = new Properties(); props.put("hibernate.connection.driver_class", "com.mysql.jdbc.Driver"); props.put("hibernate.connection.url", "jdbc:mysql://localhost/TestDB"); props.put("hibernate.connection.username", "pankaj"); props.put("hibernate.connection.password", "pankaj123"); props.put("hibernate.current_session_context_class", "thread"); configuration.setProperties(props); //we can set mapping file or class with annotation //addClass(Employee1.class) will look for resource // com/journaldev/hibernate/model/Employee1.hbm.xml (not good) configuration.addAnnotatedClass(Employee1.class); ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder().applySettings(configuration.getProperties()).build(); System.out.println("Hibernate Java Config serviceRegistry created"); SessionFactory sessionFactory = configuration.buildSessionFactory(serviceRegistry); return sessionFactory; } catch (Throwable ex) { System.err.println("Initial SessionFactory creation failed." + ex); throw new ExceptionInInitializerError(ex); } } public static SessionFactory getSessionFactory() { if(sessionFactory == null) sessionFactory = buildSessionFactory(); return sessionFactory; } public static SessionFactory getSessionAnnotationFactory() { if(sessionAnnotationFactory == null) sessionAnnotationFactory = buildSessionAnnotationFactory(); return sessionAnnotationFactory; } public static SessionFactory getSessionJavaConfigFactory() { if(sessionJavaConfigFactory == null) sessionJavaConfigFactory = buildSessionJavaConfigFactory(); return sessionJavaConfigFactory; } }


Creating

SessionFactory

for XML based configuration is same whether mapping is XML based or annotation based. For properties based, we need to set the properties in

Configuration

object and add annotation classes before creating the

SessionFactory

. Overall creating SessionFactory includes following steps:


Configurationobject and configure it


ServiceRegistryobject and apply configuration settings.


configuration.buildSessionFactory()by passing


ServiceRegistryobject as argument to get the


SessionFactoryobject.


Our application is almost ready now, let’s write some test programs and execute them.

Our test program looks like below.


package com.journaldev.hibernate.main; import java.util.Date; import org.hibernate.Session; import com.journaldev.hibernate.model.Employee; import com.journaldev.hibernate.util.HibernateUtil; public class HibernateMain { public static void main(String[] args) { Employee emp = new Employee(); emp.setName("Pankaj"); emp.setRole("CEO"); emp.setInsertTime(new Date()); //Get Session Session session = HibernateUtil.getSessionFactory().getCurrentSession(); //start transaction session.beginTransaction(); //Save the Model object session.save(emp); //Commit transaction session.getTransaction().commit(); System.out.println("Employee ID="+emp.getId()); //terminate session factory, otherwise program won't end HibernateUtil.getSessionFactory().close(); } }


The program is self understood, when we execute the test program, we get following output.


May 06, 2014 12:40:06 AM org.hibernate.annotations.common.reflection.java.JavaReflectionManager

INFO: HCANN000001: Hibernate Commons Annotations {4.0.4.Final} May 06, 2014 12:40:06 AM org.hibernate.Version logVersion INFO: HHH000412: Hibernate Core {4.3.5.Final} May 06, 2014 12:40:06 AM org.hibernate.cfg.Environment

INFO: HHH000206: hibernate.properties not found May 06, 2014 12:40:06 AM org.hibernate.cfg.Environment buildBytecodeProvider INFO: HHH000021: Bytecode provider name : javassist May 06, 2014 12:40:06 AM org.hibernate.cfg.Configuration configure INFO: HHH000043: Configuring from resource: hibernate.cfg.xml May 06, 2014 12:40:06 AM org.hibernate.cfg.Configuration getConfigurationInputStream INFO: HHH000040: Configuration resource: hibernate.cfg.xml May 06, 2014 12:40:07 AM org.hibernate.cfg.Configuration addResource INFO: HHH000221: Reading mappings from resource: employee.hbm.xml May 06, 2014 12:40:08 AM org.hibernate.cfg.Configuration doConfigure INFO: HHH000041: Configured SessionFactory: null Hibernate Configuration loaded Hibernate serviceRegistry created May 06, 2014 12:40:08 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl configure WARN: HHH000402: Using Hibernate built-in connection pool (not for production use!) May 06, 2014 12:40:08 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl buildCreator INFO: HHH000401: using driver [com.mysql.jdbc.Driver] at URL [jdbc:mysql://localhost/TestDB] May 06, 2014 12:40:08 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl buildCreator INFO: HHH000046: Connection properties: {user=pankaj, password=****} May 06, 2014 12:40:08 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl buildCreator INFO: HHH000006: Autocommit mode: false May 06, 2014 12:40:08 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl configure INFO: HHH000115: Hibernate connection pool size: 1 (min=1) May 06, 2014 12:40:08 AM org.hibernate.dialect.Dialect

INFO: HHH000400: Using dialect: org.hibernate.dialect.MySQLDialect May 06, 2014 12:40:08 AM org.hibernate.engine.jdbc.internal.LobCreatorBuilder useContextualLobCreation INFO: HHH000423: Disabling contextual LOB creation as JDBC driver reported JDBC version [3] less than 4 May 06, 2014 12:40:08 AM org.hibernate.engine.transaction.internal.TransactionFactoryInitiator initiateService INFO: HHH000399: Using default transaction strategy (direct JDBC transactions) May 06, 2014 12:40:08 AM org.hibernate.hql.internal.ast.ASTQueryTranslatorFactory

INFO: HHH000397: Using ASTQueryTranslatorFactory Hibernate: select max(ID) from EMPLOYEE Hibernate: insert into EMPLOYEE (NAME, ROLE, insert_time, ID) values (?, ?, ?, ?) Employee ID=19 May 06, 2014 12:40:08 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl stop INFO: HHH000030: Cleaning up connection pool [jdbc:mysql://localhost/TestDB]






Notice that it’s printing the generated employee id, you can check database table to confirm it.


package com.journaldev.hibernate.main; import java.util.Date; import org.hibernate.Session; import org.hibernate.SessionFactory; import com.journaldev.hibernate.model.Employee1; import com.journaldev.hibernate.util.HibernateUtil; public class HibernateAnnotationMain { public static void main(String[] args) { Employee1 emp = new Employee1(); emp.setName("David"); emp.setRole("Developer"); emp.setInsertTime(new Date()); //Get Session SessionFactory sessionFactory = HibernateUtil.getSessionAnnotationFactory(); Session session = sessionFactory.getCurrentSession(); //start transaction session.beginTransaction(); //Save the Model object session.save(emp); //Commit transaction session.getTransaction().commit(); System.out.println("Employee ID="+emp.getId()); //terminate session factory, otherwise program won't end sessionFactory.close(); } }


When we execute above program, we get following output.


May 06, 2014 12:42:22 AM org.hibernate.annotations.common.reflection.java.JavaReflectionManager

INFO: HCANN000001: Hibernate Commons Annotations {4.0.4.Final} May 06, 2014 12:42:22 AM org.hibernate.Version logVersion INFO: HHH000412: Hibernate Core {4.3.5.Final} May 06, 2014 12:42:22 AM org.hibernate.cfg.Environment

INFO: HHH000206: hibernate.properties not found May 06, 2014 12:42:22 AM org.hibernate.cfg.Environment buildBytecodeProvider INFO: HHH000021: Bytecode provider name : javassist May 06, 2014 12:42:22 AM org.hibernate.cfg.Configuration configure INFO: HHH000043: Configuring from resource: hibernate-annotation.cfg.xml May 06, 2014 12:42:22 AM org.hibernate.cfg.Configuration getConfigurationInputStream INFO: HHH000040: Configuration resource: hibernate-annotation.cfg.xml May 06, 2014 12:42:23 AM org.hibernate.cfg.Configuration doConfigure INFO: HHH000041: Configured SessionFactory: null Hibernate Annotation Configuration loaded Hibernate Annotation serviceRegistry created May 06, 2014 12:42:23 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl configure WARN: HHH000402: Using Hibernate built-in connection pool (not for production use!) May 06, 2014 12:42:23 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl buildCreator INFO: HHH000401: using driver [com.mysql.jdbc.Driver] at URL [jdbc:mysql://localhost/TestDB] May 06, 2014 12:42:23 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl buildCreator INFO: HHH000046: Connection properties: {user=pankaj, password=****} May 06, 2014 12:42:23 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl buildCreator INFO: HHH000006: Autocommit mode: false May 06, 2014 12:42:23 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl configure INFO: HHH000115: Hibernate connection pool size: 20 (min=1) May 06, 2014 12:42:23 AM org.hibernate.dialect.Dialect

INFO: HHH000400: Using dialect: org.hibernate.dialect.MySQL5Dialect May 06, 2014 12:42:23 AM org.hibernate.engine.jdbc.internal.LobCreatorBuilder useContextualLobCreation INFO: HHH000423: Disabling contextual LOB creation as JDBC driver reported JDBC version [3] less than 4 May 06, 2014 12:42:23 AM org.hibernate.engine.transaction.internal.TransactionFactoryInitiator initiateService INFO: HHH000399: Using default transaction strategy (direct JDBC transactions) May 06, 2014 12:42:23 AM org.hibernate.hql.internal.ast.ASTQueryTranslatorFactory

INFO: HHH000397: Using ASTQueryTranslatorFactory Employee ID=20 May 06, 2014 12:42:23 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl stop INFO: HHH000030: Cleaning up connection pool [jdbc:mysql://localhost/TestDB]






Have a look at the output and compare it with the output from the XML based configuration, you will notice some differences. For example, we are not setting connection pool size for annotation based configuration, so it’s setting to default value 20.


package com.journaldev.hibernate.main; import java.util.Date; import org.hibernate.Session; import org.hibernate.SessionFactory; import com.journaldev.hibernate.model.Employee1; import com.journaldev.hibernate.util.HibernateUtil; public class HibernateJavaConfigMain { public static void main(String[] args) { Employee1 emp = new Employee1(); emp.setName("Lisa"); emp.setRole("Manager"); emp.setInsertTime(new Date()); //Get Session SessionFactory sessionFactory = HibernateUtil.getSessionJavaConfigFactory(); Session session = sessionFactory.getCurrentSession(); //start transaction session.beginTransaction(); //Save the Model object session.save(emp); //Commit transaction session.getTransaction().commit(); System.out.println("Employee ID="+emp.getId()); //terminate session factory, otherwise program won't end sessionFactory.close(); } }


Output of the above test program is:


May 06, 2014 12:45:09 AM org.hibernate.annotations.common.reflection.java.JavaReflectionManager

INFO: HCANN000001: Hibernate Commons Annotations {4.0.4.Final} May 06, 2014 12:45:09 AM org.hibernate.Version logVersion INFO: HHH000412: Hibernate Core {4.3.5.Final} May 06, 2014 12:45:09 AM org.hibernate.cfg.Environment

INFO: HHH000206: hibernate.properties not found May 06, 2014 12:45:09 AM org.hibernate.cfg.Environment buildBytecodeProvider INFO: HHH000021: Bytecode provider name : javassist Hibernate Java Config serviceRegistry created May 06, 2014 12:45:09 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl configure WARN: HHH000402: Using Hibernate built-in connection pool (not for production use!) May 06, 2014 12:45:09 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl buildCreator INFO: HHH000401: using driver [com.mysql.jdbc.Driver] at URL [jdbc:mysql://localhost/TestDB] May 06, 2014 12:45:09 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl buildCreator INFO: HHH000046: Connection properties: {user=pankaj, password=****} May 06, 2014 12:45:09 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl buildCreator INFO: HHH000006: Autocommit mode: false May 06, 2014 12:45:09 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl configure INFO: HHH000115: Hibernate connection pool size: 20 (min=1) May 06, 2014 12:45:10 AM org.hibernate.dialect.Dialect

INFO: HHH000400: Using dialect: org.hibernate.dialect.MySQL5Dialect May 06, 2014 12:45:10 AM org.hibernate.engine.jdbc.internal.LobCreatorBuilder useContextualLobCreation INFO: HHH000423: Disabling contextual LOB creation as JDBC driver reported JDBC version [3] less than 4 May 06, 2014 12:45:10 AM org.hibernate.engine.transaction.internal.TransactionFactoryInitiator initiateService INFO: HHH000399: Using default transaction strategy (direct JDBC transactions) May 06, 2014 12:45:10 AM org.hibernate.hql.internal.ast.ASTQueryTranslatorFactory

INFO: HHH000397: Using ASTQueryTranslatorFactory Employee ID=21 May 06, 2014 12:45:10 AM org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl stop INFO: HHH000030: Cleaning up connection pool [jdbc:mysql://localhost/TestDB]






That’s all for hibernate tutorial for beginners, I hope it will be enough to get you started. We will look into different features of Hibernate framework in future tutorials. Download the complete project from below link and play around with it to learn more.

Thanks for learning with the DigitalOcean Community. Check out our offerings for compute, storage, networking, and managed databases.

Very good. i got two problems and those were resolved by solving as follows 1) in pom.xml version is changed 8.0.16 2) Every where changed the database name,here userlogin is mine specific jdbc:mysql://localhost/userlogin

– raj

Thank you Sir for this awesome Tutorial!

– mahesh

update this need to be ADDED in hibernate.cgf.xml or otherwise it won’t work

– Mohit Nirwan

Really nice to read, more clear when developing. Thanks a lot

– Vijayakumar

Thank you. Simple and clear understanding

– Sujan Maka

we can create sesion factory directly then what is the need of ServiceRegistry plz explian me Thanks

– Hemanth

finally it’s work thank you very much,

– Akhand Singh

Hello sir thanks for this tutorial you have define every steps very clearly

– Rajinder singh

Can you please do all your examples with annotations as well. I want to learn with annotations. Thanks in advance

– Rajat Gupta

For Hibernate 5.x.x private static SessionFactory buildSessionFactory() { try { StandardServiceRegistry standardRegistry = new StandardServiceRegistryBuilder() .configure(“hibernate.cfg.xml”).build(); Metadata metadata = new MetadataSources(standardRegistry).getMetadataBuilder().build(); return metadata.getSessionFactoryBuilder().build(); } catch (HibernateException e) { System.err.println(“Initial SessionFactory creation failed.” + e); throw new ExceptionInInitializerError(e); } }

– Vijay Raj R

Click below to sign up and get $200 of credit to try our products over 60 days!

Working on improving health and education, reducing inequality, and spurring economic growth? We’d like to help.

Get paid to write technical tutorials and select a tech-focused charity to receive a matching donation.

Hibernate Tutorial This hibernate tutorial provides in-depth concepts of Hibernate Framework with simplified examples. It was started in 2001 by Gavin King as an alternative to EJB2 style entity bean. Hibernate Framework Hibernate is a Java framework that simplifies the development of Java application to interact with the database. It is an open source, lightweight, ORM (Object Relational Mapping) tool. Hibernate implements the specifications of JPA (Java Persistence API) for data persistence. ORM Tool An ORM tool simplifies the data creation, data manipulation and data access. It is a programming technique that maps the object to the data stored in the database. The ORM tool internally uses the JDBC API to interact with the database. What is JPA? Java Persistence API (JPA) is a Java specification that provides certain functionality and standard to ORM tools. The javax.persistence package contains the JPA classes and interfaces. Advantages of Hibernate Framework Following are the advantages of hibernate framework: 1) Open Source and Lightweight Hibernate framework is open source under the LGPL license and lightweight. 2) Fast Performance The performance of hibernate framework is fast because cache is internally used in hibernate framework. There are two types of cache in hibernate framework first level cache and second level cache. First level cache is enabled by default. 3) Database Independent Query HQL (Hibernate Query Language) is the object-oriented version of SQL. It generates the database independent queries. So you don’t need to write database specific queries. Before Hibernate, if database is changed for the project, we need to change the SQL query as well that leads to the maintenance problem. 4) Automatic Table Creation Hibernate framework provides the facility to create the tables of the database automatically. So there is no need to create tables in the database manually. 5) Simplifies Complex Join Fetching data from multiple tables is easy in hibernate framework. 6) Provides Query Statistics and Database Status Hibernate supports Query cache and provide statistics about query and database status. Hibernate Index Hibernate Tutorial Hibernate with Eclipse Hibernate Example Hibernate Log4j Inheritance Mapping Hibernate Mapping Tx Management HQL HCQL Named Query Hibernate Caching Second Level Cache Integration Interview Questions Next TopicHibernate Architecture

Mapping[edit]

The mapping of Java classes to database tables is implemented by the configuration of an XML file or by using Java Annotations. When using an XML file, Hibernate can generate skeleton source code for the persistence classes. This is auxiliary when annotations are used. Hibernate can use the XML file or the Java annotations to maintain the database schema.

There are provided facilities to arrange one-to-many and many-to-many relationships between classes.[2]: 140–171 In addition to managing associations between objects, Hibernate can also manage reflexive associations wherein an object has a one-to-many relationship with other instances of the class type.

Hibernate supports the mapping of custom value types. This makes the following scenarios possible:

• Overriding the default SQL type when mapping a column to a property.
• Mapping Java Enums to columns as though they were regular properties.[2]: 89–90
• Mapping a single property to multiple columns.

Definition: Objects in an object-oriented application follow OOP principles, while objects in the back-end follow database normalization principles, resulting in different representation requirements. This problem is called “object–relational impedance mismatch”. Mapping is a way of resolving the object–relational impedance mismatch problem.

Mapping informs the ORM tool of what Java class object to store in which database table.

Hibernate Framework là gì?

Hibernate framework là một giải pháp ORM (Object Relational Mapping) mã nguồn mở, gọn nhẹ. Hibernate giúp đơn giản hoá sự phát triển của ứng dụng java để tương tác với cơ sở dữ liệu.

Tool ORM giúp đơn giản hoá việc tạo ra dữ liệu, thao tác dữ liệu và truy cập dữ liệu. Đó là một kỹ thuật lập trình để ánh xạ đối tượng vào dữ liệu được lưu trữ trong cơ sở dữ liệu.

Các tool ORM sử dụng JDBC API để tương tác với cơ sở dữ liệu.

Tại sao nên dùng Hibernate thay vì JDBC

Object Mapping

Với JDBC ta phải map các trường trong bảng với các thuộc tính của Java object một cách “thủ công”. Với Hibernate sẽ hỗ trợ ta map một cách “tự động” thông qua các file cấu hình map XML hay sử dụng các anotation.

JDBC sẽ map Java object với table như sau:

//rs là ResultSet trả về từ câu query get dữ liệu bảng user. List

users = new ArrayList<>(); while(rs.next()) { User user = new User(); user.setId(rs.getInt(“id”)); user.setUsername(rs.getString(“username”)); user.setPassword(rs.getString(“password”)); user.setCreatedDate(rs.getDate(“createdDate”)); users.add(user); }

Cũng với table user đó sử dụng các anotaion để Hibernate có thể map một cách “tự động” như sau.

@Entity @Table(name = “user”) @Data public class UserModel { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Integer id; @NotEmpty @Column(name = “username”) private String username; @NotEmpty @Column(name = “password”) private String password; @NotEmpty @Column(name = “createdDate”) private Date createdDate; }

HQL

Hibernate cung cấp các câu lệnh truy vấn tương tự SQL, HQL của Hibernate hỗ trợ đầy đủ các truy vấn đa hình như, HQL “hiểu” các khái niệm như kế thừa (inheritance), đa hình (polymorphysm), và liên kết (association)

Database Independent

Code sử dụng Hibernate là độc lập với hệ quản trị cơ sở dữ liệu, nghĩa là ta không cần thay đổi câu lệnh HQL khi ta chuyển từ hệ quản trị CSDL MySQL sang Oracle, hay các hệ quản trị CSDL khác… Do đó rất dễ để ta thay đổi CSDL quan hệ, đơn giản bằng cách thay đổi thông tin cấu hình hệ quản trị CSDL trong file cấu hình.

//used MySQL com.mysql.jdbc.Driver // used Oracle oracle.jdbc.driver.OracleDriver

Ví dụ khi ta muốn lấy 10 bản ghi dữ liệu của một table từ 2 CSDL khác nhau.

Với JDBC ta có câu truy vấn như sau.

# MySQL SELECT column_name FROM table_name ORDER BY column_name ASC LIMIT 10; # SQL Server SELECT TOP 10 column_name FROM table_name ORDER BY column_name ASC;

Với Hibernate câu truy vấn không thay đổi với cả 2 CSDL.

Session.CreateQuery(“SELECT E.id FROM Employee E ORDER BY E.id ASC”).SetMaxResults(10).List();

Minimize Code Changes

Khi ta thay đổi (thêm) cột vào bảng, với JDBC ta phải thay đổi những gì:

• Thêm thuộc tính vào POJO class.
• Thay đổi method chứa câu truy vấn “select”, “insert”, “update” để bổ sung cột mới.
• Có thể có rất nhiều method, nhiều class chứa các câu truy vấn như trên.

Với Hibernate ta chỉ cần:

• Thêm thuộc tính vào Entity class.
• Cập nhật Hibernate Annotation để map column – property..

Lazy Loading

Với những ứng dụng Java làm việc với cơ sở dữ liệu lớn hàng trăm triệu bản ghi, việc có sử dụng Lazy loading trong truy xuất dữ liệu từ database mang lại lợi ích rất lớn.

Ví dụ những file tài liệu do người dùng upload được lưu ở bảng document. Bảng user có quan hệ một-nhiều với bảng document. Trong trường hợp này class User là class cha, class Document là class con. Bảng document nhanh chóng đầy lên theo thời gian. Mỗi khi ta lấy thông tin user và document tương ứng từ database giả sử dữ liệu document là rất lớn, để ứng dụng không bị chậm vì phải mất nhiều bộ nhớ để chứa toàn bộ document của toàn bộ user, ta áp dụng Lazy loading cho từng user như sau.

// Declaring fetch type for one to many association in your POJO @OneToMany(mappedBy = “user”, fetch = FetchType.LAZY) private Set documents = new HashSet(); // To fetch user with document use initialize() method as follows User user = (User)session.get(User.class, new Integer(100)); // This code will fetch all products for user 100 from database ‘NOW’ documents = user.getDocuments();

Loại bỏ Try-Catch Blocks

Sử dụng JDBC nếu lỗi xảy khi tao tác với database thì sẽ có exception SQLexception ném ra. Bởi vậy ta phải sử dụng try-catch block để xử lý ngoại lệ.

Hibernate xử lý việc này giúp bạn bằng cách nó override toàn bộ JDBC exception thành Unchecked Exception và ta không cần viết try-catch trong code của mình nữa.

Quản lý commit/ rollback Transaction

Transaction là nhóm các hoạt động (với database) của một tác vụ. Nếu một hoạt động không thành công thì toàn bộ tác vụ không thành công.

Với JDBC lập trình viên phải chủ động thực hiện commit khi toàn bộ hoạt động của tác vụ thành công, hay phải rollback khi có một hoạt động không thành công để kết thúc tác vụ.

Với Hibernate thì ta không cần quan tâm đến commit hay rollback, Hibernate đã quản lý nó giúp ta rồi.

Hibernate Caching

Hibernate cung cấp một cơ chế bộ nhớ đệm, giúp giảm số lần truy cập vào database của ứng dụng càng nhiều càng tốt. Điều này sẽ có tác dụng tăng performance đáng kể cho ứng dụng của bạn.

Hibernate lưu trữ các đối tượng trong session khi transation được kích hoạt. Khi một query được thực hiện liên tục, giá trị được lưu trữ trong session được sử dụng lại. Khi một transaction mới bắt đầu, dữ liệu được lấy lại từ database và được lưu trữ session. Hibernate cung cấp hai cấp độ Cache: bộ nhớ cache cấp một (first level cache) và bộ nhớ cache cấp hai (second level cache).

Chúng ta sẽ tìm hiểu chi tiết hơn về Cache trong Hibernate ở các bài viết kế tiếp.

Associations

Thật dễ dàng để tạo một liên kết giữa các bảng bằng Hibernate như quan hệ một-một, một-nhiều, nhiều-một và nhiều-nhiều trong Hibernate bằng cách sử dụng các Annotation để ánh xạ đối tượng của bảng.

Chẳng hạn, chúng ta có bảng Person quan hệ 1-1 với bảng PersonDetail. Với JDBC, chúng ta phải viết SQL để thực hiện INNER JOIN giữa 2 bảng. Với Hibernate, chỉ đơn giản thêm Annotation @OneToOne như sau:

JPA Annotation Support

Hibernate implement đặc tả JPA, do đó chúng ta có thể sử dụng các Annotation của JPA như @Entity, @Table, @Column, … Nhờ đặc điểm này, chúng ta có thể dễ dàng chuyển đổi giữa các ORM Framework mà không cần phải sử đổi code.

Connection Pooling

Như chúng ta đã biết, Connection Pooling giúp tăng performance nhờ vào sử dụng lại các kết nối khi có yêu cầu thay vì việc tạo kết nối mới.

Một số Connection Pooling được hỗ trợ bởi Hibernate: C3p0, Apache DBCP.

Chúng ta có thể dễ dàng tích hợp với các thư viện Connection Pooling có sẵn chỉ với vài dòng cấu hình như sau:

20 300 50 3000

Trên đây là một số khái niệm cơ bản về Hibernate mà tôi muốn giới thiệu đến các bạn. Trong các bài viết tiếp theo chúng ta sẽ cùng tìm hiểu cách cài đặt và sử dụng các API của Hibernate.

Tài liệu tham khảo:

• https://hibernate.org
• https://docs.jboss.org/hibernate/orm/current/userguide/html_single/Hibernate_User_Guide.html
• https://www.tutorialspoint.com/hibernate/index.htm
• https://www.javatpoint.com/hibernate-tutorial
• https://dzone.com/articles/15-reasons-to-choose-hibernate-over-jdbc

Hibernate (framework)

Developer(s)	Red Hat
Initial release	23 May 2001
Stable release	6.1.4.Final / October 5, 2022[1]
Repository
Written in	Java
Operating system	Cross-platform (JVM)
Platform	Java Virtual Machine
Type	Object–relational mapping
License	GNU Lesser General Public License
Website	hibernate

Hibernate ORM (or simply Hibernate) is an object–relational mapping[2]: §1.2.2, [12] tool for the Java programming language. It provides a framework for mapping an object-oriented domain model to a relational database. Hibernate handles object–relational impedance mismatch problems by replacing direct, persistent database accesses with high-level object handling functions.

Hibernate is free software that is distributed under the GNU Lesser General Public License 2.1.

Hibernate’s primary feature is mapping from Java classes to database tables, and mapping from Java data types to SQL data types. Hibernate also provides data query and retrieval facilities. It generates SQL calls and relieves the developer from the manual handling and object conversion of the result set.

History[edit]

Hibernate was started in 2001 by Gavin King with colleagues from Cirrus Technologies as an alternative to using EJB2-style entity beans. The original goal was to offer better persistence capabilities than those offered by EJB2; by simplifying the complexities and supplementing certain missing features.

In early 2003, the Hibernate development team began Hibernate2 releases, which offered many significant improvements over the first release.

JBoss, Inc. (now part of Red Hat) later hired the lead Hibernate developers in order to further its development.

In 2005, Hibernate version 3.0 was released. Key features included a new Interceptor/Callback architecture, user defined filters, and JDK 5.0 Annotations (Java’s metadata feature). As of 2010[update], Hibernate 3 (version 3.5.0 and up) was a certified implementation of the Java Persistence API 2.0 specification via a wrapper for the Core module which provides conformity with the JSR 317 standard.[5]

In Dec 2011, Hibernate Core 4.0.0 Final was released. This includes new features such as multi-tenancy support, introduction of ServiceRegistry (a major change in how Hibernate builds and manages “services”), better session opening from SessionFactory, improved integration via org.hibernate.integrator.spi.Integrator and auto discovery, internationalization support, message codes in logging, and a more distinction between the API, SPI or implementation classes.[6]

In December 2012, Hibernate ORM 4.1.9 Final was released.[7]

In Mar 2013, Hibernate ORM 4.2 Final was released.[8]

In December 2013, Hibernate ORM 4.3.0 Final was released.[9] It features Java Persistence API 2.1.

In September 2015, Hibernate ORM 5.0.2 Final was released. It has improved bootstrapping, hibernate-java8, hibernate-spatial, Karaf support.

In November 2018, Hibernate ORM 5.1.17 Final was released. This is the final release of the 5.1 series.

In October 2018, Hibernate ORM 5.3 Final was released. It featured Java Persistence API 2.2 inheritance caching.

In December 2018, Hibernate ORM 5.4.0 Final was released.[10]

In October 2022, Hibernate ORM 6.1.4 Final was released.[11]

Integration[edit]

Hibernate can be used both in standalone Java applications and in Java EE applications using servlets, EJB session beans, and JBI service components. It can also be included as a feature in other programming languages. For example, Adobe integrated Hibernate into version 9 of ColdFusion (which runs on J2EE app servers) with an abstraction layer of new functions and syntax added into CFML.

Growing Pains With Non-Flexible Solutions

Monica – Hey John, remember the project we spoke about last year?

John – Sure. How’s it going?

Monica – We are going to production soon. Everything is fine, but some questions have popped up.

John – Sure, hit me.

Monica – Well, we can no longer generate our database schema from scratch. What’s the best way to support schema changes without losing data?

John – Well, first, Hibernate isn’t intended to be used as production migration tool. Use something like FlywayDB or Liquibase. It’s pretty simple. You write down migration scripts, then you update the entity model along with the Hibernate mappings, so it keeps in sync with the actual database structure.

Monica – Hmm, I see. We were using just plain SQL migration in the previous project.

John – That’s fine too. As long as you keep the entity model and schema in sync, do it how you like.

Monica – I see. There’s another thing. We’re always struggling with lazy/eager fetching problems. At one point, we decided to do everything eagerly, but it seems suboptimal, and besides, sometimes it’s not possible to access some fields because there is no session, or something like that. Is that normal?

John – You need to learn more about Hibernate. Mapping from the database is not straightforward. Basically, there are multiple ways of doing it. You just need to pick a way that works for you. Lazy fetching gives you the ability to load those objects on demand, but you need to operate within an active session.

Monica – We’re still struggling with which database engine to use for the final deployment. I thought Hibernate was portable, but we have some native queries that use some MS SQL magic, and we’d actually like to go with MySQL in the production.

John – Hibernate gives you flexibility as long as you are using detached criteria or HQL; any native queries will just bind your solution to the database.

Monica – Seems like we have to stick to the MS SQL then. Last question: My teammate said that there is no “limit” keyword in HQL. I thought he was joking, but I couldn’t find it either. Sorry for the stupid question…

John – Indeed, there is no “limit” keyword in HQL. You can control this via query object since it’s database-vendor specific.

Monica – Seems weird that all the other elements are in HQL. Nevermind. Thanks for your time!

References[edit]

1. ^ “Hibernate ORM 6.1.4.Final released”. Retrieved 11 October 2022.
2. ^ a b c d e f g h i j Bauer, King & Gregory 2015.
3. ^ “Equals and HashCode”. JBoss Community.
4. ^ “Hibernate User Guide: 2.5.5. Provide identifier attribute”. JBoss Community.
5. ^ “Hibernate 3.5.0-Final release”. In Relation To…
6. ^ “Releases – Hibernate ORM”. hibernate.org.
7. ^ “In Relation To… Hibernate ORM 4.1.9.Final Released”. Archived from the original on 2013-01-29. Retrieved 2012-12-13.
8. ^ “GC: Hibernate-core-4.2.0.Final.jar – GrepCode Java Project Source”. Archived from the original on 2014-12-05. Retrieved 2014-11-27.
9. ^ “GC: Hibernate-core-4.3.0.Final.jar – GrepCode Java Project Source”. Archived from the original on 2014-12-05. Retrieved 2014-11-27.
10. ^ “Releases – Hibernate ORM”. hibernate.org.
11. ^ Boriero, Andrea. “Hibernate ORM 6.1.4.Final released”. In Relation To. Retrieved 2022-10-11.
12. ^ “Hibernate JavaDocs”. docs.jboss.org.
13. ^ “Session (Hibernate JavaDocs)”. docs.jboss.org.
14. ^ “Hibernate: Relational Persistence for Java and .NET”. JBoss Community.
15. ^ “Hibernate ORM 4.1.0 Release”. JBoss Community.
16. ^ “HIBERNATE – Relational Persistence for Idiomatic Java”. JBoss Community.
17. ^ “No more hibernate-annotations module”. JBoss Community.
18. ^ “Hibernate Annotations”. JBoss Community.
19. ^ “hibernate-entitymanager merged into hibernate-core”. JBoss Community.
20. ^ “Hibernate EntityManager”. JBoss Community.
21. ^ “Hibernate Envers – Easy Entity Auditing”. JBoss Community.
22. ^ “Hibernate OGM”. JBoss Community.
23. ^ “Hibernate Shards”. JBoss Community.
24. ^ “Hibernate Search”. JBoss Community.
25. ^ “Hibernate Tools for Eclipse and Ant”. JBoss Community.
26. ^ “Hibernate Validator”. JBoss Community.
27. ^ “Hibernate Metamodel Generator”. JBoss Community.
28. ^ “NHibernate”. NHibernate Forge. Archived from the original on 2012-07-12. Retrieved 2011-04-26.

Hibernate trong Java là gì?

1.ORM

Như chúng ta đã biết, ORM (Object Relational Mapping) framework là một cơ chế cho phép người lập trình thao tác với database một cách hoàn toàn tự nhiên thông qua các đối tượng. Lập trình viên hoàn toàn không quan tâm đến loại database sử dụng SQL Server, MySQL, PostgreSQL,…

ORM giúp đơn giản hoá việc tạo ra dữ liệu, thao tác dữ liệu và truy cập dữ liệu. Đó là một kỹ thuật lập trình để ánh xạ đối tượng vào dữ liệu được lưu trữ trong cơ sở dữ liệu.

1.Persistence layer

Một ứng dụng có thể được chia làm 3 phần như sau: giao diện người dùng (presentation layer), phần xử lý nghiệp vụ (business layer) và phần chứa dữ liệu (data layer). Cụ thể ra, business layer có thể được chia nhỏ thành 2 layer con là business logic layer và persistence layer.

– Business logic layer: các tính toán logic nhằm thỏa mãn yêu cầu người dùng.

– Persistence layer: chịu trách nhiệm giao tiếp với data layer (thường là một hệ quản trị cơ sở dữ liệu quan hệ – Relational DBMS). Persistence sẽ đảm nhiệm các nhiệm vụ mở kết nối, truy xuất và lưu trữ dữ liệu vào các Relational DBMS.

1.Hibernate

Hibernate là một trong những ORM Framework. Hibernate framework là một framework cho persistence layer. Như vậy, nhờ có Hibernate framework mà giờ đây khi bạn phát triển ứng dụng bạn chỉ còn chú tâm vào những layer khác mà không phải bận tâm nhiều về persistence layer nữa.

Hibernate giúp lập trình viên viết ứng dụng Java có thể map các object (POJO) với hệ quản trị cơ sở dữ liệu quan hệ (database), và hỗ trợ thực hiện các khái niệm lập trình hướng đối tượng với cơ dữ liệu quan hệ.

Hibernate giúp lưu trữ và truy vấn dữ liệu quan hệ mạnh mẽ và nhanh. Hibernate cho phép bạn truy vấn dữ liệu thông qua Java Persistence API (JPA) hoặc bằng ngôn ngữ SQL mở rộng của Hibernate (HQL) hoặc bằng SQL thuần (Native SQL).

Hibernate vốn là một thư viện sinh ra để làm việc với mọi loại database, nó không phụ thuộc vào bạn chọn loại database nào. Nếu Java là “Viết 1 lần chạy mọi nơi” thì Hibernate là “Viết 1 lần chạy trên mọi loại database”.

Hibernate mang lại cho chúng ta nhiều lợi ích sau đây:

– Mã nguồn mở và nhẹ: Hibernate Framework là mã nguồn mở có giấy phép LGPL và nhẹ.

– Hiệu suất nhanh: Hiệu suất của Hibernate Framework là nhanh bởi vì bộ nhớ cache được sử dụng trong nội bộ Hibernate Framework. Có hai loại bộ nhớ cache trong Hibernate Framework, gồm bộ nhớ cache cấp một (first level cache) và bộ nhớ cache cấp hai (second level cache). Bộ nhớ cache cấp một được enable mặc định.

– Truy vấn cơ sở dữ liệu độc lập: HQL (Hibernate Query Language) là phiên bản hướng đối tượng của SQL. Nó tạo ra các truy vấn cơ sở dữ liệu độc lập. Vì vậy, bạn không cần phải viết các truy vấn cơ sở dữ liệu cụ thể. Trước Hibernate, nếu dự án có cơ sở dữ liệu bị thay đổi, chúng ta cần phải thay đổi truy vấn SQL dẫn đến risk và dễ gây lỗi.

– Tạo bảng tự động: Hibernate framework cung cấp phương tiện để tạo ra các bảng cơ sở dữ liệu một cách tự động. Vì vậy, không cần phải tốn công sức tạo ra các bảng trong cơ sở dữ liệu thủ công.

– Đơn giản lệnh join phức tạp: Có thể lấy dữ liệu từ nhiều bảng một cách dễ dàng với Hibernate framework.

– Cung cấp thống kê truy vấn và trạng thái cơ sở dữ liệu: Hibernate hỗ trợ bộ nhớ cache truy vấn và cung cấp số liệu thống kê về truy vấn và trạng thái cơ sở dữ liệu.

What is Hibernate?

Hibernate is an open-source, lightweight ORM (Object Relational Mapping) tool that provides Object-Relational persistence and query service for any Java application. It is one of the most popular implementations of Java Persistence API. It helps to map java objects to the database and helps to reduce common persistence-related programming tasks. This task can be done quickly using XML files, and you do not need to write any line of code. If there is a change in the database or in any table, you need to change the XML file properties only.

Hibernate uses cache internally, which increases the performance of this framework. It has two types of cache, first-level cache, and second-level cache. By default, the first level is enabled.

HQL, which stands for Hibernate Query Language, is the object-oriented version of SQL. It generates independent database queries. So it is not required to write database-specific questions. Before Hibernate, if the database is changed for the project, we need to change the SQL query, which results in a maintenance problem.

There is no need to create tables manually; hibernate allows you to automatically create tables for your database. Additionally, the retrieval of data from multiple tables is easy in this framework.

Following are the databases that hibernate supports:

• Oracle
• Microsoft SQL Server Database
• HSQL Database Engine
• DB2/NT
• FrontBase
• Sybase SQL Server
• PostgreSQL
• MySQL
• Informix Dynamic Server

Features of JPA

Following are the features of Java Persistence API:

Stored Procedure Query: It is a way to implement stored procedure calls without the use of annotations. To use this feature, EntityManager is extended by the createStoredProcedureQuery(String procedureName, Class… resultClasses) method.

Constructor Result Mapping: For mapping the result of the query to the existing constructor call, you can use @ConstructorResult annotation. It is an addition to @SqlResultSetMapping.

JPQL Enhancements: There are some additions to JPQL. You can use the ON keyword to define additional join parameters, the FUNCTION keyword to call database functions, and the TREAT keyword to downcast the entities.

Bean Validation: You have to annotate with the javax.validation.constraints annotations to the fields which require the validations. If the fields are failed in the validation, the values are not presented to the back end.

JDBC Properties: There are several properties defined in the persistence.xml that have become standard for JPA specification. In JPA 1, these properties are vendor-specific, but JPA 2 makes it the standard. Some of the important properties are:

• javax.persistence.jdbc.driver – the fully qualified name for the driver class
• javax.persistence.jdbc.URL – driver-specific URL
• javax.persistence.jdbc.user – the username used for database connection.
• javax.persistence.jdbc.password – the password for validation of database connection.

Shared Cache: JPA 2 version provides a standard for the shared cache mechanism. In this mechanism, entities can be stored in the persistence layer to share among all other contexts if they are long-lived. JPA accomplishes this feature by invoking the standard cache interface from EntityManagerFactory.getCache() method.

Database Schema Generation: Before JPA 2.1 version, developers were using vendor-specific configuration parameters for defining database setup in the persistence.xml file, but now we have the following parameters that help to set up the database:

• javax.persistence.schema-generation.database.action
• javax.persistence.schema-generation.scripts.action
• javax.persistence.schema-generation.create-source
• javax.persistence.schema-generation.drop-source
• javax.persistence.schema-generation.create-database-schemas
• javax.persistence.schema-generation.create-script-source
• javax.persistence.schema-generation.drop-script-source
• javax.persistence.schema-generation.connection
• javax.persistence.schema-generation.scripts.create-target
• javax.persistence.schema-generation.scripts.drop-target
• javax.persistence.database-product-name
• javax.persistence.database-major-version
• javax.persistence.database-minor-version
• javax.persistence.sql-load-script-source

Mappings: Previous versions of JPA have covered most of the mappings and associations, but JPA 2 has dramatically improved the mappings by adding more combinations helpful in using the legacy systems. Here is a quick list of changes.

• Element Collections
• Derived Identifiers
• Persistently Ordered Lists
• Unidirectional One-to-Many With No Join Table
• Orphan Removal
• Maps
• Adding a Join Table

Application programming interface[edit]

The Hibernate API is provided in the Java package

org.hibernate

.[12]

org.hibernate.SessionFactory interface[edit]

The

org.hibernate.SessionFactory

interface is the native equivalent version of the JPA’s standard

EntityManagerFactory

.[2]: 26

org.hibernate.Session interface[edit]

The

org.hibernate.Session

interface[13] represents a Hibernate session, i.e., the main point of the manipulation performed on the database entities. The latter activities include (among the other things) managing the persistence state (transient, persisted, detached[clarification needed]) of the objects, fetching the persisted ones from the database and the management of the transaction demarcation[clarification needed].

A

Session

is intended to last as long as the logical transaction on the database. Due to the latter feature,

Session

implementations are not expected to be thread safe nor to be used by multiple clients.

Grzegorz Gajos

Grzegorz is a software architect with an international consulting & programming background, & a co-founder for Open Tangerine software house

Imagine that you are a Java developer, and you’re about to start your next big project. You need to make the fundamental decisions that will stick with you for the rest of the project. You want to pick the best object-oriented abstraction of your flexible data model because you do not want to deal with plain SQL. You want to support all kinds of data, and ideally, support all sorts of databases.

The obvious answer is to just use Hibernate, right? 90% of Java developers would agree with you, but does that make it the right decision?

Let’s take a look at what can go wrong if you blindly use Hibernate just because it’s the accepted standard.

Consider Monica, a Java developer. Monica has recently been promoted to the role of architect and is now responsible for laying out the technology stack for a new product at her company. She knows that in the Java world there is only one good tool for handling database communication: Hibernate. Hibernate is a well known and supported JPA standard. However, it is always a good idea to check a few things before starting a project. Fortunately, her colleague, Ben, knows the right guy.

Hibernate Framework là gì?

ORM

Như chúng ta đã biết, ORM (Object Relational Mapping) framework là một cơ chế cho phép người lập trình thao tác với database một cách hoàn toàn tự nhiên thông qua các đối tượng. Lập trình viên hoàn toàn không quan tâm đến loại database sử dụng SQL Server, MySQL, PostgreSQL, …

ORM giúp đơn giản hoá việc tạo ra dữ liệu, thao tác dữ liệu và truy cập dữ liệu. Đó là một kỹ thuật lập trình để ánh xạ đối tượng vào dữ liệu được lưu trữ trong cơ sở dữ liệu.

Peristence layer

Một ứng dụng có thể được chia làm 3 phần như sau: giao diện người dùng (presentation layer), phần xử lý nghiệp vụ (business layer) và phần chứa dữ liệu (data layer). Cụ thể ra, business layer có thể được chia nhỏ thành 2 layer con là business logic layer và persistence layer.

• Business logic layer: các tính toán logic nhằm thỏa mãn yêu cầu người dùng.
• Persistence layer: chịu trách nhiệm giao tiếp với data layer (thường là một hệ quản trị cơ sở dữ liệu quan hệ – Relational DBMS). Persistence sẽ đảm nhiệm các nhiệm vụ mở kết nối, truy xuất và lưu trữ dữ liệu vào các Relational DBMS.

Hibernate

Hibernate là một trong những ORM Framework. Hibernate framework là một framework cho persistence layer. Như vậy, nhờ có Hibernate framework mà giờ đây khi bạn phát triển ứng dụng bạn chỉ còn chú tâm vào những layer khác mà không phải bận tâm nhiều về persistence layer nữa.

Hibernate giúp lập trình viên viết ứng dụng Java có thể map các object (POJO) với hệ quản trị cơ sở dữ liệu quan hệ (database), và hỗ trợ thực hiện các khái niệm lập trình hướng đối tượng với cơ dữ liệu quan hệ.

Hibernate giúp lưu trữ và truy vấn dữ liệu quan hệ mạnh mẽ và nhanh. Hibernate cho phép bạn truy vẫn dữ liệu thông qua Java Persistence API (JPA) hoặc bằng ngôn ngữ SQL mở rộng của Hibernate (HQL) hoặc bằng SQL thuần (Native SQL).

Hibernate vốn là một thư viện sinh ra để làm việc với mọi loại database, nó không phụ thuộc vào bạn chọn loại database nào. Nếu Java là “Viết 1 lần chạy mọi nơi” thì Hibernate là “Viết 1 lần chạy trên mọi loại database”.

Lợi ích của Hibernate Framework

Hibernate Framework có các lợi ích như dưới đây:

• Mã nguồn mở và nhẹ: Hibernate Framework là mã nguồn mở có giấy phép LGPL và nhẹ.
• Hiệu suất nhanh: Hiệu suất của Hibernate Framework là nhanh bởi vì bộ nhớ cache được sử dụng trong nội bộ Hibernate Framework. Có hai loại bộ nhớ cache trong Hibernate Framework, gồm bộ nhớ cache cấp một (first level cache) và bộ nhớ cache cấp hai (second level cache). Bộ nhớ cache cấp một được enable mặc định.
• Truy vấn cơ sở dữ liệu độc lập: HQL (Hibernate Query Language) là phiên bản hướng đối tượng của SQL. Nó tạo ra các truy vấn cơ sở dữ liệu độc lập. Vì vậy, bạn không cần phải viết các truy vấn cơ sở dữ liệu cụ thể. Trước Hibernate, nếu dự án có cơ sở dữ liệu bị thay đổi, chúng ta cần phải thay đổi truy vấn SQL dẫn đến risk và dễ gây lỗi.
• Tạo bảng tự động: Hibernate framework cung cấp phương tiện để tạo ra các bảng cơ sở dữ liệu một cách tự động. Vì vậy, không cần phải tốn công sức tạo ra các bảng trong cơ sở dữ liệu thủ công.
• Đơn giản lệnh join phức tạp: Có thể lấy dữ liệu từ nhiều bảng một cách dễ dàng với Hibernate framework.
• Cung cấp thống kê truy vấn và trạng thái cơ sở dữ liệu: Hibernate hỗ trợ bộ nhớ cache truy vấn và cung cấp số liệu thống kê về truy vấn và trạng thái cơ sở dữ liệu.

Database

Hibernate hỗ trợ hầu hết tất cả RDBMS chính, chẳng hạn: Oracle, Microsoft SQL Server, PostgreSQL, MySQL, …

Application programming interface[edit]

The Hibernate API is provided in the Java package

org.hibernate

.[12]

org.hibernate.SessionFactory interface[edit]

The

org.hibernate.SessionFactory

interface is the native equivalent version of the JPA’s standard

EntityManagerFactory

.[2]: 26

org.hibernate.Session interface[edit]

The

org.hibernate.Session

interface[13] represents a Hibernate session, i.e., the main point of the manipulation performed on the database entities. The latter activities include (among the other things) managing the persistence state (transient, persisted, detached[clarification needed]) of the objects, fetching the persisted ones from the database and the management of the transaction demarcation[clarification needed].

A

Session

is intended to last as long as the logical transaction on the database. Due to the latter feature,

Session

implementations are not expected to be thread safe nor to be used by multiple clients.

Giới thiệu về Hibernate

Hibernate ra đời năm 2001 bởi nhà sáng lập Gavin King như một sự thay thế cho EJB2 kiểu thực thể bean. Hiện nay, phiên bản mới nhất của Hibernate là 5.2.10.Final. Seri bài hướng dẫn học Hibernate này cung cấp các khái niệm về Hibernate Framework cùng với các ví dụ đơn giản và nâng cao. Seri bài học này rất hữu ích cho người mới bắt đầu và những người đã có kinh nghiệm.

Entities and components[edit]

In Hibernate jargon, an entity is a stand-alone object in Hibernate’s persistent mechanism which can be manipulated independently of other objects.[2]: 62–74 In contrast, a component is subordinate to an entity and can be manipulated only with respect to that entity. For example, an Album object may represent an entity; but the Tracks object associated with the Album objects would represent a component of the Album entity, if it is assumed that Tracks can only be saved or retrieved from the database through the Album object. Unlike J2EE, Hibernate can switch databases.

Hibernate Advantages

Here are the advantages of Hibernate:

• Hibernate map Java classes to database tables using XML files.
• It provides APIs for storing and retrieving Java objects directly from the database.
• If there is a change in the database, then we just need to change the XML file properties.
• Abstracts out the unknown SQL types and provides a way to work around standard Java Objects.
• It does not require an application server to operate.
• Manipulates Complex relationships of objects in the database.
• Minimizes database access with smart fetching strategies.
• Simple querying of data.

What is JDBC?

JDBC (Java Database Connectivity) provides a set of Java APIs to access the relational databases from the Java program. Java APIs enable programs to execute SQL statements and interact with any SQL database.

JDBC gives a flexible architecture to write a database-independent web application that can execute on different platforms and interact with different DBMS without any change.

Giving Up On Hibernate

Monica – John, I thought we were entering a new era of software development. I thought we were doing a light-year’s jump. But, after four years, it seems like we are still dealing with all the same problems, only from a different angle. I had to learn Hibernate architecture, configuration, logging, naming strategies, tuplizers, entity name resolvers, enhanced identifier generators, identifier generator optimization, union-subclasses, XDoclet markup, bidirectional associations with indexed collections, ternary associations, idbag, mixing implicit polymorphism with other inheritance mappings, replicating object between two different datastores, detached objects and automatic versioning, connection release modes, stateless session interface, taxonomy of collection persistence, cache levels, lazy or eager fetching and many, many more. Even with everything I know, it seems like we’ve failed badly. It’s a software fiasco! Ultimate failure! Disaster! Armageddon!

John – Wait! What happened?

Monica – We’ve reached a dead end. Our application performance is ridiculously slow! To get a report, we have to wait two days! Two days to actually generate a dashboard for a customer. It means every day we have to increase our calculation tail, while our dashboard gets more and more outdated. Our DBA expert has been working two months to optimize some queries, while our database structure is a complete mess. There are developers supporting him, but the problem is the DBA is thinking in SQL, and the developers are spending days trying to translate this into detached criteria or HQL format. We are trying to use native SQL as much as possible since performance is crucial at the moment. Anyway, we can’t do much since the database schema just seems to be wrong. It felt right from the object-oriented perspective, but it seems ridiculous from the relational one. I’m asking myself: How has this happened? The developers are telling us changing the entities structure is going to be a massive effort, so we can’t afford that. I remember in the previous project it was a mess, but we never wound up at such a critical point. We were able to write an entirely different application to work with the data. Now, it’s risky to modify those generated tables since it’s really hard to make sure the entity model will always behave properly. And this isn’t even the worst part! To increase performance, we have to solve not only database issues, but also issues with the entire layer between our database and the application. It’s overwhelming! We have these new guys, you know, consultants. They are trying to extract data, put it into some other storage and then perform calculations from the outside. It’s all taking too much time!

John – I don’t know what to say.

Monica – You see John; I don’t want to blame you. I picked Hibernate to solve all these problems, but now I’ve learned it’s not a silver bullet. The damage has been done, and it’s irreversible. Actually, I would like to ask you something: I spent the last four years of my career dealing with Hibernate stuff. It seems I do not have a future at my current company. Can you help me?

Database được hỗ trợ

Hibernate hỗ trợ hầu hết tất cả RDBMS chính. Dưới đây là danh sách vài cơ sở dữ liệu quan hệ được hỗ trợ bởi Hibernate.

• HSQL Database Engine
• DB2/NT
• MySQL
• PostgreSQL
• FrontBase
• Oracle
• Microsoft SQL Server Database
• Sybase SQL Server
• Informix Dynamic Server

Hibernate Query Language (HQL)[edit]

Hibernate provides a SQL inspired language called Hibernate Query Language (HQL) for writing SQL-like queries against Hibernate’s data objects. Criteria Queries are provided as an object-oriented alternative to HQL. Criteria Query is used to modify the objects and provide the restriction for the objects.[2]: 347–349 HQL (Hibernate Query Language) is the object-oriented version of SQL. It generates database independent queries so that there is no need to write database-specific queries. Without this capability, changing the database would require individual SQL queries to be changed as well, leading to maintenance issues.

Nên dùng Hibernate để thay thế JDBC hay không?

Câu trả lời cho câu hỏi này là có. Với Hibernate, chúng ta có thể làm được nhiều thứ hơn rất nhiều.

– Object mapping: thay vì việc phải map các thuộc tính trong bảng với Java object một cách thủ công thì Hibernate sẽ hỗ trợ chúng ta mapping một cách tự động trông qua các file cấu hình resource mapping xml hoặc các annotation có thể cấu hình trong class.


@Entity @Table(name = "role") public class Role implements Serializable{ @Id private String id; @Column(name = "name") private String name; ... }


– HQL: Hibernate cung cấp các câu lệnh truy vấn tương tự SQL, HQL của Hibernate hỗ trợ đầy đủ các truy vấn đa hình như, HQL “hiểu” các khái niệm như kế thừa (inheritance), đa hình (polymorphism), và liên kết (association).

– Database Independent: Code sử dụng Hibernate là độc lập với hệ quản trị cơ sở dữ liệu, nghĩa là ta không cần thay đổi câu lệnh HQL khi ta chuyển từ hệ quản trị CSDL MySQL sang Oracle, hay các hệ quản trị CSDL khác… Do đó rất dễ để ta thay đổi CSDL quan hệ, đơn giản bằng cách thay đổi thông tin cấu hình hệ quản trị CSDL trong file cấu hình:

//used MySQL

com.mysql.jdbc.Driver

// used Oracle

oracle.jdbc.driver.OracleDriver

– Lazy Loading: Với những ứng dụng Java làm việc với cơ sở dữ liệu lớn hàng trăm triệu bản ghi, việc có sử dụng Lazy loading trong truy xuất dữ liệu từ database mang lại lợi ích rất lớn.

– Quản lý commit/ rollback Transaction: Transaction là nhóm các hoạt động (với database) của một tác vụ. Nếu một hoạt động không thành công thì toàn bộ tác vụ không thành.công. Với JDBC lập trình viên phải chủ động thực hiện commit khi toàn bộ hoạt động của tác vụ thành công, hay phải rollback khi có một hoạt động không thành công để kết thúc tác vụ. Với Hibernate thì ta không cần quan tâm đến commit hay rollback, Hibernate đã quản lý nó giúp ta rồi.

– Hibernate Caching: Hibernate cung cấp một cơ chế bộ nhớ đệm, giúp giảm số lần truy cập vào database của ứng dụng càng nhiều càng tốt. Điều này sẽ có tác dụng tăng performance đáng kể cho ứng dụng của bạn.

Conclusion

In this blog, we discussed the two popular topics i.e., JPA and Hibernate in Java; one is a specification, and the other is an implementation. Several differences have been highlighted between Hibernate vs JPA. They have reduced the workload of Java developers with its several features. Both can be used as per their correct usage for developing any java application conveniently. They have turned down the gap between java objects and relational databases.

Kiến trúc của Hibernate trong Java

Kiến trúc Hibernate bao gồm nhiều đối tượng như đối tượng persistent, session factory, transaction factory, connection factory, session, transaction, …

2.Persistence object

Chính là các POJO object map với các table tương ứng của cơ sở dữ liệu quan hệ.

2.Configuration

Là đối tượng đầu tiên và duy nhất bạn cần tạo trong một chương trình có sử dụng Hibernate. Nó đại diện cho thông tin cấu hình hoặc thuộc tính yêu cầu của Hibernate. Đối tượng này sẽ cung cấp cho chúng ta hai thành phần chính:

– Database Connection: Thao tác này được xử lý thông qua một hoặc nhiều tệp cấu hình được Hibernate hỗ trợ. Các tệp này là hibernate.properties và hibernate.cfg.xml.

– Class mapping: Tạo ra kết nối giữa các lớp Java và các bảng trong cơ sở dữ liệu

>>> Xem thêm bài viết:

– Khai báo và sử dụng mảng các đối tượng trong Java

– Phân biệt ArrayList, Set và Vector trong Java

– Lập trình đa luồng là gì? Hướng dẫn lập trình đa luồng bằng ngôn ngữ Java

2.Session Factory

Là một interface giúp tạo ra session kết nối đến database bằng cách đọc các cấu hình trong Hibernate configuration.

SessionFactory là đối tượng nặng (heavy weight object) nên thường nó được tạo ra trong quá trình khởi động ứng dụng và lưu giữ để sử dụng sau này.

SessionFactory là một đối tượng luồng an toàn (Thread-safe) và được sử dụng bởi tất cả các luồng của một ứng dụng.

Mỗi một database phải có một SessionFactory. Vì vậy, nếu bạn đang sử dụng nhiều cơ sở dữ liệu thì bạn sẽ phải tạo nhiều đối tượng SessionFactory. Giả sử ta sử dụng MySQL và Oracle cho ứng dụng Java của mình thì ta cần có một SessionFactory cho MySQL, và một SessionFactory cho Oracle.

2.Hibernate Session

Một session được sử dụng để có được một kết nối vật lý với một cơ sở dữ liệu. Đối tượng Session là nhẹ và được thiết kế để được tạo ra instance mỗi khi tương tác với cơ sở dữ liệu. Các đối tượng liên tục được lưu và truy xuất thông qua một đối tượng Session.

Các đối tượng Session không nên được mở trong một thời gian dài bởi vì chúng thường không phải là luồng an toàn (thread-unsafe) và chúng cần được tạo ra và được đóng khi cần thiết.

Mỗi một đối tượng Session được SessionFactory tạo ra sẽ tạo một kết nối đến database.

2.Transaction

Một Transaction đại diện cho một đơn vị làm việc với cơ sở dữ liệu và hầu hết các RDBMS hỗ trợ chức năng transaction. Các transaction trong Hibernate được xử lý bởi trình quản lý transaction (từ JDBC hoặc JTA).

Transaction đảm bảo tính toàn vẹn của phiên làm việc với cơ sở dữ liệu. Tức là nếu có một lỗi xảy ra trong transaction thì tất cả các tác vụ thực hiện sẽ thất bại.

Transaction là một đối tượng tùy chọn và các ứng dụng Hibernate có thể chọn không sử dụng interface này, thay vào đó quản lý transaction trong code ứng dụng riêng.

2.Query

Các đối tượng Query sử dụng chuỗi truy vấn SQL (Native SQL) hoặc Hibernate Query Language (HQL) để lấy dữ liệu từ cơ sở dữ liệu và tạo các đối tượng.

2.Criteria

Đối tượng Criteria được sử dụng để tạo và thực hiện các tiêu chí truy vấn để lấy các đối tượng từ database.

Mapping[edit]

The mapping of Java classes to database tables is implemented by the configuration of an XML file or by using Java Annotations. When using an XML file, Hibernate can generate skeleton source code for the persistence classes. This is auxiliary when annotations are used. Hibernate can use the XML file or the Java annotations to maintain the database schema.

There are provided facilities to arrange one-to-many and many-to-many relationships between classes.[2]: 140–171 In addition to managing associations between objects, Hibernate can also manage reflexive associations wherein an object has a one-to-many relationship with other instances of the class type.

Hibernate supports the mapping of custom value types. This makes the following scenarios possible:

• Overriding the default SQL type when mapping a column to a property.
• Mapping Java Enums to columns as though they were regular properties.[2]: 89–90
• Mapping a single property to multiple columns.

Definition: Objects in an object-oriented application follow OOP principles, while objects in the back-end follow database normalization principles, resulting in different representation requirements. This problem is called “object–relational impedance mismatch”. Mapping is a way of resolving the object–relational impedance mismatch problem.

Mapping informs the ORM tool of what Java class object to store in which database table.

Bibliography[edit]

• Linwood, Ananda; Minter, Dave (May 28, 2010), Beginning Hibernate (Second ed.), Apress, p. 400, ISBN 978-1-4302-2850-9, archived from the original on December 5, 2010, retrieved September 4, 2010
• Bernard, Emmanuel; Griffin, John (December 30, 2008), Hibernate Search in Action (First ed.), Manning Publications, p. 488, ISBN 978-1-933988-64-1
• Elliott, James; O’Brien, Tim (April 22, 2008), Harnessing Hibernate (First ed.), O’Reilly Media, p. 380, ISBN 978-0-596-51772-4
• Bauer, Christian; King, Gavin; Gregory, Gary (November 8, 2015). Java Persistence with Hibernate. Manning Publications. ISBN 1-61729-045-9.
• Linwood, Jeff; Minter, Dave (August 25, 2006), Beginning Hibernate: From Novice to Professional (Third ed.), Apress, p. 360, ISBN 1-59059-693-5, archived from the original on December 24, 2010, retrieved April 24, 2009
• Minter, Dave; Linwood, Jeff (June 27, 2005), Pro Hibernate 3 (First ed.), Apress, pp. 242, ISBN 1-59059-511-4
• Iverson, Will (December 2, 2004), Hibernate: A J2EE Developer’s Guide (First ed.), Addison Wesley, pp. 384, ISBN 0-321-26819-9
• Pugh, Eric; Gradecki, Joseph D. (October 8, 2004), Professional Hibernate (Programmer to Programmer) (First ed.), Wrox, p. 456, ISBN 0-7645-7677-1, archived from the original on April 4, 2009, retrieved April 26, 2009
• Bauer, Christian; King, Gavin (August 1, 2004), Hibernate In Action (Second ed.), Manning Publications, pp. 400, ISBN 1-932394-15-X
• James, Elliott (May 10, 2004), Hibernate: A Developer’s Notebook (First ed.), O’Reilly Media, pp. 190, ISBN 0-596-00696-9

How Hibernate Almost Ruined My Career

Are you building the next big thing? Planning to become the next Facebook or Google? Are you at the point of making fundamental decisions that will stay with you for the entire project? There is a good chance that you will pick a robust language like Java. If so, you want to pick the best object-oriented abstraction of your flexible data model because you don’t want to deal with plain SQL. You want to support all kinds of data and ideally, support all kind of databases. If so, there’s only one right choice for you: Hibernate.

Freelance Software Engineer Grzegorz Gajos explores some possible scenarios where things can go wrong using Hibernate.

Are you building the next big thing? Planning to become the next Facebook or Google? Are you at the point of making fundamental decisions that will stay with you for the entire project? There is a good chance that you will pick a robust language like Java. If so, you want to pick the best object-oriented abstraction of your flexible data model because you don’t want to deal with plain SQL. You want to support all kinds of data and ideally, support all kind of databases. If so, there’s only one right choice for you: Hibernate.

Freelance Software Engineer Grzegorz Gajos explores some possible scenarios where things can go wrong using Hibernate.

FAQs

Q: Can we use JPA without Hibernate?A: JPA can be used without a JPA provider aka Hibernate, EclipseLink, and so on only if the application server has already a JPA implementation.

Q: Is JPA an ORM?A: JPA is considered a standard approach for ORM. It is a specification of Java that is used to access, manage, and persist data between Java objects and relational databases.

Q: What is the JPQL?A: JPQL is the Java Persistence query language defined in the JPA specification. It is used to construct the queries.

Q: What is Session in Hibernate?A: A session is an object that maintains the connection between the Java object application and the database. Session also has methods for storing, retrieving, modifying or deleting data from databases69 using methods like persist(), load(), get(), update(), delete(), etc. Additionally, It has factory methods to return Query, Criteria, and Transaction objects.

Q: Name some of the important interfaces of Hibernate framework.A: Hibernate interfaces are: SessionFactory (org.hibernate.SessionFactory), Session (org.hibernate.Session), Transaction (org.hibernate.Transaction)

Q: What do you mean by Hibernate Configuration File?A: Hibernate Configuration File mainly contains database-specific configurations and is used to initialize SessionFactory. Some important parts of the Hibernate Configuration File are Dialect information, so that hibernate knows the database type and mapping file or class details.

Q: What is the role of the EntityManager in JPA?A: An entity manager is responsible for the following roles in JPA.

• The entity manager has the role of managing an object referenced by an entity.
• It implements the API and encapsulates all of them within a single interface.
• It is used for operations like reading, deleting, and writing an entity.

Q: What type of objects can be stored in the JPA collections mapping?A: Following are the type of objects that JPA allows to store: –

• Basic Types
• Entities
• Embeddable

Sử dụng Framework Hibernate trong Java Web Application

Bài đăng này đã không được cập nhật trong 2 năm

Hibernate Framework

Framework trong phần mềm là một khái niệm dùng để chỉ những “cấu trúc dùng để hỗ trợ đã được định nghĩa sẵn” mà trong đó những dự án phần mềm khác có thể sử dung nó để phát triển. Một framework bao gồm những program hỗ trợ, core library và một ngôn ngữ lập trình để giúp phát triển và gắn những thành phần khác nhau ứng dụng phần mềm lại với nhau. Hibernate là một trong những ORM Framework. Hibernate framework là một framework cho persistence layer. Như vậy sử dụng Hibernate framework giúp bạn phát triển ứng dụng nhanh và chỉ còn chú tâm vào những layer khác mà không cần chú tâm nhiều đến persistence layer nữa. Hibernate giúp lưu trữ và truy vấn dữ liệu quan hệ mạnh mẽ và nhanh. Hibernate cho phép bạn truy vẫn dữ liệu bằng ngôn ngữ SQL mở rộng của Hibernate (HQL) hoặc bằng SQL thuần.


Trong bài viết này tôi sẽ hướng dẫn các bạn làm quen với framework Hibernate qua những thao tác đơn giản. Hibernate cung cấp công cụ object relational mapping ORM như đã nói ở trên nên trong bài viết này tôi sẽ sử dụng luôn thế mạnh của framework này kết hợp cùng "JSF managed bean" và "JSF 2.x pages" để hiển lấy về dữ liệu và hiển thị ra giao diện web application.


Công cụ và môi trường phát triển

Trong bài viết này tôi sử dụng môi trường window 8.1 và cài đặt những IDE hỗ trợ sau:

• Java SE Development Kit 8u71
• Netbean IDE 8.1
• XamPP 5.6.15 – For Mysql Version 5.x
• GlassFish Server 4.1.1 – Nên chọn Netbean có sẵn server này (hoặc có thể dùng Jboss, Apache Tomcat…)

Các bạn có thể dùng các hệ quản trị cơ sử dữ liệu khác như Oracle DB, Sql Server … IDE để soạn thảo code thì có thể dùng những lựa chọn khác như eclip, IntelliJ IDEA … mỗi editor tool đều có sự khác biệt một chút nhưng đa phần đều support Hibernate.

Tạo mới một database

Trong bài viết này tối sẽ sử dụng luôn IDE netbean để tạo mới và thao tác với database. Để tạo một database các vào tab

Services

click chuột phải vào connection và chọn

Create Datatbase...


ở đây tôi lấy tên database là

liem_report_db

các bạn có thể thay đổi tùy theo ý thích

Bây giờ chúng ta sẽ tạo ra một table có với tên là

User

ở đây là table demo nên tôi chỉ tạo ít field, các bạn có thể tùy biến để phù hợp với yêu cầu công việc

như vậy là chúng ta đã có table

User

nhưng chưa có dữ liệu nên chúng ta sẽ thêm môt ít dữ liệu demo. Để thực hiện câu lệnh query luôn trên IDE thì chúng ta click chuột phải vào connect và chọn

Execute Command...


Test dữ liệu vừa thêm vào


Select * from User;


Và chúng ta có kết quả:

Lưu ý: những bước ở trên mục đích là để tạo một database và thiết lập dữ liệu trong đó để sử dụng sau này, nếu bạn đã có database rồi thì không cần phải thực hiện loại. Tên database, tables, fields có thể tùy biến theo ý thích.

Tạo mới một project Web Application

Để tạo mới một project trong Netbean khá dễ bạn chỉ cần thao tác theo những bước sau:

1. Trên thanh Menu bạn chọn
   
File

   >
   
New Project

   (sử dung phím tắt Ctrl-Shift-N). Ở phần
   
Category

   bạn chọn loại ứng dụng muốn tạo là
   
Web Application

   sau đó click vào nút
   
Next

   .

Ở bước này tôi sẽ yêu cầu chọn

Server

để

Run

project ở đây tôi chọn luôn server

Glass Server 4.1.1

đi kèm sẵn trong bản Netbean. Các bạn có thể chọn server khác.

Đến bước này khá quan trọng, các bạn chọn

JavaServer Faces

và

Hibernate 4.3.1

có thể version sẽ khác đi, tùy thuộc vào version của bản framework bạn bạn tích hợp vào Netbean

Sau đó click vào button

Finish

. Thế là chúng ta đã tạo ra một project được import các library của Hibernate và JSF (JavaServer Faces)

Hệ thống sẽ tự động sinh ra cho chúng ta một file có tên

hibernate.cfg.xml

nằm trong

Source Packages

> giờ chúng ta sẽ thêm một số config cho nó như sau:

org.hibernate.dialect.MySQLDialect com.mysql.jdbc.Driver jdbc:mysql://localhost:3306/liem_report_db root true thread org.hibernate.hql.internal.classic.ClassicQueryTranslatorFactory

nếu các bạn để ý thì đây là những

property

cung cấp thông tin connection, việc này sẽ giúp cho Hibernate có thể thao tác với database của chúng ta.
Thẻ cuối cùng hơi đặc biệt một chút

org.hibernate.hql.internal.classic.ClassicQueryTranslatorFactory

ở đây chúng ta khai báo class sẽ xử lý genarate ra câu lệnh sql. Trong bản Hibernate 4 tôi sử dụng đường dẫn package như vây, nếu bạn sử dụng bản khác (thấp hơn) thì thay đổi đường dẫn tương ứng

Tạo mới một class HibernateUtil.java

Để tạo mới một Hibernate Util class chúng ta thao tác như sau:

1. Chuột phải vào
   
Source Packages

   chọn
   
New

   >
   
Other

   để mở cửa sổ
   
New File wizard

   .
2. Chọn
   
Hibernate

   từ list danh mục và ở khung đối diện
   
File Types

   ta chọn
   
HibernateUtil.java

   . Sau đó click vào button
   
Next

   . Type HibernateUtil for the class name and dvdrental for the package. Click Finish.

Nhập vào tên cho class bạn muốn tạo. Ở đây tôi đặt tên là

HibernateUtil

cho dễ nhớ và chọn

Package

là

app

bạn có thể tùy biến tên class và package.

Tiếp theo chúng ta sẽ tạo một file

Hibernate Reverse Engineering

mục đích là để phục vụ cho việc mapping dữ liệu

Sau đó click vào button

Next

và chúng ta thấy hiện ra table có tên

user

như hình dưới:

Đây chính là tên table tôi tạo lúc đầu trong database, nếu các bạn tạo table khác thì tên nó sẽ hiện ra trong đó. Chúng ta chọn table và nhấn vào button

Add

move sang khung

Selected Table

sau đó chúng ta click button

Finish


Hibernate Mapping Files and POJOs

Bây giờ chúng ta sẽ sử dụng Hibernate Mapping Files and POJOs để generate file từ table

user

đã chọn ở trước đó. Chúng ta thực hiện như sau:

1. Chuột phải vào
   
Source Packages

   chọn
   
New

   >
   
Other

   để mở
   
New File wizard

   .
2. Sau đó chúng ta chọn
   
Hibernate

   ở khung bên cạnh chọn
   
Hibernate Mapping Files and POJOs from Database

   sau đó click vào button
   
Next

   .
3. Trong dropdown list chọn file cấu hình
   
hibernate.cfg.xml

   và
   
hibernate.reveng.xml

4. Check vào
   
JDK 5 Language Features

5. Check vào
   
Domain Code

   và
   
Hibernate XML Mappings

   để hệ thống nhận biết định dạng cần thiết để generate code.
6. Đặt tên cho
   
Package name

   tôi chọn là
   
app

   . Sau đó click vào button
   
Finish

   .

Ở công đoạn này nhiều người thường hay gặp phải message thông báo lỗi như hình dưới:

Nguyên nhân là do hệ thống không tìm được class

ClassicQueryTranslatorFactory

mà bạn đã cung cấp ở file cấu hình của Hibernate. Hãy kiểm tra lại version của hibernate và chỉnh sửa lại package cho đúng ở thuộc tính

org.hibernate.hql.internal.classic.ClassicQueryTranslatorFactory

Lưu ý: để nhanh chóng check xem đường dẫn đã đúng hay chưa bạn chỉ cần tạo mới một Class và import đường dẫn đó vào, nếu không tồn tại IDE sẽ báo đỏ, còn không thì đường dẫn là hợp lệ

Sau đó ta click vào

Finish

. Hệ thống sẽ tự động sinh ra 2 file mới trong app package đó là

User.java

và

User.hbm.xml


Class User đã có sẵn các field và được mapping thành các property dễ dàng cho việc thao tác sau này.

User.hbm.xml

chứa thông tin mapping với user table:
File: User.java


import java.util.Date; /** * User generated by hbm2java */ public class User implements java.io.Serializable { private int id; private String firstName; private String lastName; private String username; private String password; private Date created; public User() { } public User(int id, String username) { this.id = id; this.username = username; } public User(int id, String firstName, String lastName, String username, String password, Date created) { this.id = id; this.firstName = firstName; this.lastName = lastName; this.username = username; this.password = password; this.created = created; } public int getId() { return this.id; } public void setId(int id) { this.id = id; } public String getFirstName() { return this.firstName; } public void setFirstName(String firstName) { this.firstName = firstName; } public String getLastName() { return this.lastName; } public void setLastName(String lastName) { this.lastName = lastName; } public String getUsername() { return this.username; } public void setUsername(String username) { this.username = username; } public String getPassword() { return this.password; } public void setPassword(String password) { this.password = password; } public Date getCreated() { return this.created; } public void setCreated(Date created) { this.created = created; } }


File: User.hbm.xml

Test query với HQL Query

Hibernate hỗ trợ thực thi HQL query để phục vụ cho việc truy xuất dữ liệu trong quá trình phát triển, bước này để test xem việc config, dữ liệu để connect tới db, mapping data đã thành công hay chưa:
Chuột phải vào file

hibernate.cfg.xml

chọn

Run HQL Query

để mở cửa sổ

HQL Query

sau đó ta thực hiện câu lệnh truy vấn


from User


Và được kết quả như trong ảnh, nếu không hiện ra hoặc báo

Generate erro

thì bạn kiểm tra lại file cấu hình của hibernate

Tạo mới class UserHelper.java

Chúng ta tạo chuột phải vào

app

package để create một class tên có thể tùy biến, ở đây tôi đặt là

UserHelper

cho dễ nhớ:


/* * To change this license header, choose License Headers in Project Properties. * To change this template file, choose Tools | Templates * and open the template in the editor. */ package app; /** * * @author DUYLIEMPRO */ public class UserHelper { public UserHelper() { } }


Sau đó viết thêm các method để lấy dữ liệu ra:


/* * To change this license header, choose License Headers in Project Properties. * To change this template file, choose Tools | Templates * and open the template in the editor. */ package app; import java.util.ArrayList; import java.util.List; import org.hibernate.Query; import org.hibernate.Session; /** * * @author DUYLIEMPRO */ public class UserHelper { Session session = null; List

userList; public UserHelper() { this.session = HibernateUtil.getSessionFactory().getCurrentSession(); } @SuppressWarnings("unchecked") public List

getUserList() { userList = new ArrayList

(); try { org.hibernate.Transaction tx = session.beginTransaction(); Query q = session.createQuery("from User as user"); userList = (List

) q.list(); } catch (Exception e) { userList = null; e.printStackTrace(); } return userList; } public User getUserByID(int userId) { User user = null; try { org.hibernate.Transaction tx = session.beginTransaction(); Query q = session.createQuery("from User as user where user.id=" + userId); user = (User) q.uniqueResult(); } catch (Exception e) { e.printStackTrace(); } return user; } }






Tạo mới JSF Managed Bean

Bước này mục đích là tạo ra bean class để lấy dữ liệu fill ra file view. Để tạo một bean class các bạn thực hiện như sau:

1. Chuột phải vào
   
source package

   chọn
   
New

   >
   
Other

   .
2. Chọn
   
JSF Managed Bean

   trong danh mục
   
JavaServer Faces

   . Sau đó click
   
Next

   .
3. Nhập tên bean class
   
UserController

   .
4. Nhập tên package là
   
app

5. Nhập
   
UserController

   cho ô
   
name

   sau này sẽ được sử dụng gọi ở file view (managed bean) 6 Thiết lập
   
Scope

   là
   
Session

   . Sau đó click vào
   
Finish

   .

File: UserController.java


/* * To change this license header, choose License Headers in Project Properties. * To change this template file, choose Tools | Templates * and open the template in the editor. */ package app; import javax.inject.Named; import javax.enterprise.context.SessionScoped; import java.io.Serializable; /** * * @author DUYLIEMPRO */ @Named(value = "userController") @SessionScoped public class UserController implements Serializable { /** * Creates a new instance of UserController */ public UserController() { } }


Chúng ta sẽ viết các method xử lý lấy dữ liệu vào class này, ở đây tôi sẽ viết ví dụ 2 method, các bạn có thể thêm tùy ý:


/* * To change this license header, choose License Headers in Project Properties. * To change this template file, choose Tools | Templates * and open the template in the editor. */ package app; import javax.inject.Named; import javax.enterprise.context.SessionScoped; import java.io.Serializable; import javax.faces.model.DataModel; import javax.faces.model.ListDataModel; /** * * @author DUYLIEMPRO */ @Named(value = "userController") @SessionScoped public class UserController implements Serializable { DataModel useList; UserHelper helper; private User current; /** * Creates a new instance of UserController */ public UserController() { helper = new UserHelper(); } public User getSelected() { if (current == null) { current = new User(); } return current; } public DataModel getUseList() { if (useList == null) { useList = new ListDataModel(helper.getUserList()); } return useList; } }


Lưu ý

Muốn sử dụng được những function này trong file view (.xhtml) thì bắt buộc chúng ta phải viết tên method theo quy ước “get” + tên method(Tên method phải viết hoa chữ cái đầu). Khi hiển thị trên file view thì tiền tố “get” tự động sẽ bị remove, chữ cái đầu trong tên method sẽ tự động chuyển sang thường.

Tạo mới file Web Pages

Ở đây tôi sẽ sử dụng template để dễ dàng hơn cho việc thiết lập layout chung cho nhiều page, để tạo một template các bạn làm như sau:

1. Chuột phải vào
   
source package

   chọn
   
New

   >
   
Other

   .
2. Chọn
   
Facelets Template

   trong danh mục
   
JavaServer Faces

   . sau đó click
   
Next

   .
3. Tôi đặt tên là
   
template

   và chọn layout style sử dụng
   
CSS

   (Table đều được).
4. Click vào button
   
Finish

   . Kết quả là chúng ta được một file: template.xhtml trong thư mục web pages





Top

Content





Tùy layout bạn chọn mà sẽ có nội dung khác nhau nhưng tất cả đều thẻ



Content



Đây là nơi mà nội dung sẽ được chèn vào khi sử dụng template này.

Khi tạo mới ứng dụng hệ thống sẽ tự động tạo mới cho ta file

index.xhtml

trong thư mục

Web Pages

chúng ta sẽ sử dụng luôn file này để hiển thị dữ liệu. Tôi sẽ sử dụng JSF lib để sử dụng layout và hiển thị dữ liệu ra:

Lưu ý


xmlns:h="http://java.sun.com/jsf/html" xmlns:ui="http://java.sun.com/jsf/facelets" xmlns:f="http://xmlns.jcp.org/jsf/core"


Đây là khai báo tên các thẻ sẽ được sẽ được sử dụng trong file view . Các bạn có thể thay đổi tên thẻ sẽ sử dụng vd: xmlns:a=”http://java.sun.com/jsf/html” và lúc dùng gọi

Run Project

1. Để chạy thử project các bạn chuột phải vào tên project chọn
   
Clean and Build

   để hệ thống compile nếu có lỗi sẽ thông báo ở cửa sổ Output dưới. 2. Sau khi build xong chúng ta chuột phải vào projec một lần nữa chọn run (Lần đầu hệ thống sẽ start
   
GlassFish Server

   nên hơi lâu một chút) nếu ok dưới cửa sổ sẽ thông báo


Incrementally deploying report Completed incremental distribution of report run-deploy: Browsing: http://localhost:8080/report run-display-browser: run: BUILD SUCCESSFUL (total time: 0 seconds)


và trình duyệt sẽ bật ra cửa sổ vối đường link: http://localhost:8080/report

Và chúng ta được kết quả như hình bên dưới:

Database file

Đây là file datbase export cho những bạn nào cần:


CREATE DATABASE `liem_report_db`; USE `liem_report_db`; CREATE TABLE `user` ( `id` int(11) NOT NULL, `first_name` varchar(50) DEFAULT NULL, `last_name` varchar(50) DEFAULT NULL, `username` varchar(20) NOT NULL, `password` varchar(32) DEFAULT NULL, `created` time DEFAULT NULL, PRIMARY KEY (`id`), UNIQUE KEY `username` (`username`) ) ENGINE=InnoDB DEFAULT CHARSET=latin1; INSERT INTO `user` VALUES ('1', 'Tran', 'Liem', 'tranducliem', '25f9e794323b453885f5181f1b624d0b', '00:00:00'); INSERT INTO `user` VALUES ('2', 'Le', 'Minh', 'levanminh', '25f9e794323b453885f5181f1b624d0b', '00:00:00'); INSERT INTO `user` VALUES ('3', 'Phan', 'Tuan', 'phanquoctuan', '25f9e794323b453885f5181f1b624d0b', '00:00:00'); INSERT INTO `user` VALUES ('4', 'Tran', 'Sang', 'tranvansang', '25f9e794323b453885f5181f1b624d0b', '00:00:00');



Bài viết có tham khảo tài liệu User Guide của [Hibernate Framework](http://hibernate.org/orm/documentation/4.2/).


Xin cảm ơn các bạn rất nhiều ! LiemTD – Framgia.

All rights reserved

Không có giới hạn nào đối với kỹ năng lập trình của bạn. Nếu thường xuyên sử dụng ngôn ngữ lập trình Java, chắc hẳn bạn đã nghe đến cái tên Hibernate. Tất nhiên chúng ta đều biết Hibernate là công cụ hỗ trợ cho các phần mềm phát triển từ Java. Tuy nhiên, bạn nên hiểu các khái niệm về Hibernate, cách nó được xây dựng và cách sử dụng nó. Bằng cách đó bạn có thể tận dụng tối đa Hibernate. Trong bài viết này, Stringee và các bạn sẽ cùng nhau tìm hiểu về Hibernate trong Java.

Kiến trúc Hibernate

Kiến trúc Hibernate bao gồm nhiều đối tượng như đối tượng persistent, session factory, transaction factory, connection factory, session, transaction, …

Persistence object

Chính là các POJO object map với các table tương ứng của cơ sở dữ liệu quan hệ. Nó như là những container chứa dữ liệu từ ứng dụng để lưu xuống database, hay chứa dữ liệu tải lên ứng dụng từ database.

Configuration

Là đối tượng Hibernate đầu tiên bạn tạo trong bất kỳ ứng dụng Hibernate nào và chỉ cần tạo một lần trong quá trình khởi tạo ứng dụng. Nó đại diện cho một tập tin cấu hình hoặc thuộc tính yêu cầu của Hibernate. Đối tượng Configuration cung cấp hai thành phần chính:

• Database Connection: Thao tác này được xử lý thông qua một hoặc nhiều tệp cấu hình được Hibernate hỗ trợ. Các tệp này là hibernate.properties và hibernate.cfg.xml.
• Class Mapping Setup: Thành phần này tạo ra kết nối giữa các lớp Java và các bảng cơ sở dữ liệu.

Session Factory

Là một interface giúp tạo ra session kết nối đến database bằng cách đọc các cấu hình trong Hibernate configuration.

SessionFactory là đối tượng nặng (heavy weight object) nên thường nó được tạo ra trong quá trình khởi động ứng dụng và lưu giữ để sử dụng sau này.

SessionFactory là một đối tượng luồng an toàn (Thread-safe) và được sử dụng bởi tất cả các luồng của một ứng dụng.

Mỗi một database phải có một session factory. Vì vậy, nếu bạn đang sử dụng nhiều cơ sở dữ liệu thì bạn sẽ phải tạo nhiều đối tượng SessionFactory. Giả sử ta sử dụng MySQL và Oracle cho ứng dụng Java của mình thì ta cần có một session factory cho MySQL, và một session factory cho Oracle.

Hibernate Session

Một session được sử dụng để có được một kết nối vật lý với một cơ sở dữ liệu. Đối tượng Session là nhẹ và được thiết kế để được tạo ra instance mỗi khi tương tác với cơ sở dữ liệu. Các đối tượng liên tục được lưu và truy xuất thông qua một đối tượng Session.

Các đối tượng Session không nên được mở trong một thời gian dài bởi vì chúng thường không phải là luồng an toàn (thread-unsafe) và chúng cần được tạo ra và được đóng khi cần thiết.

Mỗi một đối tượng session được Session factory tạo ra sẽ tạo một kết nối đến database.

Transation

Một Transaction đại diện cho một đơn vị làm việc với cơ sở dữ liệu và hầu hết các RDBMS hỗ trợ chức năng transaction. Các transaction trong Hibernate được xử lý bởi trình quản lý transaction và transaction (từ JDBC hoặc JTA).

Transaction đảm bảo tính toàn vẹn của phiên làm việc với cớ sở dữ liệu. Tức là nếu có một lỗi xảy ra trong transaction thì tất cả các tác vụ thực hiện sẽ thất bại.

Transaction là một đối tượng tùy chọn và các ứng dụng Hibernate có thể chọn không sử dụng interface này, thay vào đó quản lý transaction trong code ứng dụng riêng.

Query

Các đối tượng Query sử dụng chuỗi truy vấn SQL (Native SQL) hoặc Hibernate Query Language (HQL) để lấy dữ liệu từ cơ sở dữ liệu và tạo các đối tượng.

Criteria

Đối tượng Criteria được sử dụng để tạo và thực hiện các tiêu chí truy vấn để lấy các đối tượng từ database.

Integration[edit]

Hibernate can be used both in standalone Java applications and in Java EE applications using servlets, EJB session beans, and JBI service components. It can also be included as a feature in other programming languages. For example, Adobe integrated Hibernate into version 9 of ColdFusion (which runs on J2EE app servers) with an abstraction layer of new functions and syntax added into CFML.

Software components[edit]

The Hibernate software includes the following components:[14]

• Hibernate ORM (known as Hibernate Core before release 4.1[15]) – the base software for an object–relational mapping solution for Java environments[16]
• Hibernate Annotations (merged into Hibernate Core/ORM since version 3.6[17]) – metadata that governs the transformation of data between the object-oriented model and the relational database model according to the JSR 317 Java Persistence API (JPA 2)[18]
• Hibernate EntityManager (merged into Hibernate Core/ORM since version 5.2[19])– together with Hibernate Annotations, a wrapper that implements a JSR 317 Java Persistence API (JPA 2) persistence solution[20]
• Hibernate Envers – auditing and versioning of persistent classes[21]
• Hibernate OGM (Object/Grid Mapper) – an extension to store data in a NoSQL store[22]
• Hibernate Shards – horizontal partitioning for multiple relational databases[23]
  • While Hibernate Shards is not compatible with 4.x releases of Hibernate Core, some of the Shards capability was integrated into Core in the 4.0 release
• Hibernate Search – integrates the full text library functionality from Apache Lucene in the Hibernate and JPA model[24]
• Hibernate Tools – a set of tools implemented as a suite of Eclipse plugins and Ant tasks included in JBoss Developer Studio[25]
• Hibernate Validator – the reference implementation of JSR 303 Bean Validation[26][2]: 49–51
• Hibernate Metamodel Generator – an annotation processor that creates JSR 317 Java Persistence API (JPA 2) static metamodel classes using the JSR 269 Pluggable Annotation Processing API[27]
• NHibernate – an object–relational mapping solution for the .NET Framework[28]

Hibernate Query Language (HQL)[edit]

Hibernate provides a SQL inspired language called Hibernate Query Language (HQL) for writing SQL-like queries against Hibernate’s data objects. Criteria Queries are provided as an object-oriented alternative to HQL. Criteria Query is used to modify the objects and provide the restriction for the objects.[2]: 347–349 HQL (Hibernate Query Language) is the object-oriented version of SQL. It generates database independent queries so that there is no need to write database-specific queries. Without this capability, changing the database would require individual SQL queries to be changed as well, leading to maintenance issues.

We’re Now Hacking Together Solutions In SQL Again

Monica – John, at the beginning we weren’t going to deal with SQL, but now it seems like we have to. Our needs are growing, and it seems like there’s no way around it. It feels wrong, but we’ve started using SQL again on a daily basis.

John – Well, it’s not wrong. You didn’t have to focus on the database at the very beginning. However, as the project grows, it’s good to use SQL and work on the performance optimization.

Monica – Sometimes we spend days looking for errors. It seems like we have to analyze Hibernate-generated SQL because we have no idea why it’s not working as expected and it’s producing unexpected results. We hit some problems that are well known in the Hibernate bug tracker. Additionally, it’s hard to write proper migrations while keeping the entity model in sync. It’s time-consuming since we need to learn a lot about Hibernate internals and predict how it’ll work.

John – There’s always a learning curve. You don’t have to write much, but you do need to know how it works.

Monica – Working with bigger datasets is also annoying. Recently, we did a massive import to the database, and it was painfully slow. Then we found out that we had to clear the session to make it faster. Even so, it’s still significantly slower, so we decided to rewrite it as plain SQL statements. What’s funny is that writing plain SQL was actually the fastest way of doing it, so we decided to do it as our last option.

John – Import is not an object-oriented process. Hibernate focuses on object-oriented design. Remember that you can always use native queries.

Monica – Can you help me understand how Hibernate cache works? I just don’t get it. There are some first/second level caches. What is this all about?

John – Sure. It’s a so-called transaction-level cache of persistent data. It’s possible to configure a cluster or JVM-level cache on a class-by-class and collection-by-collection basis. You can even plug in a clustered cache. But remember that caches aren’t aware of any changes made to the persistent store by another application. They can, however, be configured to delete expired cached data regularly.

Monica – Sorry, think I’m having a bad day. Can you explain this a bit more?

John – Sure. Whenever you pass an object to

save

,

update

,

saveOrUpdate

, or retrieve it via

load

,

get

,

list

,

iterate

or

scroll

, that object is added to the internal cache of the session. You can also remove the object and its collections from the first-level cache.

Monica – Er…

John – Additionally, you can control cache modes. You can use

normal

mode to read and write items to the second-level cache. Use

get

mode to read from the second level but you can’t write back. Use

put

, which is same as

get

but you can’t read from the second level. You can also use

refresh

mode, which is going to write to the second level, but not read from it and bypass the

use minimal puts

property, forcing a refresh of the second-level cache for all items read from the database.

Monica – I see. Ok. Let me think about this. Oh, it’s late, I need to go. Thanks for your time!

John – You’re welcome!

What is JPA?

For almost every application, you need to perform database operations like storing and retrieval for handling a large amount of data. This is a tedious task that usually takes a lot of time to be done. So, to reduce the burden of interacting with databases, JPA is an excellent option for Java developers. It stands for Java Persistence API, a Java specification that provides an object mapping facility to relational databases for Java applications. It provides a mechanism for managing persistence and object-relational mapping. JPA defines these mappings internally rather than depending on vendor-specific implementations. It does not do operations by itself; instead, it uses ORM (Object Relational Mapping) tools like TopLink, Hibernate, etc.

Confused about your next job?

JPA represents how to define POJO (Plain Old Java Object) as an entity and manage it with relations using some meta configurations. They are defined either by annotations or by XML files. JPA is compatible with operating both inside and outside of Java EE (Enterprise Edition) containers; on the other hand, it is used for testing application functions for Java SE versions.

Following are the elements of JPA used for easy persistence management:

• Persistence unit
• EntityManagerFactory
• Persistence context
• EntityManager
• Entity objects

Software components[edit]

The Hibernate software includes the following components:[14]

• Hibernate ORM (known as Hibernate Core before release 4.1[15]) – the base software for an object–relational mapping solution for Java environments[16]
• Hibernate Annotations (merged into Hibernate Core/ORM since version 3.6[17]) – metadata that governs the transformation of data between the object-oriented model and the relational database model according to the JSR 317 Java Persistence API (JPA 2)[18]
• Hibernate EntityManager (merged into Hibernate Core/ORM since version 5.2[19])– together with Hibernate Annotations, a wrapper that implements a JSR 317 Java Persistence API (JPA 2) persistence solution[20]
• Hibernate Envers – auditing and versioning of persistent classes[21]
• Hibernate OGM (Object/Grid Mapper) – an extension to store data in a NoSQL store[22]
• Hibernate Shards – horizontal partitioning for multiple relational databases[23]
  • While Hibernate Shards is not compatible with 4.x releases of Hibernate Core, some of the Shards capability was integrated into Core in the 4.0 release
• Hibernate Search – integrates the full text library functionality from Apache Lucene in the Hibernate and JPA model[24]
• Hibernate Tools – a set of tools implemented as a suite of Eclipse plugins and Ant tasks included in JBoss Developer Studio[25]
• Hibernate Validator – the reference implementation of JSR 303 Bean Validation[26][2]: 49–51
• Hibernate Metamodel Generator – an annotation processor that creates JSR 317 Java Persistence API (JPA 2) static metamodel classes using the JSR 269 Pluggable Annotation Processing API[27]
• NHibernate – an object–relational mapping solution for the .NET Framework[28]

Kết

Trên đây là một số khái niệm cơ bản về Hibernate mà Stringee muốn giới thiệu đến các bạn. Trong các bài viết tiếp theo chúng ta sẽ cùng tìm hiểu cách cài đặt và sử dụng các API của Hibernate.

Stringee Communication APIs là giải pháp cung cấp các tính năng giao tiếp như gọi thoại, gọi video, tin nhắn chat, SMS hay tổng đài CSKH cho phép tích hợp trực tiếp vào ứng dụng/website của doanh nghiệp nhanh chóng. Nhờ đó giúp tiết kiệm đến 80% thời gian và chi phí cho doanh nghiệp bởi thông thường nếu tự phát triển các tính năng này có thể mất từ 1 – 3 năm.

Bộ API giao tiếp của Stringee hiện đang được tin dùng bởi các doanh nghiệp ở mọi quy mô, lĩnh vực ngành nghề như TPBank, VOVBacsi24, VNDirect, Shinhan Finance, Ahamove, Logivan, Homedy, Adavigo, bTaskee…

Quý bạn đọc quan tâm xin mời đăng ký NHẬN TƯ VẤN TẠI ĐÂY: