├── HibernateSample ├── pom.xml └── src │ ├── main │ ├── java │ │ └── com │ │ │ └── home │ │ │ └── hibernate │ │ │ └── entity │ │ │ ├── Address.java │ │ │ ├── Car.java │ │ │ ├── CarOwner.java │ │ │ ├── FourWheeler.java │ │ │ ├── House.java │ │ │ ├── Insurance.java │ │ │ ├── Owner.java │ │ │ ├── Person.java │ │ │ ├── Phone.java │ │ │ ├── TwoWheeler.java │ │ │ └── Vehicle.java │ └── resources │ │ └── hibernate.cfg.xml │ └── test │ └── java │ └── com │ └── home │ └── hibernate │ └── test │ └── HibernateTest.java └── README.md /HibernateSample/pom.xml: -------------------------------------------------------------------------------- 1 | 3 | 4.0.0 4 | 5 | com.home.hibernate 6 | HibernateSample 7 | 1.0 8 | jar 9 | 10 | HibernateSample 11 | http://maven.apache.org 12 | 13 | 14 | 3.5.1 15 | 4.12 16 | 5.1.0.Final 17 | 2.3.3 18 | 19 | 20 | 21 | 22 | junit 23 | junit 24 | ${junit.version} 25 | test 26 | 27 | 28 | 29 | org.hibernate 30 | hibernate-core 31 | ${hibernate.version} 32 | 33 | 34 | 35 | org.hsqldb 36 | hsqldb 37 | ${hsqldb.verson} 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | org.apache.maven.plugins 50 | maven-compiler-plugin 51 | ${maven.compiler.plugin.version} 52 | 53 | 54 | 1.7 55 | 1.7 56 | 57 | 58 | 59 | 60 | 61 | -------------------------------------------------------------------------------- /HibernateSample/src/main/java/com/home/hibernate/entity/Address.java: -------------------------------------------------------------------------------- 1 | package com.home.hibernate.entity; 2 | 3 | import javax.persistence.Embeddable; 4 | 5 | /** 6 | * @author preetham 7 | */ 8 | @Embeddable 9 | public class Address 10 | { 11 | 12 | private String street; 13 | private String city; 14 | private String state; 15 | private String pincode; 16 | 17 | public Address() 18 | { 19 | 20 | } 21 | 22 | public Address( String street, String city, String state, String pincode ) 23 | { 24 | this.street = street; 25 | this.state = state; 26 | this.city = city; 27 | this.pincode = pincode; 28 | } 29 | 30 | public String getStreet() 31 | { 32 | return street; 33 | } 34 | 35 | public void setStreet( String street ) 36 | { 37 | this.street = street; 38 | } 39 | 40 | public String getCity() 41 | { 42 | return city; 43 | } 44 | 45 | public void setCity( String city ) 46 | { 47 | this.city = city; 48 | } 49 | 50 | public String getState() 51 | { 52 | return state; 53 | } 54 | 55 | public void setState( String state ) 56 | { 57 | this.state = state; 58 | } 59 | 60 | public String getPincode() 61 | { 62 | return pincode; 63 | } 64 | 65 | public void setPincode( String pincode ) 66 | { 67 | this.pincode = pincode; 68 | } 69 | 70 | @Override 71 | public String toString() 72 | { 73 | return "Address [street=" + street + ", city=" + city + ", state=" + state + ", pincode=" + pincode + "]"; 74 | } 75 | 76 | } 77 | -------------------------------------------------------------------------------- /HibernateSample/src/main/java/com/home/hibernate/entity/Car.java: -------------------------------------------------------------------------------- 1 | package com.home.hibernate.entity; 2 | 3 | import java.util.ArrayList; 4 | import java.util.Collection; 5 | 6 | import javax.persistence.Entity; 7 | import javax.persistence.GeneratedValue; 8 | import javax.persistence.GenerationType; 9 | import javax.persistence.Id; 10 | import javax.persistence.JoinColumn; 11 | import javax.persistence.JoinTable; 12 | import javax.persistence.ManyToMany; 13 | 14 | /** 15 | * @author preetham 16 | */ 17 | @Entity 18 | public class Car 19 | { 20 | @Id 21 | @GeneratedValue( strategy = GenerationType.AUTO ) 22 | private int id; 23 | private String name; 24 | @ManyToMany 25 | @JoinTable( name = "CAR_CAROWNER", joinColumns = @JoinColumn( name = "CAR_OWNER_ID" ), inverseJoinColumns = @JoinColumn( name = "CAR_ID" ) ) 26 | private Collection owners = new ArrayList<>(); // mappedBy="owners" 27 | 28 | public Car() 29 | { 30 | // TODO Auto-generated constructor stub 31 | } 32 | 33 | public Car( String name ) 34 | { 35 | this.name = name; 36 | } 37 | 38 | public int getId() 39 | { 40 | return id; 41 | } 42 | 43 | public void setId( int id ) 44 | { 45 | this.id = id; 46 | } 47 | 48 | public String getName() 49 | { 50 | return name; 51 | } 52 | 53 | public void setName( String name ) 54 | { 55 | this.name = name; 56 | } 57 | 58 | public Collection getOwners() 59 | { 60 | return owners; 61 | } 62 | 63 | public void setOwners( Collection owners ) 64 | { 65 | this.owners = owners; 66 | } 67 | 68 | } 69 | -------------------------------------------------------------------------------- /HibernateSample/src/main/java/com/home/hibernate/entity/CarOwner.java: -------------------------------------------------------------------------------- 1 | package com.home.hibernate.entity; 2 | 3 | import java.util.ArrayList; 4 | import java.util.Collection; 5 | 6 | import javax.persistence.CascadeType; 7 | import javax.persistence.Entity; 8 | import javax.persistence.GeneratedValue; 9 | import javax.persistence.GenerationType; 10 | import javax.persistence.Id; 11 | import javax.persistence.ManyToMany; 12 | import javax.persistence.Transient; 13 | 14 | /** 15 | * @author preetham 16 | */ 17 | @Entity 18 | public class CarOwner 19 | { 20 | @Id 21 | @GeneratedValue( strategy = GenerationType.AUTO ) 22 | private int id; 23 | private String name; 24 | @Transient 25 | private String details; 26 | @ManyToMany( cascade = CascadeType.ALL, mappedBy = "owners" ) 27 | private Collection cars = new ArrayList<>(); 28 | 29 | public CarOwner() 30 | { 31 | // TODO Auto-generated constructor stub 32 | } 33 | 34 | public CarOwner( String name ) 35 | { 36 | this.name = name; 37 | } 38 | 39 | public int getId() 40 | { 41 | return id; 42 | } 43 | 44 | public void setId( int id ) 45 | { 46 | this.id = id; 47 | } 48 | 49 | public String getName() 50 | { 51 | return name; 52 | } 53 | 54 | public void setName( String name ) 55 | { 56 | this.name = name; 57 | } 58 | 59 | public Collection getCars() 60 | { 61 | return cars; 62 | } 63 | 64 | public void setCars( Collection cars ) 65 | { 66 | this.cars = cars; 67 | } 68 | 69 | public String getDetails() 70 | { 71 | return details; 72 | } 73 | 74 | public void setDetails( String details ) 75 | { 76 | this.details = details; 77 | } 78 | 79 | } 80 | -------------------------------------------------------------------------------- /HibernateSample/src/main/java/com/home/hibernate/entity/FourWheeler.java: -------------------------------------------------------------------------------- 1 | package com.home.hibernate.entity; 2 | 3 | import javax.persistence.DiscriminatorValue; 4 | import javax.persistence.Entity; 5 | 6 | /** 7 | * @author preetham 8 | */ 9 | @Entity 10 | @DiscriminatorValue( "CAR" ) 11 | public class FourWheeler extends Vehicle 12 | { 13 | private String steeringWheel; 14 | 15 | public String getSteeringWheel() 16 | { 17 | return steeringWheel; 18 | } 19 | 20 | public void setSteeringWheel( String steeringWheel ) 21 | { 22 | this.steeringWheel = steeringWheel; 23 | } 24 | 25 | } 26 | -------------------------------------------------------------------------------- /HibernateSample/src/main/java/com/home/hibernate/entity/House.java: -------------------------------------------------------------------------------- 1 | package com.home.hibernate.entity; 2 | 3 | import javax.persistence.Entity; 4 | import javax.persistence.GeneratedValue; 5 | import javax.persistence.GenerationType; 6 | import javax.persistence.Id; 7 | import javax.persistence.JoinColumn; 8 | import javax.persistence.ManyToOne; 9 | 10 | /** 11 | * @author preetham 12 | */ 13 | @Entity 14 | public class House 15 | { 16 | @Id 17 | @GeneratedValue( strategy = GenerationType.AUTO ) 18 | private int id; 19 | private String name; 20 | @ManyToOne 21 | @JoinColumn( name = "OWNER_ID" ) 22 | private Owner owner; // mappedBy 23 | 24 | public int getId() 25 | { 26 | return id; 27 | } 28 | 29 | public void setId( int id ) 30 | { 31 | this.id = id; 32 | } 33 | 34 | public Owner getOwner() 35 | { 36 | return owner; 37 | } 38 | 39 | public void setOwner( Owner owner ) 40 | { 41 | this.owner = owner; 42 | } 43 | 44 | public String getName() 45 | { 46 | return name; 47 | } 48 | 49 | public void setName( String name ) 50 | { 51 | this.name = name; 52 | } 53 | 54 | public House() 55 | { 56 | // TODO Auto-generated constructor stub 57 | } 58 | 59 | public House( String name ) 60 | { 61 | this.name = name; 62 | } 63 | 64 | } 65 | -------------------------------------------------------------------------------- /HibernateSample/src/main/java/com/home/hibernate/entity/Insurance.java: -------------------------------------------------------------------------------- 1 | package com.home.hibernate.entity; 2 | 3 | import javax.persistence.Embeddable; 4 | 5 | /** 6 | * @author preetham 7 | */ 8 | @Embeddable 9 | public class Insurance 10 | { 11 | private String name; 12 | private String level; 13 | 14 | public Insurance() 15 | { 16 | 17 | } 18 | 19 | public Insurance( String name, String level ) 20 | { 21 | this.name = name; 22 | this.level = level; 23 | } 24 | 25 | public String getName() 26 | { 27 | return name; 28 | } 29 | 30 | public void setName( String name ) 31 | { 32 | this.name = name; 33 | } 34 | 35 | public String getLevel() 36 | { 37 | return level; 38 | } 39 | 40 | public void setLevel( String level ) 41 | { 42 | this.level = level; 43 | } 44 | 45 | @Override 46 | public String toString() 47 | { 48 | return "Company [name=" + name + ", level=" + level + "]"; 49 | } 50 | 51 | } 52 | -------------------------------------------------------------------------------- /HibernateSample/src/main/java/com/home/hibernate/entity/Owner.java: -------------------------------------------------------------------------------- 1 | package com.home.hibernate.entity; 2 | 3 | import java.util.ArrayList; 4 | import java.util.Collection; 5 | 6 | import javax.persistence.Entity; 7 | import javax.persistence.GeneratedValue; 8 | import javax.persistence.GenerationType; 9 | import javax.persistence.Id; 10 | import javax.persistence.OneToMany; 11 | 12 | /** 13 | * @author preetham 14 | */ 15 | @Entity 16 | public class Owner 17 | { 18 | @Id 19 | @GeneratedValue( strategy = GenerationType.AUTO ) 20 | private int id; 21 | private String name; 22 | @OneToMany( mappedBy = "owner" ) 23 | private Collection house = new ArrayList(); 24 | 25 | public int getId() 26 | { 27 | return id; 28 | } 29 | 30 | public void setId( int id ) 31 | { 32 | this.id = id; 33 | } 34 | 35 | public Collection getHouse() 36 | { 37 | return house; 38 | } 39 | 40 | public void setHouse( Collection house ) 41 | { 42 | this.house = house; 43 | } 44 | 45 | public String getName() 46 | { 47 | return name; 48 | } 49 | 50 | public void setName( String name ) 51 | { 52 | this.name = name; 53 | } 54 | 55 | public Owner() 56 | { 57 | // TODO Auto-generated constructor stub 58 | } 59 | 60 | public Owner( String name ) 61 | { 62 | this.name = name; 63 | } 64 | 65 | } 66 | -------------------------------------------------------------------------------- /HibernateSample/src/main/java/com/home/hibernate/entity/Person.java: -------------------------------------------------------------------------------- 1 | package com.home.hibernate.entity; 2 | 3 | import java.util.ArrayList; 4 | import java.util.Collection; 5 | import java.util.Date; 6 | 7 | import javax.persistence.AttributeOverride; 8 | import javax.persistence.AttributeOverrides; 9 | import javax.persistence.Column; 10 | import javax.persistence.ElementCollection; 11 | import javax.persistence.Embedded; 12 | import javax.persistence.Entity; 13 | import javax.persistence.GeneratedValue; 14 | import javax.persistence.GenerationType; 15 | import javax.persistence.Id; 16 | import javax.persistence.JoinColumn; 17 | import javax.persistence.JoinTable; 18 | import javax.persistence.OneToMany; 19 | import javax.persistence.OneToOne; 20 | import javax.persistence.Table; 21 | import javax.persistence.Temporal; 22 | import javax.persistence.TemporalType; 23 | 24 | /** 25 | * @author preetham 26 | */ 27 | @Entity 28 | @Table( name = "PERSON" ) 29 | public class Person 30 | { 31 | @Id 32 | @GeneratedValue( strategy = GenerationType.AUTO ) 33 | @Column( name = "id" ) 34 | private long id; 35 | @Column( name = "FIRST_NAME" ) 36 | private String firstName; 37 | @Column( name = "LAST_NAME" ) 38 | private String lastName; 39 | @Column( name = "EMAIL" ) 40 | private String email; 41 | @Column( name = "JOINED_DATE" ) 42 | @Temporal( TemporalType.DATE ) 43 | private Date joinedDate; 44 | 45 | @Embedded 46 | @AttributeOverrides( { 47 | 48 | @AttributeOverride( name = "street", column = @Column( name = "OFFICE_STREET" ) ), @AttributeOverride( name = "city", column = @Column( name = "OFFICE_CITY" ) ), @AttributeOverride( name = "state", column = @Column( name = "OFFICE_STATE" ) ), 49 | @AttributeOverride( name = "pincode", column = @Column( name = "OFFICE_PINCODE" ) ) 50 | 51 | } ) 52 | private Address officeAddress; 53 | 54 | @Embedded 55 | private Address homeAddress; 56 | 57 | @ElementCollection 58 | // ( fetch = FetchType.EAGER ) //Uncomment the ( fetch = FetchType.EAGER ) for testing testEagerLoading 59 | @JoinTable( name = "PERSON_INSURANCES", joinColumns = @JoinColumn( name = "PERSON_ID" ) ) 60 | private Collection insurances = new ArrayList(); 61 | 62 | @OneToOne 63 | @JoinColumn( name = "VEHICLE_ID" ) 64 | private Vehicle vehicle; 65 | 66 | @OneToMany 67 | @JoinTable( name = "PERSON_PHONES", joinColumns = @JoinColumn( name = "PERSON_ID" ), inverseJoinColumns = @JoinColumn( name = "PHONE_ID" ) 68 | 69 | ) 70 | private Collection phones = new ArrayList<>(); 71 | 72 | public Person() 73 | { 74 | 75 | } 76 | 77 | public Person( String firstName, String lastName, String email, Date joinedDate ) 78 | { 79 | this.firstName = firstName; 80 | this.lastName = lastName; 81 | this.email = email; 82 | this.joinedDate = joinedDate; 83 | 84 | } 85 | 86 | public Collection getPhones() 87 | { 88 | return phones; 89 | } 90 | 91 | public void setPhones( Collection phones ) 92 | { 93 | this.phones = phones; 94 | } 95 | 96 | public Address getOfficeAddress() 97 | { 98 | return officeAddress; 99 | } 100 | 101 | public void setOfficeAddress( Address officeAddress ) 102 | { 103 | this.officeAddress = officeAddress; 104 | } 105 | 106 | public Address getHomeAddress() 107 | { 108 | return homeAddress; 109 | } 110 | 111 | public void setHomeAddress( Address homeAddress ) 112 | { 113 | this.homeAddress = homeAddress; 114 | } 115 | 116 | public String getFirstName() 117 | { 118 | return firstName; 119 | } 120 | 121 | public void setFirstName( String firstName ) 122 | { 123 | this.firstName = firstName; 124 | } 125 | 126 | public String getLastName() 127 | { 128 | return lastName; 129 | } 130 | 131 | public void setLastName( String lastName ) 132 | { 133 | this.lastName = lastName; 134 | } 135 | 136 | public String getEmail() 137 | { 138 | return email; 139 | } 140 | 141 | public void setEmail( String email ) 142 | { 143 | this.email = email; 144 | } 145 | 146 | public Date getJoinedDate() 147 | { 148 | return joinedDate; 149 | } 150 | 151 | public void setJoinedDate( Date joinedDate ) 152 | { 153 | this.joinedDate = joinedDate; 154 | } 155 | 156 | public long getId() 157 | { 158 | return id; 159 | } 160 | 161 | public void setId( long id ) 162 | { 163 | this.id = id; 164 | } 165 | 166 | public Collection getInsurances() 167 | { 168 | return insurances; 169 | } 170 | 171 | public void setInsurances( Collection insurance ) 172 | { 173 | this.insurances = insurance; 174 | } 175 | 176 | public Vehicle getVehicle() 177 | { 178 | return vehicle; 179 | } 180 | 181 | public void setVehicle( Vehicle vehicle ) 182 | { 183 | this.vehicle = vehicle; 184 | } 185 | 186 | @Override 187 | public String toString() 188 | { 189 | return "Person [id=" + id + ", firstName=" + firstName + ", lastName=" + lastName + ", email=" + email + ", joinedDate=" + joinedDate + ", officeAddress=" + officeAddress + ", homeAddress=" + homeAddress + ", insurances=" + insurances + "]"; 190 | } 191 | 192 | } 193 | -------------------------------------------------------------------------------- /HibernateSample/src/main/java/com/home/hibernate/entity/Phone.java: -------------------------------------------------------------------------------- 1 | package com.home.hibernate.entity; 2 | 3 | import javax.persistence.Column; 4 | import javax.persistence.Entity; 5 | import javax.persistence.GeneratedValue; 6 | import javax.persistence.GenerationType; 7 | import javax.persistence.Id; 8 | import javax.persistence.NamedNativeQuery; 9 | import javax.persistence.NamedQuery; 10 | 11 | /** 12 | * @author preetham 13 | */ 14 | @Entity 15 | @NamedQuery( name = "Phone.byName", query = "from Phone where name=?" ) 16 | @NamedNativeQuery( name = "Phone.byId", query = "select * from PHONE where PHONE_ID=:id", resultClass = Phone.class ) 17 | public class Phone 18 | { 19 | @Id 20 | @Column( name = "PHONE_ID" ) 21 | @GeneratedValue( strategy = GenerationType.AUTO ) 22 | private int id; 23 | 24 | public Phone() 25 | { 26 | 27 | } 28 | 29 | public Phone( String name ) 30 | { 31 | this.name = name; 32 | } 33 | private String name; 34 | 35 | public int getId() 36 | { 37 | return id; 38 | } 39 | 40 | public void setId( int id ) 41 | { 42 | this.id = id; 43 | } 44 | 45 | public String getName() 46 | { 47 | return name; 48 | } 49 | 50 | public void setName( String name ) 51 | { 52 | this.name = name; 53 | } 54 | 55 | } 56 | -------------------------------------------------------------------------------- /HibernateSample/src/main/java/com/home/hibernate/entity/TwoWheeler.java: -------------------------------------------------------------------------------- 1 | package com.home.hibernate.entity; 2 | 3 | import javax.persistence.DiscriminatorValue; 4 | import javax.persistence.Entity; 5 | 6 | /** 7 | * @author preetham 8 | */ 9 | @Entity 10 | @DiscriminatorValue( "BIKE" ) 11 | public class TwoWheeler extends Vehicle 12 | { 13 | private String steeringHandle; 14 | 15 | public String getSteeringHandle() 16 | { 17 | return steeringHandle; 18 | } 19 | 20 | public void setSteeringHandle( String steeringHandle ) 21 | { 22 | this.steeringHandle = steeringHandle; 23 | } 24 | 25 | } 26 | -------------------------------------------------------------------------------- /HibernateSample/src/main/java/com/home/hibernate/entity/Vehicle.java: -------------------------------------------------------------------------------- 1 | package com.home.hibernate.entity; 2 | 3 | import javax.persistence.Column; 4 | import javax.persistence.Entity; 5 | import javax.persistence.GeneratedValue; 6 | import javax.persistence.GenerationType; 7 | import javax.persistence.Id; 8 | import javax.persistence.Table; 9 | 10 | /** 11 | * @author preetham 12 | */ 13 | @Entity 14 | @Table( name = "VEHICLE" ) 15 | // @Inheritance(strategy=InheritanceType.SINGLE_TABLE) //testSingleTableStrategy test case 16 | // @DiscriminatorColumn(name="VEHICLE_TYPE", discriminatorType=DiscriminatorType.STRING) //testSingleTableStrategy test case 17 | // @Inheritance(strategy=InheritanceType.TABLE_PER_CLASS) //testTablePerClassStrategy test case 18 | // @Inheritance(strategy=InheritanceType.JOINED) //testTableJoinedStrategy test case 19 | public class Vehicle 20 | { 21 | @Id 22 | @GeneratedValue( strategy = GenerationType.AUTO ) 23 | @Column( name = "VEHICLE_ID" ) 24 | private int id; 25 | 26 | @Column( name = "VEHICLE_NAME" ) 27 | private String name; 28 | 29 | public Vehicle() 30 | { 31 | 32 | } 33 | 34 | public Vehicle( String name ) 35 | { 36 | this.name = name; 37 | } 38 | 39 | public int getId() 40 | { 41 | return id; 42 | } 43 | 44 | public void setId( int id ) 45 | { 46 | this.id = id; 47 | } 48 | 49 | public String getName() 50 | { 51 | return name; 52 | } 53 | 54 | public void setName( String name ) 55 | { 56 | this.name = name; 57 | } 58 | 59 | @Override 60 | public String toString() 61 | { 62 | return "Vehicle [id=" + id + ", name=" + name + "]"; 63 | } 64 | 65 | } 66 | -------------------------------------------------------------------------------- /HibernateSample/src/main/resources/hibernate.cfg.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 6 | 7 | 8 | 9 | org.hsqldb.jdbc.JDBCDriver 10 | jdbc:hsqldb:hsql://localhost/ 11 | sa 12 | 13 | 14 | 15 | 1 16 | 17 | 18 | org.hibernate.dialect.HSQLDialect 19 | 20 | 21 | thread 22 | 23 | 24 | org.hibernate.cache.NoCacheProvider 25 | 26 | true 27 | 28 | 29 | create 30 | 31 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | -------------------------------------------------------------------------------- /HibernateSample/src/test/java/com/home/hibernate/test/HibernateTest.java: -------------------------------------------------------------------------------- 1 | package com.home.hibernate.test; 2 | 3 | import static org.junit.Assert.assertEquals; 4 | import static org.junit.Assert.assertNotEquals; 5 | import static org.junit.Assert.assertNull; 6 | 7 | import java.util.List; 8 | 9 | import org.hibernate.Criteria; 10 | import org.hibernate.LazyInitializationException; 11 | import org.hibernate.Query; 12 | import org.hibernate.Session; 13 | import org.hibernate.SessionFactory; 14 | import org.hibernate.cfg.Configuration; 15 | import org.hibernate.criterion.Example; 16 | import org.hibernate.criterion.Order; 17 | import org.hibernate.criterion.Projections; 18 | import org.hibernate.criterion.Restrictions; 19 | import org.junit.AfterClass; 20 | import org.junit.BeforeClass; 21 | import org.junit.Test; 22 | 23 | import com.home.hibernate.entity.Address; 24 | import com.home.hibernate.entity.Car; 25 | import com.home.hibernate.entity.CarOwner; 26 | import com.home.hibernate.entity.FourWheeler; 27 | import com.home.hibernate.entity.House; 28 | import com.home.hibernate.entity.Insurance; 29 | import com.home.hibernate.entity.Owner; 30 | import com.home.hibernate.entity.Person; 31 | import com.home.hibernate.entity.Phone; 32 | import com.home.hibernate.entity.TwoWheeler; 33 | import com.home.hibernate.entity.Vehicle; 34 | 35 | /** 36 | * @author preetham 37 | */ 38 | public class HibernateTest 39 | { 40 | private static SessionFactory sessionFactory = null; 41 | 42 | @BeforeClass 43 | public static void setUp() throws Exception 44 | { 45 | sessionFactory = new Configuration().configure().buildSessionFactory(); 46 | 47 | } 48 | 49 | @AfterClass 50 | public static void tearDown() throws Exception 51 | { 52 | sessionFactory.close(); 53 | } 54 | 55 | @Test 56 | public void testSaveOperation() 57 | { 58 | System.out.println( "testSaveOperation begins ........ This is \"C\" of CRUD" ); 59 | Person person = new Person( "James", "Bond", "007@jamesbond.com", new java.util.Date() ); 60 | Person person2 = new Person( "Forest", "Gump", "forestgump@jamesbond.com", new java.util.Date() ); 61 | 62 | Session session = sessionFactory.openSession(); 63 | session.beginTransaction(); 64 | 65 | session.save( person ); 66 | session.save( person2 ); 67 | 68 | session.getTransaction().commit(); 69 | session.close(); 70 | System.out.println( "testSaveOperation ends ......." ); 71 | 72 | } 73 | 74 | @Test 75 | public void testRetriveOnePerson() 76 | { 77 | System.out.println( "testRetriveOnePerson begins .......This is \"R\" of CRUD" ); 78 | testSaveOperation(); 79 | Session session = sessionFactory.openSession(); 80 | session.beginTransaction(); 81 | 82 | Person p = session.get( Person.class, 1L ); 83 | 84 | session.getTransaction().commit(); 85 | System.out.println( "Retrieved person from DB is " + p ); 86 | session.close(); 87 | assertEquals( 1L, p.getId() ); 88 | System.out.println( "testRetriveOnePerson ends ......." ); 89 | 90 | } 91 | 92 | @Test 93 | public void testUpdateOnePerson() 94 | { 95 | System.out.println( "testRetriveOnePerson begins .......This is \"U\" of CRUD" ); 96 | testSaveOperation(); 97 | Session session = sessionFactory.openSession(); 98 | session.beginTransaction(); 99 | 100 | Person p = session.get( Person.class, 1L ); 101 | System.out.println( "Retrieved person from DB is " + p ); 102 | p.setFirstName( "Changing the name" ); 103 | session.update( p ); 104 | session.getTransaction().commit(); 105 | System.out.println( "Updated the person, so retrieve one more time to confirm" ); 106 | Person p2 = session.get( Person.class, 1L ); 107 | System.out.println( "Retrieved person from DB after updation is " + p2 ); 108 | session.close(); 109 | assertEquals( 1L, p.getId() ); 110 | System.out.println( "testRetriveOnePerson ends ......." ); 111 | 112 | } 113 | 114 | @Test 115 | public void testDeletePerson() 116 | { 117 | System.out.println( "testRetriveOnePerson begins .......This is \"D\" of CRUD" ); 118 | testSaveOperation(); 119 | Session session = sessionFactory.openSession(); 120 | session.beginTransaction(); 121 | 122 | Person p = session.get( Person.class, 1L ); 123 | System.out.println( "Retrieved person from DB is " + p ); 124 | session.delete( p ); 125 | session.getTransaction().commit(); 126 | System.out.println( "Deleted the person, so retrieve one more time to confirm" ); 127 | Person p2 = session.get( Person.class, 1L ); 128 | System.out.println( "Retrieved person from DB after deletion is " + p2 ); 129 | session.close(); 130 | assertNull( p2 ); 131 | System.out.println( "testRetriveOnePerson ends ......." ); 132 | 133 | } 134 | 135 | @Test 136 | public void testEmbeddedObjectWithAttributeOverride() 137 | { 138 | System.out.println( "testEmbeddedObjectWithAttributeOverride begins" ); 139 | Session session = sessionFactory.openSession(); 140 | session.beginTransaction(); 141 | Person person = new Person( "James", "Bond", "007@jamesbond.com", new java.util.Date() ); 142 | 143 | Address addr1 = new Address( "Baker street", "Bangalore", "Karnataka", "560034" ); 144 | Address addr2 = new Address( "Walker street", "Chennai", "Tamil Nadu", "560021" ); 145 | 146 | person.setHomeAddress( addr1 ); 147 | person.setOfficeAddress( addr2 ); 148 | 149 | session.save( person ); 150 | session.getTransaction().commit(); 151 | session.close(); 152 | System.out.println( "testEmbeddedObjectWithAttributeOverride ends ......." ); 153 | 154 | } 155 | 156 | @Test 157 | public void testElementCollection() 158 | { 159 | System.out.println( "testElementCollection begins" ); 160 | Session session = sessionFactory.openSession(); 161 | session.beginTransaction(); 162 | Person person = new Person( "James", "Bond", "007@jamesbond.com", new java.util.Date() ); 163 | 164 | Insurance insurance = new Insurance( "ABC", "400" ); 165 | Insurance insurance1 = new Insurance( "XYZ", "500" ); 166 | person.getInsurances().add( insurance ); 167 | person.getInsurances().add( insurance1 ); 168 | 169 | session.save( person ); 170 | session.getTransaction().commit(); 171 | session.close(); 172 | System.out.println( "testElementCollection ends ......." ); 173 | 174 | } 175 | 176 | @Test( expected = LazyInitializationException.class ) 177 | public void testLazyLoading() 178 | { 179 | System.out.println( "testLazyLoading begins ......." ); 180 | testElementCollection(); 181 | Session session = sessionFactory.openSession(); 182 | session.beginTransaction(); 183 | Person p = session.get( Person.class, 1L ); 184 | session.getTransaction().commit(); 185 | session.close(); 186 | System.out.println( "Test case is passed if the LazyInitializationException occurs, if there is no expception next line will have the list of insurances" ); 187 | System.out.println( p.getInsurances() ); 188 | System.out.println( "testLazyLoading ends ......." ); 189 | 190 | } 191 | 192 | @Test 193 | public void testEagerLoading() 194 | { 195 | System.out.println( "testEagerLoading begins ......Prequsite is change the fetch type to eager for insurances variable in Person class. @ElementCollection(fetch=FetchType.EAGER)" ); 196 | testElementCollection(); 197 | Session session = sessionFactory.openSession(); 198 | session.beginTransaction(); 199 | Person p = session.get( Person.class, 1L ); 200 | session.getTransaction().commit(); 201 | session.close(); 202 | System.out.println( "Test case is passed if there is no LazyInitializationException occurs, if there is no expception next line will have the list of companies" ); 203 | System.out.println( p.getInsurances() ); 204 | System.out.println( "testEagerLoading ends ......." ); 205 | 206 | } 207 | 208 | @Test 209 | public void testOneToOneMapping() 210 | { 211 | System.out.println( "testOneToOne begins" ); 212 | Session session = sessionFactory.openSession(); 213 | session.beginTransaction(); 214 | Person person = new Person( "James", "Bond", "007@jamesbond.com", new java.util.Date() ); 215 | 216 | Vehicle vehicle = new Vehicle( "Ferrari" ); 217 | person.setVehicle( vehicle ); 218 | session.save( vehicle ); 219 | session.save( person ); 220 | session.getTransaction().commit(); 221 | session.close(); 222 | System.out.println( "testOneToOne ends ......." ); 223 | 224 | } 225 | 226 | @Test 227 | public void testOneToManyMapping() 228 | { 229 | System.out.println( "testOneToManyMapping begins" ); 230 | Session session = sessionFactory.openSession(); 231 | session.beginTransaction(); 232 | Person person = new Person( "James", "Bond", "007@jamesbond.com", new java.util.Date() ); 233 | Phone p = new Phone( "samsung" ); 234 | Phone p2 = new Phone( "Apple" ); 235 | person.getPhones().add( p ); 236 | person.getPhones().add( p2 ); 237 | session.save( p ); 238 | session.save( p2 ); 239 | session.save( person ); 240 | session.getTransaction().commit(); 241 | session.close(); 242 | System.out.println( "testOneToManyMapping ends ......." ); 243 | 244 | } 245 | 246 | @Test 247 | public void testManyToOneMapping() 248 | { 249 | System.out.println( "testManyToOneMapping begins" ); 250 | Session session = sessionFactory.openSession(); 251 | session.beginTransaction(); 252 | House h1 = new House( "house1" ); 253 | House h2 = new House( "house2" ); 254 | Owner o1 = new Owner( "Sherlock" ); 255 | 256 | o1.getHouse().add( h1 ); 257 | o1.getHouse().add( h2 ); 258 | h1.setOwner( o1 ); 259 | h2.setOwner( o1 ); 260 | 261 | session.save( o1 ); 262 | session.save( h1 ); 263 | session.save( h2 ); 264 | session.getTransaction().commit(); 265 | session.close(); 266 | System.out.println( "testManyToOneMapping ends ......." ); 267 | 268 | } 269 | 270 | @Test 271 | public void testManyToManyMapping() 272 | { 273 | System.out.println( "testManyToManyMapping begins" ); 274 | Session session = sessionFactory.openSession(); 275 | session.beginTransaction(); 276 | 277 | Car c = new Car( "Ferrari" ); 278 | Car c1 = new Car( "BMW" ); 279 | 280 | CarOwner o1 = new CarOwner( "owner1" ); 281 | CarOwner o2 = new CarOwner( "owner2" ); 282 | 283 | c.getOwners().add( o1 ); 284 | c.getOwners().add( o2 ); 285 | c1.getOwners().add( o1 ); 286 | c1.getOwners().add( o2 ); 287 | 288 | o1.getCars().add( c ); 289 | o1.getCars().add( c1 ); 290 | o2.getCars().add( c ); 291 | o2.getCars().add( c1 ); 292 | 293 | session.persist( o1 );// cascading on in entity class(CarOwner) 294 | session.persist( o2 );// cascading on in entity class(CarOwner) 295 | session.getTransaction().commit(); 296 | session.close(); 297 | System.out.println( "testManyToManyMapping ends ......." ); 298 | 299 | } 300 | 301 | @Test 302 | public void testSingleTableStrategy() 303 | { 304 | System.out.println( "testSingleTableStrategy begins. Uncomment @Inheritance(strategy=InheritanceType.SINGLE_TABLE) in Vehicle class" ); 305 | Session session = sessionFactory.openSession(); 306 | session.beginTransaction(); 307 | 308 | Vehicle v = new Vehicle( "Ferrari" ); 309 | TwoWheeler bike = new TwoWheeler(); 310 | bike.setSteeringHandle( "bike steering handle" ); 311 | bike.setName( "pulsar" ); 312 | 313 | FourWheeler car = new FourWheeler(); 314 | car.setName( "alto" ); 315 | car.setSteeringWheel( "car steering wheel" ); 316 | 317 | session.save( car ); 318 | session.save( bike ); 319 | session.save( v ); 320 | session.getTransaction().commit(); 321 | session.close(); 322 | System.out.println( "testSingleTableStrategy ends ......." ); 323 | 324 | } 325 | 326 | @Test 327 | public void testTablePerClassStrategy() 328 | { 329 | System.out.println( "testTablePerClassStrategy begins. Uncomment @Inheritance(strategy=InheritanceType.TABLE_PER_CLASS) in Vehicle class " ); 330 | Session session = sessionFactory.openSession(); 331 | session.beginTransaction(); 332 | 333 | Vehicle v = new Vehicle( "Ferrari" ); 334 | TwoWheeler bike = new TwoWheeler(); 335 | bike.setSteeringHandle( "bike steering handle" ); 336 | bike.setName( "pulsar" ); 337 | 338 | FourWheeler car = new FourWheeler(); 339 | car.setName( "alto" ); 340 | car.setSteeringWheel( "car steering wheel" ); 341 | 342 | session.save( car ); 343 | session.save( bike ); 344 | session.save( v ); 345 | session.getTransaction().commit(); 346 | session.close(); 347 | System.out.println( "testTablePerClassStrategy ends ......." ); 348 | 349 | } 350 | 351 | @Test 352 | public void testTableJoinedStrategy() 353 | { 354 | System.out.println( "testTableJoinedStrategy begins. Uncomment @Inheritance(strategy=InheritanceType.JOINED) in Vehicle class " ); 355 | Session session = sessionFactory.openSession(); 356 | session.beginTransaction(); 357 | 358 | Vehicle v = new Vehicle( "Ferrari" ); 359 | TwoWheeler bike = new TwoWheeler(); 360 | bike.setSteeringHandle( "bike steering handle" ); 361 | bike.setName( "pulsar" ); 362 | 363 | FourWheeler car = new FourWheeler(); 364 | car.setName( "alto" ); 365 | car.setSteeringWheel( "car steering wheel" ); 366 | 367 | session.save( car ); 368 | session.save( bike ); 369 | session.save( v ); 370 | session.getTransaction().commit(); 371 | session.close(); 372 | System.out.println( "testTableJoinedStrategy ends ......." ); 373 | 374 | } 375 | 376 | @Test 377 | public void testPersistentObject() 378 | { 379 | System.out.println( "testPersistentObject begins ......." ); 380 | Person person = new Person( "James", "Bond", "007@jamesbond.com", new java.util.Date() ); 381 | Session session = sessionFactory.openSession(); 382 | session.beginTransaction(); 383 | System.out.println( "Savin the object with state " + person ); 384 | session.save( person ); 385 | System.out.println( "Saved the object and now updating using setter method" ); 386 | person.setFirstName( "updated the name" ); 387 | System.out.println( "The upadted object after saving is " + person ); 388 | session.getTransaction().commit(); 389 | session.close(); 390 | session = sessionFactory.openSession(); 391 | session.beginTransaction(); 392 | Person p2 = session.get( Person.class, 1L ); 393 | System.out.println( "Retrieved object is " + p2 ); 394 | assertEquals( person.getFirstName(), p2.getFirstName() ); 395 | System.out.println( "testPersistentObject ends ......." ); 396 | 397 | } 398 | 399 | @Test 400 | public void testDetachedObject() 401 | { 402 | System.out.println( "testDetachedObject begins ......." ); 403 | Person person = new Person( "James", "Bond", "007@jamesbond.com", new java.util.Date() ); 404 | Session session = sessionFactory.openSession(); 405 | session.beginTransaction(); 406 | System.out.println( "Savin the object with state " + person ); 407 | session.save( person ); 408 | session.getTransaction().commit(); 409 | session.close(); 410 | System.out.println( "Saved the object and closed the session and now updating using setter method" ); 411 | person.setFirstName( "updated the name" ); 412 | System.out.println( "The upadted object after saving and closing the session is " + person ); 413 | session = sessionFactory.openSession(); 414 | session.beginTransaction(); 415 | Person p2 = session.get( Person.class, 1L ); 416 | System.out.println( "Retrieved object is " + p2 ); 417 | assertNotEquals( person.getFirstName(), p2.getFirstName() ); 418 | System.out.println( "testDetachedObject ends ......." ); 419 | 420 | } 421 | 422 | @Test 423 | public void testTransientObject() 424 | { 425 | System.out.println( "testTransientObject begins ......" ); 426 | testSaveOperation(); 427 | Session session = sessionFactory.openSession(); 428 | session.beginTransaction(); 429 | 430 | Person p = session.get( Person.class, 1L ); 431 | System.out.println( "Retrieved person from DB is " + p ); 432 | session.delete( p ); 433 | session.getTransaction().commit(); 434 | System.out.println( "Deleted the person, so retrieve one more time to confirm. After deleteing the object becomes transient" ); 435 | p.setFirstName( "Deleted Object name" ); 436 | Person p2 = session.get( Person.class, 1L ); 437 | System.out.println( "Retrieved person from DB after deletion is " + p2 ); 438 | session.close(); 439 | assertEquals( "Deleted Object name", p.getFirstName() ); 440 | assertNull( p2 ); 441 | System.out.println( "testTransientObject ends ......." ); 442 | 443 | } 444 | 445 | @Test 446 | public void testPersistingDetachedObject() 447 | { 448 | System.out.println( "testPersistingDetachedObject begins .......This is \"R\" of CRUD" ); 449 | Person person = new Person( "James", "Bond", "007@jamesbond.com", new java.util.Date() ); 450 | Session session = sessionFactory.openSession(); 451 | session.beginTransaction(); 452 | System.out.println( "Savin the object with state " + person ); 453 | session.save( person ); 454 | session.getTransaction().commit(); 455 | session.close(); 456 | System.out.println( "Saved the object and closed the session and now updating using setter method. It's detached object now" ); 457 | person.setFirstName( "updated the name" ); 458 | System.out.println( "The upadted object after saving and closing the session is " + person ); 459 | session = sessionFactory.openSession(); 460 | session.beginTransaction(); 461 | session.update( person ); 462 | System.out.println( "Updated the object, so now it's persistent object" ); 463 | person.setEmail( "udpated@email.com" ); 464 | System.out.println( "Updated the object email id" + person ); 465 | person.setEmail( "udpated2@email.com" ); 466 | System.out.println( "Updated the object email id 2nd time" + person ); 467 | Person p3 = session.get( Person.class, 1L ); 468 | System.out.println( "Got the object from db " + p3 ); 469 | assertEquals( person.getEmail(), p3.getEmail() ); 470 | session.getTransaction().commit(); 471 | session.close(); 472 | System.out.println( "testPersistingDetachedObject ends ......." ); 473 | 474 | } 475 | 476 | @Test 477 | public void testHQL() 478 | { 479 | System.out.println( "testHQL begins .......This is \"R\" of CRUD" ); 480 | testSaveOperation(); 481 | Session session = sessionFactory.openSession(); 482 | session.beginTransaction(); 483 | 484 | Query query = session.createQuery( "from Person where id>:personId" ); 485 | long i = 0; 486 | query.setLong( "personId", i ); 487 | List list = (List) query.list(); 488 | 489 | session.getTransaction().commit(); 490 | System.out.println( "Size of list is " + list.size() ); 491 | assertEquals( 2, list.size() ); 492 | session.close(); 493 | System.out.println( "testHQL ends ......." ); 494 | 495 | } 496 | 497 | @Test 498 | public void testHQLWithPagination() 499 | { 500 | System.out.println( "testHQLWithPagination begins ......." ); 501 | testSaveOperation(); 502 | testSaveOperation(); 503 | Session session = sessionFactory.openSession(); 504 | session.beginTransaction(); 505 | 506 | Query query = session.createQuery( "select firstName from Person" ); 507 | query.setFirstResult( 1 ); 508 | query.setMaxResults( 6 ); 509 | List list = (List) query.list(); 510 | 511 | session.getTransaction().commit(); 512 | System.out.println( "Size of list is " + list.size() ); 513 | assertEquals( 2, list.size() ); 514 | session.close(); 515 | System.out.println( "testHQLWithPagination ends ......." ); 516 | 517 | } 518 | 519 | @Test 520 | public void testNamedQueries() 521 | { 522 | System.out.println( "testNamedQueries begins ......." ); 523 | Session session = sessionFactory.openSession(); 524 | session.beginTransaction(); 525 | Phone p = new Phone( "samsung" ); 526 | Phone p2 = new Phone( "apple" ); 527 | session.save( p ); 528 | session.save( p2 ); 529 | session.getTransaction().commit(); 530 | Query query = session.getNamedQuery( "Phone.byName" ); 531 | query.setString( 0, "apple" ); 532 | List list = (List) query.list(); 533 | System.out.println( "Size of list is " + list.size() ); 534 | assertEquals( 1, list.size() ); 535 | session.close(); 536 | System.out.println( "testNamedQueries ends ......." ); 537 | 538 | } 539 | 540 | @Test 541 | public void testNamedNativeQueries() 542 | { 543 | System.out.println( "testNamedNativeQueries begins ......." ); 544 | Session session = sessionFactory.openSession(); 545 | session.beginTransaction(); 546 | Phone p = new Phone( "samsung" ); 547 | Phone p2 = new Phone( "apple" ); 548 | session.save( p ); 549 | session.save( p2 ); 550 | session.getTransaction().commit(); 551 | Query query = session.getNamedQuery( "Phone.byId" ); 552 | query.setInteger( "id", 1 ); 553 | List list = (List) query.list(); 554 | System.out.println( "Size of list is " + list.size() ); 555 | assertEquals( 1, list.size() ); 556 | session.close(); 557 | System.out.println( "testNamedNativeQueries ends ......." ); 558 | 559 | } 560 | 561 | @Test 562 | public void testCriteria() 563 | { 564 | System.out.println( "testNamedNativeQueries begins ......." ); 565 | Session session = sessionFactory.openSession(); 566 | session.beginTransaction(); 567 | Phone p = new Phone( "samsung" ); 568 | Phone p2 = new Phone( "apple" ); 569 | session.save( p ); 570 | session.save( p2 ); 571 | session.getTransaction().commit(); 572 | 573 | Criteria criteria = session.createCriteria( Phone.class ); 574 | criteria.add( Restrictions.or( Restrictions.eq( "name", "apple" ), Restrictions.between( "id", 1, 5 ) ) ); 575 | 576 | List list = (List) criteria.list(); 577 | System.out.println( "Size of list is " + list.size() ); 578 | assertEquals( 2, list.size() ); 579 | session.close(); 580 | System.out.println( "testNamedNativeQueries ends ......." ); 581 | 582 | } 583 | 584 | @Test 585 | public void testProjections() 586 | { 587 | System.out.println( "testProjections begins ......." ); 588 | Session session = sessionFactory.openSession(); 589 | session.beginTransaction(); 590 | Phone p = new Phone( "samsung" ); 591 | Phone p2 = new Phone( "apple" ); 592 | session.save( p ); 593 | session.save( p2 ); 594 | session.getTransaction().commit(); 595 | 596 | Criteria criteria = session.createCriteria( Phone.class ); 597 | criteria.setProjection( Projections.property( "id" ) ).addOrder( Order.desc( "id" ) ); 598 | 599 | List list = (List) criteria.list(); 600 | System.out.println( "Size of list is " + list.size() ); 601 | assertEquals( 2, list.size() ); 602 | session.close(); 603 | System.out.println( "testProjections ends ......." ); 604 | 605 | } 606 | 607 | @Test 608 | public void testExample() 609 | { 610 | System.out.println( "testExample begins ......." ); 611 | Session session = sessionFactory.openSession(); 612 | session.beginTransaction(); 613 | Phone p = new Phone( "samsung" ); 614 | Phone p2 = new Phone( "apple" ); 615 | session.save( p ); 616 | session.save( p2 ); 617 | session.getTransaction().commit(); 618 | 619 | Phone p3 = new Phone( "apple" ); 620 | 621 | Example ex = Example.create( p3 ); 622 | Criteria criteria = session.createCriteria( Phone.class ); 623 | criteria.add( ex ); 624 | List list = (List) criteria.list(); 625 | System.out.println( "Size of list is " + list.size() ); 626 | assertEquals( 1, list.size() ); 627 | session.close(); 628 | System.out.println( "testExample ends ......." ); 629 | 630 | } 631 | 632 | } 633 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | #This project covers basic hibernate concepts 2 | 3 | ###### Concepts Covered 4 | 5 | 1)CRUD operations 6 | 2)Embedding value types 7 | 3)Saving collections 8 | 4)Eager and Lazy fetching 9 | 5)Primary key auto generation strategy 10 | 6)One to One mapping 11 | 7)One to Many mapping 12 | 8)Many to One mapping 13 | 9)Many to Many mapping 14 | 10)Cascade types 15 | 11)Single Table strategy 16 | 12)Table per Class startegy 17 | 13)Joined strategy 18 | 14)Transient, Persistent and Detached objects 19 | 15)HQL and HQL pagination 20 | 16)Named queries and named native queries 21 | 17)Criteria API 22 | 18)Restrictions 23 | 19)Query by Example 24 | 25 | 26 | ## Points to be noted 27 | 28 | * Make sure HSQL DB server is running before running the test case. (Download HSQL DB from https://sourceforge.net/projects/hsqldb/files/ ) 29 | * Run individual test cases inside /HibernateSample/src/test/java/com/home/hibernate/test/HibernateTest.java as *JUnit test*. 30 | * TestCase name is self explanatory 31 | * Modify the hibernate.cfg.xml file as per your DB details 32 | * After running the test case, check the console output to understand the flow 33 | * Comment non related annotations (refer the entity class annotations and the test case) 34 | * Uncomment the required annotations(refer the entity class annotations and the test case) 35 | 36 | *Note: This project needs to be refactored to use best practices which will be done later. As of now this code should be used only for understanding purposes.* 37 | 38 | 39 | 40 | 41 | * *Note: Run individual test cases instead of running all the test cases together to understand better. Comment non related annotations and uncomment required annotations by refering the test case and entity class so that you will not get confused.* 42 | 43 | 44 | 45 | 46 | --------------------------------------------------------------------------------