Understanding JPA Annotations: @PrePersist and @PreUpdate

`@PrePersist` and `@PreUpdate` are annotations in the Java Persistence API (JPA) that are used to specify methods that should be executed automatically by the JPA provider before an entity is persisted (inserted into the database) or updated (modified in the database).

1. @PrePersist:

The `@PrePersist` annotation is used to mark a method in an entity class that should be executed just before the entity is persisted for the first time. This method is called automatically by the JPA provider before the entity is inserted into the database.

Use cases:
— Calculating and setting default values for fields before insertion.
— Timestamping the creation time of an entity.
— Performing validation or initialization logic before persistence.

Example:
```java
@Entity
public class Product {
// Entity fields and methods

@PrePersist
protected void onCreate() {
// Perform logic before entity is persisted
// Set creation timestamp or default values, etc.
}
}
```

2. @PreUpdate:

The `@PreUpdate` annotation is used to mark a method in an entity class that should be executed just before an entity is updated in the database. This method is called automatically by the JPA provider before the entity’s changes are synchronized with the database.

Use cases:
— Updating modified timestamp before an update.
— Enforcing business rules or validations before updates are applied.

Example:
```java
@Entity
public class Order {
// Entity fields and methods

@PreUpdate
protected void onUpdate() {
// Perform logic before entity is updated
// Update modified timestamp, validate changes, etc.
}
}
```

By using these annotations, you can encapsulate specific logic that should be executed before an entity’s persistence or update, ensuring that data is prepared or validated appropriately. These annotations help in maintaining cleaner and more organized code, as the logic related to these operations is encapsulated within the entity class itself.

It’s important to note that methods annotated with `@PrePersist` and `@PreUpdate` must adhere to certain rules:
- The method should have `void` return type.
- The method should not have any parameters.
- The method should be non-final and non-static.
- The method should be defined in an entity class or a superclass of the entity class.

Additionally, these annotations are part of the JPA specification and can be used with any JPA provider, such as Hibernate, EclipseLink, etc.