Showing posts with label Hibernate. Show all posts
Showing posts with label Hibernate. Show all posts

Thursday, 4 May 2017

Domain Model in Hibernate

Domain Model in Hibernate

The application domain model is the central character in an ORM. Domain Model are the classes we would be mapping in our application. These domain model classes needs to follow the Plain Old Java Object (POJO) / JavaBean programming model in order to make Hibernate works best.
Applications using Hibernate uses its proprietary XML mapping file format for this purpose. With JPA, most of this information is now defined in a way that is portable across ORM/JPA providers using annotations and/or standardized XML format.

Mapping types
Hibernate understands both the Java and JDBC representations of application data. The ability to read/write this data from/to the database is the function of a Hibernate type. A type, is an implementation of the org.hibernate.type.Type interface.
To help understand the type categorizations, we take an example of a simple table and domain model that we wish to map.

create table ContactInfo (
    id integer not null,
    firstName varchar(255),
    lastName varchar(255),
    middleName varchar(255),
    notes varchar(255),
    starred boolean not null,
    website varchar(255),
    primary key (id)
)


@Entity(name = "ContactInfo")
public static class ContactInfo {

    @Id
    private Integer id;
    private Name name;
    private String notes;
    private URL website;
    private boolean starred;

    //Getters and setters
}



@Embeddable
public class Name {

    private String firstName;
    private String middleName;
    private String lastName;

    // getters and setters
}


In the broadest sense, Hibernate categorizes types into two groups:
  • Value types
  • Entity types


Value types
A value type is a piece of data that does not define its own lifecycle. It is, owned by an entity, which defines its lifecycle. All the state of an entity is made up entirely of value types. These state fields or JavaBean properties are termed persistent attributes. The persistent attributes of the ContactInfo class are value types.

Value types are further classified into three sub-categories:

Basic types
In mapping the ContactInfo table, all attributes except for name would be basic types.

Embeddable types
The name attribute is an example of an embeddable type.

Collection types
Collection types are also a distinct category among value types.

Entity types
Entities, exist independently of other objects whereas values do not. Entities are domain model classes which correlate to rows in a database table, using a unique identifier. Entities exist independently and define their own lifecycle. The ContactInfo class is an example of an entity. 

Monday, 1 May 2017

Hibernate Architecture Overview

Hibernate Architecture Overview

Hibernate, is an ORM solution, which sits between the Java application data access layer and the Relational Database. The Java application makes use of the Hibernate APIs to load, store, query, etc its domain data. Hibernate implements the Java Persistence API (JPA) specifications. 


SessionFactory (org.hibernate.SessionFactory)
SessionFactory  is a thread-safe representation of the mapping of the application domain model to a database. SessionFactory acts as a factory for org.hibernate.Session instances. The EntityManagerFactory is the JPA equivalent of a SessionFactory.

A SessionFactory is very expensive to create, so, for any given database, the application should have only one associated SessionFactory. The SessionFactory maintains services that Hibernate uses across all Sessions such as second level caches, connection pools, transaction system integrations, etc.

Session (org.hibernate.Session)
A single-threaded, short-lived object conceptually modeling a "Unit of Work". In JPA nomenclature, the Session is represented by an EntityManager.
The Hibernate Session wraps a JDBC java.sql.Connection and acts as a factory for org.hibernate.Transaction instances. 

Transaction (org.hibernate.Transaction)
A single-threaded, short-lived object used by the application to demarcate individual physical transaction boundaries. 


Tuesday, 18 April 2017

Advantage of Hibernate over JDBC

Advantage of Hibernate over JDBC


