BÁO CÁO MÔ TẢ HỌC THUẬT: GIÁO TRÌNH LẬP TRÌNH JAVA – CHƯƠNG 6: MÔ HÌNH 3 LỚP (3-LAYER ARCHITECTURE)

Thông tin học phần:

  • Môn học: Lập trình Java (Java Programming)
  • Chủ đề tài liệu: Chương 6 – Mô hình 3 lớp (Chapter 6: 3-Layer Architecture & MVC)
  • Giảng viên biên soạn: Tạ Việt Phương (E-mail: phuongtv@uit.vn)
  • Đơn vị công tác: Trường Đại học Công nghệ Thông tin – ĐHQG TP.HCM (UIT)
  • Cấp độ đào tạo: Đại học / Cao học ngành Công nghệ Thông tin, Kỹ thuật Phần mềm

1. Tổng quan về giáo trình (250-300 từ)

Chương 6: "Mô hình 3 lớp" thuộc học phần Lập trình Java là học liệu chuyên sâu về kiến trúc phần mềm, giữ vị trí bản lề trong việc chuyển đổi tư duy lập trình từ hướng cấu trúc/hướng đối tượng đơn thuần sang tư duy tổ chức hệ thống phân lớp chuyên biệt trong chương trình đào tạo kỹ sư Công nghệ Thông tin và Kỹ thuật Phần mềm.

Mục tiêu học tập (Learning Outcomes) của tài liệu tập trung vào bốn trọng tâm:

  1. Phân biệt bản chất kỹ thuật giữa khái niệm kiến trúc vật lý 3 tầng (3-tiers) và cấu trúc phân chia logic 3 lớp (3-layer).
  2. Nắm vững chức năng, ranh giới trách nhiệm của từng thành phần: Presentation Layer (GUI), Business Logic Layer (BLL/BUS), Data Access Layer (DAL/DAO) và đối tượng trung chuyển Data Transfer Object (DTO).
  3. Thiết kế và hiện thực hóa hoàn chỉnh một ứng dụng Java Desktop thao tác với hệ quản trị cơ sở dữ liệu Microsoft SQL Server thông qua thư viện kết nối JDBC.
  4. Hiểu nguyên lý vận hành của mô hình Model – View – Controller (MVC) và phân tích sự khác biệt về quy trình xử lý công việc (workflow) giữa MVC và 3-Layer.

Cấu trúc tài liệu được thiết kế theo phương pháp tiếp cận diễn dịch kết hợp thực nghiệm: bắt đầu từ định nghĩa kiến trúc tổng quát, làm rõ cơ chế tương tác giữa các lớp, chuẩn hóa quy tắc truyền dữ liệu và xử lý ngoại lệ, sau đó cụ thể hóa toàn bộ lý thuyết thông qua hệ thống mã nguồn mẫu của bài toán quản lý nhân sự (QLNhanSu). Điểm đặc sắc của tài liệu là tính thực chứng cao, thể hiện rõ sự phân tách mã nguồn thành các package độc lập (GUI, BLL, DAL, DTO), giúp người học hình thành quy chuẩn thiết kế phần mềm có tính module hóa cao.

2. Nội dung kiến thức cốt lõi (500-600 từ)

Các chương và chủ đề chính

Tài liệu Chương 6 được tổ chức tuần tự theo các khối kiến trúc logic:

+-----------------------------------------------------------------------+
|                       Presentation Layer (GUI)                        |
|        - employeeGUI.java (JFrame, JTable, DefaultTableModel)         |
+-----------------------------------------------------------------------+
                                   |  ^  (Truyền / nhận employeeDTO)
                                   v  |  (Chuyển tiếp thông báo lỗi)
+-----------------------------------------------------------------------+
|                     Business Logic Layer (BLL/BUS)                    |
|        - employeeBLL.java (Kiểm tra nghiệp vụ, hasEmployeeID)         |
+-----------------------------------------------------------------------+
                                   |  ^  (Truyền / nhận employeeDTO)
                                   v  |  (Chuyển tiếp kết quả truy vấn)
