Khám Phá Spring Data JDBC: Nhẹ Nhàng, Nhanh Chóng Cho Database Trên Lộ Trình Java Spring

Giới Thiệu: Một Lựa Chọn Mới Cho Tương Tác Database

Chào mừng các bạn quay trở lại với series “Lộ trình Java Spring“!

Trong những bài viết trước, chúng ta đã cùng nhau khám phá rất nhiều khía cạnh quan trọng của Spring Framework, từ những khái niệm cốt lõi như Dependency Injection, IoC Container, cách Spring hoạt động, cho đến việc xây dựng ứng dụng web với Spring MVC và tương tác database bằng Spring Data JPA (cùng với Hibernate).

Spring Data JPA là một lựa chọn tuyệt vời và rất phổ biến khi làm việc với cơ sở dữ liệu quan hệ, mang lại sức mạnh của ORM (Object-Relational Mapping) và giúp chúng ta thao tác với database thông qua các đối tượng Java quen thuộc. Tuy nhiên, đôi khi, sự “thông minh” và các tính năng phức tạp của ORM như quản lý trạng thái (state management), lazy loading, caching có thể trở thành rào cản hoặc không thực sự cần thiết, thậm chí gây khó khăn trong việc kiểm soát hiệu năng hoặc hiểu rõ chuyện gì đang xảy ra “phía sau”.

Đó là lúc Spring Data JDBC tỏa sáng. Sinh ra từ nhu cầu về một giải pháp truy cập database quan hệ đơn giản, nhẹ nhàng và gần với JDBC gốc hơn, Spring Data JDBC cung cấp một cách tiếp cận khác – tập trung vào việc ánh xạ trực tiếp các bản ghi database thành các đối tượng Java một cách minh bạch, ít “phép thuật” hơn. Nó không phải là một ORM đầy đủ tính năng như JPA/Hibernate, mà là một thư viện ánh xạ đối tượng đơn giản (Simple Object Mapper).

Trong bài viết này, chúng ta sẽ cùng nhau khám phá Spring Data JDBC, hiểu rõ triết lý hoạt động của nó, cách nó khác biệt so với Spring Data JPA và làm thế nào để bắt đầu sử dụng nó trong các ứng dụng Spring Boot của bạn. Hãy cùng tìm hiểu tại sao nó lại được coi là “nhẹ nhàng” và “nhanh chóng”!

Spring Data JDBC Là Gì và Tại Sao Nó Xuất Hiện?

Như tên gọi, Spring Data JDBC là một phần của họ dự án Spring Data, chuyên sâu vào việc cung cấp một mô hình lập trình quen thuộc (như Repository Pattern) cho các ứng dụng sử dụng JDBC (Java Database Connectivity) trực tiếp, thay vì thông qua một lớp ORM phức tạp như JPA/Hibernate.

JDBC là API gốc của Java để kết nối và tương tác với database quan hệ. Mặc dù mạnh mẽ, việc sử dụng JDBC trực tiếp thường yêu cầu rất nhiều mã lặp đi lặp lại (boilerplate code) như quản lý kết nối, chuẩn bị câu lệnh SQL (PreparedStatement), xử lý kết quả (ResultSet), và quản lý tài nguyên (đóng kết nối, statement, resultset). Spring Framework đã có các template như `JdbcTemplate` để giảm bớt gánh nặng này, nhưng vẫn yêu cầu bạn tự viết hoặc tạo ra phần lớn câu lệnh SQL và ánh xạ kết quả thủ công.

Spring Data JDBC xuất hiện để giải quyết vấn đề này bằng cách cung cấp một tầng trừu tượng cao hơn `JdbcTemplate`, tương tự như cách Spring Data JPA trừu tượng hóa JPA. Tuy nhiên, thay vì xây dựng trên một ORM đầy đủ, nó xây dựng trực tiếp trên `JdbcTemplate`. Nó tự động tạo các câu lệnh SQL cơ bản (như INSERT, UPDATE, SELECT, DELETE) dựa trên cấu trúc của lớp Java của bạn và quy ước đặt tên, và tự động ánh xạ dữ liệu từ `ResultSet` sang đối tượng Java.

Mục tiêu chính của Spring Data JDBC là:

