Xây dựng CRUD hoàn chỉnh với 3-layer architecture

Mục tiêu

Sau bài này, bạn sẽ:

  • Hiểu tại sao cần kiến trúc 3-layer, không chỉ biết cách code
  • Phân tích được trách nhiệm của từng tầng và lý do phân tách
  • Áp dụng Spring Data JPA đúng cách, hiểu vì sao dùng interface mà không cần implement
  • Xây dựng CRUD hoàn chỉnh có validation, giao diện và REST API

1. Vấn đề: Tại sao cần 3-layer?

Nhìn lại cách làm với Servlet/JSP

Trong các ứng dụng Servlet/JSP truyền thống, bạn thường viết:

@WebServlet("/products")
public class ProductServlet extends HttpServlet {
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) {
        // 1. Nhận request
        String action = req.getParameter("action");
        
        // 2. Kết nối database (JDBC)
        Connection conn = DriverManager.getConnection(...);
        Statement stmt = conn.createStatement();
        ResultSet rs = stmt.executeQuery("SELECT * FROM products");
        
        // 3. Xử lý logic (chuyển đổi dữ liệu)
        List<Product> products = new ArrayList<>();
        while(rs.next()) {
            Product p = new Product();
            p.setId(rs.getLong("id"));
            // ... set các trường
            products.add(p);
        }
        
        // 4. Đóng kết nối
        rs.close(); stmt.close(); conn.close();
        
        // 5. Chuyển sang JSP
        req.setAttribute("products", products);
        req.getRequestDispatcher("/products.jsp").forward(req, resp);
    }
    
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) {
        // Lại viết lại toàn bộ quy trình trên
    }
}

Vấn đề của cách này:

Vấn đềHậu quả
Một servlet làm quá nhiều việcCode dài, khó đọc, khó bảo trì
Trộn lẫn các concernNhận request, xử lý database, logic nghiệp vụ, chuyển trang viết chung
Lặp lại codeMỗi servlet lại viết lại JDBC, đóng mở connection, xử lý exception
Khó testKhông thể test riêng logic nghiệp vụ mà không chạy servlet
Khó thay đổiMuốn đổi từ MySQL sang Oracle, phải sửa khắp nơi

Giải pháp: Phân tách trách nhiệm

3-layer architecture ra đời để giải quyết các vấn đề trên bằng cách chia ứng dụng thành 3 tầng rõ ràng:

[Presentation Layer] - Giao tiếp với người dùng (Controller)
        ↓
[Business Logic Layer] - Xử lý nghiệp vụ (Service)
        ↓
[Data Access Layer] - Thao tác database (Repository)

2. Tổng quan 3-layer trong Spring Boot

Trước khi đi vào code, hãy hiểu vai trò từng tầng:

TầngThành phầnTrách nhiệmVí dụ công việc
Presentation@Controller, 
@RestController
– Nhận request từ client
– Kiểm tra dữ liệu đầu vào cơ bản
– Gọi service xử lý
– Trả về response (view hoặc JSON)
GET /products -> gọi service -> trả về danh sách
Business@Service– Chứa logic nghiệp vụ chính
– Phối hợp nhiều repository
– Đảm bảo tính toàn vẹn dữ liệu (transaction)
– Xử lý các quy tắc nghiệp vụ
Tính tổng tiền, kiểm tra kho, gửi email
Data@Repository (hoặc JpaRepository)– Thao tác với database
– CRUD cơ bản
– Truy vấn phức tạp
– Che giấu chi tiết database
save(), findById(), delete()

Nguyên tắc quan trọng:

  • Tầng trên gọi tầng dưới (Controller -> Service -> Repository)
  • Tầng dưới không được gọi lên tầng trên
  • Mỗi tầng giao tiếp qua interface, không phụ thuộc vào implement cụ thể

3. Tại sao dùng Spring Data JPA (Repository)?

Trong Servlet, bạn phải tự viết JDBC:

  • Mở connection
  • Tạo statement
  • Xử lý ResultSet
  • Đóng connection
  • Bắt SQLException

Vấn đề: Lặp lại, dễ sai sót, khó bảo trì.

Spring Data JPA giải quyết thế nào?

public interface ProductRepository extends JpaRepository<Product, Long> {
    List<Product> findByNameContainingIgnoreCase(String name);
}

Chỉ với 1 dòng interface, bạn có được:

Tính năngTự làm JDBC mất bao lâu?Spring Data JPA
CRUD cơ bảnViết 4-5 method mỗi entityCó sẵn: save(), findAll(), findById(), deleteById()
TransactionTự quản lý commit/rollback@Transactional tự động
Mapping dữ liệuTự viết code chuyển ResultSet → ObjectTự động nhờ JPA
Truy vấn theo tênViết JPQL thủ côngfindByNameContainingIgnoreCase → tự động sinh query
Connection poolTự cấu hìnhSpring Boot tự động cấu hình HikariCP

Tại sao chỉ là interface mà vẫn chạy được?

  • Spring Data JPA dùng proxy pattern: khi chạy, nó tự động sinh ra class implement dựa trên tên method
  • Bạn chỉ cần định nghĩa method theo quy tắc đặt tên, phần còn lại để framework

4. Tại sao dùng @Service?

Nhiều người thắc mắc: “Sao không gọi thẳng Repository từ Controller cho nhanh?”

Hãy xem hậu quả:

// KHÔNG NÊN: Gọi repository trực tiếp từ controller
@RestController
public class ProductController {
    @Autowired
    private ProductRepository repository;
    
    @PostMapping("/products")
    public Product create(@RequestBody Product p) {
        // Mất cơ hội kiểm tra logic nghiệp vụ
        return repository.save(p);
    }
}

