Xây dựng API CRUD với Spring Data MongoDB | Lộ trình Java Spring

Chào Mừng Trở Lại Lộ Trình Java Spring!

Xin chào các bạn developer, đặc biệt là những người đang trên hành trình khám phá Lộ trình Java Spring Boot 2025! Sau khi chúng ta đã cùng nhau tìm hiểu về kiến trúc cốt lõi, Dependency Injection, Spring MVC, và đặc biệt là cách Spring Data JPA giúp làm việc với cơ sở dữ liệu quan hệ (ánh xạ thực thể, mối quan hệ, Repository), đã đến lúc mở rộng chân trời sang thế giới NoSQL.

Trong bài viết này, chúng ta sẽ tập trung vào một trong những cơ sở dữ liệu NoSQL phổ biến nhất: MongoDB, và cách Spring Data MongoDB “phù phép” để việc xây dựng các API CRUD cơ bản trở nên nhanh chóng và dễ dàng như thế nào. Việc nắm vững cách tương tác với NoSQL là một kỹ năng quan trọng trong bối cảnh các ứng dụng hiện đại ngày càng yêu cầu sự linh hoạt và khả năng mở rộng cao.

Tại sao lại là MongoDB và Spring Data MongoDB?

Cơ sở dữ liệu quan hệ (RDBMS) đã thống trị một thời gian dài và vẫn rất quan trọng. Tuy nhiên, trong nhiều trường hợp, đặc biệt là với dữ liệu có cấu trúc thay đổi liên tục, dữ liệu phi cấu trúc, hoặc yêu cầu khả năng mở rộng theo chiều ngang (horizontal scaling) dễ dàng, cơ sở dữ liệu NoSQL như MongoDB lại là lựa chọn ưu việt.

MongoDB là một cơ sở dữ liệu hướng document (document-oriented database). Thay vì lưu trữ dữ liệu trong các bảng với hàng và cột cố định như RDBMS, MongoDB lưu trữ dữ liệu dưới dạng các document kiểu BSON (một dạng nhị phân của JSON). Điều này mang lại sự linh hoạt đáng kể trong việc định nghĩa và thay đổi schema.

Spring Data MongoDB là một phần của hệ sinh thái Spring Data, cung cấp một abstraction layer (tầng trừu tượng) để làm việc với MongoDB. Tương tự như Spring Data JPA, nó giúp giảm thiểu đáng kể lượng mã boilerplate (mã lặp đi lặp lại) mà bạn phải viết để thực hiện các thao tác dữ liệu. Bạn có thể dễ dàng tạo ra các Repository chỉ bằng việc khai báo interface và Spring Data sẽ tự động cung cấp implementation (hiện thực) cho các phương thức CRUD cơ bản và cả các query phức tạp hơn dựa trên tên phương thức hoặc sử dụng annotations.

Thiết lập dự án Spring Boot với Spring Data MongoDB

Bước đầu tiên luôn là tạo một dự án Spring Boot. Cách nhanh nhất là sử dụng Spring Initializr. Bạn sẽ cần các dependency sau:

  • Spring Web: Để xây dựng các API REST.
  • Spring Data MongoDB: Để kết nối và tương tác với MongoDB.
  • Spring Boot DevTools (Optional nhưng hữu ích): Tăng tốc độ phát triển.
  • Lombok (Optional nhưng hữu ích): Giảm mã boilerplate cho getter/setter, constructor, etc.

Nếu bạn sử dụng Maven, file pom.xml của bạn sẽ có các dependency tương tự thế này (phiên bản có thể khác tùy thời điểm):

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-mongodb</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <scope>runtime</scope>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

Tiếp theo, bạn cần cấu hình kết nối đến MongoDB trong file application.properties hoặc application.yml. Ví dụ với application.properties:

spring.data.mongodb.host=localhost
spring.data.mongodb.port=27017
spring.data.mongodb.database=mydatabase # Thay bằng tên database của bạn
# spring.data.mongodb.uri=mongodb://username:password@host:port/database # Alternative using connection string

Đảm bảo rằng bạn đã cài đặt và chạy MongoDB server trên máy local hoặc có sẵn một instance MongoDB để kết nối.

Định nghĩa Model (Document)

Trong MongoDB, dữ liệu được lưu trữ dưới dạng document. Trong Java, chúng ta sẽ ánh xạ các document này thành các POJO (Plain Old Java Object). Spring Data MongoDB cung cấp các annotations để giúp việc này.

Hãy tạo một model đơn giản, ví dụ Product:

import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;
import org.springframework.data.mongodb.core.mapping.Field;
import lombok.Data; // Sử dụng Lombok để tạo getter/setter, etc.

