Hibernate Interview Questions Part 2

1.What is the difference between load() and get()?

load() vs. get() :-

load()	get()
Only use the load() method if you are sure that the object exists.	If you are not sure that the object exists, then use one of the get() methods.
load() method will throw an exception if the unique id is not found in the database.	get() method will return null if the unique id is not found in the database.
load() just returns a proxy by default and database won�t be hit until the proxy is first invoked.	get() will hit the database immediately.

2.What is the difference between and merge and update ?

Use update() if you are sure that the session does not contain an already persistent instance with the same identifier, and merge() if you want to merge your modifications at any time without consideration of the state of the session.

3.How do you define sequence generated primary key in hibernate?

Using <generator> tag.
Example:-

<id column="USER_ID" name="id" type="java.lang.Long"> 
   <generator class="sequence"> 
     <param name="table">SEQUENCE_NAME</param>
   <generator>
</id>

4.Define cascade and inverse option in one-many mapping?

cascade - enable operations to cascade to child entities.
cascade="all|none|save-update|delete|all-delete-orphan"

inverse - mark this collection as the "inverse" end of a bidirectional association.
inverse="true|false"
Essentially "inverse" indicates which end of a relationship should be ignored, so when persisting a parent who has a collection of children, should you ask the parent for its list of children, or ask the children who the parents are?

5.What do you mean by Named � SQL query?

Named SQL queries are defined in the mapping xml document and called wherever required.
Example:

<sql-query name = "empdetails">
   <return alias="emp" class="com.test.Employee"/>
      SELECT emp.EMP_ID AS {emp.empid},
                 emp.EMP_ADDRESS AS {emp.address},
                 emp.EMP_NAME AS {emp.name} 
      FROM Employee EMP WHERE emp.NAME LIKE :name
</sql-query>

Invoke Named Query :

List people = session.getNamedQuery("empdetails")
       .setString("TomBrady", name)
       .setMaxResults(50)
       .list();

6.How do you invoke Stored Procedures?

<sql-query name="selectAllEmployees_SP" callable="true">
 <return alias="emp" class="employee">
   <return-property name="empid" column="EMP_ID"/>       

   <return-property name="name" column="EMP_NAME"/>       
   <return-property name="address" column="EMP_ADDRESS"/>
    { ? = call selectAllEmployees() }
 </return>
</sql-query>

7.Explain Criteria API

Criteria is a simplified API for retrieving entities by composing Criterion objects. This is a very convenient approach for functionality like "search" screens where there is a variable number of conditions to be placed upon the result set.
Example :

List employees = session.createCriteria(Employee.class)
           .add(Restrictions.like("name", "a%") )
           .add(Restrictions.like("address", "Boston"))
    .addOrder(Order.asc("name") )
    .list();

8.Define HibernateTemplate?

org.springframework.orm.hibernate.HibernateTemplate is a helper class which provides different methods for querying/retrieving data from the database. It also converts checked HibernateExceptions into unchecked DataAccessExceptions.

9.What are the benefits does HibernateTemplate provide?

The benefits of HibernateTemplate are :

• HibernateTemplate, a Spring Template class simplifies interactions with Hibernate Session.
• Common functions are simplified to single method calls.
• Sessions are automatically closed.
• Exceptions are automatically caught and converted to runtime exceptions.

10.How do you switch between relational databases without code changes?

Using Hibernate SQL Dialects , we can switch databases. Hibernate will generate appropriate hql queries based on the dialect defined.

11.If you want to see the Hibernate generated SQL statements on console, what should we do?

In Hibernate configuration file set as follows:
<property name="show_sql">true</property>

12.What are derived properties?

The properties that are not mapped to a column, but calculated at runtime by evaluation of an expression are called derived properties. The expression can be defined using the formula attribute of the element.

13.What is component mapping in Hibernate?

• A component is an object saved as a value, not as a reference
• A component can be saved directly without needing to declare interfaces or identifier properties
• Required to define an empty constructor
• Shared references not supported

Example:

14.What is the difference between sorted and ordered collection in hibernate?

sorted collection vs. order collection :-

sorted collection	order collection
A sorted collection is sorting a collection by utilizing the sorting features provided by the Java collections framework. The sorting occurs in the memory of JVM which running Hibernate, after the data being read from database using java comparator.	Order collection is sorting a collection by specifying the order-by clause for sorting this collection when retrieval.
If your collection is not large, it will be more efficient way to sort it. source:http://www.developersbook.com/	If your collection is very large, it will be more efficient way to sort it .

Hibernate 4.3 Introduction Tutorial

An introduction to Hibernate 4

In this article I will show you how can you use Hibernate 4,  along with a simple example application available to try out what you read about.

What is Hibernate and why should I care?

Hibernate was created to leverage the connection between Java applications and relational databases because it is hard to map back and forth between a database table and a Java object.

And because Hibernate does this, it reduces development time which is consumed by JDBC query-execution and data mapping.

Getting Hibernate

To get the latest version of Hibernate, just visit this site. For this article I will use the version 4.3.10.Final.