1. Đơn giản hóa việc truy cập database quan hệ: Loại bỏ boilerplate code của JDBC và `JdbcTemplate`.
2. Cung cấp mô hình lập trình quen thuộc: Sử dụng Repository Pattern giống như Spring Data JPA.
3. Minh bạch và dễ hiểu: Ít “phép thuật” hơn ORM, hành vi tương tác với database rõ ràng hơn.
4. Nhẹ nhàng và hiệu năng tốt: Tránh được overhead của các tính năng ORM không cần thiết.

Spring Data JDBC Khác Gì So Với Spring Data JPA?

Đây là điểm mấu chốt để quyết định khi nào sử dụng Spring Data JDBC thay vì Spring Data JPA. Mặc dù cả hai đều là một phần của Spring Data và sử dụng Repository Pattern, chúng có những triết lý và cơ chế hoạt động khác biệt đáng kể.

Chúng ta hãy cùng xem bảng so sánh dưới đây:

Như bạn thấy, sự khác biệt cốt lõi nằm ở mức độ trừu tượng và cách xử lý mapping cùng quan hệ. Spring Data JPA mang đến một “Persistent Context” quản lý các Entity và mối quan hệ phức tạp. Spring Data JDBC thì đơn giản hơn nhiều: nó lấy dữ liệu từ database, điền vào đối tượng Java, và khi lưu, nó ánh xạ ngược lại thành câu lệnh SQL. Không có quản lý trạng thái lâu dài, không có proxy cho lazy loading.

Bắt Đầu Với Spring Data JDBC

Để bắt đầu sử dụng Spring Data JDBC, chúng ta cần thêm dependency và cấu hình kết nối database.

Thêm Dependency

Nếu sử dụng Spring Boot, bạn chỉ cần thêm starter cho Spring Data JDBC. Hãy nhớ thêm dependency cho driver database của bạn nữa (ví dụ: H2 cho database nhúng, PostgreSQL, MySQL…).

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jdbc</artifactId>
</dependency>
<!-- Ví dụ với H2 Database (in-memory) -->
<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>runtime</scope>
</dependency>

Hoặc với Gradle:

implementation 'org.springframework.boot:spring-boot-starter-data-jdbc'
// Ví dụ với H2 Database (in-memory)
runtimeOnly 'com.h2database:h2'

Cấu Hình Database

Bạn cấu hình datasource trong file `application.properties` hoặc `application.yml` giống như các dự án Spring Boot khác.

# application.properties
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driver-class-name=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.sql.init.mode=always # Optional: để chạy script khởi tạo schema

Bạn có thể tạo file `schema.sql` và `data.sql` trong thư mục `src/main/resources` để Spring Boot tự động khởi tạo schema và dữ liệu ban đầu khi ứng dụng chạy.

-- src/main/resources/schema.sql
CREATE TABLE customer (
    id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(255) NOT NULL,
    email VARCHAR(255)
);

CREATE TABLE product (
    id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(255) NOT NULL,
    price DECIMAL(10, 2)
);

CREATE TABLE order_table ( -- 'order' is a reserved keyword
    id INT AUTO_INCREMENT PRIMARY KEY,
    customer_id INT,
    order_date TIMESTAMP,
    FOREIGN KEY (customer_id) REFERENCES customer(id)
);

CREATE TABLE order_item (
    id INT AUTO_INCREMENT PRIMARY KEY,
    order_id INT,
    product_id INT,
    quantity INT,
    FOREIGN KEY (order_id) REFERENCES order_table(id),
    FOREIGN KEY (product_id) REFERENCES product(id)
);

-- src/main/resources/data.sql
INSERT INTO customer (name, email) VALUES ('Alice', 'alice@example.com');
INSERT INTO customer (name, email) VALUES ('Bob', 'bob@example.com');

INSERT INTO product (name, price) VALUES ('Laptop', 1200.00);
INSERT INTO product (name, price) VALUES ('Mouse', 25.00);
INSERT INTO product (name, price) VALUES ('Keyboard', 75.00);

Định Nghĩa “Aggregate”

Trong Spring Data JDBC, khái niệm quan trọng nhất là “Aggregate Root”. Một aggregate là một cụm các đối tượng được coi là một đơn vị duy nhất khi thực hiện các thay đổi dữ liệu. Aggregate Root là đối tượng chính trong cụm đó và là điểm truy cập duy nhất từ bên ngoài. Nó có một ID duy nhất.

Ví dụ, trong hệ thống bán hàng, `Order` có thể là Aggregate Root. Các `OrderItem` (các mặt hàng trong đơn hàng) là một phần của aggregate `Order`. Khi bạn lưu hoặc load một `Order`, bạn thường muốn lưu/load tất cả `OrderItem` của nó cùng lúc.