+-----------------------------------------------------------------------+
|                     Data Access Layer (DAL/DAO)                       |
|        - employeeDAL.java (JDBC, SQL Server Driver, QLNhanSu)         |
+-----------------------------------------------------------------------+
                                   |  ^
                                   v  |  (Truy vấn SQL / ResultSet)
+-----------------------------------------------------------------------+
|                           Cơ sở dữ liệu                               |
|        - Bảng Employee (employee_id, employee_name, ...)              |
+-----------------------------------------------------------------------+

  • Chủ đề 1: Phân định 3-Tiers và 3-Layer:

    • 3-Tiers (3 Tầng): Kiến trúc Client/Server phân tán về mặt vật lý; giao diện người dùng (UI), quy tắc nghiệp vụ (Business Rules/Logic), và nơi lưu trữ dữ liệu (Data) được vận hành trên các nền tảng cơ sở hạ tầng độc lập.
    • 3-Layer (3 Lớp): Phân chia ứng dụng theo vai trò chức năng logic. Toàn bộ các layer cùng thực thi trong một phân vùng bộ nhớ của cùng một tiến trình (process). Một tier vật lý có thể chứa nhiều layer logic.

  • Chủ đề 2: Cấu trúc chi tiết mô hình 3-Layer và quy ước đặt tên:

    • Presentation Layer (GUI): Giao tiếp người dùng qua WinForm/WebForm/Swing Form; thu nhận dữ liệu đầu vào, hiển thị dữ liệu và kiểm tra tính đúng đắn sơ bộ trước khi chuyển tiếp.
    • Business Logic Layer (BLL/BUS): Tiếp nhận dữ liệu từ GUI, kiểm tra tính toàn vẹn và các ràng buộc nghiệp vụ, thực hiện tính toán, điều phối luồng dữ liệu trước khi gửi tới DAL hoặc trả kết quả về GUI.
    • Data Access Layer (DAL/DAO): Trực tiếp tương tác với hệ quản trị CSDL qua các thao tác truy vấn (Select, Insert, Update, Delete).
    • Data Transfer Object (DTO): Các lớp thực thể đại diện cho cấu trúc bảng trong CSDL (như employeeDTO), đóng vai trò vật chứa dữ liệu để truyền tải xuyên suốt giữa các layer.
    • Quy ước đặt tên đồng bộ: Tài liệu nêu 3 hệ thống định danh: (1) GUI - BUS - DAL; (2) GUI - BLL - DAO - DTO; (3) Presentation - BLL - DAL.

  • Chủ đề 3: Luồng vận hành (Workflow) và kiểm soát lỗi:

    • Luồng xuôi: User -> GUI (kiểm tra sơ bộ) -> BLL (kiểm tra nghiệp vụ) -> DAL (truy vấn CSDL) -> Database.
    • Luồng phản hồi: Database -> DAL -> BLL -> GUI -> Hiển thị kết quả cho User.
    • Xử lý ngoại lệ: Lỗi phát sinh tại layer nào sẽ được đóng gói và ném ngược lên layer cao hơn một bậc tuần tự cho tới Presentation Layer để thông báo cho người dùng.

  • Chủ đề 4: Hiện thực hóa mã nguồn Java (Hệ thống QLNhanSu):

    • Cơ sở dữ liệu: Bảng Employee gồm các trường: employee_id, employee_name, birthyear, address.
    • Package DTO: Lớp employeeDTO khai báo các thuộc tính tương ứng kèm phương thức getter/setter (setEmployee_name, getBirthYear,...).
    • Package DAL: Lớp employeeDAL sử dụng Class.forName("...SQLServerDriver"), chuỗi kết nối jdbc:sqlserver://localhost:1433;DatabaseName=QLNhanSu cùng các hàm openConnection(), getAllEmployees() trả về Vector<employeeDTO>, addEmployee(employeeDTO emp) dùng PreparedStatement, hasEmployeeID(int id).
    • Package BLL: Lớp employeeBLL thực thi kiểm tra nghiệp vụ empDAL.hasEmployeeID(emp.getEmployee_id()) để trả về các thông báo: "Mã NV đã tồn tại", "Thêm thành công", "Thêm thất bại".
    • Package GUI: Lớp employeeGUI kế thừa JFrame, quản lý JTable, sử dụng DefaultTableModel để tải danh sách nhân sự (loadEmployeeList()) và xử lý sự kiện addEmployeeActionPerformed() bằng cách gọi JOptionPane.showMessageDialog(). Lớp main khởi tạo và hiển thị form.

  • Chủ đề 5: Kiến trúc MVC và so sánh với 3-Layer:

    • Mô hình MVC: Phân tách ứng dụng thành Model (chứa nghiệp vụ logic, xử lý dữ liệu, truy xuất CSDL), View (hiển thị giao diện, form HTML/Swing), và Controller (tiếp nhận request từ URL/form, điều hướng đến phương thức xử lý ở Model).
    • Điểm khác biệt cốt lõi: Trong MVC, Model đảm nhận vai trò gộp của cả BLL và DAL trong mô hình 3-Layer. 3-Layer phù hợp cho lập trình ứng dụng Desktop có tính cấu trúc DTO chặt chẽ, còn MVC được ưu chuộng trong lập trình website nhờ tính linh hoạt cao.