@Data // Lombok annotation
@Document(collection = "products") // Ánh xạ lớp này tới collection "products" trong MongoDB
public class Product {

    @Id // Đánh dấu trường này là ID chính của document. Spring Data tự động tạo ObjectId nếu trường là null.
    private String id;

    @Field("name") // Tùy chọn: Đổi tên trường trong document nếu khác tên thuộc tính Java
    private String name;

    private double price;

    private int quantity;

    // Lombok @Data tự động tạo constructors, getters, setters, toString, equals, hashCode
}

Ở đây, @Document(collection = "products") cho Spring Data biết rằng lớp Product này tương ứng với một collection có tên là “products” trong MongoDB. Annotation @Id đánh dấu trường id là khóa chính của document. Spring Data MongoDB sẽ tự động quản lý trường này, bao gồm việc tạo ra một ObjectId duy nhất khi bạn lưu một document mới nếu id là null.

Tạo Repository với Spring Data MongoDB

Đây là nơi “phép màu” của Spring Data tỏa sáng. Bạn chỉ cần tạo một interface mở rộng MongoRepository. Spring Data sẽ tự động tạo ra một implementation cho interface này tại runtime, cung cấp sẵn các phương thức CRUD cơ bản.

import org.springframework.data.mongodb.repository.MongoRepository;
import org.springframework.stereotype.Repository;

@Repository // Mặc dù MongoRepository đã bao gồm, thêm @Repository giúp rõ ràng hơn
public interface ProductRepository extends MongoRepository<Product, String> {

    // Spring Data MongoDB tự động hiện thực phương thức này dựa trên tên
    Product findByName(String name);

    // Hoặc tìm kiếm theo khoảng giá
    List<Product> findByPriceBetween(double priceStart, double priceEnd);
}

Interface ProductRepository mở rộng MongoRepository<Product, String>. Tham số generic đầu tiên là loại Document mà Repository này quản lý (Product), và tham số thứ hai là kiểu dữ liệu của ID (String, vì MongoDB ObjectId thường được biểu diễn bằng String trong Java).
Ngoài các phương thức CRUD có sẵn như save(), findById(), findAll(), deleteById(), v.v., bạn có thể khai báo các phương thức query tùy chỉnh bằng cách tuân theo quy ước đặt tên của Spring Data (ví dụ: findByName, findByPriceBetween).

Xây dựng Service Layer

Service layer là nơi chứa logic nghiệp vụ. Controller sẽ gọi đến các phương thức trong Service, và Service sẽ sử dụng Repository để tương tác với cơ sở dữ liệu.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Optional;

@Service // Đánh dấu lớp này là một Spring Service Bean
public class ProductService {

    private final ProductRepository productRepository;

    @Autowired // Spring sẽ tự động Inject ProductRepository vào đây (Dependency Injection)
    public ProductService(ProductRepository productRepository) {
        this.productRepository = productRepository;
    }

    // CREATE
    public Product createProduct(Product product) {
        // Có thể thêm logic kiểm tra hoặc xử lý trước khi lưu
        return productRepository.save(product);
    }

    // READ ALL
    public List<Product> getAllProducts() {
        return productRepository.findAll();
    }

    // READ BY ID
    public Optional<Product> getProductById(String id) {
        return productRepository.findById(id);
    }

    // UPDATE
    public Product updateProduct(String id, Product productDetails) {
        Optional<Product> optionalProduct = productRepository.findById(id);

        if (optionalProduct.isPresent()) {
            Product existingProduct = optionalProduct.get();
            existingProduct.setName(productDetails.getName());
            existingProduct.setPrice(productDetails.getPrice());
            existingProduct.setQuantity(productDetails.getQuantity());

            // Lưu lại product đã cập nhật
            return productRepository.save(existingProduct);
        } else {
            // Xử lý trường hợp không tìm thấy product (ví dụ: ném ngoại lệ)
            return null; // Hoặc ném new ResourceNotFoundException()
        }
    }

    // DELETE
    public boolean deleteProduct(String id) {
        Optional<Product> optionalProduct = productRepository.findById(id);
        if (optionalProduct.isPresent()) {
            productRepository.delete(optionalProduct.get());
            return true; // Xóa thành công
        } else {
            return false; // Không tìm thấy để xóa
        }
    }

    // READ by Name (ví dụ sử dụng phương thức custom)
    public Product getProductByName(String name) {
        return productRepository.findByName(name);
    }
}

Trong lớp ProductService, chúng ta sử dụng Dependency Injection (thông qua constructor injection với @Autowired) để có được instance của ProductRepository. Các phương thức trong Service layer gọi các phương thức tương ứng từ Repository để thực hiện các thao tác dữ liệu.

