Figure 8.1 illustrates a one-to-one relationship from the address attribute of an Employee object to an Address object.
Figure 8.1
According to the relationship each Employee should have a unique address. Since the Student and Address entities are strongly related (composition relation), it is better to store them in a single table. The relational model is shown below.in Figure 8.2
Relational Database
Figure 8.2
First create a new Java Project and configure it as Maven Project. For Reference, Click Here
Add the following dependencies in pom.xml
<dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.8.2</version> <scope>test</scope> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.15</version> </dependency> <dependency> <groupId>org.hibernate</groupId> <artifactId>hibernate-core</artifactId> <version>3.6.3.Final</version> </dependency> <dependency> <groupId>javassist</groupId> <artifactId>javassist</artifactId> <version>3.12.1.GA</version> </dependency> <dependency> <groupId>org.slf4j</groupId> <artifactId>slf4j-log4j12</artifactId> <version>1.6.6</version> </dependency> </dependencies>
1. Sql Script
Use the following Sql Script for creating table.
create table Employee( EMPLOYEE_ID int(10) primary key NOT NULL AUTO_INCREMENT, Name varchar(50), City varchar(50), Country varchar(50), Province varchar(50));
2. Pojo
Now create Employee and Address Class as following.
Employee.java
package com.kruders.model.bean; public class Employee { private int employeeId; private String name; private Address address; public Address getAddress() { return address; } public void setAddress(Address address) { this.address = address; } public Employee() { } public Employee(String name) { this.name = name; } public int getEmployeeId() { return employeeId; } public void setEmployeeId(int employeeId) { this.employeeId = employeeId; } public String getName() { return name; } public void setName(String name) { this.name = name; } }
Address.java
package com.kruders.model.bean; public class Address { private int employeeId; private String city; private String country; private String province; private Employee employee; public Address() { } public Address(String city, String province, String country) { this.city = city; this.province = province; this.country = country; } public Employee getEmployee() { return employee; } public void setEmployee(Employee employee) { this.employee = employee; } public String getCity() { return city; } public void setCity(String city) { this.city = city; } public String getProvince() { return province; } public void setProvince(String province) { this.province = province; } public String getCountry() { return country; } public void setCountry(String country) { this.country = country; } public int getEmployeeId() { return employeeId; } public void setEmployeeId(int employeeId) { this.employeeId = employeeId; } }
The @Embedded Annotation is used to specify the Address entity should be stored in the Employee table as a component.
3. Hibernate Configuration File
Now create the hibernate configuration file and add all the mapping files.
hibernate.cfg.xml
<?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> <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property> <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/test</property> <property name="hibernate.connection.username">root</property> <property name="hibernate.connection.password"></property> <property name="connection.pool_size">1</property> <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property> <property name="show_sql">true</property> <mapping class="com.kruders.model.bean.Employee" /> </session-factory> </hibernate-configuration>
4. Hibernate Utility Class
Now create HibernateUtil class. The HibernateUtil class helps in creating the SessionFactory from the Hibernate configuration file. A org.hibernate.SessionFactory is used to obtain org.hibernate.Session instances. A org.hibernate.Session represents a single-threaded unit of work. The org.hibernate.SessionFactory is a thread-safe global object that is instantiated once.
package com.kruders.util; import org.hibernate.SessionFactory; import org.hibernate.cfg.AnnotationConfiguration; public class HibernateUtil { private static final SessionFactory sessionFactory = buildSessionFactory(); private static SessionFactory buildSessionFactory() { try { // Create the SessionFactory from hibernate.cfg.xml return new AnnotationConfiguration().configure().buildSessionFactory(); } 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); } } public static SessionFactory getSessionFactory() { return sessionFactory; } }
5. Run Program
Create Main.java> class that perform CRUD operations and run it as Java Application
package com.kruders.core; import java.util.Iterator; import java.util.List; import org.hibernate.HibernateException; import org.hibernate.Session; import org.hibernate.Transaction; import com.kruders.model.bean.Address; import com.kruders.model.bean.Employee; import com.kruders.util.HibernateUtil; public class Main { public static void main(String args[]) { Session session = HibernateUtil.getSessionFactory().openSession(); Transaction transaction = null; try { transaction = session.beginTransaction(); Address address = new Address("New Delhi", "Delhi", "India"); Employee employee = new Employee("Puneet"); employee.setAddress(address); session.save(employee); transaction.commit(); }catch (HibernateException e) { transaction.rollback(); e.printStackTrace(); } finally { session.close(); } //updateEmployee("Puneet", "Raghav", "LA", "Delhi"); //listEmployee(); //deleteEmployee(2); } public void listEmployee() { Session session = HibernateUtil.getSessionFactory().openSession(); Transaction transaction = null; try { transaction = session.beginTransaction(); List employees = session.createQuery("from Employee").list(); for (Iterator iterator = employees.iterator(); iterator.hasNext();) { Employee employee = (Employee) iterator.next(); System.out.println("Name " + employee.getName()); System.out.println("City " + employee.getAddress().getCity()); } transaction.commit(); } catch (HibernateException e) { transaction.rollback(); e.printStackTrace(); } finally { session.close(); } } public void updateEmployee(String oldName, String newName, String oldCity, String newCity) { Session session = HibernateUtil.getSessionFactory().openSession(); Transaction transaction = null; try { transaction = session.beginTransaction(); List employees = session.createQuery("from Employee where Name ='" + oldName + "'").list(); for (Iterator iterator = employees.iterator(); iterator.hasNext();) { Employee employee = (Employee) iterator.next(); employee.setName(newName); employee.getAddress().setCity(newCity); } transaction.commit(); } catch (HibernateException e) { transaction.rollback(); e.printStackTrace(); } finally { session.close(); } } public void deleteEmployee(Integer employeeId) { Session session = HibernateUtil.getSessionFactory().openSession(); Transaction transaction = null; try { transaction = session.beginTransaction(); List employees = session.createQuery("from Employee where employeeId ='" + employeeId + "'").list(); for (Iterator iterator = employees.iterator(); iterator.hasNext();) { Employee employee = (Employee) iterator.next(); session.delete(employee); } transaction.commit(); } catch (HibernateException e) { transaction.rollback(); e.printStackTrace(); } finally { session.close(); } } }
The folder structure of the example is shown below in Figure 8.3
Figure 8.3
No comments yet.