Kiến thức nền tảng được xây dựng

  • Nguyên lý tách biệt mối quan tâm (Separation of Concerns) nhằm giảm sự kết dính (coupling) và tăng tính gắn kết (cohesion).
  • Kỹ thuật ánh xạ dữ liệu quan hệ vào đối tượng thông qua DTO.
  • Cơ chế quản lý kết nối và thao tác dữ liệu qua JDBC (Connection, Statement, PreparedStatement, ResultSet).

Kỹ năng phát triển

  • Kỹ thuật phân chia cấu trúc dự án Java theo package chuẩn công nghiệp.
  • Kỹ năng kiểm soát dữ liệu nhiều tầng: kiểm tra định dạng tại GUI, kiểm tra quy tắc nghiệp vụ tại BLL, thực thi toàn vẹn dữ liệu tại DAL.
  • Kỹ năng lập trình giao diện đồ họa Java Swing liên kết động với bảng dữ liệu (JTable / DefaultTableModel).

3. Phương pháp giảng dạy và học tập (300-350 từ)

Tài liệu sử dụng phương pháp sư phạm tiếp cận từ trừu tượng đến cụ thể (Deductive and Implementation-driven approach). Giáo trình không trình bày lý thuyết tách rời mà luôn đi kèm kiến trúc luồng dữ liệu và mã nguồn tham chiếu trực tiếp.

                    QUY TRÌNH TIẾP CẬN SƯ PHẠM
+----------------------------------------------------------------+
| 1. Lý thuyết nền tảng: Phân biệt 3-Tiers vs 3-Layer           |
+----------------------------------------------------------------+
                               |
                               v
+----------------------------------------------------------------+
| 2. Phân rã chức năng: GUI - BLL - DAL - DTO                    |
+----------------------------------------------------------------+
                               |
                               v
+----------------------------------------------------------------+
| 3. Thực hành Case Study CSDL QLNhanSu (Mã nguồn Java hoàn chỉnh)|
+----------------------------------------------------------------+
                               |
                               v
