Your Code
    ↓
Spring Data JPA       ← Repositories, Query Methods
    ↓
JPA (javax/jakarta.persistence)  ← Standard API
    ↓
Hibernate             ← JPA Implementation (ORM)
    ↓
JDBC
    ↓
Database (MySQL, PostgreSQL, H2, etc.)

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

<!-- Choose your DB driver -->
<dependency>
    <groupId>com.mysql</groupId>
    <artifactId>mysql-connector-j</artifactId>
    <scope>runtime</scope>
</dependency>

# DataSource
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=secret
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

# JPA / Hibernate
spring.jpa.hibernate.ddl-auto=update
# Options: none | validate | update | create | create-drop

spring.jpa.show-sql=true
spring.jpa.format-sql=true
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQLDialect

# Naming strategy
spring.jpa.hibernate.naming.physical-strategy=org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl

import jakarta.persistence.*;
import java.time.LocalDateTime;

@Entity
@Table(name = "users",
       uniqueConstraints = @UniqueConstraint(columnNames = "email"))
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "full_name", nullable = false, length = 100)
    private String name;

    @Column(unique = true, nullable = false)
    private String email;

    @Column(name = "is_active", columnDefinition = "BOOLEAN DEFAULT TRUE")
    private boolean active = true;

    @Enumerated(EnumType.STRING)
    @Column(nullable = false)
    private Role role;

    @CreationTimestamp
    @Column(name = "created_at", updatable = false)
    private LocalDateTime createdAt;

    @UpdateTimestamp
    @Column(name = "updated_at")
    private LocalDateTime updatedAt;

    // Getters, Setters, Constructors
}

// UUID strategy example
@Id
@GeneratedValue(strategy = GenerationType.UUID)
private String id;

@Entity
public class User {
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @OneToOne(cascade = CascadeType.ALL)
    @JoinColumn(name = "profile_id", referencedColumnName = "id")
    private UserProfile profile;
}

@Entity
public class UserProfile {
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String bio;
    private String avatarUrl;

    @OneToOne(mappedBy = "profile")
    private User user;
}

@Entity
public class Department {
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;

    @OneToMany(mappedBy = "department", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    private List<Employee> employees = new ArrayList<>();
}

@Entity
public class Employee {
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "department_id")
    private Department department;
}

@Entity
public class Student {
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;

    @ManyToMany(cascade = {CascadeType.PERSIST, CascadeType.MERGE})
    @JoinTable(
        name = "student_course",
        joinColumns = @JoinColumn(name = "student_id"),
        inverseJoinColumns = @JoinColumn(name = "course_id")
    )
    private Set<Course> courses = new HashSet<>();
}

@Entity
public class Course {
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String title;

    @ManyToMany(mappedBy = "courses")
    private Set<Student> students = new HashSet<>();
}

@OneToMany(cascade = CascadeType.ALL, orphanRemoval = true)

// Always prefer LAZY for collections to avoid N+1 problems
@OneToMany(fetch = FetchType.LAZY)
private List<Order> orders;

// In Repository
@EntityGraph(attributePaths = {"department"})
List<Employee> findAll();

// OR with JPQL
@Query("SELECT e FROM Employee e JOIN FETCH e.department")
List<Employee> findAllWithDepartment();

Repository (marker interface)
    └── CrudRepository<T, ID>        → Basic CRUD
            └── PagingAndSortingRepository<T, ID>  → + Pagination & Sorting
                    └── JpaRepository<T, ID>       → + JPA-specific (flush, batch, etc.)

public interface UserRepository extends JpaRepository<User, Long> { }

public interface UserRepository extends JpaRepository<User, Long> {

    // SELECT * FROM users WHERE name = ?
    List<User> findByName(String name);

    // SELECT * FROM users WHERE email = ? AND active = ?
    Optional<User> findByEmailAndActive(String email, boolean active);

    // SELECT * FROM users WHERE name LIKE '%keyword%'
    List<User> findByNameContaining(String keyword);

    // SELECT * FROM users WHERE created_at BETWEEN ? AND ?
    List<User> findByCreatedAtBetween(LocalDateTime start, LocalDateTime end);

    // SELECT * FROM users WHERE age > ?
    List<User> findByAgeGreaterThan(int age);

    // SELECT * FROM users ORDER BY name ASC
    List<User> findByActiveOrderByNameAsc(boolean active);

    // SELECT COUNT(*) FROM users WHERE role = ?
    long countByRole(Role role);

    // DELETE FROM users WHERE active = false
    void deleteByActive(boolean active);

    // Check existence
    boolean existsByEmail(String email);
}

// JPQL uses entity class names and field names (not table/column names)
@Query("SELECT u FROM User u WHERE u.email = :email")
Optional<User> findByEmail(@Param("email") String email);

@Query("SELECT u FROM User u WHERE u.active = true ORDER BY u.name ASC")
List<User> findAllActiveUsers();

// JPQL with JOIN
@Query("SELECT u FROM User u JOIN FETCH u.orders WHERE u.id = :id")
Optional<User> findByIdWithOrders(@Param("id") Long id);

@Query(value = "SELECT * FROM users WHERE email = :email", nativeQuery = true)
Optional<User> findByEmailNative(@Param("email") String email);

// Native with pagination
@Query(
    value = "SELECT * FROM users WHERE active = true",
    countQuery = "SELECT COUNT(*) FROM users WHERE active = true",
    nativeQuery = true
)
Page<User> findActiveUsers(Pageable pageable);