Vấn đề khi bỏ qua Service:

  1. Không thể tái sử dụng logic: Nếu sau này cần thêm sản phẩm từ nhiều chỗ (API, batch job, import Excel), bạn phải copy code
  2. Không quản lý transaction hiệu quả: Mỗi method controller là một transaction riêng
  3. Khó thêm logic nghiệp vụ: Ví dụ “khi thêm sản phẩm, kiểm tra trùng tên và gửi email thông báo” – phải sửa controller, vi phạm Single Responsibility
  4. Khó test: Controller phụ thuộc trực tiếp vào repository, khó mock

Service layer giải quyết:

@Service
@Transactional
public class ProductService {
    @Autowired
    private ProductRepository repository;
    
    public Product saveProduct(Product product) {
        // 1. Kiểm tra nghiệp vụ
        if (product.getPrice() < 0) {
            throw new BusinessException("Giá không thể âm");
        }
        // 2. Kiểm tra trùng tên
        if (repository.existsByName(product.getName())) {
            throw new BusinessException("Tên sản phẩm đã tồn tại");
        }
        // 3. Lưu
        Product saved = repository.save(product);
        // 4. Gửi email (gọi service khác)
        emailService.sendNotification(saved);
        return saved;
    }
}

5. Tại sao dùng @Controller riêng cho Web và API?

Trong ứng dụng thực tế, bạn thường cần cả hai:

  • Giao diện người dùng (HTML) dùng Thymeleaf
  • API cho mobile/SPA trả về JSON

Cách 1: Gộp chung (KHÔNG NÊN)

@Controller
@RequestMapping("/products")
public class ProductController {
    
    @GetMapping(produces = "text/html")
    public String listWeb(Model model) { ... }
    
    @GetMapping(produces = "application/json")
    @ResponseBody
    public List<Product> listApi() { ... }
}

Vấn đề:

  • Controller phụ trách quá nhiều định dạng
  • Khó bảo trì khi số lượng method tăng
  • Vi phạm Single Responsibility

Cách 2: Tách riêng (NÊN DÙNG)

// Web controller - trả về view
@Controller
@RequestMapping("/products")
public class ProductWebController {
    @Autowired private ProductService service;
    
    @GetMapping
    public String list(Model model) {
        model.addAttribute("products", service.getAll());
        return "product/list";
    }
}

// API controller - trả về JSON
@RestController
@RequestMapping("/api/products")
public class ProductApiController {
    @Autowired private ProductService service;
    
    @GetMapping
    public List<Product> list() {
        return service.getAll();
    }
}

Lợi ích:

  • Mỗi controller chỉ làm một việc
  • Dễ dàng thay đổi giao diện mà không ảnh hưởng API
  • Có thể bảo mật riêng (ví dụ: API yêu cầu JWT, web thì không)

6. Tại sao dùng DTO? (Giới thiệu)

Trong bài này tôi chưa dùng DTO để giữ đơn giản, nhưng cần hiểu vấn đề khi trả trực tiếp Entity:

// Entity có thể chứa thông tin nhạy cảm
@Entity
public class User {
    private String username;
    private String password; // KHÔNG MUỐN TRẢ VỀ API
    private String creditCard; // TUYỆT ĐỐI KHÔNG ĐƯỢC TRẢ
}

Nếu trả Entity trực tiếp từ API:

  • Lộ password, thông tin thẻ tín dụng
  • Gây ràng buộc: thay đổi Entity ảnh hưởng đến API
  • Có thể gây lỗi vòng lặp vô hạn (khi có quan hệ)

Giải pháp: DTO (Data Transfer Object)

  • Tạo class riêng chỉ chứa trường cần trả về
  • Copy dữ liệu từ Entity sang DTO (dùng ModelMapper hoặc MapStruct)

Chúng ta sẽ học chi tiết ở bài sau.

7. Phân tích luồng dữ liệu trong ứng dụng

Khi user thêm sản phẩm mới, luồng dữ liệu đi qua các tầng:

1. Trình duyệt gửi POST /products/save (form data)
   ↓
2. Controller nhận request, tự động bind vào Product object (nhờ @ModelAttribute)
   ↓
3. Controller kiểm tra validation (BindingResult) - nếu lỗi trả lại form
   ↓
4. Nếu OK, gọi productService.saveProduct(product)
   ↓
5. Service nhận Product, có thể kiểm tra thêm logic nghiệp vụ
   ↓
6. Service gọi repository.save(product)
   ↓
7. Repository dùng JPA để insert vào database
   ↓
8. Service nhận lại Product đã có ID, trả về cho Controller
   ↓
9. Controller redirect sang /products kèm thông báo thành công

Tại sao lại redirect (POST-Redirect-GET pattern)?

  • Tránh submit form trùng lặp khi user refresh trang
  • Giữ cho URL sau khi thêm là /products (danh sách), không phải /products/save

8. Tổng kết: Lợi ích của 3-layer so với Servlet/JSP

Tiêu chíServlet/JSPSpring Boot 3-layer
Tổ chức codeTất cả trong ServletController (web/api), Service, Repository riêng
DatabaseJDBC thủ công, lặp lạiJPA, chỉ cần interface
Logic nghiệp vụLẫn trong ServletTập trung ở Service, dễ test
ValidationTự viết if-elseAnnotation + BindingResult
TransactionTự quản lý@Transactional tự động
Thay đổi databaseSửa khắp nơiChỉ cần sửa cấu hình
TestRất khóDễ dàng test từng tầng với Mock
Bảo trìKhó khi ứng dụng lớnDễ dàng nhờ phân tách rõ ràng

Comments are closed.