Các lớp Java đại diện cho aggregate này cần tuân thủ một số quy ước:

• Aggregate Root phải có trường ID được đánh dấu bằng @Id.
• Mặc định, tên bảng sẽ là tên lớp chuyển sang dạng snake_case (ví dụ: Customer -> customer, OrderItem -> order_item). Bạn có thể ghi đè bằng @Table("your_table_name").
• Các thuộc tính kiểu Collection (List, Set) trong cùng Aggregate Root sẽ được ánh xạ tới các bảng liên quan bằng cách sử dụng @MappedCollection. Spring Data JDBC sẽ tìm kiếm các bản ghi trong bảng liên quan có khóa ngoại trỏ về ID của Aggregate Root.

Ví dụ về lớp `Customer` và `Order`:

import org.springframework.data.annotation.Id;
import org.springframework.data.relational.core.mapping.MappedCollection;
import org.springframework.data.relational.core.mapping.Table;

import java.time.LocalDateTime;
import java.util.HashSet;
import java.util.Set;

// Customer là một Aggregate Root
@Table("customer") // Tên bảng trong database
public class Customer {

    @Id // Đánh dấu trường ID là khóa chính của Aggregate Root
    private Long id;
    private String name;
    private String email;

    // Quan hệ 1-nhiều với Order - trong trường hợp này, Order không nằm trong aggregate Customer
    // Chúng ta chỉ lưu ID của Customer trong Order
    // @MappedCollection không dùng ở đây vì Order là một Aggregate Root riêng biệt
    // Chúng ta sẽ load Orders của Customer thông qua OrderRepository

    public Customer(Long id, String name, String email) {
        this.id = id;
        this.name = name;
        this.email = email;
    }

    // Getters and setters
    public Long getId() { return id; }
    public String getName() { return name; }
    public String getEmail() { return email; }

    public void setId(Long id) { this.id = id; }
    public void setName(String name) { this.name = name; }
    public void setEmail(String email) { this.email = email; }

    @Override
    public String toString() {
        return "Customer{" +
               "id=" + id +
               ", name='" + name + '\'' +
               ", email='" + email + '\'' +
               '}';
    }
}

import org.springframework.data.annotation.Id;
import org.springframework.data.relational.core.mapping.Column;
import org.springframework.data.relational.core.mapping.MappedCollection;
import org.springframework.data.relational.core.mapping.Table;

import java.time.LocalDateTime;
import java.util.HashSet;
import java.util.Set;

// Order là một Aggregate Root
@Table("order_table") // Tên bảng trong database (tránh từ khóa 'order')
public class Order {

    @Id
    private Long id;

    @Column("customer_id") // Ánh xạ tới cột customer_id
    private Long customerId; // Lưu ID của Customer

    private LocalDateTime orderDate;

    // Quan hệ 1-nhiều với OrderItem - OrderItem NẰM TRONG aggregate Order
    // Khi load/save Order, các OrderItem cũng được load/save
    @MappedCollection(keyColumn = "id", idColumn = "order_id") // Cấu hình cách ánh xạ collection
    private Set<OrderItem> items = new HashSet<>();

    public Order(Long id, Long customerId, LocalDateTime orderDate) {
        this.id = id;
        this.customerId = customerId;
        this.orderDate = orderDate;
    }

    // Getters and setters
    public Long getId() { return id; }
    public Long getCustomerId() { return customerId; }
    public LocalDateTime getOrderDate() { return orderDate; }
    public Set<OrderItem> getItems() { return items; }

    public void setId(Long id) { this.id = id; }
    public void setCustomerId(Long customerId) { this.customerId = customerId; }
    public void setOrderDate(LocalDateTime orderDate) { this.orderDate = orderDate; }
    public void setItems(Set<OrderItem> items) { this.items = items; } // Cẩn thận khi set thẳng, nên có add method

    public void addItem(OrderItem item) {
        this.items.add(item);
    }

    @Override
    public String toString() {
        return "Order{" +
               "id=" + id +
               ", customerId=" + customerId +
               ", orderDate=" + orderDate +
               ", items=" + items + // Bao gồm OrderItem trong toString
               '}';
    }
}

import org.springframework.data.annotation.Id;
import org.springframework.data.relational.core.mapping.Column;
import org.springframework.data.relational.core.mapping.Table;

// OrderItem KHÔNG phải Aggregate Root, nó là một phần của Aggregate Order
@Table("order_item")
public class OrderItem {