If you download and extract the package you can see some sub-folders in the lib folder. Everything under required is required for any project using Hibernate. The other folders contain libraries for special cases. For example under jpa you find the library providing the JPA entity manager support.

Alternatively you can set up a Maven project and add Hibernate as a dependency. In this case you do not need to take care about the other required dependencies of Hibernate, which come along in the required package with the bundle-download. Using Maven is more simple and straightforward so I will use Maven as dependency management.

A simple example

In the simple example I will create a Java application which stores information about books in the database. The database will be an H2 memory database for the sake of simplicity.

Dependencies are managed with Maven and the output is an executable JAR with all dependencies.

The entity

The entity I will store in the database is the following:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

package example; public class Book {    private String isbn;    private String title;    private String author;    Book() {    }    public Book(String isbn, String title, String author) {        this.isbn = isbn;        this.title = title;        this.author = author;    }    public String getIsbn() {        return this.isbn;    }    public String getTitle() {        return this.title;    }    public void setTitle(String title) {        this.title = title;    }    public String getAuthor() {        return this.author;    }    public void setAuthor(String author) {        this.author = author;    }    public void setIsbn(String isbn) {        this.isbn = isbn;    } }

The no-argument constructor is a requirement for all persistent classes because Hibernate creates the object instances per reflection. In this case this constructor is private to prevent creation of books without information.

The dependencies

To get the app running, we need two dependencies in the project: Hibernate and H2. To do this, add the following to the pom.xml:

1 2 3 4 5 6 7 8 9 10 11 12

<dependencies> <dependency>    <groupId>org.hibernate</groupId>    <artifactId>hibernate-core</artifactId>    <version>4.3.10.Final</version> </dependency> <dependency>    <groupId>com.h2database</groupId>    <artifactId>h2</artifactId>    <version>1.4.187</version> </dependency> </dependencies>

Now we are ready to continue on.

Configuring Hibernate

Hibernate needs some configuration to get started. This you need to include in the hibernate.cfg.xml file. It is plain old XML. It contains the database connection properties and the entity mapping files inclusive location.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

<!DOCTYPE hibernate-configuration PUBLIC        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd"> <hibernate-configuration>    <session-factory>        <!-- Database connection settings -->        <property name="connection.driver_class">org.h2.Driver</property>        <property name="connection.url">jdbc:h2:mem:db1;DB_CLOSE_DELAY=-1;MVCC=TRUE</property>        <property name="connection.username">sa</property>        <property name="connection.password"/>        <!-- JDBC connection pool (use the built-in) -->        <property name="connection.pool_size">1</property>        <!-- SQL dialect -->        <property name="dialect">org.hibernate.dialect.H2Dialect</property>        <!-- Disable the second-level cache -->        <property name="cache.provider_class">org.hibernate.cache.internal.NoCacheProvider</property>        <!-- Echo all executed SQL to stdout -->        <property name="show_sql">true</property>        <!-- Drop and re-create the database schema on startup -->        <property name="hbm2ddl.auto">create</property>        <mapping resource="hibernate_example/hbm/Book.hbm.xml"/>    </session-factory> </hibernate-configuration>

The entity mapping

To map the right fields to the right column in the database, Hibernate requires a mapping file for the entities. These are located in the .hbm.xml files which start with the entity’s name. In this example Book.hbm.xml.

1 2 3 4 5 6 7 8 9 10 11 12 13

<!DOCTYPE hibernate-mapping PUBLIC      "-//Hibernate/Hibernate Mapping DTD 3.0//EN"        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> <hibernate-mapping package="hibernate_example">    <class name="Book" table="BOOKS">        <id name="isbn" type="string"/>        <property name="title"/>        <property name="author"/>    </class> </hibernate-mapping>

The main method

To use the application with Hibernate we still need an entry point — and in Java this is the main method. To start, we need some configuration, like creating a session with a session factory… So let’s look at the code how it goes:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

public class Main {    public static void main(String[] args) {        final Configuration configuration = new Configuration().configure();        final StandardServiceRegistryBuilder builder = new StandardServiceRegistryBuilder().applySettings(configuration.getProperties());        final SessionFactory factory = configuration.buildSessionFactory(builder.build());        final Session session = factory.openSession();        final Book book = new Book("93939398948 ", "Java 8", "Author");        session.beginTransaction();        session.save(book);        session.getTransaction().commit();        final List<Book> books = session.createCriteria(Book.class).list();        System.out.println("\n----\n");        System.out.println(MessageFormat.format("Storing {0} books in the database", books.size()));        for (final Book b : books) {            System.out.println(b);        }        System.out.println("\n----\n");        session.close();        factory.close();    } }

After running the application the console should have some log messages and the one book added to the database:
—-

1 2	Storing 1 books in the database Java 8 by JBT (ISBN:9393939894

—–

Conclusion

Hibernate gives a nice feature to leverage mapping between Java objects and relational databases. Naturally this sample application does not show the full power of Hibernate: for better user experience you could add a user interface to create and list books in the application.

In a later article I will show how to get rid of the XML configuration (called by some developers as the “XML-Hell”) and use annotations instead. So stay tuned.

Source:javabeginnerstutorial.co