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

1. Introduction Hibernate

 Introduction Hibernate  - Hibernate is a java framework that simplifies the developement of java application to intract with the Database.  - It is invented by Gavin King in 2001. - Hibernate is the ORM framework/tool . - Hibernate Implement specifiaction of JPA ( Java Persistence API ) for the data persistence. - Hibernate is non-inversive framework , means it wont forces to programmer to extend / implement any class/interface. - We can build any type of application using hibernate.(like standalone, servlets , desktop etc) - It is a java framework which is used to develop persistence logic. Persistence logic means to store and process the data for long use. Advantages of Hibernates  - Hibernate takes care of mapping Java classes to database tables using XML files and without writing any line of code. - If there is change in the database or in any table, then you need to change the XML file properties only. - Minimizes database access with smart fetching strategies....
Read more

2. Hibernate Architecture

Image
  Hibernate Architecture   The architecture of Hibernate is based on the following key components: 1. Hibernate Configuration:    - The configuration file (`hibernate.cfg.xml`) is used to configure Hibernate properties such as database connection settings, dialect, mapping files, and other environment-specific settings.    - Alternatively, you can configure Hibernate programmatically using the `Configuration` class. The Configuration object provides two keys components − Database Connection − This is handled through one or more configuration files supported by Hibernate. These files are hibernate.properties and hibernate.cfg.xml. Class Mapping Setup − This component creates the connection between the Java classes and database tables. 2. SessionFactory:      - SessionFactory is an Interface which is present in org.hibernate package and it is used to create Session Object.    - The `SessionFactory` is a heavyweight.    ...
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