    // OrderItem cũng có ID riêng
    private Long id;

    // Quan hệ khóa ngoại ngược về Order - Spring Data JDBC dùng nó để liên kết OrderItem với Order
    // Cần chú ý tên cột phải khớp với idColumn trong @MappedCollection bên lớp Order
    @Column("order_id")
    private Long orderId; // Không cần annotation @Id ở đây vì đây là phần tử của collection

    // Liên kết với Product - chỉ cần lưu ID
    @Column("product_id")
    private Long productId;

    private int quantity;

    // Constructor cần thiết cho Spring Data JDBC
    public OrderItem(Long id, Long orderId, Long productId, int quantity) {
        this.id = id;
        this.orderId = orderId;
        this.productId = productId;
        this.quantity = quantity;
    }

    // Getters and setters
    public Long getId() { return id; }
    public Long getOrderId() { return orderId; }
    public Long getProductId() { return productId; }
    public int getQuantity() { return quantity; }

    public void setId(Long id) { this.id = id; }
    public void setOrderId(Long orderId) { this.orderId = orderId; }
    public void setProductId(Long productId) { this.productId = productId; }
    public void setQuantity(int quantity) { this.quantity = quantity; }

    @Override
    public String toString() {
        return "OrderItem{" +
               "id=" + id +
               ", orderId=" + orderId +
               ", productId=" + productId +
               ", quantity=" + quantity +
               '}';
    }
}

Lưu ý rằng trong ví dụ trên, `Customer` và `Order` là các Aggregate Root riêng biệt. `OrderItem` là một phần của aggregate `Order`. Mối quan hệ từ `Order` đến `Customer` chỉ được thể hiện bằng cách lưu `customerId` trong lớp `Order`. Khi bạn load một `Order`, bạn không tự động load `Customer` tương ứng. Bạn sẽ cần load `Customer` đó thông qua `CustomerRepository` nếu cần.

Mối quan hệ 1-N giữa `Order` và `OrderItem` được xử lý bằng `@MappedCollection`. Spring Data JDBC sẽ tự động load tất cả `OrderItem` có `order_id` tương ứng khi bạn load một `Order`, và lưu/xóa chúng khi bạn lưu/xóa `Order`.

Tạo Repository

Giống như Spring Data JPA, bạn tạo một interface kế thừa từ `CrudRepository` (hoặc `PagingAndSortingRepository`, `ListCrudRepository`…). Spring Data sẽ tự động tạo implement class vào runtime.

import org.springframework.data.repository.CrudRepository;

public interface CustomerRepository extends CrudRepository<Customer, Long> {
    // Spring Data JDBC cũng hỗ trợ Derived Query Methods
    Customer findByName(String name);
}

import org.springframework.data.repository.CrudRepository;

public interface OrderRepository extends CrudRepository<Order, Long> {
    // Tìm đơn hàng theo ID khách hàng
    // Lưu ý: Phương thức này sẽ trả về List<Order>, mỗi Order sẽ bao gồm cả OrderItem của nó
    List<Order> findByCustomerId(Long customerId);
}

Thực Hiện Các Thao Tác Cơ Bản (CRUD)

Bây giờ, bạn có thể inject các Repository này vào Service hoặc Component khác và sử dụng các phương thức CRUD được cung cấp sẵn.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;
import java.util.List;
import java.util.Optional;

@Component
public class DataInitializer implements CommandLineRunner {

    private final CustomerRepository customerRepository;
    private final OrderRepository orderRepository;
    private final ProductRepository productRepository; // Bạn sẽ cần tạo ProductRepository tương tự

    @Autowired
    public DataInitializer(CustomerRepository customerRepository, OrderRepository orderRepository, ProductRepository productRepository) {
        this.customerRepository = customerRepository;
        this.orderRepository = orderRepository;
        this.productRepository = productRepository;
    }