Lưu ý cách chúng ta xử lý các thao tác Update và Delete: tìm kiếm document theo ID trước, kiểm tra sự tồn tại, sau đó mới thực hiện logic cập nhật hoặc xóa.

Thiết lập REST Controller

Controller là điểm cuối (endpoint) mà client (ví dụ: trình duyệt, ứng dụng di động) tương tác để gửi request. Controller sẽ nhận request, gọi Service layer để xử lý nghiệp vụ, và trả về response HTTP.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.Optional;

@RestController // Đánh dấu lớp này là một REST Controller
@RequestMapping("/api/products") // Đường dẫn cơ sở cho tất cả các endpoint trong controller này
public class ProductController {

    private final ProductService productService;

    @Autowired
    public ProductController(ProductService productService) {
        this.productService = productService;
    }

    // Endpoint: POST /api/products
    // CREATE
    @PostMapping
    public ResponseEntity<Product> createProduct(@RequestBody Product product) {
        Product createdProduct = productService.createProduct(product);
        return new ResponseEntity<>(createdProduct, HttpStatus.CREATED); // Trả về 201 Created
    }

    // Endpoint: GET /api/products
    // READ ALL
    @GetMapping
    public ResponseEntity<List<Product>> getAllProducts() {
        List<Product> products = productService.getAllProducts();
        return new ResponseEntity<>(products, HttpStatus.OK); // Trả về 200 OK
    }

    // Endpoint: GET /api/products/{id}
    // READ BY ID
    @GetMapping("/{id}")
    public ResponseEntity<Product> getProductById(@PathVariable String id) {
        Optional<Product> product = productService.getProductById(id);
        return product.map(value -> new ResponseEntity<>(value, HttpStatus.OK)) // Nếu tìm thấy, trả về 200 OK
                      .orElseGet(() -> new ResponseEntity<>(HttpStatus.NOT_FOUND)); // Nếu không, trả về 404 Not Found
    }

    // Endpoint: PUT /api/products/{id}
    // UPDATE
    @PutMapping("/{id}")
    public ResponseEntity<Product> updateProduct(@PathVariable String id, @RequestBody Product productDetails) {
        Product updatedProduct = productService.updateProduct(id, productDetails);
        if (updatedProduct != null) {
            return new ResponseEntity<>(updatedProduct, HttpStatus.OK); // Trả về 200 OK
        } else {
            return new ResponseEntity<>(HttpStatus.NOT_FOUND); // Trả về 404 Not Found
        }
    }

    // Endpoint: DELETE /api/products/{id}
    // DELETE
    @DeleteMapping("/{id}")
    public ResponseEntity<HttpStatus> deleteProduct(@PathVariable String id) {
        boolean deleted = productService.deleteProduct(id);
        if (deleted) {
            return new ResponseEntity<>(HttpStatus.NO_CONTENT); // Trả về 204 No Content
        } else {
            return new ResponseEntity<>(HttpStatus.NOT_FOUND); // Trả về 404 Not Found
        }
    }

    // Endpoint: GET /api/products/name/{name}
    // READ by Name (ví dụ cho phương thức custom)
    @GetMapping("/name/{name}")
    public ResponseEntity<Product> getProductByName(@PathVariable String name) {
        Product product = productService.getProductByName(name);
        if (product != null) {
            return new ResponseEntity<>(product, HttpStatus.OK);
        } else {
            return new ResponseEntity<>(HttpStatus.NOT_FOUND);
        }
    }
}

Ở đây, chúng ta sử dụng các Spring Annotations như @RestController và @RequestMapping để định nghĩa controller và đường dẫn cơ sở. Các annotation như @PostMapping, @GetMapping, @PutMapping, @DeleteMapping ánh xạ các phương thức handler tới các HTTP request tương ứng.

  • @RequestBody: Dùng để lấy dữ liệu từ body của request (thường là JSON) và tự động chuyển đổi nó thành đối tượng Java.
  • @PathVariable: Dùng để lấy giá trị từ phần đường dẫn URL.
  • ResponseEntity<T>: Một cách tốt để trả về response HTTP tùy chỉnh, bao gồm body, header và status code.

Chúng ta sử dụng các HTTP status code tiêu chuẩn để báo hiệu kết quả của thao tác (ví dụ: 201 Created, 200 OK, 404 Not Found, 204 No Content).

Tổng kết các Endpoint CRUD

Để dễ hình dung, đây là bảng tổng kết các endpoint CRUD mà chúng ta vừa xây dựng:

Thao tác (CRUD) HTTP Method Endpoint Mô tả
Create (Tạo mới) POST /api/products Thêm một sản phẩm mới vào database. Body request chứa thông tin sản phẩm.
Read (Đọc tất cả) GET /api/products Lấy danh sách tất cả sản phẩm.
Read (Đọc theo ID) GET /api/products/{id} Lấy thông tin sản phẩm dựa trên ID.
Update (Cập nhật) PUT /api/products/{id} Cập nhật thông tin sản phẩm dựa trên ID. Body request chứa thông tin sản phẩm mới.
Delete (Xóa) DELETE /api/products/{id} Xóa sản phẩm dựa trên ID.

Kiểm thử (Testing)

Sau khi chạy ứng dụng Spring Boot chính (lớp có annotation @SpringBootApplication), bạn có thể sử dụng các công cụ như Postman, Insomnia, hoặc curl để kiểm thử các API này. Đảm bảo rằng MongoDB server của bạn đang chạy.

  1. POST /api/products: Gửi request POST với body là JSON của một sản phẩm mới (ví dụ: {"name": "Laptop", "price": 1200.0, "quantity": 50}). Bạn sẽ nhận được phản hồi 201 Created cùng với thông tin sản phẩm đã được lưu (bao gồm ID được tạo bởi MongoDB).
  2. GET /api/products: Gửi request GET. Bạn sẽ nhận được phản hồi 200 OK với danh sách tất cả sản phẩm trong database.
  3. GET /api/products/{id}: Thay {id} bằng ID của sản phẩm bạn vừa tạo hoặc một sản phẩm khác. Bạn sẽ nhận được 200 OK nếu tìm thấy hoặc 404 Not Found nếu không.
  4. PUT /api/products/{id}: Gửi request PUT tới ID của một sản phẩm, với body là JSON thông tin cập nhật (ví dụ: thay đổi giá hoặc số lượng). Bạn sẽ nhận được 200 OK với thông tin sản phẩm đã cập nhật hoặc 404 Not Found.
  5. DELETE /api/products/{id}: Gửi request DELETE tới ID của một sản phẩm. Bạn sẽ nhận được 204 No Content nếu xóa thành công hoặc 404 Not Found.
  6. GET /api/products/name/{name}: Gửi request GET tới tên của một sản phẩm (ví dụ: /api/products/name/Laptop).

Những Bước Tiếp Theo và Lưu Ý

API CRUD cơ bản là nền tảng, nhưng các ứng dụng thực tế sẽ phức tạp hơn nhiều. Dưới đây là một số điểm bạn có thể khám phá tiếp:

  • Validation: Thêm các ràng buộc kiểm tra dữ liệu đầu vào (ví dụ: tên không được rỗng, giá phải dương) sử dụng Bean Validation API (JSR 303/380) và annotation như @Valid trong Controller.
  • DTOs (Data Transfer Objects): Trong ứng dụng thực tế, bạn thường không nên trả về trực tiếp các entity (Document) từ API. Thay vào đó, hãy sử dụng DTO để chỉ expose những thông tin cần thiết và định hình lại cấu trúc dữ liệu cho phù hợp với client.
  • Error Handling: Xây dựng cơ chế xử lý lỗi tập trung (ví dụ: sử dụng @ControllerAdvice) để trả về các phản hồi lỗi nhất quán và thân thiện với client.
  • Phân trang và Sắp xếp: Spring Data Repositories hỗ trợ rất tốt cho việc này bằng cách sử dụng Pageable và Sort objects trong các phương thức Repository và Controller.
  • Query phức tạp hơn: Khám phá cách sử dụng annotation @Query trên các phương thức Repository để viết các query MongoDB phức tạp hơn hoặc sử dụng MongoTemplate để có sự kiểm soát chi tiết hơn.
  • Security: Các API này hiện tại chưa được bảo mật. Trong các bài viết tiếp theo trên Lộ trình Java Spring, chúng ta sẽ đi sâu vào Spring Security để bảo vệ các endpoint của mình.

Kết Luận

Spring Data MongoDB làm cho việc tương tác với cơ sở dữ liệu NoSQL trở nên dễ dàng một cách đáng kinh ngạc, tương tự như cách Spring Data JPA làm với RDBMS. Bằng cách tận dụng Repository pattern và các quy ước đặt tên phương thức, bạn có thể xây dựng các API CRUD mạnh mẽ và dễ bảo trì chỉ với một lượng mã Java tối thiểu.

Việc hiểu và sử dụng Spring Data MongoDB là một bước tiến quan trọng trên Lộ trình Java Spring của bạn, mở ra cánh cửa làm việc với thế giới dữ liệu phi cấu trúc đang ngày càng phổ biến. Hãy thực hành xây dựng các API này, thử nghiệm với các loại query khác nhau, và chuẩn bị cho những chủ đề hấp dẫn tiếp theo mà chúng ta sẽ cùng khám phá!

Recent News Articles

Fresh job related news content posted each day.

Mục lục

→ Chỉ mục