JDBC 
Hibernate 
With JDBC, developer has to write code to map an object model's data to a relational data model and its corresponding database schema.  
Hibernate is flexible and powerful ORM solution to map Java classes to database tables. Hibernate takes care of this mapping using XML files so developer need not write code for this. 
The mapping of Java objects with database tables and vice versa conversion is to be taken care of by the developer, the developer needs to write code for this.  
Hibernate provides transparent persistence, to map database tables rows to application objects during interaction with RDBMS.  
JDBC supports Structured Query Language (SQL). Developer has to find out the efficient way to access database, i.e. to select effective query from a number of queries to perform same task.  
Hibernate provides a powerful query language Hibernate Query Language. Hibernate also supports native SQL statements. It also selects an effective way to perform a database manipulation task for an application.  
Application using JDBC to handle persistent data having database specific code. The code is written to map table fields to object properties. As table changes or database changes then it is essential to change object structure as well to map table-to-object/object-to-table. 
Hibernate provides this mapping. The actual mapping between tables and application objects is done in XML files. If there is change in Database or in any table then the only need to change XML file properties.  
With JDBC, it is developer’s responsibility to handle JDBC result set and convert it to Java objects through code to use this persistent data in application. 
Hibernate reduces lines of code by maintaining object-table mapping and returns result to application in form of Java objects. It relieves programmer from manual handling of persistent data, hence reducing the development time and maintenance cost.  
With JDBC, to enable caching the developer needs to write the code for caching of Objects
Hibernate, has its own caching facility, instead of coding for the caching feature, the developer just configures caching through configuration files.  
In JDBC there is no check that always every user has updated data. This check has to be added by the developer.  
Hibernate enables developer to define version type field which updates database table every time a row is updated in form of Java object to that table.If two users retrieve same row and modify it and one user save this modified row   to database, version is automatically updated for this row by Hibernate. When other user tries to save updated row to database then it does not allow saving it because this user does not have updated data.  

Tuesday, 17 January 2017

Object Relational Mapping

Object Relational Mapping (ORM) in computer science is a programming technique for converting data between incompatible type systems in object-oriented programming languages.
In object-oriented programming, data-management tasks act on object-oriented (OO) objects that are almost always non-scalar values.
For example, 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. The list of phone numbers would itself contain "PhoneNumber objects" and so on. The address-book entry is treated as a single object by the programming language (it can be referenced by a single variable containing a pointer to the object, for instance). Various methods can be associated with the object, such as a method to return the preferred phone number, the home address, and so on.
However, many popular database products such as SQL database management systems (DBMS) can only store and manipulate scalar values such as integers and strings organized within tables. The programmer must either convert the object values into groups of simpler values for storage in the database (and convert them back upon retrieval), or only use simple scalar values within the program. Object-relational mapping implements the first approach.
The heart of the problem involves translating the logical representation of the objects into an atomized form that is capable of being stored in the database, while preserving the properties of the objects and their relationships so that they can be reloaded as objects when needed. If this storage and retrieval functionality is implemented, the objects are said to be persistent.

Persistence

ORM is concerned with helping your application to achieve persistence.
Persistence means that we would like our application’s data to outlive the applications process. In Java terms, we would like the state of (some of) our objects to live beyond the scope of the JVM so that the same state is available later.

Relational Databases

Specifically, ORM is concerned with data persistence as it applies to relational databases (RDBMS). RDBMS is a very popular persistence mechanism.

The Object-Relational Impedance Mismatch

'Object-Relational Impedance Mismatch' (sometimes called the 'paradigm mismatch') is a way of saying that object models and relational models do not work very well together. RDBMSs represent data in a tabular format, whereas object-oriented languages, such as Java, represent it as objects. Loading and storing objects using a tabular relational database exposes us to 5 mismatch problems…​

Granularity

Sometimes you will have an object model which has more classes than the number of corresponding tables in the database, we says the object model is more granular than the relational model.

Subtypes (Inheritance)

Inheritance is a natural paradigm in object-oriented programming languages. However, RDBMSs do not define anything similar on the whole.

Identity

A RDBMS defines exactly one notion of 'sameness': the primary key. Java, however, defines both object identity a==b and object equality a.equals(b).

Associations

Associations are represented as unidirectional references in Object Oriented languages whereas RDBMSs use the notion of foreign keys. If you need bidirectional relationships in Java, you must define the association twice.
Likewise, you cannot determine the multiplicity of a relationship by looking at the object domain model.

Data navigation

The way you access data in Java is fundamentally different than the way you do it in a relational database. In Java, you navigate from one association to another walking the object network.

This is not an efficient way of retrieving data from a relational database. You typically want to minimize the number of SQL queries and thus load several entities via JOINs and select the targeted entities before you start walking the object network.

Object-relational mapping

Object-relational mapping



Related Posts Plugin for WordPress, Blogger...