@Modifying
@Transactional
@Query("UPDATE User u SET u.active = false WHERE u.id = :id")
int deactivateUser(@Param("id") Long id);

@Modifying
@Transactional
@Query("DELETE FROM User u WHERE u.active = false")
void deleteInactiveUsers();

// Repository method
Page<User> findByActive(boolean active, Pageable pageable);
List<User> findByRole(Role role, Sort sort);

// Service usage
public Page<User> getUsers(int page, int size) {
    Pageable pageable = PageRequest.of(page, size, Sort.by("name").ascending());
    return userRepository.findByActive(true, pageable);
}

Page<User> result = userRepository.findAll(pageable);

result.getContent();          // List of users on this page
result.getTotalElements();    // Total records in DB
result.getTotalPages();       // Total pages
result.getNumber();           // Current page number (0-based)
result.getSize();             // Page size
result.isFirst();             // Is this the first page?
result.isLast();              // Is this the last page?
result.hasNext();             // Has next page?

Sort.by("name").ascending()
Sort.by("name").descending()
Sort.by("name").ascending().and(Sort.by("createdAt").descending())

// In Pageable
PageRequest.of(0, 10, Sort.by(Sort.Direction.DESC, "createdAt"))

// Add to repository
public interface UserRepository extends JpaRepository<User, Long>,
                                         JpaSpecificationExecutor<User> { }

// Define Specifications
public class UserSpecifications {

    public static Specification<User> hasName(String name) {
        return (root, query, cb) ->
            name == null ? null : cb.equal(root.get("name"), name);
    }

    public static Specification<User> isActive(Boolean active) {
        return (root, query, cb) ->
            active == null ? null : cb.equal(root.get("active"), active);
    }

    public static Specification<User> hasRole(Role role) {
        return (root, query, cb) ->
            role == null ? null : cb.equal(root.get("role"), role);
    }
}

// Service usage — combine dynamically
public List<User> searchUsers(String name, Boolean active, Role role) {
    Specification<User> spec = Specification
        .where(UserSpecifications.hasName(name))
        .and(UserSpecifications.isActive(active))
        .and(UserSpecifications.hasRole(role));

    return userRepository.findAll(spec);
}

@Transactional(
    propagation = Propagation.REQUIRED,   // default
    isolation = Isolation.DEFAULT,         // default
    readOnly = false,
    rollbackFor = Exception.class,
    timeout = 30
)
public void processOrder(Order order) {
    // All DB operations here run in one transaction
}

// Read-only for SELECT queries (performance optimization)
@Transactional(readOnly = true)
public List<User> getAllUsers() {
    return userRepository.findAll();
}

// Enable auditing in main class or config
@SpringBootApplication
@EnableJpaAuditing(auditorAwareRef = "auditorProvider")
public class MyApp { }

// Auditable base entity
@MappedSuperclass
@EntityListeners(AuditingEntityListener.class)
public abstract class BaseEntity {

    @CreatedDate
    @Column(updatable = false)
    private LocalDateTime createdAt;

    @LastModifiedDate
    private LocalDateTime updatedAt;

    @CreatedBy
    @Column(updatable = false)
    private String createdBy;

    @LastModifiedBy
    private String updatedBy;
}

// Extend in your entities
@Entity
public class User extends BaseEntity {
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
}

// Provide current user
@Component
public class AuditorProvider implements AuditorAware<String> {
    @Override
    public Optional<String> getCurrentAuditor() {
        return Optional.of(
            SecurityContextHolder.getContext()
                .getAuthentication().getName()
        );
    }
}

public interface UserSummary {
    String getName();
    String getEmail();
}

// Repository
List<UserSummary> findByActive(boolean active);

public record UserDTO(String name, String email) { }

// Repository
@Query("SELECT new com.example.dto.UserDTO(u.name, u.email) FROM User u WHERE u.active = true")
List<UserDTO> findActiveUserDTOs();

<T> List<T> findByActive(boolean active, Class<T> type);

// Usage
List<UserSummary> summaries = repo.findByActive(true, UserSummary.class);
List<User> full = repo.findByActive(true, User.class);

@Entity
public class User {

    @PrePersist
    public void prePersist() {
        System.out.println("Before insert");
    }

    @PostPersist
    public void postPersist() {
        System.out.println("After insert");
    }

    @PreUpdate
    public void preUpdate() {
        System.out.println("Before update");
    }

    @PostUpdate
    public void postUpdate() {
        System.out.println("After update");
    }

    @PreRemove
    public void preRemove() {
        System.out.println("Before delete");
    }

    @PostRemove
    public void postRemove() {
        System.out.println("After delete");
    }

    @PostLoad
    public void postLoad() {
        System.out.println("After load from DB");
    }
}

@Entity
public class User {
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;

    @Column(name = "deleted")
    private boolean deleted = false;
}

@Repository
public interface UserRepository extends JpaRepository<User, Long> {

    // Automatically filter deleted records
    @Query("SELECT u FROM User u WHERE u.deleted = false")
    List<User> findAllActive();

    // Soft delete
    @Modifying
    @Transactional
    @Query("UPDATE User u SET u.deleted = true WHERE u.id = :id")
    void softDelete(@Param("id") Long id);
}

@Entity
@SQLRestriction("deleted = false")
public class User { ... }