+----------------------------------------------------------------+
| 4. Đối sánh mở rộng: Phân tích so sánh 3-Layer vs MVC          |
+----------------------------------------------------------------+

  • Thiết kế bài tập và tình huống mẫu (Case Study): Học liệu triển khai một tình huống xuyên suốt: Ứng dụng quản lý bảng Employee trong CSDL QLNhanSu. Người học được hướng dẫn hiện thực hóa đầy đủ 4 thao tác nghiệp vụ cơ bản:

    1. Trích xuất toàn bộ danh sách nhân viên (getAllEmployees) đưa vào Vector<employeeDTO>.
    2. Thêm mới nhân sự (addEmployee) có kiểm tra trùng khóa chính qua hàm hasEmployeeID.
    3. Bắt lỗi nhập liệu từ giao diện GUI (kiểm tra rỗng, sai định dạng số).
    4. Phản hồi thông báo trực tiếp qua hộp thoại JOptionPane.

  • Phương pháp đánh giá kết quả học tập (Assessment Methods):

    • Đánh giá khả năng phân tầng: Đo lường mức độ tuân thủ nguyên tắc không viết mã SQL trong lớp GUI hoặc không đưa đối tượng giao diện vào lớp DAL/BLL.
    • Đánh giá tính toàn vẹn của DTO: Xem xét việc trung chuyển dữ liệu giữa các tầng có đi qua thực thể employeeDTO hay không.
    • Đánh giá khả năng kiểm soát lỗi: Kiểm tra cơ chế đóng gói và đẩy ngoại lệ từ CSDL qua DAL -> BLL -> GUI.

  • Hướng dẫn tự học (Self-study Guidelines):

    1. Thiết lập CSDL QLNhanSu trên SQL Server với tài khoản sa.
    2. Xây dựng tuần tự các package từ dưới lên: tạo DTO (employeeDTO.java) -> tạo DAL (employeeDAL.java) kiểm tra kết nối JDBC -> tạo BLL (employeeBLL.java) viết các điều kiện kiểm tra logic -> tạo GUI (employeeGUI.java) thiết kế giao diện Swing và gắn sự kiện.
    3. Tự kiểm tra luồng lỗi bằng cách nhập trùng mã nhân viên hoặc nhập sai định dạng tuổi để quan sát luồng xử lý của BLL và GUI.

4. Điểm nổi bật và cập nhật (250-300 từ)

Nội dung tài liệu mang tính chuẩn hóa cao về mặt kỹ thuật phần mềm, tập trung làm sáng tỏ các điểm then chốt thường gây nhầm lẫn trong quá trình phát triển ứng dụng:

  • Làm rõ sự khác biệt giữa Tiers và Layers: Tài liệu định nghĩa rành mạch: "Tầng" (Tier) thể hiện sự phân chia vật lý trên hạ tầng phần cứng độc lập (Client/Server), trong khi "Lớp" (Layer) là sự phân chia logic về mặt chức năng phần mềm chạy trong cùng một không gian bộ nhớ tiến trình.
  • Chuẩn hóa kiến trúc truyền dữ liệu DTO: Việc định nghĩa DTO như một phương tiện giao tiếp dữ liệu bắt buộc giữa các layer giúp mã nguồn loại bỏ sự phụ thuộc trực tiếp vào các cấu trúc dữ liệu thô, tăng cường tính bảo mật và đóng gói.
  • Tối ưu hóa khả năng bảo trì và phân công công việc:
    • Tính tường minh: Giảm độ kết dính (loose coupling) bằng cách cô lập giao diện, xử lý nghiệp vụ và truy vấn CSDL.
    • Khả năng bảo trì: Mọi biến động logic hoặc thay đổi hệ quản trị CSDL chỉ tác động cục bộ lên một lớp duy nhất (hoặc lớp lân cận) mà không phá vỡ toàn bộ hệ thống.
    • Khả năng làm việc nhóm: Cho phép phân chia nhân lực rõ ràng (nhóm chuyên trách GUI, nhóm phụ trách BLL, nhóm phụ trách CSDL/DAL).
  • Phân tích so sánh hệ thống với mô hình MVC: Thay vì chỉ giới thiệu đơn lẻ, tài liệu đặt 3-Layer trong thế đối sánh với MVC. Việc chỉ ra thành phần Model trong MVC đảm nhận vai trò của cả BLL và DAL, cũng như sự phân định phạm vi ứng dụng (3-Layer cho Desktop App, MVC cho Web App), cung cấp góc nhìn toàn diện về kiến trúc cho người học.

