Spring Data JPA & Hibernate — Kiến thức nền tảng

public User findUserById(Long id) {
    String sql = "SELECT id, username, email, full_name, bio, role, " +
                 "is_active, created_at, updated_at FROM users WHERE id = ?";
    
    Connection connection = null;
    PreparedStatement statement = null;
    ResultSet resultSet = null;
    
    try {
        // 1. Lấy kết nối database
        connection = DriverManager.getConnection(
            "jdbc:mariadb://localhost:3306/blogdb", "bloguser", "blogpass");
        
        // 2. Chuẩn bị câu lệnh SQL
        statement = connection.prepareStatement(sql);
        statement.setLong(1, id);
        
        // 3. Thực thi truy vấn
        resultSet = statement.executeQuery();
        
        // 4. Ánh xạ kết quả sang đối tượng Java — THỦ CÔNG, từng cột một
        if (resultSet.next()) {
            User user = new User();
            user.setId(resultSet.getLong("id"));
            user.setUsername(resultSet.getString("username"));
            user.setEmail(resultSet.getString("email"));
            user.setFullName(resultSet.getString("full_name"));
            user.setBio(resultSet.getString("bio"));
            // ... và còn nhiều cột nữa
            return user;
        }
        return null;
        
    } catch (SQLException e) {
        throw new RuntimeException("Không thể tìm người dùng", e);
    } finally {
        // 5. Đóng mọi thứ — theo thứ tự ngược, kiểm tra null
        try { if (resultSet != null) resultSet.close(); } catch (SQLException e) { }
        try { if (statement != null) statement.close(); } catch (SQLException e) { }
        try { if (connection != null) connection.close(); } catch (SQLException e) { }
    }
}

Class Java    ←→  Bảng Database
Đối tượng     ←→  Hàng
Trường        ←→  Cột
Tham chiếu    ←→  Khóa ngoại
Collection    ←→  Truy vấn JOIN

// KHÔNG CÓ ORM (JDBC) — 40 dòng boilerplate
User user = findUserById(1L);  // Code JDBC phức tạp

// CÓ ORM (JPA/Hibernate) — một dòng
User user = entityManager.find(User.class, 1L);

Code của bạn
    ↓
Spring Data JPA  (Repository interface, derived query, phân trang)
    ↓
JPA              (Annotation và interface tiêu chuẩn)
    ↓
Hibernate        (Triển khai ORM thực tế, sinh SQL)
    ↓
JDBC             (Giao tiếp database cấp thấp)
    ↓
MariaDB Driver   (Giao thức đặc thù MariaDB)
    ↓
MariaDB Server

<dependencies>
    <!-- Dependency hiện có -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!-- MỚI: Spring Data JPA — bao gồm Hibernate, JPA, và Spring Data -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>

    <!-- MỚI: JDBC Driver MariaDB — cho phép Java giao tiếp với MariaDB -->
    <dependency>
        <groupId>org.mariadb.jdbc</groupId>
        <artifactId>mariadb-java-client</artifactId>
        <scope>runtime</scope>
    </dependency>
</dependencies>

# ============================================
# Cấu hình DataSource
# ============================================
spring.datasource.url=jdbc:mariadb://localhost:3306/blogdb
spring.datasource.username=bloguser
spring.datasource.password=blogpass
spring.datasource.driver-class-name=org.mariadb.jdbc.Driver

# ============================================
# Cấu hình JPA / Hibernate
# ============================================
# Chiến lược DDL Auto — kiểm soát cách Hibernate quản lý schema database
spring.jpa.hibernate.ddl-auto=update

# Hiển thị câu lệnh SQL Hibernate sinh ra (hữu ích cho học tập/debug)
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.format_sql=true

# Dialect Hibernate — đảm bảo SQL tối ưu được sinh cho MariaDB
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MariaDBDialect

# ============================================
# Cấu hình HikariCP Connection Pool
# ============================================
spring.datasource.hikari.maximum-pool-size=10
spring.datasource.hikari.minimum-idle=5
spring.datasource.hikari.connection-timeout=30000

Không có pool:     Request → Tạo Connection → Truy vấn → Đóng Connection → Response
                   (100ms)       (5ms)     (100ms)

Có pool:           Request → Mượn Connection → Truy vấn → Trả Connection → Response
                   (0.1ms)        (5ms)      (0.1ms)

package com.example.blogapi.model;

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

// @Entity đánh dấu class này là JPA entity — sẽ được ánh xạ đến bảng database.
@Entity