    @Override
    public void run(String... args) throws Exception {
        System.out.println("--- Spring Data JDBC Example ---");

        // Tìm Customer theo ID
        Optional<Customer> aliceOptional = customerRepository.findById(1L);
        aliceOptional.ifPresent(customer -> {
            System.out.println("Found Customer: " + customer);

            // Tìm Order theo Customer ID
            List<Order> orders = orderRepository.findByCustomerId(customer.getId());
            System.out.println("Orders for " + customer.getName() + ": " + orders.size());
            orders.forEach(System.out::println);
        });

        // Tạo Order mới cho Bob
        Customer bob = customerRepository.findByName("Bob");
        if (bob != null) {
            System.out.println("Creating order for: " + bob.getName());

            Product laptop = productRepository.findById(1L).orElseThrow(); // Giả sử ProductRepository tồn tại
            Product mouse = productRepository.findById(2L).orElseThrow();

            Order newOrder = new Order(null, bob.getId(), LocalDateTime.now());
            newOrder.addItem(new OrderItem(null, null, laptop.getId(), 1)); // orderId sẽ được set khi Order được lưu
            newOrder.addItem(new OrderItem(null, null, mouse.getId(), 2));

            Order savedOrder = orderRepository.save(newOrder); // Lưu Order và OrderItems liên quan
            System.out.println("Saved new Order: " + savedOrder);

            // Load lại Order để kiểm tra OrderItems đã được lưu chưa
            Optional<Order> loadedOrder = orderRepository.findById(savedOrder.getId());
            loadedOrder.ifPresent(order -> System.out.println("Loaded Order with items: " + order));
        }

        // Cập nhật Customer
        Optional<Customer> custToUpdateOpt = customerRepository.findById(1L);
        custToUpdateOpt.ifPresent(cust -> {
            cust.setEmail("alice.updated@example.com");
            customerRepository.save(cust); // Lưu lại
            System.out.println("Updated Customer 1: " + customerRepository.findById(1L).get());
        });

        // Xóa Order
        // Optional<Order> orderToDeleteOpt = orderRepository.findById(1L); // Thay bằng ID Order thực tế
        // orderToDeleteOpt.ifPresent(order -> {
        //     orderRepository.delete(order); // Xóa Order và OrderItems liên quan (nếu cấu hình FK đúng)
        //     System.out.println("Deleted Order: " + order.getId());
        // });

        System.out.println("--- End of Spring Data JDBC Example ---");
    }
}

Khi bạn gọi orderRepository.save(newOrder), Spring Data JDBC sẽ thực hiện các thao tác sau:

• Kiểm tra newOrder.getId(). Nếu là null, thực hiện INSERT vào bảng order_table. Sau khi insert, nó sẽ lấy ID được sinh ra và set vào đối tượng newOrder.
• Kiểm tra collection items trong newOrder. Với mỗi OrderItem trong collection:
  • Set orderId của OrderItem bằng ID của newOrder vừa được sinh ra.
  • Kiểm tra OrderItem.getId(). Nếu là null, thực hiện INSERT vào bảng order_item.
  • Nếu OrderItem.getId() không null, thực hiện UPDATE vào bảng order_item.

Khi bạn gọi orderRepository.findById(id), Spring Data JDBC sẽ thực hiện:

• Thực hiện SELECT từ bảng order_table dựa trên ID.
• Thực hiện SELECT từ bảng order_item tìm tất cả bản ghi có order_id tương ứng.
• Ánh xạ kết quả từ cả hai truy vấn vào đối tượng Order và collection items của nó.

Các Khái Niệm Chính Cần Nắm Vững

• Aggregate Root: Là trung tâm của mọi thao tác. Tất cả các thay đổi dữ liệu nên đi qua Aggregate Root để đảm bảo tính nhất quán. Đối tượng này được đánh dấu bằng @Id cho trường ID của nó.
• @Id: Đánh dấu trường là khóa chính. Spring Data JDBC sử dụng nó để xác định một đối tượng có phải là mới (cần INSERT) hay đã tồn tại (cần UPDATE).
• @Table: Dùng để chỉ định tên bảng trong database nếu khác với quy ước đặt tên mặc định (tên lớp dạng snake_case).
• @Column: Dùng để chỉ định tên cột trong database nếu khác với quy ước đặt tên mặc định (tên thuộc tính dạng snake_case).
• @MappedCollection: Được đặt trên các thuộc tính kiểu Collection (List, Set) trong Aggregate Root để ánh xạ mối quan hệ 1-N trong cùng Aggregate. Bạn cần chỉ định idColumn là tên cột khóa ngoại trong bảng “Nhiều” (bảng của các phần tử trong collection) trỏ về ID của Aggregate Root. keyColumn (tùy chọn) có thể dùng để ánh xạ một cột khác làm key trong Map.
• No Lazy Loading: Nhắc lại một lần nữa, khi bạn load một Aggregate Root, tất cả các Collection được đánh dấu @MappedCollection sẽ được load ngay lập tức (Eager loading).

