Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
Scribd Logo
Upload

Welcome to Scribd!

  • 17 views

    Hibernate

    Uploaded by

    Sudeep Mishra
    Hibernate provides advantages over JDBC such as cleaner code through eliminating boilerplate code, an object-oriented query language (HQL), implicit transaction management, and exception handling. It supports object-oriented features like inheritance and associations. The core interfaces of Hibernate include Configuration, SessionFactory, Session, Criteria, Query, and Transaction. A SessionFactory is a thread-safe object that provides Session instances to communicate with the database based on a configuration. The Criteria API allows building dynamic queries programmatically and adding restrictions to selectively retrieve data, providing more flexibility than HQL. It incorporates interfaces like CriteriaBuilder and CriteriaQuery in Hibernate 5.

    Copyright:

    © All Rights Reserved
    Download as DOCX, PDF, TXT or read online from Scribd

    Hibernate

    Uploaded by

    Sudeep Mishra
    17 views6 pages
    Hibernate provides advantages over JDBC such as cleaner code through eliminating boilerplate code, an object-oriented query language (HQL), implicit transaction management, and exception handling. It supports object-oriented features like inheritance and associations. The core interfaces of Hibernate include Configuration, SessionFactory, Session, Criteria, Query, and Transaction. A SessionFactory is a thread-safe object that provides Session instances to communicate with the database based on a configuration. The Criteria API allows building dynamic queries programmatically and adding restrictions to selectively retrieve data, providing more flexibility than HQL. It incorporates interfaces like CriteriaBuilder and CriteriaQuery in Hibernate 5.

    Copyright

    © © All Rights Reserved

    Available Formats

    DOCX, PDF, TXT or read online from Scribd

    Did you find this document useful?

    Is this content inappropriate?

    Hibernate provides advantages over JDBC such as cleaner code through eliminating boilerplate code, an object-oriented query language (HQL), implicit transaction management, and exception handling. It supports object-oriented features like inheritance and associations. The core interfaces of Hibernate include Configuration, SessionFactory, Session, Criteria, Query, and Transaction. A SessionFactory is a thread-safe object that provides Session instances to communicate with the database based on a configuration. The Criteria API allows building dynamic queries programmatically and adding restrictions to selectively retrieve data, providing more flexibility than HQL. It incorporates interfaces like CriteriaBuilder and CriteriaQuery in Hibernate 5.

    Copyright:

    © All Rights Reserved
    Download as DOCX, PDF, TXT or read online from Scribd
    Download as docx, pdf, or txt
    17 views6 pages

    Hibernate

    Uploaded by

    Sudeep Mishra
    Hibernate provides advantages over JDBC such as cleaner code through eliminating boilerplate code, an object-oriented query language (HQL), implicit transaction management, and exception handling. It supports object-oriented features like inheritance and associations. The core interfaces of Hibernate include Configuration, SessionFactory, Session, Criteria, Query, and Transaction. A SessionFactory is a thread-safe object that provides Session instances to communicate with the database based on a configuration. The Criteria API allows building dynamic queries programmatically and adding restrictions to selectively retrieve data, providing more flexibility than HQL. It incorporates interfaces like CriteriaBuilder and CriteriaQuery in Hibernate 5.

    Copyright:

    © All Rights Reserved
    Download as DOCX, PDF, TXT or read online from Scribd
    Download as docx, pdf, or txt
    of 6

    HIBERNATE

    1. What are the advantages of Hibernate over JDBC?


    The advantages of Hibernate over JDBC are listed below:
     Clean Readable Code: Using hibernate, helps in eliminating a lot of JDBC API-based boiler-plate
    codes, thereby making the code look cleaner and readable.
     HQL (Hibernate Query Language): Hibernate provides HQL which is closer to Java and is object-
    oriented in nature. This helps in reducing the burden on developers for writing database
    independent queries. In JDBC, this is not the case. A developer has to know the database-specific
    codes.
     Transaction Management: JDBC doesn't support implicit transaction management. It is upon the
    developer to write transaction management code using commit and rollback methods. Whereas,
    Hibernate implicity provides this feature.
     Exception Handling: Hibernate wraps the JDBC exceptions and throws unchecked exceptions like
    JDBCException or HibernateException. This along with the built-in transaction management
    system helps developers to avoid writing multiple try-catch blocks to handle exceptions. In the
    case of JDBC, it throws a checked exception called SQLException thereby mandating the developer
    to write try-catch blocks to handle this exception at compile time.
     Special Features: Hibernate supports OOPs features like inheritance, associations and also
    supports collections. These are not available in JDBC.

    2. What are some of the important interfaces of Hibernate framework?


    Hibernate core interfaces are:
    Configuration
    SessionFactory
    Session
    Criteria
    Query
    Transaction

    3. What is a SessionFactory?
    SessionFactory provides an instance of Session. It is a factory class that gives the Session objects based
    on the configuration parameters in order to establish the connection to the database.
    As a good practice, the application generally has a single instance of SessionFactory. The internal state
    of a SessionFactory which includes metadata about ORM is immutable, i.e once the instance is created,
    it cannot be changed.

    This also provides the facility to get information like statistics and metadata related to a class, query
    executions, etc. It also holds second-level cache data if enabled.
    HIBERNATE
    4. What do you think about the statement - “session being a thread-safe object”?
    No, Session is not a thread-safe object which means that any number of threads can access data from
    it simultaneously.

    5. Can you explain what is lazy loading in hibernate?


    Lazy loading is mainly used for improving the application performance by helping to load the child
    objects on demand.

    It is to be noted that, since Hibernate 3 version, this feature has been enabled by default. This signifies
    that child objects are not loaded until the parent gets loaded.

    6. What is the difference between first level cache and second level cache?
    Hibernate has 2 cache types. First level and second level cache for which the difference is given below:

    This is local to the Session object and cannot be shared between multiple sessions.------This cache is
    maintained at the SessionFactory level and shared among all sessions in Hibernate.

    7. What can you tell about Hibernate Configuration File?


    Hibernate Configuration File or hibernate.cfg.xml is one of the most required configuration files in
    Hibernate. By default, this file is placed under the src/main/resource folder.
    The file contains database related configurations and session-related configurations.
    Hibernate facilitates providing the configuration either in an XML file (like hibernate.cfg.xml) or a
    properties file (like hibernate.properties).

    8. How do you create an immutable class in hibernate?


    Immutable class in hibernate creation could be in the following way. If we are using the XML form of
    configuration, then a class can be made immutable by markingmutable=false. The default value is true
    there which indicating that the class was not created by default.

    In the case of using annotations, immutable classes in hibernate can also be created by using
    @Immutable annotation.

    9. Is hibernate prone to SQL injection attack?


    SQL injection attack is a serious vulnerability in terms of web security wherein an attacker can interfere
    with the queries made by an application/website to its database thereby allowing the attacker to view
    sensitive data which are generally irretrievable. It can also give the attacker to modify/ remove the
    data resulting in damages to the application behavior.

    Hibernate does not provide immunity to SQL Injection. However, following good practices avoids SQL
    injection attacks. It is always advisable to follow any of the below options:
    HIBERNATE
    Incorporate Prepared Statements that use Parameterized Queries.
    Use Stored Procedures.
    Ensure data sanity by doing input validation.

    10. Differentiate between get() and load() in Hibernate session


    These are the methods to get data from the database. The primary differences between get and load
    in Hibernate are given below:

    This method gets the data from the database as soon as it is called.----This method returns a proxy
    object and loads the data only when it is required.
    The database is hit every time the method is called.----The database is hit only when it is really needed
    and this is called Lazy Loading which makes the method better.
    The method returns null if the object is not found.-----The method throws ObjectNotFoundException if
    the object is not found.

    11.What is criteria API in hibernate?


    Criteria API in Hibernate helps developers to build dynamic criteria queries on the persistence
    database. Criteria API is a more powerful and flexible alternative to HQL (Hibernate Query Language)
    queries for creating dynamic queries.

    This API allows to programmatically development criteria query objects. The org.hibernate.Criteria
    interface is used for these purposes. The Session interface of hibernate framework has createCriteria()
    method that takes the persistent object’s class or its entity name as the parameters and returns
    persistence object instance the criteria query is executed.

    It also makes it very easy to incorporate restrictions to selectively retrieve data from the database. It
    can be achieved by using the add() method which accepts the org.hibernate.criterion.Criterion object
    representing individual restriction.

    Usage examples:

    To return all the data of InterviewBitEmployee entity class.

    Criteria criteria = session.createCriteria(InterviewBitEmployee.class);


    List<InterviewBitEmployee> results = criteria.list();
    To retrive objects whose property has value equal to the restriction, we use Restrictions.eq() method.
    For example, to fetch all records with name ‘Hibernate’:

    Criteria criteria= session.createCriteria(InterviewBitEmployee.class);


    criteria.add(Restrictions.eq("fullName","Hibernate"));
    List<InterviewBitEmployee> results = criteria.list();
    HIBERNATE
    To get objects whose property has the value “not equal to” the restriction, we use Restrictions.ne()
    method. For example, to fetch all the records whose employee’s name is not Hibernate:

    Criteria criteria= session.createCriteria(InterviewBitEmployee.class);


    criteria.add(Restrictions.ne("fullName","Hibernate"));
    List<Employee> results = criteria.list()
    To retrieve all objects whose property matches a given pattern, we use Restrictions.like() (for case
    sensitivenes) and Restrictions.ilike()(for case insensitiveness)

    Criteria criteria= session.createCriteria(InterviewBitEmployee.class);


    criteria.add(Restrictions.like("fullName","Hib%",MatchMode.ANYWHERE));
    List<InterviewBitEmployee> results = criteria.list();

    Similarly, it also has other methods like isNull(), isNotNull(), gt(), ge(), lt(), le() etc for adding more
    varieties of restrictions. It has to be noted that for Hibernate 5 onwards, the functions returning an
    object of typeCriteria are deprecated. Hibernate 5 version has provided interfaces like CriteriaBuilder
    and CriteriaQuery to serve the purpose:

    javax.persistence.criteria.CriteriaBuilder
    javax.persistence.criteria.CriteriaQuery

    // Create CriteriaBuilder
    CriteriaBuilder builder = session.getCriteriaBuilder();

    // Create CriteriaQuery
    CriteriaQuery<YourClass> criteria = builder.createQuery(YourClass.class);

    To get a list of all records from InterviewBitEmployee Table using HQL:

    Query query=session.createQuery("from InterviewBitEmployee");


    List<InterviewBitEmployee> list=query.list();
    System.out.println(list.get(0));

    12.What does session.lock() method in hibernate do?


    session.lock() method is used to reattach a detached object to the session. session.lock() method does
    not check for any data synchronization between the database and the object in the persistence
    context and hence this reattachment might lead to loss of data synchronization.
    HIBERNATE
    13. What is hibernate caching?
    Hibernate caching is the strategy for improving the application performance by pooling objects in the
    cache so that the queries are executed faster. Hibernate caching is particularly useful when fetching
    the same data that is executed multiple times. Rather than hitting the database, we can just access the
    data from the cache. This results in reduced throughput time of the application.

    14.When is merge() method of the hibernate session useful?


    Merge() method can be used for updating existing values. The specialty of this method is, once the
    existing values are updated, the method creates a copy from the entity object and returns it. This
    result object goes into the persistent context and is then tracked for any changes. The object that was
    initially used is not tracked.

    15. Can we declare the Entity class final?


    No, we should not define the entity class final because hibernate uses proxy classes and objects for
    lazy loading of data and hits the database only when it is absolutely needed. This is achieved by
    extending the entity bean. If the entity class (or bean) is made final, then it cant be extended and
    hence lazy loading can not be supported

    16. What are the states of a persistent entity?


    A persistent entity can exist in any of the following states:

    Transient:
    This state is the initial state of any entity object.
    Once the instance of the entity class is created, then the object is said to have entered a transient
    state. These objects exist in heap memory.
    In this state, the object is not linked to any session. Hence, it is not related to any database due to
    which any changes in the data object don't affect the data in the database.
    InterviewBitEmployee employee=new InterviewBitEmployee(); //The object is in the transient state.
    employee.setId(101);
    employee.setFullName("Hibernate");
    employee.setEmail("hibernate@interviewbit.com");

    Persistent:
    This state is entered whenever the object is linked or associated with the session.
    An object is said to be in a persistence state whenever we save or persist an object in the database.
    Each object corresponds to the row in the database table. Any modifications to the data in this state
    cause changes in the record in the database.
    HIBERNATE
    Following methods can be used upon the persistence object:
    session.save(record);
    session.persist(record);
    session.update(record);
    session.saveOrUpdate(record);
    session.lock(record);
    session.merge(record);

    Detached:
    The object enters this state whenever the session is closed or the cache is cleared.
    Due to the object being no longer part of the session, any changes in the object will not reflect in the
    corresponding row of the database. However, it would still have its representation in the database.
    In case the developer wants to persist changes of this object, it has to be reattached to the hibernate
    session.
    In order to achieve the reattachment, we can use the methods load(), merge(), refresh(), update(), or
    save() methods on a new session by using the reference of the detached object.
    The object enters this state whenever any of the following methods are called:

    session.close();
    session.clear();
    session.detach(record);
    session.evict(record);

    17. Explain Query Cache


    Hibernate framework provides an optional feature called cache region for the queries’ resultset.
    Additional configurations have to be done in code in order to enable this. The query cache is useful for
    those queries which are most frequently called with the same parameters. This increases the speed of
    the data retrieval and greatly improves performance for commonly repetitive queries.

    This does not cache the state of actual entities in the result set but it only stores the identifier values
    and results of the value type. Hence, query cache should be always used in association with second-
    level cache.

    You might also like