5. Đối tượng sử dụng giáo trình (200-250 từ)

  • Sinh viên chuyên ngành:

    • Sinh viên bậc đại học hoặc cao học các ngành Khoa học Máy tính, Kỹ thuật Phần mềm, Công nghệ Thông tin, Hệ thống Thông tin đang theo học học phần Lập trình Java hoặc Kiến trúc Thiết kế Phần mềm.
    • Sinh viên làm đồ án môn học xây dựng ứng dụng quản lý Desktop hoặc chuẩn bị chuyển tiếp sang các framework lập trình Web.

  • Yêu cầu kiến thức tiên quyết (Prerequisites):

    • Nắm vững lập trình hướng đối tượng bằng Java (OOP: tính đóng gói, kế thừa, đa hình, các hàm getter/setter).
    • Kiến thức về cơ sở dữ liệu quan hệ: viết truy vấn SQL cơ bản (Select, Insert, Where), hiểu khái niệm khóa chính (Primary Key).
    • Kiến thức cơ bản về thư viện JDBC (trình điều khiển kết nối SQL Server, Connection, PreparedStatement) và thư viện đồ họa Java Swing (JFrame, JTable, Vector, ActionEvent).

  • Giảng viên và kỹ sư phần mềm:

    • Giảng viên sử dụng tài liệu làm khung bài giảng chuẩn cho các buổi học lý thuyết và thực hành tại phòng máy.
    • Lập trình viên tự học muốn hệ thống hóa lại cấu trúc mã nguồn theo các chuẩn module hóa phần mềm chuyên nghiệp.

6. Câu hỏi thường gặp (FAQ) (250-300 từ)

1. Mô hình 3-Layer trong tài liệu này phù hợp nhất với loại ứng dụng nào?
Mô hình 3-Layer được trình bày phù hợp nhất cho các ứng dụng phần mềm Desktop (như Java Swing, WinForm), nơi ứng dụng chạy trong một tiến trình bộ nhớ duy nhất và có quy định trao đổi dữ liệu nghiêm ngặt qua DTO.

2. Sự khác biệt căn bản giữa 3-Tiers và 3-Layer là gì?
3-Tiers đề cập đến sự phân chia vật lý trên các nền tảng phần cứng/hạ tầng độc lập (mô hình Client/Server). 3-Layer là sự phân chia chức năng logic chạy chung trong một phân vùng bộ nhớ của một tiến trình phần mềm.

3. Tại sao cần phải sử dụng Data Transfer Object (DTO) giữa các lớp?
DTO đóng vai trò là đối tượng chứa dữ liệu được ánh xạ từ các bảng trong CSDL. Việc dùng DTO giúp các layer trao đổi dữ liệu có cấu trúc một cách an toàn, tường minh và giảm sự phụ thuộc lẫn nhau giữa Presentation, BLL và DAL.

4. Điểm khác nhau căn bản giữa mô hình 3-Layer và MVC là gì?
Khác biệt lớn nhất nằm ở luồng xử lý (workflow): Trong MVC, thành phần Model gộp chung chức năng của cả BLL và DAL. Ngoài ra, MVC được ưu chuộng cho môi trường Web do tính linh hoạt và không bắt buộc DTO như 3-Layer.

5. Cơ chế xử lý lỗi trong kiến trúc 3-Layer được tài liệu quy định như thế nào?
Khi phát sinh lỗi dữ liệu tại bất kỳ layer nào, thông tin lỗi sẽ được chuyển ngược lên layer cao hơn một bậc tuần tự theo thứ tự: DAL -> BLL -> Presentation (GUI), sau đó GUI sẽ hiển thị thông báo lỗi ra màn hình cho người dùng.

7. Kết luận (150 từ)

Chương 6: "Mô hình 3 lớp" của tác giả Tạ Việt Phương (UIT) là tài liệu học thuật hoàn chỉnh, cung cấp nền tảng lý thuyết và giải pháp thực thi thực tế về kiến trúc phân tầng trong lập trình Java. Học liệu xác lập ranh giới rõ ràng giữa các thành phần GUI, BLL, DAL và DTO, đồng thời đối sánh chi tiết với mô hình MVC.

Lộ trình học tập đề xuất: Người học cần nắm vững lý thuyết phân tầng logic/vật lý, sau đó thực hành từng bước cài đặt các lớp mã nguồn Java trên hệ cơ sở dữ liệu QLNhanSu, và cuối cùng mở rộng nghiên cứu sang mô hình MVC cho các ứng dụng nền tảng Web. Tài nguyên tham khảo trực tiếp gồm các gói mã nguồn package DTO, package DAL, package BLL, package GUI kết nối với SQL Server thông qua thư viện Java JDBC.