Introduction
Hibernate Criteria API is used to perform the bulk(multiple) select operations means it is only for selecting the objects from the database.Where as by using HQL many operations will be performed like updation, insertion, selection.criterion is an interface was given by org.hibernate.criterion Following is a syntax to criteria.
Criteria crit = session.createCriteria(–Our class object–);
Description
To select Entity’s from the database using Criteria API, create a criteria object by calling createCriteria() of Session interface.
Criteria criteria = session.createCriteria();
- To read the full entity from Database, call list method on Criteria object.
Criteria criteria=session.createCriteria(" SPLessons.class ");
List list=criteria.list();
Iterator iterator=list.iterator();
while(iterator.hasNext())
{
SPLessons splessons = (SPLessons)iterator.next();
System.out.println(splessons);
}
2. To read full entity with a condition, initially create a Criterion object for the condition.Then add Criterion object to Criteria object.
For Example, If employeeName is selected in SpLessons table where sal=8000.
Criteria criteria=session.createCriteria(" SPLessons.class ");
Criterion criterion=Restrictions.eq("sal", 8000);
criteria.add(criterion);
List list=criteria.list();
Iterator iterator=list.iterator();
Criterion is an interface and Restriction is a class. In Restriction class, all static methods exists.So methods can be called directly using a class name.
Criterion and Restriction both are from the same package like org.hibernate.Criterion.
3. To read partial entity then create a Projection object for each property.
All Projection objects are added to the ProjectionList, then ProjectionList object is added to Criteria object.
For Example, to select employeeName and employeeSal from the database follow the below code.
Criteria criteria=session.createCriteria(" SpLessons.class ");
Projection projection1=Projections.property("employeeName");
Projection projection2=Projections.property("employeeSal");
ProjectionList projectionlist=Projections.ProjectionList();
projectionlist.add(projection1);
projectionlist.add(projection2);
criteria.setProjection(projectionlist);
List list=criteria.list();
Iterator iterator=list.iterator();
while(iterator.hasNext())
{
Object[] object=(Object[])iterator.next();
System.out.println(object[]);
}
Projection and ProjectionList both are interfaces and Projections is a class.
4. To read a partial entity with a single property then create a Projection object.
Criteria criteria=session.createCriteria(" SpLessons.class ");
Projection projection=Projections.property("employeeName");
criteria.setProjection(projection);
List list=criteria.list();
Iterator iterator=list.iterator();
while(iterator.hasNext())
{
String string=iterator.next();
System.out.println(string);
}
Example
Employee.java
public class Employee {
private int id;
private String firstName;
private String lastName;
private int salary;
public Employee() {}
public Employee(String fname, String lname, int salary) {
this.firstName = fname;
this.lastName = lname;
this.salary = salary;
}
public int getId() {
return id;
}
public void setId( int id ) {
this.id = id;
}
public String getFirstName() {
return firstName;
}
public void setFirstName( String first_name ) {
this.firstName = first_name;
}
public String getLastName() {
return lastName;
}
public void setLastName( String last_name ) {
this.lastName = last_name;
}
public int getSalary() {
return salary;
}
public void setSalary( int salary ) {
this.salary = salary;
}
}
Set and Get methods are a pattern of data encapsulation. Instead of accessing class member variables directly, one can define get methods to access these variables, and set methods to modify them. By encapsulating them in this manner,one can have control over the public interface.
Now create the employee table in database as follows.
create table EMPLOYEE ( id INT NOT NULL auto_increment, first_name VARCHAR(20) default NULL, last_name VARCHAR(20) default NULL, salary INT default NULL, PRIMARY KEY (id) );
Now write hibernate mapping file as follows.
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="Employee" table="EMPLOYEE">
<meta attribute="class-description">
This class contains the employee detail.
</meta>
<id name="id" type="int" column="id">
<generator class="native"/>
</id>
<property name="firstName" column="first_name" type="string"/>
<property name="lastName" column="last_name" type="string"/>
<property name="salary" column="salary" type="int"/>
</class>
</hibernate-mapping>
Now create the main method to call as ManageEmployee.java
import java.util.List;
import java.util.Date;
import java.util.Iterator;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.SessionFactory;
import org.hibernate.Criteria;
import org.hibernate.criterion.Restrictions;
import org.hibernate.criterion.Projections;
import org.hibernate.cfg.Configuration;
public class ManageEmployee {
private static SessionFactory factory;
public static void main(String[] args) {
try{
factory = new Configuration().configure().buildSessionFactory();
}catch (Throwable ex) {
System.err.println("Failed to create sessionFactory object." + ex);
throw new ExceptionInInitializerError(ex);
}
ManageEmployee ME = new ManageEmployee();
/* Add few employee records in database */
Integer empID1 = ME.addEmployee("Zara", "Ali", 2000);
Integer empID2 = ME.addEmployee("Daisy", "Das", 5000);
Integer empID3 = ME.addEmployee("John", "Paul", 5000);
Integer empID4 = ME.addEmployee("Mohd", "Yasee", 3000);
/* List down all the employees */
ME.listEmployees();
/* Print Total employee's count */
ME.countEmployee();
/* Print Toatl salary */
ME.totalSalary();
}
/* Method to CREATE an employee in the database */
public Integer addEmployee(String fname, String lname, int salary){
Session session = factory.openSession();
Transaction tx = null;
Integer employeeID = null;
try{
tx = session.beginTransaction();
Employee employee = new Employee(fname, lname, salary);
employeeID = (Integer) session.save(employee);
tx.commit();
}catch (HibernateException e) {
if (tx!=null) tx.rollback();
e.printStackTrace();
}finally {
session.close();
}
return employeeID;
}
/* Method to READ all the employees having salary more than 2000 */
public void listEmployees( ){
Session session = factory.openSession();
Transaction tx = null;
try{
tx = session.beginTransaction();
Criteria cr = session.createCriteria(Employee.class);
// Add restriction.
cr.add(Restrictions.gt("salary", 2000));
List employees = cr.list();
for (Iterator iterator =
employees.iterator(); iterator.hasNext();){
Employee employee = (Employee) iterator.next();
System.out.print("First Name: " + employee.getFirstName());
System.out.print(" Last Name: " + employee.getLastName());
System.out.println(" Salary: " + employee.getSalary());
}
tx.commit();
}catch (HibernateException e) {
if (tx!=null) tx.rollback();
e.printStackTrace();
}finally {
session.close();
}
}
/* Method to print total number of records */
public void countEmployee(){
Session session = factory.openSession();
Transaction tx = null;
try{
tx = session.beginTransaction();
Criteria cr = session.createCriteria(Employee.class);
// To get total row count.
cr.setProjection(Projections.rowCount());
List rowCount = cr.list();
System.out.println("Total Coint: " + rowCount.get(0) );
tx.commit();
}catch (HibernateException e) {
if (tx!=null) tx.rollback();
e.printStackTrace();
}finally {
session.close();
}
}
/* Method to print sum of salaries */
public void totalSalary(){
Session session = factory.openSession();
Transaction tx = null;
try{
tx = session.beginTransaction();
Criteria cr = session.createCriteria(Employee.class);
// To get total salary.
cr.setProjection(Projections.sum("salary"));
List totalSalary = cr.list();
System.out.println("Total Salary: " + totalSalary.get(0) );
tx.commit();
}catch (HibernateException e) {
if (tx!=null) tx.rollback();
e.printStackTrace();
}finally {
session.close();
}
}
}
The java.lang.Throwable.printStackTrace() strategy prints this throwable and its backtrace to the standard mistake stream. It prints a stack follow for this Throwable item on the mistake yield stream that is the estimation of the field System.err.
Output
When compile the code from main method result will be as follows.
First Name: Daisy Last Name: Das Salary: 5000 First Name: John Last Name: Paul Salary: 5000 First Name: Mohd Last Name: Yasee Salary: 3000 Total Coint: 4 Total Salary: 15000
Now check the database.
Points
- The important point is that criteria is only for selecting objects from the database.
- Criteria has the ability to execute dynamic queries.
- Criteria supports pagination where as HQL does not support pagination.