// @Table chỉ định bảng nào entity này ánh xạ đến.
// Chúng ta chỉ định "users" vì "user" là từ khóa dành riêng trong một số database.
@Table(name = "users")
public class User {

    // @Id đánh dấu trường này là khóa chính.
    // Mỗi entity PHẢI có đúng một trường @Id.
    @Id

    // @GeneratedValue cho JPA biết database sinh giá trị này.
    // GenerationType.IDENTITY nghĩa là database dùng AUTO_INCREMENT.
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String username;
    private String email;

    // JPA yêu cầu constructor không tham số (có thể protected).
    // Hibernate dùng constructor này để tạo instance qua reflection.
    protected User() { }

    public User(String username, String email) {
        this.username = username;
        this.email = email;
    }

    // Getter và setter...
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getUsername() { return username; }
    public void setUsername(String username) { this.username = username; }
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
}

// IDENTITY — dùng tính năng auto-increment của database (MariaDB, MySQL).
// Đây là lựa chọn tốt nhất cho MariaDB.
@GeneratedValue(strategy = GenerationType.IDENTITY)

// SEQUENCE — dùng sequence database (PostgreSQL, Oracle).
@GeneratedValue(strategy = GenerationType.SEQUENCE)

// AUTO — để JPA provider chọn chiến lược. Có thể không dự đoán được.
@GeneratedValue(strategy = GenerationType.AUTO)

@Entity
@Table(name = "users")
public class User {

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

    @Column(name = "username", nullable = false, unique = true, length = 50)
    private String username;

    @Column(name = "password_hash", nullable = false)
    private String passwordHash;

    // TEXT — dùng columnDefinition cho kiểu đặc thù database
    @Column(columnDefinition = "TEXT")
    private String bio;

    // Cột không cập nhật — JPA sẽ bao gồm trong INSERT nhưng không trong UPDATE
    @Column(name = "created_at", nullable = false, updatable = false)
    private LocalDateTime createdAt;
}

// Trường Java:       fullName
// Cột được sinh ra:  full_name   (tự động chuyển đổi!)

public enum PostStatus {
    DRAFT, PUBLISHED, ARCHIVED
}

@Entity
public class Post {
    // EnumType.STRING lưu tên enum dưới dạng chuỗi trong database.
    // LUÔN dùng STRING. Với ORDINAL, nếu bạn thêm constant mới giữa chừng,
    // dữ liệu cũ bị lỗi!
    @Enumerated(EnumType.STRING)
    @Column(nullable = false, length = 20)
    private PostStatus status = PostStatus.DRAFT;
}

private LocalDateTime createdAt;   // → TIMESTAMP trong MariaDB
private LocalDate birthDate;       // → DATE trong MariaDB

# CREATE — Xóa tất cả bảng và tạo lại mỗi khi app khởi động.
# CẢNH BÁO: MẤT TẤT CẢ DỮ LIỆU mỗi lần khởi động lại!
spring.jpa.hibernate.ddl-auto=create

# UPDATE — So sánh entity class với database và áp dụng thay đổi.
# Thêm bảng và cột mới, nhưng KHÔNG BAO GIỜ xóa hay đổi tên.
spring.jpa.hibernate.ddl-auto=update

# VALIDATE — So sánh entity với database và ném lỗi nếu không khớp.
# KHÔNG sửa đổi database.
spring.jpa.hibernate.ddl-auto=validate

# NONE — Không làm gì. Hibernate bỏ qua khác biệt schema.
spring.jpa.hibernate.ddl-auto=none

package com.example.blogapi.repository;

import com.example.blogapi.model.User;
import org.springframework.data.jpa.repository.JpaRepository;

// Chỉ vậy thôi. Không class, không implementation, không cần @Repository.
// Spring Data JPA sinh implementation tại runtime.
public interface UserRepository extends JpaRepository<User, Long> {
    // JpaRepository<User, Long> nghĩa là:
    // - User là kiểu entity
    // - Long là kiểu khóa chính (trường id)
}

// TẠO / CẬP NHẬT
User save(User entity);                          // Lưu hoặc cập nhật
List<User> saveAll(Iterable<User> entities);      // Lưu nhiều

// ĐỌC
Optional<User> findById(Long id);                 // Tìm theo khóa chính
List<User> findAll();                              // Lấy tất cả
long count();                                      // Đếm tổng
boolean existsById(Long id);                       // Kiểm tra tồn tại

// XÓA
void deleteById(Long id);                          // Xóa theo ID
void delete(User entity);                          // Xóa theo entity

