Composite Primary Key :
If Table having more than one primary key we can call it as Composite Primary key.
Criteria :
Projections :
Types of Hibernate :
- IDENTITY
- SEQUENCE
- CUSTOM GENERATOR
- AUTO
Optimistic locking :
Frequently accessing the data on a table, that time lock will happen on table. To optimize that we can use "Versioning" or "Time stamp" on a table. Which acts as a cache, when ever values changes it will fetch the latest data.
Cache :
When Cache will apply on api's?
Where ever frequent changes wont happen then we can implement cache on that api.
Ex : Search the particular data in Case Module.
2 Types of Cache in Hibernate :
1st Level Cache : Session Level Cache. Default cache in hibernate.
2nd Level Cache : Session Factory Level Cache. Need to configure and customize.
How Cache works ?
@Cacheable annotation will take care about cached data.
@Cacheable(Value = "temp") : Value will take about the data changes in cache.
EhCache.xml : Need to specify the cache details by using Cache value. Name and value should be same in both. Here we will mention the cache timing based on this time cache will update the data.
Difference between Load() and Get()?
Load () : It wont hit the database and retrieve the value. Because it will create one proxy object with the given identifier. If Object is not found then it will through "Object Not Found Exception "
Get () : It will always hit the database to retrieve the values.If Row is not found it will throws "Object Not Found Exception".
Difference between Eager and Lazy Load :
Eager Loading :
- Load all the relationships data from the database.
- Bit Slow.
- By Default it will fetch eager.
Lazy Loading :
- Doesn't Load the relationship unless explicitly asked via getters.
- More Faster.
Difference between Merge and Update :
Update() :
update returns serializable object.
When ever data is there then update will happen based on id or some other attribute.
Merge():
Merge return type is void.
Its acts as a persist() means, If we want to save any modification at anytime without knowing the state of an object then we can go for persist().
Aggregations:
1. One To One Mapping:
Ex : One Student will have One Laptop
@Entity
public class Student
{
@Id
Private int sid;
private String sname;
@OneToOne
private Laptop laptop;
------
------
}
2. One To Many Mapping & Many To One Mapping
Ex : One Student will have Many Laptops
@Entity
public class Student
{
@Id
Private int sid;
private String sname;
@OneToMany(mapped By = "sid")
private List<Laptop> laptop;
-----
-----
}
Note : If we didnt specify the mapped By = "sid", it will create a new table like Laptop_Student.
3. Many To Many Mapping
Ex : One Student will have Many Laptops.
Multiple Laptops belong to One Student.
@Entity
public class Student
{
@Id
Private int sid;
private String sname;
@ManyToMany(mapped By = "students")
private List<Laptop> laptops;
-----
-----
}
@Entity
public class Laptop
{
@Id
Private int lid;
private String lname;
@ManyToMany(mapped By = "laptops")
private List<Student> students;
-----
-----
}
Note : If we didnt specify the Mapped By ="names" then it will create 4 extra tables.
