Objective

Understand the Hibernate Framework, an Object-Relational Mapping (ORM) tool for Java, to simplify database interactions. Learn Hibernate's architecture, lifecycle, mappings, and query mechanisms, and apply them to develop a web application with persistent data storage.

Lecture Topics

1. Introduction to Hibernate Framework

• Definition: Hibernate is an open-source ORM framework that maps Java objects (POJOs) to relational database tables, simplifying database operations.
• Purpose:
  • Eliminates boilerplate JDBC code (e.g., manual connection management, SQL queries).
  • Provides a high-level, object-oriented interface for database operations.
  • Supports CRUD operations, relationships, and transactions.
• Key Features:
  • Automatic mapping of Java classes to database tables.
  • Support for HQL (Hibernate Query Language), similar to SQL but object-oriented.
  • Caching for performance optimization.
  • Transaction management and lazy loading.
• Advantages:
  • Reduces development time by automating persistence logic.
  • Database-agnostic (works with MySQL, PostgreSQL, Oracle, etc.).
  • Handles complex relationships (e.g., one-to-many, many-to-many).
• Comparison with JDBC:
  • JDBC: Manual SQL queries, error-prone, no object-relational mapping.
  • Hibernate: Maps objects to tables, reduces SQL usage, improves maintainability.

2. Hibernate Architecture

• Components:
  1. SessionFactory:
     • A thread-safe, immutable factory for creating Session objects.
     • Configured using hibernate.cfg.xml or programmatically.
     • Heavyweight object, created once per application.
  2. Session:
     • Represents a single unit of work with the database.
     • Provides methods for CRUD operations (e.g., save(), get(), update(), delete()).
     • Lightweight, short-lived, not thread-safe.
  3. Transaction:
     • Manages database transactions to ensure data consistency.
     • Example: session.beginTransaction(), transaction.commit(), transaction.rollback().
  4. Query:
     • Executes HQL, Criteria, or native SQL queries.
  5. ConnectionProvider:
     • Manages database connections (often via a connection pool like C3P0).
  6. TransactionFactory:
     • Creates transaction objects for Hibernate.
• Architecture Diagram (for exam understanding):
  • Java Application ↔ Hibernate (SessionFactory, Session, Transaction) ↔ JDBC ↔ Database.
• Configuration:

  • hibernate.cfg.xml: Configures database connection, dialect, and mappings.

    <hibernate-configuration>
        <session-factory>
            <property name="hibernate.connection.driver_class">com.mysql.cj.jdbc.Driver</property>
            <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/bookshop</property>
            <property name="hibernate.connection.username">root</property>
            <property name="hibernate.connection.password">password</property>
            <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
            <property name="hibernate.show_sql">true</property>
            <mapping resource="com/example/Book.hbm.xml"/>
        </session-factory>
    </hibernate-configuration>
    
    

  • Programmatic Configuration (alternative):

    Configuration config = new Configuration()
        .setProperty("hibernate.connection.driver_class", "com.mysql.cj.jdbc.Driver")
        .setProperty("hibernate.connection.url", "jdbc:mysql://localhost:3306/bookshop")
        .addAnnotatedClass(Book.class);
    SessionFactory sessionFactory = config.buildSessionFactory();
    
    

3. Hibernate in IDE

• Setup:

  • Add Hibernate dependencies (e.g., via Maven):

    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-core</artifactId>
        <version>5.6.15.Final</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.33</version>
    </dependency>
    
    

  • Configure IDE (e.g., Eclipse, IntelliJ) to recognize Hibernate configuration files and mappings.

  • Use Hibernate Tools (e.g., in Eclipse) for generating mappings or reverse-engineering database schemas.

• Creating a Web Application Using Hibernate API:

  • Steps:

    1. Configure hibernate.cfg.xml with database details.
    2. Create entity classes with annotations or XML mappings.
    3. Use SessionFactory and Session in a Servlet or DAO for persistence.

  • Example Servlet:

    @WebServlet("/books")
    public class BookServlet extends HttpServlet {
        private SessionFactory sessionFactory;
    
        @Override
        public void init() throws ServletException {
            sessionFactory = new Configuration().configure().buildSessionFactory();
        }
    
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            Session session = sessionFactory.openSession();
            List<Book> books = session.createQuery("FROM Book", Book.class).list();
            req.setAttribute("books", books);
            session.close();
            req.getRequestDispatcher("/books.jsp").forward(req, resp);
        }
    }
    
    

4. Lifecycle of Hibernate Entities

• States:
  1. Transient: Object instantiated but not associated with a Hibernate session or database.
     • Example: Book book = new Book();
  2. Persistent: Object associated with a session and saved to the database.
     • Example: session.save(book);
  3. Detached: Object no longer associated with a session but exists in the database.
     • Example: After session.close().
  4. Removed: Object marked for deletion from the database.
     • Example: session.delete(book);
• Transitions:
  • Transient → Persistent: session.save() or session.persist().
  • Persistent → Detached: session.evict() or session.close().
  • Persistent → Removed: session.delete().
  • Detached → Persistent: session.update() or session.merge().