Core Methods

The get() method returns the object from the database or null if the object does not exist.

The load() method returns a proxy object that represents the requested object. The actual object is loaded from the database when a method is called on the proxy object.

You would prefer to use get() over load() when you want to immediately retrieve the object from the database and handle the case when the object does not exist by checking for null.

On the other hand, you would prefer to use load() over get() when you are confident that the object with the provided identifier exists in the database and you want to avoid the immediate database query. However, you need to be cautious when using load() as it throws an exception if the object does not exist.

If there is no record with the provided identifier in the database:

• The get() method returns null.
• The load() method throws an exception.

The return type of the save() method in Hibernate is Serializable. It returns the identifier (primary key) of the saved object.

If we call the save() method without setting the primary key, Hibernate will generate a primary key value for the object automatically. This is typically done using an identifier generator strategy configured in the Hibernate mapping.

Both save() and persist() methods in Hibernate are used to save an object into the database. However, there are some differences:

• The save() method returns the identifier (primary key) of the saved object, while the persist() method does not return anything.
• The save() method can be called before or after the transaction is committed, while the persist() method can only be called within an active transaction.
• The save() method generates a new identifier value for a transient object, while the persist() method throws an exception if called on a transient object with a non-null identifier.

If we call update() on a transient object, Hibernate will throw an exception. A transient object is an object that is not associated with any database row. In order to update an object, it must be in the persistent state, meaning it must be associated with a database row. To update a transient object, we need to first make it persistent by either saving it using the save() method or retrieving it using the get() or load() methods.

The update() and merge() methods in Hibernate are used to update the state of persistent objects, but they have some differences:

• The update() method is used to update the state of a persistent object with the new values from the object passed as a parameter. It throws an exception if the object is transient.

• The merge() method is used to merge the state of a detached object with the state of a persistent object. It returns the persistent object with the merged state. If the object is transient, it will be saved as a new row in the database.

In summary, the update() method updates the state of a persistent object in place, while the merge() method merges the state of a detached object with a persistent object and returns the merged object.

The update() method in Hibernate can lead to an exception in the following scenario:

• If we call update() on a transient object, Hibernate will throw a TransientObjectException. A transient object is an object that is not associated with any database row. In order to update an object, it must be in the persistent state, meaning it must be associated with a database row. To update a transient object, we need to first make it persistent by either saving it using the save() method or retrieving it using the get() or load() methods.

After the evict() method is called, the object becomes detached from the session. This means that any changes made to the object will not be automatically synchronized with the database. The object will no longer be managed by Hibernate and any further operations on the object will not be tracked by Hibernate.

The evict() method in Hibernate removes a persistent instance from the session cache and detaches it from the session. It does not delete the object from the database.

On the other hand, the remove() method is used to delete an object from the database. It not only removes the object from the session cache but also deletes it from the database.

In summary, evict() removes the object from the session cache without deleting it from the database, while remove() deletes the object from both the session cache and the database.

The evict() method in Hibernate is useful in scenarios where you want to remove an object from the session cache without deleting it from the database. This can be beneficial in situations where you have a large number of objects in the session cache and you want to release memory by removing unnecessary objects. It can also be used when you want to detach an object from the session to prevent any further changes from being tracked by Hibernate.

After the remove() method is called, the object becomes detached from the Hibernate session. It is no longer associated with any persistent context and any further changes made to the object will not be synchronized with the database.

If we call remove() on a detached object, Hibernate will throw a NonUniqueObjectException. This exception is thrown because Hibernate cannot determine which persistent instance of the object to delete from the database.

The remove() method is a Hibernate-specific method that marks an object for deletion and removes it from the session cache. The actual deletion from the database occurs when the session is flushed or when a transaction is committed.

On the other hand, the delete() method is a JPA standard method that directly deletes an object from the database. It does not remove the object from the session cache and does not require a session flush or transaction commit to perform the deletion.