Ưu Điểm Của Spring Data JDBC

• Đơn giản và Minh bạch: Mô hình ánh xạ rất rõ ràng. Bạn thấy trực tiếp cấu trúc database phản ánh trong các lớp Java và ngược lại. Ít “phép thuật” ẩn giấu hơn ORM.
• Hiệu năng Dễ Dự đoán: Do không có lazy loading, caching ngầm định hay quản lý trạng thái phức tạp, hiệu năng của các thao tác database trở nên dễ hiểu và dự đoán hơn. Thường rất nhanh cho các tác vụ CRUD đơn giản.
• Phù hợp với Aggregate Pattern (DDD): Spring Data JDBC được thiết kế dựa trên ý tưởng về Aggregate Root, khuyến khích bạn suy nghĩ về ranh giới dữ liệu theo hướng DDD.
• Kiểm soát: Dễ dàng viết các truy vấn SQL tùy chỉnh bằng @Query khi cần hiệu năng hoặc logic phức tạp mà không cần đấu tranh với JPQL/HQL hay tiêu chí API.
• Nhẹ nhàng: Dependencies ít hơn so với full ORM, runtime overhead thấp hơn.

Khi Nào Nên Chọn Spring Data JDBC?

Spring Data JDBC là lựa chọn tốt trong các trường hợp sau:

• Bạn đang xây dựng các Microservice với mô hình dữ liệu đơn giản, giới hạn bởi ranh giới của dịch vụ.
• Ứng dụng của bạn chủ yếu thực hiện các tác vụ CRUD cơ bản và không cần đến các tính năng phức tạp của ORM như caching tầng 2 hay lazy loading.
• Hiệu năng là yếu tố cực kỳ quan trọng và bạn muốn tránh overhead tiềm ẩn của ORM.
• Bạn ưa thích sự minh bạch, muốn hiểu rõ các câu lệnh SQL nào đang được thực thi.
• Bạn làm việc tốt với thiết kế database quan hệ và muốn mô hình Java phản ánh gần gũi với schema đó.
• Bạn muốn áp dụng mô hình Aggregate trong Domain-Driven Design.

Ngược lại, nếu bạn làm việc với các ứng dụng monolith phức tạp, có mô hình dữ liệu đa dạng, sử dụng rộng rãi các tính năng ORM như entity graph, lazy loading, caching tầng 2, hoặc các truy vấn phức tạp liên quan nhiều bảng cần tối ưu bởi ORM, thì Spring Data JPA (với Hibernate) có thể vẫn là lựa chọn phù hợp hơn.

Kết Luận: Bước Tiếp Theo Trên Lộ Trình

Spring Data JDBC là một mảnh ghép quan trọng trong hệ sinh thái Spring Data, cung cấp một giải pháp truy cập database quan hệ hiệu quả, đơn giản và minh bạch. Nó không phải là sự thay thế cho Spring Data JPA, mà là một lựa chọn thay thế (alternative) phù hợp cho những ngữ cảnh cụ thể, đặc biệt là trong thế giới của microservices và các ứng dụng cần hiệu năng cao với mô hình dữ liệu rõ ràng.

Việc hiểu rõ sự khác biệt và ưu nhược điểm của Spring Data JDBC so với Spring Data JPA sẽ giúp bạn đưa ra quyết định đúng đắn khi lựa chọn công nghệ cho tầng database trong dự án của mình.

Chúng ta đã đi qua một chặng đường khá dài trên Lộ trình Java Spring, từ những kiến thức nền tảng đến các module nâng cao như Spring Security, Spring Cloud và giờ là các tùy chọn truy cập database. Việc làm chủ tương tác với database là kỹ năng không thể thiếu đối với mọi lập trình viên backend.

Đừng ngần ngại thử nghiệm Spring Data JDBC trong các dự án cá nhân hoặc các module nhỏ trong dự án hiện tại của bạn để cảm nhận sự khác biệt nhé!

Trong bài viết tiếp theo, chúng ta có thể sẽ tiếp tục đi sâu hơn vào các khía cạnh khác của Spring Data hoặc chuyển sang một chủ đề mới trong lộ trình. Hãy ôn lại kiến thức về Transaction Management, vì dù dùng JDBC hay JPA, việc quản lý transaction vẫn là cực kỳ quan trọng để đảm bảo tính toàn vẹn dữ liệu!

Hẹn gặp lại các bạn trong các bài viết tiếp theo!