// PHÂN TRANG & SẮP XẾP
Page<User> findAll(Pageable pageable);             // Tìm tất cả có phân trang
List<User> findAll(Sort sort);                     // Tìm tất cả có sắp xếp

@Service
public class UserService {

    private final UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public User createUser(User user) {
        return userRepository.save(user);  // Thực thi: INSERT INTO users ...
    }

    public User getUserById(Long id) {
        return userRepository.findById(id) // Thực thi: SELECT * FROM users WHERE id = ?
                .orElseThrow(() -> new RuntimeException("Không tìm thấy người dùng id: " + id));
    }

    public List<User> getAllUsers() {
        return userRepository.findAll();   // Thực thi: SELECT * FROM users
    }

    public void deleteUser(Long id) {
        userRepository.deleteById(id);     // Thực thi: DELETE FROM users WHERE id = ?
    }
}

@Entity
@Table(name = "users")
public class User {

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

    @Column(nullable = false, unique = true, length = 50)
    private String username;

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

    @Column(name = "password_hash", nullable = false)
    private String passwordHash;

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

    @Column(columnDefinition = "TEXT")
    private String bio;

    @Column(nullable = false, length = 20)
    private String role = "ROLE_USER";

    @Column(name = "is_active", nullable = false)
    private boolean active = true;

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

    @Column(name = "updated_at", nullable = false)
    private LocalDateTime updatedAt;

    // Callback vòng đời: được gọi tự động trước khi entity được lưu lần đầu
    @PrePersist
    protected void onCreate() {
        this.createdAt = LocalDateTime.now();
        this.updatedAt = LocalDateTime.now();
    }

    // Callback vòng đời: được gọi tự động trước mỗi lần cập nhật
    @PreUpdate
    protected void onUpdate() {
        this.updatedAt = LocalDateTime.now();
    }

    protected User() { }

    public User(String username, String email, String passwordHash) {
        this.username = username;
        this.email = email;
        this.passwordHash = passwordHash;
    }

    // --- Getter và Setter ---
    // (bỏ qua cho ngắn gọn — tương tự các bài trước)
}

public interface UserRepository extends JpaRepository<User, Long> {

    // Spring Data JPA sinh implementation từ tên phương thức!
    // findByEmail → SELECT * FROM users WHERE email = ?
    Optional<User> findByEmail(String email);

    // findByUsername → SELECT * FROM users WHERE username = ?
    Optional<User> findByUsername(String username);

    // existsByEmail → SELECT EXISTS(SELECT 1 FROM users WHERE email = ?)
    boolean existsByEmail(String email);

    boolean existsByUsername(String username);
}

@Entity
@Table(name = "posts")
public class Post {

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

    @Column(nullable = false, length = 500)
    private String title;

    @Column(nullable = false, length = 500, unique = true)
    private String slug;

    @Column(nullable = false, columnDefinition = "TEXT")
    private String content;

    @Column(nullable = false, length = 20)
    private String status = "DRAFT";

    // @ManyToOne định nghĩa quan hệ: nhiều bài viết thuộc một user.
    // FetchType.LAZY nghĩa là: KHÔNG tải User khi tải Post.
    // User chỉ được tải khi bạn gọi post.getAuthor().
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "author_id", nullable = false)
    private User author;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "category_id")
    private Category category;

    @PrePersist
    protected void onCreate() {
        this.createdAt = LocalDateTime.now();
        this.updatedAt = LocalDateTime.now();
    }

    @PreUpdate
    protected void onUpdate() {
        this.updatedAt = LocalDateTime.now();
    }

    // ... constructor, getter, setter
}

# Tạo dữ liệu test trong database
docker exec -it blogdb mariadb -u bloguser -pblogpass blogdb \
  -e "INSERT INTO users (username, email, password_hash, full_name, role, is_active, created_at, updated_at) VALUES ('alice', 'alice@example.com', 'temphash', 'Alice Johnson', 'ROLE_ADMIN', true, NOW(), NOW());"

# Tạo bài viết qua API
curl -X POST http://localhost:8080/api/posts \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Bắt đầu với Spring Data JPA",
    "content": "Spring Data JPA giúp truy cập database cực kỳ đơn giản...",
    "authorId": 1
  }'

# Khởi động lại ứng dụng, rồi lấy bài viết
curl http://localhost:8080/api/posts

# Bài viết VẪN CÒN ĐÓ! Dữ liệu được lưu bền vững trong MariaDB.