3. Hibernate Annotation

Hibernate Annotation 


- Hibernate is a popular Java-based framework for working with relational databases. 
- It simplifies the process of database interactions by providing an object-relational mapping (ORM) solution. 
- Annotations in Hibernate are metadata provided in the form of Java annotations that help configure and map Java objects to database tables. 
- These annotations are used to define the mapping between Java classes and database tables, specify primary keys, relationships, and other aspects of the object-relational mapping.


Some commonly used Hibernate annotations:

1. @Entity:
    - Used for declaring any POJO class as an entity for a database.
   - Marks a Java class as an entity, indicating that instances of this class will be persisted to the database. Each entity class typically corresponds to a table in the database.
   - it tells Hibernate that this class represents a table in the database.

    @Entity
    public class Employee {
        // class definition
    }
    
2. @Table:
    - This annotation specifies the details of the database table that corresponds to the entity.
   - Used to change table name, schema, and other properties.

    @Entity
    @Table(name = "employees", schema = "public")
    public class Employee {
        // class definition
    }



@Column: This annotation allows you to customize the mapping of a field to a database column. You can specify the column name, type, length, and other properties.


3. @Id:
    - This annotation marks a field as the primary key of the entity. 
    - It indicates which field uniquely identifies each record in the database table.
    
   @Id
    private int id;
    

4. @GeneratedValue:
    - This annotation specifies the strategy for generating values for the primary key field. 
    - It can be used to automatically generate unique primary key values, such as using an auto-increment column in the database.

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY) 
    private Long id;
    
    
5. @Column:
    - Allows you to customize (changes) the mapping of the annotated field to the database column. 
    - You can specify the column name, length, nullable, etc.

    
    @Column(name = "employee_name", nullable = false, length = 50)
    private String name;

6. @Transient - This Tells  to hibernate, not to add this particular column in table.
    
7. @Temporal - This annotation is used to format the date for storing in the database.

8. @Lob : Used to tell hibernate that it’s a large object and is not a simple object

9. @OrderBy : This annotation will tell hibernate to OrderBy as we do in SQL.

            For example – we need to order by student firstname in ascending order

            @OrderBy(“firstname asc”)


Hibernate annotations provide a powerful and flexible way to map Java objects to database tables and define relationships between entities.

Comments

Post a Comment

Popular posts from this blog

5. JPA Relational Mapping & Fetch Types & Cascadding

 RelationShip  -OneToOne -OneToMany -ManyToOne -ManytoMany Fetch Types 1. FetchType.LAZY  2. FetchType.EAGER In Hibernate, the "fetch type" determines how associated data should be loaded from the database.  It's like specifying whether you want to load related data eagerly (at the same time as the main entity) or lazily (only when needed). There are two main fetch types in Hibernate: 1. Eager Fetch Type    - When you fetch data eagerly, Hibernate loads the main entity along with its associated data immediately.    - It's like ordering a combo meal at a restaurant – you get the burger and fries together, even if you're not going to eat the fries right away.    - Eager loading can lead to loading more data than necessary, which may impact performance if not used carefully. 2. Lazy Fetch Type:    - When you fetch data lazily, Hibernate loads the main entity first and only loads associated data when explicitly requested. ...
Read more

4. Data Fetching Methods & @Embeddable annotation in Hibernate

  Data Fetching from Database In Hibernate, the `get` and `load` methods are used to retrieve an object from the database based on its primary key. Both methods are part of the `Session` interface in Hibernate. 1. get() method: - The get() method is a part of the Hibernate Session interface. - It retrieves an entity(persistence) object from the database by its primary key (ID). -  It takes the class of the object to be retrieved and the primary key of the object as arguments. - get() method only hits the database if the object is not present in the session cache.   - get() method returns null if there is no object present in the database.    Example:       Session session = sessionFactory.openSession();    Transaction transaction = session.beginTransaction();    // Get an object by its primary key    Employee employee = (Employee) session.get(Employee.class, 1L);    transaction.commit();    se...
Read more

6. Hibernate Query Language (HQL) & Caching in Hibernate

  Hibernate Query Language (HQL) Hibernate Query Language (HQL) is a powerful and flexible way to interact with a relational database using Hibernate, which is a popular Object-Relational Mapping (ORM) framework in Java.  1. HQL - Hibernate Query Language:    - HQL is like SQL, but it's designed to work with your Java objects, not directly with the database tables. It allows you to write queries using the names of your Java classes and properties, rather than database tables and columns. 2. Database Interaction - In traditional database operations, you use SQL (Structured Query Language) to interact with the database. SQL is a language that is specific to the database you are using (e.g., MySQL, PostgreSQL, Oracle). 3. Object-Relational Mapping (ORM): Hibernate helps you work with databases in a more object-oriented way. Instead of thinking in terms of database tables and SQL queries, you can work with Java objects that map to your database tables. Caching in Hiberna...
Read more