Hibernate Reference Persistence for Idiomatic Java HIBERNATE
Hibernate
-
Upload
shaharyar-khan -
Category
Technology
-
view
1.017 -
download
0
description
Transcript of Hibernate
![Page 2: Hibernate](https://reader037.fdocuments.net/reader037/viewer/2022110307/555a77afd8b42a98568b4812/html5/thumbnails/2.jpg)
If you have completed 2 versions of your product and the product is now stable , working great without any mess up and then
one day your user ask you to remove mySQL from backend and use Oracle as I am thinking that this is more good and efficient
2
Everyone knows that this will be like a bomb on the head of developers Because it is possible but while doing this developers can suicide due to extreme bugs in code, massive conversions of queries and may be DB design(For instance oracle supports foreign key but mySQL doesn’t).
![Page 3: Hibernate](https://reader037.fdocuments.net/reader037/viewer/2022110307/555a77afd8b42a98568b4812/html5/thumbnails/3.jpg)
So , there should be a mechanism or a smart API which provide us a layer between Database and code
This layer purpose is to interact with DB and our logical layer should have no concern or have no direct interaction with Databases.
So when we want to change our backend then nothing will be changed and we can save our a lot of time.
![Page 4: Hibernate](https://reader037.fdocuments.net/reader037/viewer/2022110307/555a77afd8b42a98568b4812/html5/thumbnails/4.jpg)
Basically Hibernate purpose is to cater this But not only this , Hibernate also provide us ORM
4
Developers Red Hat
Stable release4.1.4 Final / May 31, 2012 (some days ago)
Development status Active
Written in Java
Operating system Cross-platform (JVM)
Platform Java Virtual Machine
Type Object-relational mapping
LicenseGNU Lesser General Public License
Website www.hibernate.org
![Page 5: Hibernate](https://reader037.fdocuments.net/reader037/viewer/2022110307/555a77afd8b42a98568b4812/html5/thumbnails/5.jpg)
While working with hibernate , you can bump with these words which are the basic part of Hibernate
ORMMappingPersistence
And may beHQL
![Page 6: Hibernate](https://reader037.fdocuments.net/reader037/viewer/2022110307/555a77afd8b42a98568b4812/html5/thumbnails/6.jpg)
Data management tasks in object-oriented (OO) programming are typically implemented by manipulating objects
consider an address book entry that represents a single person along with zero or more phone numbers and zero or more addresses. This could be modeled in an object-oriented implementation by a "Person object" with attributes/fields to hold each data item that the entry comprises: the person's name, a list of phone numbers, and a list of addresses
Simply We can say that we are talking about Domain model
So ,the mapping of domain model into entity relationship model is called Object relational mapping or ORM
![Page 7: Hibernate](https://reader037.fdocuments.net/reader037/viewer/2022110307/555a77afd8b42a98568b4812/html5/thumbnails/7.jpg)
For ORM , We map JAVA classes into database tables
It is accomplished through the configuration of an XML file or by using Java Annotations
Hibernate can use the XML file or the annotations to maintain the database schema
Facilities to arrange one-to-many and many-to-many & all other relationships between classes are provided
![Page 8: Hibernate](https://reader037.fdocuments.net/reader037/viewer/2022110307/555a77afd8b42a98568b4812/html5/thumbnails/8.jpg)
Hibernate provides transparent persistence for Plain Old Java Objects(POJOs)
The only strict requirement for a persistent class is a no-argument constructor, not necessarily public
Collections of data objects are typically stored in Java collection objects such as Set and List
Hibernate can be configured to lazy load associated collections. Lazy loading is the default as of Hibernate 3
![Page 9: Hibernate](https://reader037.fdocuments.net/reader037/viewer/2022110307/555a77afd8b42a98568b4812/html5/thumbnails/9.jpg)
Hibernate provides an SQL inspired language called Hibernate Query Language (HQL)
It allows SQL-like queries to be written against Hibernate's data objects
Criteria Queries are provided as an object-oriented alternative to HQL
![Page 10: Hibernate](https://reader037.fdocuments.net/reader037/viewer/2022110307/555a77afd8b42a98568b4812/html5/thumbnails/10.jpg)
10
A “virtual object database” is created that can be used from within the programming language
![Page 11: Hibernate](https://reader037.fdocuments.net/reader037/viewer/2022110307/555a77afd8b42a98568b4812/html5/thumbnails/11.jpg)
Previous diagram shows minimal architecture of Hibernate
It creates a layer between Database and the Application
It loads the configuration details like Database connection string, entity classes, mappings etc
Hibernate creates persistent objects which synchronize data between application and database
Let see this architecture in detail diagram11
![Page 13: Hibernate](https://reader037.fdocuments.net/reader037/viewer/2022110307/555a77afd8b42a98568b4812/html5/thumbnails/13.jpg)
In order to persist data to a database, Hibernate create an instance of entity class (Java class mapped with database table)
This object is called Transient object as they are not yet associated with the session or not yet persisted to a database
To persist the object to database, the instance of SessionFactory interface is created. SessionFactory is a singleton instance which implements Factory design pattern
SessionFactory loads hibernate.cfg.xml file (Hibernate configuration file) and with the help of TransactionFactory and ConnectionProvider implements all the configuration settings on a database
![Page 14: Hibernate](https://reader037.fdocuments.net/reader037/viewer/2022110307/555a77afd8b42a98568b4812/html5/thumbnails/14.jpg)
Each database connection in Hibernate is created by creating an instance of Session interface
Session represents a single connection with database
Session objects are created from SessionFactory object
Hibernate also provides built-in Transaction APIs which abstracts away the application from underlying JDBC or JTA transaction
Each transaction represents a single atomic unit of work
One Session can span through multiple transactions.
![Page 15: Hibernate](https://reader037.fdocuments.net/reader037/viewer/2022110307/555a77afd8b42a98568b4812/html5/thumbnails/15.jpg)
Before starting any example , We should know about some configuration files
These files are needed for mapping and to load many other properties and create database connection
Hibernate provide following type of configurtions:hibernate.cfg.xml – A standard XML file which contains
hibernate configuration like database connection, class mappings etc and which resides in root of application’s CLASSPATH
hibernate.properties: A Java compliant property file which holds key value pair for different hibernate configuration strings
Programmatic configuration: This is the manual approach. The configuration can be defined in Java class
![Page 16: Hibernate](https://reader037.fdocuments.net/reader037/viewer/2022110307/555a77afd8b42a98568b4812/html5/thumbnails/16.jpg)
16
<hibernate-configuration><session-factory> <property name="hibernate.connection.driver_class"> com.mysql.jdbc.Driver</property>
<property name="hibernate.connection.url">jdbc:mysql://localhost/EmployeeDB</property>
<property name="hibernate.connection.username">root</property> <property name="hibernate.connection.password"></property> <property name="hibernate.connection.pool_size">10</property> <property name="show_sql">true</property> <property name="dialect">org.hibernate.dialect.MySQLDialect</property> <property name="hibernate.hbm2ddl.auto">update</property> <!-- Mapping files --> <mapping resource="contact.hbm.xml"/></session-factory></hibernate-configuration>
![Page 17: Hibernate](https://reader037.fdocuments.net/reader037/viewer/2022110307/555a77afd8b42a98568b4812/html5/thumbnails/17.jpg)
Once the hibernate.cfg.xml file is created and placed in root of application’s CLASSPATH, the same can be loaded in Hibernate using following API
SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();
17
This above code will load default hibernate.cfg.xml file and all the configuration mentioned in it
In case you want to override default naming convention and want to have your own configuration file like “employeedb.cfg.xml”, following API can be used:SessionFactory sf = new Configuration().configure("employeedb.cfg.xml")
.buildSessionFactory()
![Page 18: Hibernate](https://reader037.fdocuments.net/reader037/viewer/2022110307/555a77afd8b42a98568b4812/html5/thumbnails/18.jpg)
hibernate.connection.driver_class=com.mysql.jdbc.Driverhibernate.connection.url=
jdbc:mysql://localhost:3306/employeeDBhibernate.connection.username=roothibernate.connection.password=hibernate.dialect = org.hibernate.dialect.MySQLDialecthibernate.connection.pool_size=1 // C3P0(open source
JDBC // connection pool //distributed along
with //Hibernate in the lib //directory)
Note: Both hibernate.cfg.xml and hibernate.properties files can be provided simultaneously in an application. In this case hibernate.cfg.xml gets precedence over hibernate.properties.
![Page 19: Hibernate](https://reader037.fdocuments.net/reader037/viewer/2022110307/555a77afd8b42a98568b4812/html5/thumbnails/19.jpg)
We can obtain a org.hibernate.cfg.Configuration instance by instantiating it directly and specifying XML mapping documents. If the mapping files are in the classpath, use addResource().
Configuration cfg = new Configuration() .addResource("Employee.hbm.xml")
.addResource("Department.hbm.xml");
19
An alternative way is to specify the mapped class and allow Hibernate to find the mapping document for you Configuration cfg = new Configuration()
.addClass(com.deltasoft.hibernate.Employee.class) .addClass(com.deltasoft.hibernate.Department.class);
Hibernate will then search for mapping files named /com/deltasoft/hibernate/Employee.hbm.xml and /com/deltasoft/hibernate/Department.hbm.xml in the classpath. This approach eliminates any hardcoded filenames.
![Page 20: Hibernate](https://reader037.fdocuments.net/reader037/viewer/2022110307/555a77afd8b42a98568b4812/html5/thumbnails/20.jpg)
A org.hibernate.cfg.Configuration also allows you to specify configuration properties
Configuration cfg = new Configuration().addClass(com.deltasoft.hibernate.Employee.class).addClass(com.deltasoft.hibernate.Department.class).setProperty("hibernate.dialect",
"org.hibernate.dialect.MySQLInnoDBDialect").setProperty(" hibernate.connection.url ", "
jdbc:mysql://localhost/EmployeeDB ").setProperty("hibernate.order_updates", "true");
![Page 21: Hibernate](https://reader037.fdocuments.net/reader037/viewer/2022110307/555a77afd8b42a98568b4812/html5/thumbnails/21.jpg)
Let see in this example that how can we insert record in MySQL database using Hibernate
In this example , We will create a contact objecta and save it in Database ……
![Page 22: Hibernate](https://reader037.fdocuments.net/reader037/viewer/2022110307/555a77afd8b42a98568b4812/html5/thumbnails/22.jpg)
public class Contact { private String firstName; private String lastName; private String email;
private long id; //Contact.java//This is a POJO class
public String getEmail() { return email; }
public String getFirstName() { //We Can Assume that contact is an entity and these all return firstName; // are attributes of contact } public String getLastName() { return lastName; } public void setEmail(String string) { email = string; } public void setFirstName(String string) { firstName = string; } public void setLastName(String string) { lastName = string; } public long getId() { return id; } public void setId(long l) { id = l; }}
![Page 23: Hibernate](https://reader037.fdocuments.net/reader037/viewer/2022110307/555a77afd8b42a98568b4812/html5/thumbnails/23.jpg)
import org.hibernate.Session;import org.hibernate.SessionFactory;import org.hibernate.cfg.Configuration;
public class FirstExample { public static void main(String[] args) { Session session = null;
//FirstExample.java try{ // This step will read hibernate.cfg.xml and prepare hibernate for use SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory(); session =sessionFactory.openSession(); //Create new instance of Contact and set values in it by reading them from form object System.out.println("Inserting Record"); Contact contact = new Contact(); contact.setId(3); contact.setFirstName(“Shaharyar"); contact.setLastName("Khan"); contact.setEmail(“[email protected]"); session.save(contact); System.out.println("Done"); //same as we have update() , delete() methods }catch(Exception e){ System.out.println(e.getMessage()); }finally{ // Actual contact insertion will happen at this step session.flush(); session.close();} } }
![Page 24: Hibernate](https://reader037.fdocuments.net/reader037/viewer/2022110307/555a77afd8b42a98568b4812/html5/thumbnails/24.jpg)
?xml version='1.0' encoding='utf-8'?><!DOCTYPE hibernate-configuration PUBLIC"-//Hibernate/Hibernate Configuration DTD//EN""http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration><session-factory> <property name="hibernate.connection.driver_class">
com.mysql.jdbc.Driver</property> <property name="hibernate.connection.url">
jdbc:mysql://localhost/EmployeeDB</property> <property name="hibernate.connection.username">root</property> <property name="hibernate.connection.password"></property> <property name="hibernate.connection.pool_size">10</property> <property name="show_sql">true</property> <property name="dialect">org.hibernate.dialect.MySQLDialect</property> <property name="hibernate.hbm2ddl.auto">update</property> <!-- Mapping files --> <mapping resource="contact.hbm.xml"/></session-factory></hibernate-configuration>
![Page 25: Hibernate](https://reader037.fdocuments.net/reader037/viewer/2022110307/555a77afd8b42a98568b4812/html5/thumbnails/25.jpg)
In the above configuration file we specified to use the “EmployeeDB" which is running on localhost and the user of the database is root with no password. The dialect property is org.hibernate.dialect.MySQLDialect which tells the Hibernate that we are using MySQL Database.
25
DB2 - org.hibernate.dialect.DB2DialectHypersonicSQL - org.hibernate.dialect.HSQLDialect Informix - org.hibernate.dialect.InformixDialect Ingres - org.hibernate.dialect.IngresDialect PostgreSQL - org.hibernate.dialect.PostgreSQLDialect Microsoft SQL Server - org.hibernate.dialect.SQLServerDialect MySQL - org.hibernate.dialect.MySQLDialect Oracle (any version) - org.hibernate.dialect.OracleDialect Oracle 9 - org.hibernate.dialect.Oracle9Dialect Progress - org.hibernate.dialect.ProgressDialect SAP DB - org.hibernate.dialect.SAPDBDialect Sybase - org.hibernate.dialect.SybaseDialect Sybase Anywhere - org.hibernate.dialect.SybaseAnywhereDialect
Some dialects of different databases
![Page 26: Hibernate](https://reader037.fdocuments.net/reader037/viewer/2022110307/555a77afd8b42a98568b4812/html5/thumbnails/26.jpg)
<?xml version="1.0"?><!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN""http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping> <class name=“com .deltasoft.hibernate.Contact" table="CONTACT"> <id name="id" type="long" column="ID" > <generator class="assigned"/> </id>
<property name="firstName"> <column name="FIRSTNAME" /> </property> <property name="lastName"> <column name="LASTNAME"/> </property> <property name="email"> <column name="EMAIL"/> </property> </class></hibernate-mapping>
![Page 27: Hibernate](https://reader037.fdocuments.net/reader037/viewer/2022110307/555a77afd8b42a98568b4812/html5/thumbnails/27.jpg)
27
It is better to get these jar files like this Go to http://sourceforge.net/projects/hibernate/files/ Click on
Download hibernate-search-4.1.1.Final-dist.zip (31.0 MB) Now a folder will be downloaded on your machine. Extract the folder and in extracted folder you will see a
folder “required” placed in “hibernate-search-4.1.1.Final/dist/lib/required”
Copy all the jar files present in “required” folder into your classpath
![Page 28: Hibernate](https://reader037.fdocuments.net/reader037/viewer/2022110307/555a77afd8b42a98568b4812/html5/thumbnails/28.jpg)
<hibernate-mapping> elementThe first or root element of hibernate mapping document is
<hibernate-mapping> element. Between the <hibernate-mapping> tag class element(s) are present
28
<class> elementThe <Class> element maps the class object with corresponding entity
in the database. It also tells what table in the database has to access and what column in that table it should use. Within one <hibernate-mapping> element, several <class> mappings are possible
<id> elementThe <id> element in unique identifier to identify and object. In fact
<id> element map with the primary key of the table. In our code :<id name="id" type="long" column="ID" >primary key maps to the ID field of the table CONTACT. The
attributes of the id element are: name: The property name used by the persistent class. column: The column used to store the primary key value. type: The Java data type used. unsaved-value: This is the value used to determine if a class has been
made persistent. If the value of the id attribute is null, then it means that this object has not been persisted.
![Page 29: Hibernate](https://reader037.fdocuments.net/reader037/viewer/2022110307/555a77afd8b42a98568b4812/html5/thumbnails/29.jpg)
<generator> elementThe <generator> method is used to generate the primary key
for the new record. Here is some of the commonly used generators :
Increment - This is used to generate primary keys of type long, short or int that are unique only. It should not be used in the clustered deployment environment.
Sequence - Hibernate can also use the sequences to generate the primary key. It can be used with DB2, PostgreSQL, Oracle, SAP DB databases.
Assigned - Assigned method is used when application code generates the primary key.
29
<property> elementThe property elements define standard Java attributes and
their mapping into database schema. The property element supports the column child element to specify additional properties, such as the index name on a column or a specific column type
![Page 30: Hibernate](https://reader037.fdocuments.net/reader037/viewer/2022110307/555a77afd8b42a98568b4812/html5/thumbnails/30.jpg)
Same like JSF and other frameworks of java , Hibernate also supports annotations
Now if we want to transfer our previous contact example into annotations then we havn’t need “contact.hbm.xml” so delete this if you want to introduce annotations in your code
Now our Contact.java would be like this
![Page 31: Hibernate](https://reader037.fdocuments.net/reader037/viewer/2022110307/555a77afd8b42a98568b4812/html5/thumbnails/31.jpg)
31
@Entity@Table(name="EMPLOYEE")public class Contact {
@Id @GeneratedValue private long id; //Contact.java with annotations @Column(name="firstname“) private String firstName; @Column(name=“lastname“) private String lastName; @Column(name=“email“) private String email; //getter and setters
}
![Page 32: Hibernate](https://reader037.fdocuments.net/reader037/viewer/2022110307/555a77afd8b42a98568b4812/html5/thumbnails/32.jpg)
32
Now in FirstExample.java just change this line
SessionFactory sessionFactory = new Configuration().configure().
buildSessionFactory();
TO
SessionFactory sessionFactory = new AnnotationConfiguration().configure()
.buildSessionFactory();And in hibernate.cfg.xml change this
<mappingresource="net/viralpatel/hibernate/Employee.hbm.xml"/>
TO <mapping class=“com.deltasoft.hibernate.Employee"/>
![Page 34: Hibernate](https://reader037.fdocuments.net/reader037/viewer/2022110307/555a77afd8b42a98568b4812/html5/thumbnails/34.jpg)
34
Lets take an example that
Employee has a one to one relation with EmployeeDetail
So, First we create a Employee class and then EmployeeDetail in which we map them by annotations
![Page 35: Hibernate](https://reader037.fdocuments.net/reader037/viewer/2022110307/555a77afd8b42a98568b4812/html5/thumbnails/35.jpg)
@Entity@Table(name="EMPLOYEE")public class Employee { @Id @GeneratedValue @Column(name="employee_id") private Long employeeId; @Column(name="firstname") private String firstname; @Column(name="lastname") private String lastname; @Column(name="birth_date") private Date birthDate; @Column(name="cell_phone") private String cellphone; @OneToOne(mappedBy="employee", cascade=CascadeType.ALL) private EmployeeDetail employeeDetail; public Employee() { } public Employee(String firstname, String lastname, Date birthdate, String phone) { this.firstname = firstname; this.lastname = lastname; this.birthDate = birthdate; this.cellphone = phone; } // Getter and Setter methods}
![Page 36: Hibernate](https://reader037.fdocuments.net/reader037/viewer/2022110307/555a77afd8b42a98568b4812/html5/thumbnails/36.jpg)
<?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> <!-- Database connection settings --> <property
name="connection.driver_class">com.mysql.jdbc.Driver</property> <property
name="connection.url">jdbc:mysql://localhost:3306/tutorial</property> <property name="connection.username">root</property> <property name="connection.password"></property> <property name="connection.pool_size">1</property> <property name="dialect">org.hibernate.dialect.MySQLDialect</property> <property name="current_session_context_class">thread</property> <property
name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>
<property name="show_sql">true</property> <property name="hbm2ddl.auto">validate</property> <mapping class="net.viralpatel.hibernate.EmployeeDetail"/> <mapping class="net.viralpatel.hibernate.Employee"/> </session-factory></hibernate-configuration>
![Page 37: Hibernate](https://reader037.fdocuments.net/reader037/viewer/2022110307/555a77afd8b42a98568b4812/html5/thumbnails/37.jpg)
public class Main {
public static void main(String[] args) { System.out.println("Hibernate One-To-One example (Annotation)"); SessionFactory sf = = new AnnotationConfiguration().configure() .buildSessionFactory(); Session session = sf.openSession(); session.beginTransaction(); EmployeeDetail employeeDetail = new EmployeeDetail("10th
Street", "LA", "San Francisco", "U.S."); Employee employee = new Employee(“Ali", “Asim", new
Date(121212), "114-857-965"); employee.setEmployeeDetail(employeeDetail); employeeDetail.setEmployee(employee); session.save(employee); }
![Page 39: Hibernate](https://reader037.fdocuments.net/reader037/viewer/2022110307/555a77afd8b42a98568b4812/html5/thumbnails/39.jpg)
@Entity@Table(name="EMPLOYEE")public class Employee { @Id @GeneratedValue @Column(name="employee_id") private Long employeeId; @Column(name="firstname") private String firstname; @Column(name="lastname") private String lastname; @Column(name="birth_date") private Date birthDate; @Column(name="cell_phone") private String cellphone; @ManyToOne @JoinColumn(name="department_id") private Department department; public Employee() { } public Employee(String firstname, String lastname, String phone) { this.firstname = firstname; this.lastname = lastname; this.birthDate = new Date(System.currentTimeMillis()); this.cellphone = phone; } // Getter and Setter methods}
![Page 40: Hibernate](https://reader037.fdocuments.net/reader037/viewer/2022110307/555a77afd8b42a98568b4812/html5/thumbnails/40.jpg)
public class Main { @SuppressWarnings("unchecked") public static void main(String[] args) { SessionFactory sf = = new AnnotationConfiguration().configure() .buildSessionFactory(); Session session = sf.openSession(); session.beginTransaction(); Department department = new Department(); department.setDepartmentName("Sales"); session.save(department); Employee emp1 = new Employee("Nina", "Mayers", "111"); Employee emp2 = new Employee("Tony", "Almeida", "222"); emp1.setDepartment(department); emp2.setDepartment(department); session.save(emp1); session.save(emp2); session.getTransaction().commit(); session.close(); }} 40
![Page 41: Hibernate](https://reader037.fdocuments.net/reader037/viewer/2022110307/555a77afd8b42a98568b4812/html5/thumbnails/41.jpg)
41
Many Employees have many Meetings
So
We will Map Employee class with meeting class
![Page 42: Hibernate](https://reader037.fdocuments.net/reader037/viewer/2022110307/555a77afd8b42a98568b4812/html5/thumbnails/42.jpg)
42
@Entity@Table(name="EMPLOYEE")public class Employee { @Id @Column(name="EMPLOYEE_ID") @GeneratedValue private Long employeeId; @Column(name="FIRSTNAME") private String firstname; @Column(name="LASTNAME") private String lastname; @ManyToMany(cascade = {CascadeType.ALL}) @JoinTable(name="EMPLOYEE_MEETING", joinColumns={@JoinColumn(name="EMPLOYEE_ID")}, inverseJoinColumns={@JoinColumn(name="MEETING_ID")}) private Set<Meeting> meetings = new HashSet<Meeting>(); public Employee() { } public Employee(String firstname, String lastname) { this.firstname = firstname; this.lastname = lastname; } // Getter and Setter methods} [email protected]
![Page 43: Hibernate](https://reader037.fdocuments.net/reader037/viewer/2022110307/555a77afd8b42a98568b4812/html5/thumbnails/43.jpg)
@Entity@Table(name="MEETING")public class Meeting { @Id @Column(name="MEETING_ID") @GeneratedValue private Long meetingId; @Column(name="SUBJECT") private String subject; @Column(name="MEETING_DATE") private Date meetingDate; @ManyToMany(mappedBy="meetings") private Set<Employee> employees = new HashSet<Employee>(); public Meeting(String subject) { this.subject = subject; this.meetingDate = new Date(); } // Getter and Setter methods}
![Page 44: Hibernate](https://reader037.fdocuments.net/reader037/viewer/2022110307/555a77afd8b42a98568b4812/html5/thumbnails/44.jpg)
44
public class Main { public static void main(String[] args) { SessionFactory sf = new AnnotationConfiguration().configure() .buildSessionFactory(); Session session = sf.openSession(); session.beginTransaction(); Meeting meeting1 = new Meeting("Quaterly Sales meeting"); Meeting meeting2 = new Meeting("Weekly Status meeting"); Employee employee1 = new Employee("Sergey", "Brin"); Employee employee2 = new Employee("Larry", "Page"); employee1.getMeetings().add(meeting1); employee1.getMeetings().add(meeting2); employee2.getMeetings().add(meeting1); session.save(employee1); session.save(employee2); session.getTransaction().commit(); session.close(); }}
![Page 45: Hibernate](https://reader037.fdocuments.net/reader037/viewer/2022110307/555a77afd8b42a98568b4812/html5/thumbnails/45.jpg)
Hibernate Query Language or HQL for short is extremely powerful query language
HQL is much like SQL and are case-insensitive, except for the names of the Java Classes and properties
Hibernate Query Language is used to execute queries against database
Hibernate automatically generates the sql query and execute it against underlying database if HQL is used in the application.
Hibernate Query Language uses Classes and properties instead of tables and columns. 45
![Page 46: Hibernate](https://reader037.fdocuments.net/reader037/viewer/2022110307/555a77afd8b42a98568b4812/html5/thumbnails/46.jpg)
46
SubqueriesSubqueries are nothing but its a query within another query.
Hibernate supports Subqueries if the underlying database supports it.
![Page 47: Hibernate](https://reader037.fdocuments.net/reader037/viewer/2022110307/555a77afd8b42a98568b4812/html5/thumbnails/47.jpg)
//Using from Clause
String SQL_QUERY ="from Insurance insurance";
Query query = session.createQuery(SQL_QUERY); for(Iterator it=query.iterate();it.hasNext();){
Insurance insurance=(Insurance)it.next(); System.out.println("ID: " +
insurance.getLngInsuranceId()); System.out.println("First
Name: " + insurance.getInsuranceName()); }
![Page 48: Hibernate](https://reader037.fdocuments.net/reader037/viewer/2022110307/555a77afd8b42a98568b4812/html5/thumbnails/48.jpg)
String SQL_QUERY ="Select insurance.
lngInsuranceId,insurance.insuranceName," +
"insurance.investementAmount,insurance.
investementDate from Insurance insurance";
Query query = session.createQuery(SQL_QUERY); for(Iterator it=query.iterate();it.hasNext();){
Object[] row = (Object[]) it.next(); System.out.println("ID: " + row[0]); System.out.println("Name: " + row[1]);
System.out.println("Amount: " + row[2]); }
It returns resultset in form of objects
![Page 49: Hibernate](https://reader037.fdocuments.net/reader037/viewer/2022110307/555a77afd8b42a98568b4812/html5/thumbnails/49.jpg)
String SQL_QUERY =" from Insurance as insurance where insurance.lngInsuranceId='1'";
Query query = session.createQuery(SQL_QUERY);
//remaining code
![Page 50: Hibernate](https://reader037.fdocuments.net/reader037/viewer/2022110307/555a77afd8b42a98568b4812/html5/thumbnails/50.jpg)
String SQL_QUERY = "select avg
(investementAmount) from Insurance insurance";Query query = sess.createQuery(SQL_QUERY); List list = query.list();System.out.println("Average of Invested Amount: " + list.get(0));
__________________________________________________
String SQL_QUERY = "select
max(investementAmount)from Insurance insurance";Query query = sess.createQuery(SQL_QUERY);List list = query.list();
System.out.println("Max Invested Amount: " + list.get(0);
50
avg(..) usage
max(…
)
usage