Hibernate in Action

3,126 views

Published on

Published in: Technology
0 Comments
1 Like
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total views
3,126
On SlideShare
0
From Embeds
0
Number of Embeds
174
Actions
Shares
0
Downloads
106
Comments
0
Likes
1
Embeds 0
No embeds

No notes for slide

Hibernate in Action

  1. 1. List of Topics  What is Hibernate  JDBC, ORM  Hibernate Architecture  Configuration  Session  Mapping  Annotations  HQL  Caching  Batch processing  Interceptors  Exercise
  2. 2. What is Hibernate ?  Hibernate is a high-performance Object/Relational persistence and query service which is licensed under the open source GNU Lesser General Public License (LGPL) and is free to download. Hibernate not only takes care of the mapping from Java classes to database tables (and from Java data types to SQL data types), but also provides data query and retrieval facilities.  It officially maintained by JBoss Inc., started in 2001
  3. 3. JDBC What is JDBC?  JDBC stands for Java Database Connectivity and provides a set of Java API for accessing the relational databases from Java program. These Java APIs enables Java programs to execute SQL statements and interact with any SQL compliant database.  JDBC API standard provides Java developers to interact with different RDBMS and access table data through Java application without learning RDBMS details and using Database Specific JDBC Drivers.  JDBC Architecture When a Java application needs to access database:  open connection to database,  use JDBC driver to send SQL queries to database,  process the results that are returned, and  close the connection.
  4. 4. What is ORM ?  ORM stands for Object-Relational Mapping (ORM) is a programming technique for converting data between relational databases and object oriented programming languages such as Java, C# etc.  An ORM system has following advantages over plain JDBC S.N. Advantages 1 Lets business code access objects rather than DB tables. 2 Hides details of SQL queries from OO logic. 3 No need to deal with the database implementation. 4 Entities based on business concepts rather than database structure. 5 Transaction management 6 Fast development of application.
  5. 5. Java ORM framework There are several persistent frameworks and ORM options in Java. A persistent framework is an ORM service that stores and retrieves objects into a relational database.  Enterprise JavaBeans Entity Beans  Java Data Objects  Castor  TopLink  Spring DAO  Hibernate  And many more
  6. 6. Difference between Hibernate and JDBC JDBC Hibernate JDBC is a persistence technology Hibernate is a persistence Framework. In JDBC developer is responsible to taking and closing the connection and also write the SQL statement. In Hibernate HRS(Hibernate Runtime System) is responsible for taking the connections, creating the statement and releasing the connections. As table changed or database changed then it’s essential to change object structure as well as to change code written to map table-to-object/objectto-table. The actual mapping between tables and application objects is done in XML files. If there is change in Database or in any table then the only need to change XML file properties. Low performance and not scalable High performance and scalable it is developer’s responsibility to handle JDBC result set and convert it to Java objects through code to use this persistent data in application. Hibernate reduces lines of code by maintaining object-table mapping itself and returns result to application in form of Java objects.
  7. 7. Hibernate overview  Hibernate is an Object-Relational Mapping(ORM) solution for JAVA and it raised as an open source persistent framework created by Gavin King in 2001. It is a powerful, high performance Object-Relational Persistence and Query service for any Java Application.  Hibernate maps Java classes to database tables and from Java data types to SQL data types and relieve the developer from 95% of common data persistence related programming tasks.  Hibernate sits between traditional Java objects and database server to handle all the work in persisting those objects based on the appropriate O/R mechanisms and patterns.
  8. 8. Hibernate overview cont… Hibernate Advantages:  Hibernate takes care of mapping Java classes to database tables using XML       files and without writing any line of code. Provides simple APIs for storing and retrieving Java objects directly to and from the database. If there is change in Database or in any table then the only need to change XML file properties. Abstract away the unfamiliar SQL types and provide us to work around familiar Java Objects. Hibernate does not require an application server to operate. Manipulates Complex associations of objects of your database. Provides Simple querying of data
  9. 9. Hibernate overview cont… Supported Databases:  Hibernate supports almost all the major RDBMS. Following is list of few of the database engines supported by Hibernate.  HSQL Database Engine  DB2/NT  MySQL  PostgreSQL  FrontBase  Oracle  Microsoft SQL Server Database  Sybase SQL Server  Informix Dynamic Server
  10. 10. Hibernate Architecture  The Hibernate architecture is layered to keep you isolated from having to know the underlying APIs. Hibernate makes use of the database and configuration data to provide persistence services (and persistent objects) to the application.
  11. 11. Hibernate Architecture cont… Detailed view of the Hibernate Application Architecture with few important core classes.
  12. 12. Hibernate Architecture cont… Hibernate uses various existing Java APIs, like JDBC, Java Transaction API(JTA), and Java Naming and Directory Interface (JNDI). JDBC provides a rudimentary level of abstraction of functionality common to relational databases, allowing almost any database with a JDBC driver to be supported by Hibernate. JNDI and JTA allow Hibernate to be integrated with J2EE application servers. Following section gives brief description of each of the class objects involved in Hibernate Application Architecture.  Configuration Object: The Configuration object is the first Hibernate object you create in any Hibernate application and usually created only once during application initialization. It represents a configuration or properties file required by the Hibernate. The Configuration object provides two keys components:  Database Connection: This is handled through one or more configuration files supported by Hibernate. These files are hibernate.properties and hibernate.cfg.xml.  Class Mapping Setup This component creates the connection between the Java classes and database tables.
  13. 13. Hibernate Architecture cont…  SessionFactory Object:  Configuration object is used to create a SessionFactory object which in turn configures Hibernate for the application using the supplied configuration file and allows for a Session object to be instantiated. The SessionFactory is a thread safe object and used by all the threads of an application.  The SessionFactory is heavyweight object so usually it is created during application start up and kept for later use. You would need one SessionFactory object per database using a separate configuration file. So if you are using multiple databases then you would have to create multiple SessionFactory objects.  Session Object:  A Session is used to get a physical connection with a database. The Session object is lightweight and designed to be instantiated each time an interaction is needed with the database. Persistent objects are saved and retrieved through a Session object.  The session objects should not be kept open for a long time because they are not usually thread safe and they should be created and destroyed them as needed.
  14. 14. Hibernate Architecture cont…  Transaction Object:  A Transaction represents a UOW (unit of work) with the database and most of the RDBMS supports transaction functionality. Transactions in Hibernate are handled by an underlying transaction manager and transaction (from JDBC or JTA).  Query Object:  Query objects use SQL or Hibernate Query Language (HQL) string to retrieve data from the database and create objects. String hql = "FROM Employee"; Query query = session.createQuery(hql);  Criteria Object:  Criteria object are used to create and execute object oriented criteria queries to retrieve objects.
  15. 15. Hibernate Environment setup  Downloading Hibernate:  Download the latest version of Hibernate http://www.hibernate.org/downloads  Hibernate Prerequisites S.N. Packages/Libraries 1 dom4j - XML parsing www.dom4j.org/ 2 Xalan - XSLT Processor http://xml.apache.org/xalan-j/ 3 Xerces - The Xerces Java Parser http://xml.apache.org/xerces-j/ 4 cglib - Appropriate changes to Java classes at runtime http://cglib.sourceforge.net/ 5 log4j - Logging Framework http://logging.apache.org/log4j 6 Commons - Logging, Email etc. http://jakarta.apache.org/commons 7 SLF4J - Logging Facade for Java http://www.slf4j.org
  16. 16. Hibernate Configuration  Hibernate requires to know in advance where to find the mapping information that defines how your Java classes relate to the database tables. Hibernate also requires a set of configuration settings related to database and other related parameters. All such information is usually supplied as a standard Java properties file called hibernate.properties, or as an XML file named hibernate.cfg.xml.
  17. 17. Hibernate configuration cont…  Sample file <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd"> <hibernate-configuration> <session-factory> <!-- Connection to Oracle db --> <property name="hibernate.connection.driver_class">oracle.jdbc.driver.OracleDriver</property> <property name="hibernate.connection.url">jdbc:oracle:thin:@localhost:1521:xe</property> <property name="hibernate.dialect">org.hibernate.dialect.Oracle10gDialect</property> <property name="hibernate.connection.username">test</property> <property name="hibernate.connection.password">test123</property> <!-- Auto commit to false --> <property name="hibernate.connection.autocommit">false</property> <property name="hibernate.show_sql">true</property> <property name="hibernate.format_sql">true</property> <property name="hibernate.use_sql_comments">true</property> </session-factory> </hibernate-configuration>
  18. 18. Sessions  A Session is used to get a physical connection with a database. The Session object is lightweight and designed to be instantiated each time an interaction is needed with the database. Persistent objects are saved and retrieved through a Session object.  The session objects should not be kept open for a long time because they are not usually thread safe and they should be created and destroyed them as needed. The main function of the Session is to offer create, read and delete operations for instances of mapped entity classes. Instances may exist in one of the following three states at a given point in time:  transient: A new instance of a persistent class which is not associated with a Session and has no representation in the database and no identifier value is considered transient by Hibernate.  persistent: You can make a transient instance persistent by associating it with a Session. A persistent instance has a representation in the database, an identifier value and is associated with a Session.  detached: Once we close the Hibernate Session, the persistent instance will become a detached instance.
  19. 19. Sessions cont…  A typical transaction should use the following idiom: Session session = factory.openSession(); Transaction tx = null; try { tx = session.beginTransaction(); // do some work ... tx.commit(); } catch (Exception e) { if (tx!=null) tx.rollback(); e.printStackTrace(); } finally { session.close(); } If the Session throws an exception, the transaction must be rolled back and the session must be discarded.
  20. 20. Persistence class  The entire concept of Hibernate is to take the values from Java class attributes and persist them to a database table. A mapping document helps Hibernate in determining how to pull the values from the classes and map them with table and associated fields. Java classes whose objects or instances will be stored in database tables are called persistent classes in Hibernate. Hibernate works best if these classes follow some simple rules, also known as the Plain Old Java Object (POJO) programming model. There are following main rules of persistent classes, however, none of these rules are hard requirements.  All Java classes that will be persisted need a default no-argument, constructor.  All classes should contain an ID in order to allow easy identification of your objects within Hibernate and the database. This property maps to the primary key column of a database table.  All attributes that will be persisted should be declared private and have getXXX and setXXXmethods defined in the JavaBean style.  All classes that do not extend or implement some specialized classes and interfaces.  The POJO name is used to emphasize that a given object is an ordinary Java Object, not a special object, and in particular not an Enterprise JavaBean.
  21. 21. Hibernate with MySQL DB MySQL is one of the most popular open-source database systems available today. Let us create hibernate.cfg.xml configuration file and place it in the root of your application's classpath. You would have to make sure that you have testdb database available in your MySQL database and you have a user test available to access the database. The XML configuration file must conform to the Hibernate 3 Configuration DTD (document type definition) , which is available from http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd.  Sample hibernate
  22. 22. Hibernate Mapping files  An Object/relational mappings are usually defined in an XML document. This mapping file instructs Hibernate how to map the defined class or classes to the database tables. Let us consider POJO class whose objects will persist in the table defined in next section (see attached Employee class) There would be one table corresponding to each object you are willing to provide persistence. Consider above objects need to be stored and retrieved into the following RDBMS table(see attached sql query for creating table) Based on the two above entities we can define following mapping file which instructs Hibernate how to map the defined class or classes to the database tables. (see attached mapping file)
  23. 23. Hibernate O/R mapping  The mapping of associations between entity classes and the relationships between tables is the soul of ORM. Following are the four ways in which the cardinality of the relationship between the objects can be expressed. An association mapping can be unidirectional as well as bidirectional. Mapping type Description Many-to-One Mapping many-to-one relationship One-to-One Mapping one-to-one relationship One-to-Many Mapping one-to-many relationship Many-to-Many Mapping many-to-many relationship
  24. 24. Annotations  So far We have seen how Hibernate uses XML mapping file for the transformation of data from POJO to database tables and vice versa. Hibernate annotations is the newest way to define mappings without a use of XML file. You can use annotations in addition to or as a replacement of XML mapping metadata.  Hibernate Annotations is the powerful way to provide the metadata for the Object and Relational Table mapping.  Environment Setup for Hibernate Annotation  First of all you would have to make sure that you are using JDK 5.0 otherwise you need to upgrade your JDK to JDK 5.0 to take advantage of the native support for annotations.  Second, you will need to install the Hibernate 3.x annotations distribution package, available from the source forge: (http://sourceforge.net/projects/hibernate/files/hibernate-annotations/) and copy hibernate-annotations.jar, lib/hibernate-comonsannotations.jar and lib/ejb3-persistence.jar from the Hibernate Annotations distribution to your CLASSPATH
  25. 25. Annotation cont..  @Entity Annotation:  The EJB 3 standard annotations are contained in the javax.persistence package, so we import this package as the first step. Second we used the @Entity annotation to the Employee class which marks this class as an entity bean, so it must have a no-argument  @Table Annotation:  allows you to specify the details of the table that will be used to persist the entity in the database.  @Id and @GeneratedValue Annotations:  Each entity bean will have a primary key, which you annotate on the class with the @Id annotation. The primary key can be a single field or a combination of multiple fields depending on your table structure.  The @GeneratedValue annotation is used to specify the primary key generation strategy to use. If the strategy is not specified by default AUTO will be used.  @Column Annotation:  is used to specify the details of the column to which a field or property will be mapped.
  26. 26. Hibernate Query Language  Hibernate Query Language (HQL) is an object-oriented query language, similar to SQL, but instead of operating on tables and columns, HQL works with persistent objects and their properties. HQL queries are translated by Hibernate into conventional SQL queries which in turns perform action on database.
  27. 27. HQL cont…  Pagination using query
  28. 28. Criteria query  Hibernate provides alternate ways of manipulating objects and in turn data available in RDBMS tables. One of the methods is Criteria API which allows you to build up a criteria query object programmatically where you can apply filtration rules and logical conditions.  The Hibernate Session interface provides createCriteria() method which can be used to create a Criteria object that returns instances of the persistence object's class when your application executes a criteria query.
  29. 29. Native SQL  Hibernate 3.x allows you to specify handwritten SQL, including stored procedures, for all create, update, delete, and load operations. Your application will create a native SQL query from the session with the createSQLQuery() method on the Session interface.: API public SQLQuery createSQLQuery(String sqlString) throws HibernateException  Syntax : Query query = session.createSQLQuery( "select * from stock s where s.stock_code = :stockCode") .addEntity(Stock.class) .setParameter("stockCode", "7277"); List result = query.list();
  30. 30. Native SQL cont…  Named SQL queries: The following is the syntax to get entity objects from a native sql query via addEntity() and using named SQL query. String sql = "SELECT * FROM EMPLOYEE WHERE id = :employee_id"; SQLQuery query = session.createSQLQuery(sql); query.addEntity(Employee.class); query.setParameter("employee_id", 10); List results = query.list();
  31. 31. Caching  Caching is all about application performance optimization and it sits between your application and the database to avoid the number of database hits as many as possible to give a better performance for performance critical applications.
  32. 32. Caching cont…  First-level cache:      Always associates with the Session object. Hibernate uses this cache by default. Its easy to understand the first level cache if we understand the fact that it is associated with Session object. As we know session object is created on demand from session factory and it is lost, once the session is closed. Similarly, first level cache associated with session object is available only till session object is live. It is available to session object only and is not accessible to any other session object in any other part of application. When we query an entity first time, it is retrieved from database and stored in first level cache associated with hibernate session. If we query same object again with same session object, it will be loaded from cache and no sql query will be executed. The loaded entity can be removed from session using evict() method. The next loading of this entity will again make a database call if it has been removed using evict() method. The whole session cache can be removed using clear() method. It will remove all the entities stored in cache.
  33. 33. Caching cont…  Second-level cache: Always associates with sessionFactoryObject and is available to be used in all sessions which are created using that particular session factory. It also means that once session factory is closed, all cache associated with it die. It is responsible for caching objects across sessions. When this is turned on, objects will first be searched in cache and if they are not found, a database query will be fired.  Second level cache is an optional cache and first-level cache will always be consulted before any attempt is made to locate an object in the second-level cache. If Entity is not present in either 1st or 2nd level cache so, it is fetched from database.  Any third-party cache can be used with Hibernate. An org.hibernate.cache.CacheProvider interface is provided, which must be implemented to provide Hibernate with a handle to the cache implementation.   How to enable it? <property name="hibernate.cache.use_second_level_cache">true</property> <property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property>
  34. 34. Caching cont…  How to disable second level cache? <property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>  Example: Using two sessions. We load the object in the first session, update it then load it in the second session. Both sessions are created upfront and are kept open until the end. public void complexLoad (){ Session session1 = getSessionFactory().openSession(); Session session2 = getSessionFactory().openSession(); Transaction tx1 = session1.beginTransaction(); Person p1 = (Person) session1.load(Person.class, 1L); System.out.println (p1.getFirstName()); p1.setFirstName ("" + System.currentTimeMillis()); tx1.commit(); Transaction tx2 = session2.beginTransaction(); Person p2 = (Person)session2.load(Person.class, 1L); System.out.println (p2.getFirstName()); tx2.commit(); session1.close(); session2.close(); }
  35. 35. Caching cont…  Cache provider:  Sample hibernate config file with caching
  36. 36. Caching cont…  Query-level cache:  Hibernate also implements a cache for query result sets that integrates closely with the second-level cache.  This is an optional feature and requires two additional physical cache regions that hold the cached query results and the timestamps when a table was last updated. This is only useful for queries that are run frequently with the same parameters.  To use the query cache, you must first activate it using the hibernate.cache.use_query_cache="true“ property in the configuration file. By setting this property to true, you make Hibernate create the necessary caches in memory to hold the query and identifier sets.
  37. 37. Caching cont…  To use the query cache, you use the setCacheable(Boolean) method of the Query class. For example:
  38. 38. Batch Processing  Consider a situation when you need to upload a large number of records into your database using Hibernate. Following is the code snippet to achieve this using Hibernate: Session session = SessionFactory.openSession(); Transaction tx = session.beginTransaction(); for ( int i=0; i<100000; i++ ) { Employee employee = new Employee(.....); session.save(employee); } tx.commit(); session.close();  By default, Hibernate will cache all the persisted objects in the session-level cache and ultimately your application will throw an OutOfMemoryException somewhere around the 50,000th row. You can resolve this problem if you are using batch processing with Hibernate.
  39. 39. Batch processing cont…  To use the batch processing feature, first set hibernate.jdbc.batch_size as batch size to a number either at 20 or 50 depending on object size. This will tell the hibernate container that every X rows to be inserted as batch. To implement this in your code we would need to do little modification as follows: <property name="hibernate.jdbc.batch_size"> 50 </property>  add in config file  Code snippet:
  40. 40. Interceptors  Hibernate has a powerful feature called ‘interceptor‘ to intercept or hook different kind of Hibernate events, like database CRUD operation.  As you have learnt that in Hibernate, an object will be created and persisted. Once the object has been changed, it must be saved back to the database. This process continues until the next time the object is needed, and it will be loaded from the persistent store.  Thus an object passes through different stages in its life cycle and Interceptor Interface provides methods which can be called at different stages to perform some required tasks. These methods are callbacks from the session to the application, allowing the application to inspect and/or manipulate properties of a persistent object before it is saved, updated, deleted or loaded.  How to use Interceptors? To build an interceptor you can either implement Interceptor class directly or extend EmptyInterceptorclass.
  41. 41. Interceptors cont…  Following is the list of all the methods available within the Interceptor interface:
  42. 42. Disadvantage of Hibernate  It doesn’t allow some types of queries which are supported by JDBC. For e.g. it does not allow to insert multiple objects to same table using single query. Developer has to write a separate query to insert each object.  Debugging: Sometimes debugging and performance tuning becomes difficult.
  43. 43. Hibernate Examples  Hibernate with MySQL http://www.tutorialspoint.com/hibernate/hibernate_examples.htm  Hibernate with Oracle http://www.mkyong.com/hibernate/maven-3-hibernate-3-6-oracle-11gexample-xml-mapping/

×