Giới thiệu dự án

Trong kỷ nguyên chuyển đổi số và bùng nổ thông tin hiện nay, tài liệu số hóa đóng vai trò là tài sản tri thức cốt lõi của mọi tổ chức, viện nghiên cứu và doanh nghiệp. Theo các báo cáo khảo sát từ IDC và Gartner, khối lượng dữ liệu phi cấu trúc và nhu cầu cộng tác tài nguyên số trong doanh nghiệp tăng trưởng trung bình hơn 25–30% mỗi năm. Tuy nhiên, việc chia sẻ và lưu trữ tài liệu qua các kênh truyền thống như email, mạng xã hội, thiết bị lưu trữ cục bộ (USB) hoặc in ấn phân phát giấy tờ bộc lộ nhiều điểm nghẽn nghiêm trọng: lãng phí 20–30% thời gian tìm kiếm tài liệu, rủi ro phân mảnh dữ liệu, thất thoát thông tin và xung đột phiên bản (version conflict).

Trước thực tế đó, đề tài đồ án tốt nghiệp đại học "Xây dựng hệ thống chia sẻ tài liệu theo kiến trúc hướng dịch vụ" do sinh viên Phan Quốc Anh (Khoa Công nghệ Thông tin 1, Học viện Công nghệ Bưu chính Viễn thông - PTIT), dưới sự hướng dẫn của TS. Đặng Ngọc Hùng (2023), đã nghiên cứu và phát triển một nền tảng trao đổi, chia sẻ và quản trị tài liệu toàn diện nhằm giải quyết triệt để các hạn chế trên.

+-------------------------------------------------------------------------------+
|                       BÀI TOÁN QUẢN TRỊ TÀI LIỆU SỐ                           |
+-------------------------------------------------------------------------------+
         |                                                   |
         v                                                   v
 [Hệ thống truyền thống / Monolithic]               [Giải pháp Microservices đề xuất]
  - Điểm nghẽn cổ chai (Single Point of Failure)      - Phân tách dịch vụ độc lập
  - Dữ liệu phình to, khó bảo trì                     - Cơ chế Database-per-Service
  - Phân quyền lỏng lẻo, rủi ro bảo mật               - Bảo mật JWT + Google Drive API
  - Chi phí mở rộng hạ tầng rất lớn                   - Mở rộng linh hoạt từng Service

Problem Statement & Pain Points

Hệ thống giải quyết các bài toán kỹ thuật và nghiệp vụ then chốt:

  1. Quản lý và tìm kiếm dữ liệu phân tán: Khối lượng tài liệu lớn dẫn đến việc tổ chức theo danh mục và tìm kiếm gặp nhiều khó khăn nếu thiếu cấu trúc danh mục chuẩn hóa.
  2. Xung đột phiên bản và mất đồng bộ: Thiếu cơ chế lưu trữ tập trung và siêu dữ liệu (metadata) rõ ràng dẫn đến tình trạng người dùng làm việc trên các bản sao cũ.
  3. Bảo mật và phân quyền truy cập (Access Control): Các kênh truyền tải thông thường không hỗ trợ cơ chế xác thực ủy quyền phân tầng (RBAC - Role-Based Access Control) để kiểm soát quyền xem, sửa, xóa tài liệu.
  4. Hạn chế mở rộng của kiến trúc nguyên khối (Monolithic Architecture): Khi lượng truy cập và dung lượng tài liệu tăng cao, hệ thống Monolithic khó mở rộng cục bộ từng tính năng, dễ gây sập toàn bộ hệ thống khi một module gặp sự cố.

Mục tiêu dự án

  1. Nghiên cứu lý thuyết kiến trúc hướng dịch vụ (SOA - Service-Oriented Architecture) và kiến trúc vi dịch vụ (Microservices Architecture).
  2. Thiết kế và phân rã hệ thống thành các dịch vụ độc lập: UserService, CategoryService, DocumentService, CommentService và AdminService.
  3. Tích hợp API Gateway làm điểm đầu mối tiếp nhận, định tuyến, cân bằng tải và kiểm soát bảo mật tập trung qua JSON Web Token (JWT).
  4. Tích hợp giải pháp lưu trữ đám mây thông qua Google Drive REST API v3, giúp tối ưu hóa không gian lưu trữ và đảm bảo tính sẵn sàng cao.
  5. Triển khai và tối ưu hóa hệ thống bằng hệ sinh thái Spring Boot, Spring Data JPA và hệ quản trị cơ sở dữ liệu MySQL.

Giải pháp kỹ thuật và Phạm vi

Hệ thống sử dụng mô hình kiến trúc Microservices kết hợp mẫu thiết kế Database-per-Service, giúp phân tách dữ liệu cho từng dịch vụ nghiệp vụ riêng biệt. Giải pháp lưu trữ lai (Hybrid Storage) sử dụng MySQL để quản lý siêu dữ liệu (metadata) và liên kết với Google Drive API để lưu trữ file vật lý.

Phạm vi nghiên cứu: Tập trung vào các phân hệ chức năng: Quản lý người dùng, Quản lý danh mục phân cấp, Quản lý tài liệu và tải lên từ Google Drive, Hệ thống bình luận/đánh giá, và Bảng điều khiển quản trị (Admin Dashboard).

Phân tích và thiết kế giải pháp

Phân tích hiện trạng

Hầu hết các hệ thống chia sẻ tài liệu nội bộ trước đây được xây dựng trên kiến trúc Monolithic hoặc các CMS mã nguồn mở đóng gói sẵn. Khi lượng người dùng tăng đột biến, hệ thống bộc lộ nhiều điểm yếu về mặt mở rộng và độ sẵn sàng.

Tiêu chí đánh giá Kiến trúc Nguyên khối (Monolithic) Kiến trúc Vi dịch vụ (Microservices - Đề tài)
Tính độc lập của dịch vụ Thấp; toàn bộ module đóng gói chung 1 file WAR/JAR Cao; mỗi dịch vụ chạy trên tiến trình và cổng riêng
Cơ sở dữ liệu Dùng chung một cơ sở dữ liệu quan hệ duy nhất Phân tán; mỗi service quản lý cơ sở dữ liệu riêng
Khả năng mở rộng (Scalability) Phải scale toàn bộ ứng dụng, tốn tài nguyên Scale độc lập chính xác service có tải cao (vd: DocumentService)
Khả năng chịu lỗi (Fault Tolerance) Một lỗi runtime có thể làm sập toàn bộ hệ thống Dịch vụ khác vẫn hoạt động bình thường khi 1 service lỗi
Độ phức tạp triển khai & Debug Đơn giản trong giai đoạn đầu Phức tạp hơn, yêu cầu quản lý giao tiếp mạng và API Gateway

Phân loại yêu cầu người dùng theo mô hình MoSCoW

  • Must-have (Bắt buộc): Đăng ký, đăng nhập xác thực JWT, tải lên tài liệu từ Google Drive, phân loại tài liệu theo danh mục, tìm kiếm theo tên, quản lý CRUD danh mục/tài liệu/người dùng bởi Admin.
  • Should-have (Nên có): Bình luận tương tác dưới tài liệu, quản lý hồ sơ cá nhân, đổi mật khẩu, xem trước thông tin chi tiết tài liệu.
  • Could-have (Có thể mở rộng): Đánh giá xếp hạng sao (rating), tích hợp full-text search, thông báo qua email/SMS.
  • Won't-have (Chưa thực hiện ở giai đoạn này): Đồng chỉnh sửa tài liệu thời gian thực (real-time co-authoring), thanh toán tài liệu trả phí.

Thiết kế hệ thống

Kiến trúc tổng thể hệ thống (Architecture Design)

Hệ thống được thiết kế theo mô hình Microservices đa tầng với API Gateway làm trung gian điều phối giữa Client và các vi dịch vụ phía sau.

Bảng thông số Công nghệ (Technology Stack)

Thành phần Công nghệ / Thư viện Phiên bản Vai trò kỹ thuật
Core Framework Spring Boot 2.7.x / 3.x Xây dựng RESTful API backend, auto-configuration
ORM / Data Access Spring Data JPA / Hibernate 5.x / 6.x Tự động sinh truy vấn CRUD, ánh xạ Object-Relational
Cơ sở dữ liệu MySQL Server 8.0.x Lưu trữ dữ liệu quan hệ cho từng service
Bảo mật & Auth Spring Security & JJWT 0.11.5 Tạo, mã hóa và xác thực JSON Web Token
Cloud Storage Google Drive REST API v3 Lưu trữ và phân phối tệp nhị phân phân tán
Source Control Git 2.x Quản lý mã nguồn phân tán

Thiết kế Cơ sở dữ liệu phân tán (Distributed Database Design)

Thay vì sử dụng một schema tập trung, hệ thống phân chia thành 5 cơ sở dữ liệu riêng rẽ:

  • db_user: Bảng Users (id, username, password, email, full_name, role), Bảng Address (id, street, city, user_id), Bảng PhoneNumber (id, phone, user_id).
  • db_category: Bảng Category (id, category_name, description, created_at).
  • db_document: Bảng Document (id, title, description, file_url, drive_file_id, user_id, created_at), Bảng Category_Document (document_id, category_id).
  • db_comment: Bảng Comment (id, content, user_id, document_id, created_at).
  • db_admin: Bảng AdminSv (id, admin_id, action_log, target_entity, timestamp).

Đặc tả RESTful API Endpoints chính

Method Endpoint URI Phụ trách Service Quyền truy cập Mô tả nghiệp vụ
POST /api/v1/auth/login UserService Public Xác thực thông tin, cấp phát JWT token
POST /api/v1/auth/register UserService Public Đăng ký tài khoản người dùng mới
GET /api/v1/documents DocumentService User/Admin Lấy danh sách tài liệu (hỗ trợ tìm kiếm)
POST /api/v1/documents/upload DocumentService User/Admin Lưu metadata và tệp tải từ Google Drive
GET /api/v1/categories CategoryService User/Admin Xem danh mục phân loại tài liệu
POST /api/v1/comments CommentService User Thêm bình luận cho tài liệu cụ thể
DELETE /api/v1/admin/users/{id} AdminService Admin Xóa tài khoản vi phạm

Phương pháp luận phát triển (Methodology)

Dự án áp dụng phương pháp phát triển linh hoạt Agile kết hợp mô hình phát triển ứng dụng nhanh (Rapid Application Development - RAD) dựa trên các tính năng cốt lõi của Spring Boot.

      - Thu thập Use case            - Phân rã 5 Services               - Viết API Spring Boot          - Unit Test & Postman
      - Mô tả MoSCoW                 - Thiết kế Database per Service    - Tích hợp Google Drive API     - Đánh giá hiệu năng
  • Quản lý rủi ro (Risk Mitigation):
    • Rủi ro bất đồng bộ dữ liệu giữa các dịch vụ: Sử dụng khóa logic và API Gateway điều phối.
    • Rủi ro giới hạn băng thông Google Drive API: Áp dụng cơ chế lưu trữ cache metadata cục bộ, chỉ gọi Drive API khi thực hiện tải tệp hoặc phát sinh liên kết mới.
  • Đảm bảo chất lượng (Quality Assurance): Kiểm thử tự động trên JUnit 5 cho tầng Service và Repository; kiểm thử chức năng giao diện và API thông qua Postman Collection Runner.

Implementation và kết quả

Quá trình phát triển và Hiện thực hóa

Dự án hiện thực hóa các giải thuật và cấu trúc mã nguồn theo chuẩn mô hình MVC đa tầng trong Spring Framework: Controller -> Service -> Repository -> Entity.

Trích đoạn mã nguồn thực thi chính

1. Cấu hình Spring Data JPA Repository cho phân hệ Quản lý Tài liệu (DocumentRepository.java):

package com.ptit.document.repository;

import com.ptit.document.entity.Document;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import org.springframework.stereotype.Repository;
import java.util.List;

@Repository
public interface DocumentRepository extends JpaRepository<Document, Long> {
    
    // Tìm kiếm tài liệu theo từ khóa tiêu đề (case-insensitive)
    @Query("SELECT d FROM Document d WHERE LOWER(d.title) LIKE LOWER(CONCAT('%', :keyword, '%'))")
    List<Document> searchByTitleLike(@Param("keyword") String keyword);

    // Lọc tài liệu theo danh mục cụ thể thông qua bảng liên kết
    @Query(value = "SELECT d.* FROM document d " +
                   "JOIN category_document cd ON d.id = cd.document_id " +
                   "WHERE cd.category_id = :categoryId", nativeQuery = true)
    List<Document> findByCategoryId(@Param("categoryId") Long categoryId);
}

2. Service xử lý tích hợp Google Drive và lưu trữ siêu dữ liệu (DocumentServiceImpl.java):

package com.ptit.document.service.impl;

import com.ptit.document.dto.DocumentUploadRequest;
import com.ptit.document.entity.Document;
import com.ptit.document.repository.DocumentRepository;
import com.ptit.document.service.DocumentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.time.LocalDateTime;

@Service
public class DocumentServiceImpl implements DocumentService {

    @Autowired
    private DocumentRepository documentRepository;

    @Override
    @Transactional
    public Document processGoogleDriveUpload(DocumentUploadRequest request, Long userId) {
        // Khởi tạo đối tượng Entity với thông tin lấy từ Google Drive Picker
        Document document = new Document();
        document.setTitle(request.getTitle());
        document.setDescription(request.getDescription());
        document.setDriveFileId(request.getGoogleDriveFileId());
        document.setFileUrl(request.getWebViewLink());
        document.setUserId(userId);
        document.setCreatedAt(LocalDateTime.now());
        
        // Lưu trữ metadata vào cơ sở dữ liệu cục bộ db_document
        return documentRepository.save(document);
    }
}

3. Tầng bảo mật kiểm tra JWT Token tại API Gateway (JwtAuthenticationFilter.java):

package com.ptit.gateway.filter;

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpHeaders;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import org.springframework.web.server.WebFilter;
import org.springframework.web.server.WebFilterChain;
import reactor.core.publisher.Mono;

@Component
public class JwtAuthenticationFilter implements WebFilter {

    @Value("${jwt.secret.key}")
    private String secretKey;

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, WebFilterChain chain) {
        String authHeader = exchange.getRequest().getHeaders().getFirst(HttpHeaders.AUTHORIZATION);
        if (authHeader != null && authHeader.startsWith("Bearer ")) {
            String token = authHeader.substring(7);
            try {
                Claims claims = Jwts.parser()
                        .setSigningKey(secretKey.getBytes())
                        .parseClaimsJws(token)
                        .getBody();
                exchange.getRequest().mutate().header("X-User-Id", claims.getSubject()).build();
            } catch (Exception e) {
                // Token không hợp lệ hoặc hết hạn
                exchange.getResponse().setRawStatusCode(401);
                return exchange.getResponse().setComplete();
            }
        }
        return chain.filter(exchange);
    }
}

Kiểm thử và Đánh giá hiệu năng (Testing & Benchmarks)

Hệ thống đã trải qua quá trình kiểm thử tải (Load Testing) và kiểm thử chức năng toàn diện:

  • Độ bao phủ kiểm thử (Test Coverage): Đạt 86.4% code coverage cho các logic nghiệp vụ trọng yếu tại tầng Service.
  • Thời gian phản hồi API (API Response Time):
    • Truy vấn danh sách tài liệu: Trung bình 125ms (đạt yêu cầu phi chức năng < 3.000ms).
    • Tải lên metadata từ Google Drive: Trung bình 420ms.
    • Xác thực và sinh token JWT: Trung bình 85ms.
  • Thời gian tải trang Web (Page Load Time): Giao diện phản hồi trung bình 1.2s - 2.5s trên các trình duyệt Chrome, Edge, Cốc Cốc (vượt xa chỉ tiêu tối đa 10s).
+-------------------------------------------------------------------------------+
|                      BIỂU ĐỒ SO SÁNH THỜI GIAN PHẢN HỒI (ms)                   |
+-------------------------------------------------------------------------------+
Xác thực JWT         | [=====] 85ms
Truy vấn Danh mục    | [======] 110ms
Tìm kiếm Tài liệu    | [=======] 125ms
Upload Drive Metadata| [======================] 420ms
Giới hạn SLA tối đa  | [==================================================] 3000ms

Kết quả đạt được

  • Hoàn thành 100% các Use Case: Thực hiện đầy đủ 25 kịch bản use case từ phân hệ Người dùng đến Quản trị viên (Xem chi tiết, Thêm/Sửa/Xóa tài liệu, Quản lý danh mục, Upload từ Drive, Đổi mật khẩu, Bình luận).
  • Tính khả dụng và tính chịu lỗi: Hệ thống duy trì hoạt động ổn định khi giả lập sự cố tắt ngắt quãng CommentService, các tính năng tra cứu và tải tài liệu vẫn hoạt động bình thường mà không gây lỗi dây chuyền.

Đổi mới và đóng góp

  1. Mô hình Lưu trữ Lai (Hybrid Cloud-Storage Architecture): Khắc phục triệt để nhược điểm lưu trữ file cục bộ tốn kém tài nguyên máy chủ bằng cách tích hợp Google Drive API v3 để lưu trữ file nhị phân, kết hợp MySQL lưu siêu dữ liệu phục vụ chỉ mục và tìm kiếm nhanh.
  2. Triển khai kiến trúc Microservices chuẩn hóa cho bài toán quản lý tài liệu học thuật: Cung cấp mô hình tham chiếu chi tiết về việc phân rã domain bài toán quản trị tài liệu thành các vi dịch vụ độc lập với cơ sở dữ liệu riêng biệt.
  3. Hiệu quả tối ưu hóa tài nguyên: Giảm thiểu 100% dung lượng lưu trữ đĩa cứng server cho các tệp tài liệu lớn, giảm tải CPU/Memory trên máy chủ ứng dụng tới 45% so với phương pháp lưu trữ tệp trên server local.
Đặc tính Giải pháp FTP/Shared Drive Cũ Hệ thống Monolithic CMS Hệ thống Microservices (Đề tài)
Khả năng phân loại Thư mục cây đơn thuần Phân loại theo thẻ/chuyên mục Phân cấp danh mục + Đa chiều dữ liệu
Bảo mật & Phân quyền Phân quyền cấp thư mục OS Phân quyền Session/Cookie Xác thực phi trạng thái (Stateless JWT)
Khả năng mở rộng tải Kém Khó mở rộng từng phần Mở rộng độc lập từng microservice
Chi phí lưu trữ Server Rất cao Rất cao Tối ưu hóa tối đa qua Google Drive API

Ứng dụng thực tế và triển khai

Kịch bản ứng dụng thực tế

  • Môi trường Đại học / Cao đẳng: Triển khai làm cổng trao đổi giáo trình, đề cương, tài liệu tham khảo giữa giảng viên và sinh viên các khoa viện.
  • Doanh nghiệp vừa và nhỏ (SMEs): Làm kho tri thức nội bộ (Internal Knowledge Base), quản lý tài liệu quy trình, hướng dẫn công việc và chia sẻ tài nguyên dự án an toàn.

Yêu cầu triển khai hệ thống (System Deployment Requirements)

  • Cấu hình phần cứng tối thiểu (Server Node):
    • CPU: 4 Cores x86-64.
    • RAM: 8 GB DDR4.
    • Ổ cứng: 50 GB SSD khả dụng.
  • Môi trường phần mềm:
    • Hệ điều hành: Linux (Ubuntu Server 20.04/22.04 LTS) hoặc Windows Server.
    • Java Runtime Environment: OpenJDK 17+.
    • Database: MySQL Community Server 8.0.
    • Web Server: NGINX làm Reverse Proxy / SSL Termination.
+-------------------------------------------------------------------------------+
|                       LỘ TRÌNH TRIỂN KHAI DỰ ÁN (ROADMAP)                     |
+-------------------------------------------------------------------------------+
  Giai đoạn 1 (Tháng 1-2): Triển khai môi trường Dev & hoàn thiện 5 Core Services
  Giai đoạn 2 (Tháng 3-4): Tích hợp API Gateway, Google Drive OAuth2, bảo mật JWT
  Giai đoạn 3 (Tháng 5-6): Kiểm thử UAT nội bộ tại Khoa CNTT, đánh giá hiệu năng
  Giai đoạn 4 (Tháng 7+):  Đóng gói Container Docker, triển khai mở rộng K8s

Hạn chế và hướng phát triển

Hạn chế kỹ thuật

  1. Giao tiếp liên dịch vụ (Inter-service Communication): Các service hiện chủ yếu giao tiếp đồng bộ qua REST API, chưa tích hợp hàng đợi thông điệp phân tán (Message Queue như RabbitMQ hay Apache Kafka).
  2. Quản trị Transaction phân tán: Chưa áp dụng mô hình Saga Pattern để xử lý transaction phân tán phức tạp khi có nhiều service cùng cập nhật trạng thái dữ liệu.
  3. Tìm kiếm nâng cao: Tính năng tìm kiếm tài liệu hiện tại chủ yếu dùng truy vấn SQL LIKE, chưa tích hợp công cụ tìm kiếm toàn văn chuyên dụng.

Hướng phát triển tương lai

  • Tích hợp Elasticsearch: Nâng cấp công cụ tìm kiếm toàn văn (Full-text search), hỗ trợ tìm kiếm nội dung bên trong các file PDF/Word.
  • Event-Driven Architecture: Bổ sung Apache Kafka hoặc RabbitMQ để xử lý bất đồng bộ các tác vụ nặng như gửi email thông báo, ghi log kiểm toán.
  • Containerization & Orchestration: Đóng gói toàn bộ các vi dịch vụ bằng Docker và triển khai điều phối tự động trên cụm Kubernetes (K8s).

Đối tượng hưởng lợi

                                  [HỆ THỐNG CHIA SẺ TÀI LIỆU]
                                               |
        +------------------+-------------------+------------------+------------------+
        |                  |                                      |                  |
        v                  v                                      v                  v
  [Sinh viên]      [Lập trình viên]                         [Doanh nghiệp]     [Nhà nghiên cứu]
 - Tìm kiếm nhanh   - Mã nguồn mẫu Spring Boot Microservices  - Tiết kiệm 45%    - Tài liệu tham khảo
 - Tải tài liệu     - Kiến trúc phân rã chuẩn                  chi phí lưu trữ    về phân rã dịch vụ
 - Thảo luận mở     - Mẫu tích hợp Google Drive REST API      - Bảo mật cao      - Đo lường thực nghiệm
  • Sinh viên & Giảng viên: Tiếp cận nguồn tài nguyên học liệu số hóa có hệ thống, rút ngắn 60% thời gian tìm kiếm bài giảng và đề cương.
  • Lập trình viên & Kỹ sư phần mềm: Cung cấp mã nguồn tham khảo chuẩn mực về việc xây dựng hệ thống Microservices sử dụng Spring Boot, Spring Data JPA, JWT và tích hợp Google Drive API.
  • Doanh nghiệp & Tổ chức: Sở hữu giải pháp quản trị tri thức chi phí thấp, tối ưu hóa hạ tầng máy chủ nhờ tận dụng cloud storage công cộng nhưng vẫn đảm bảo tính phân quyền chặt chẽ.
  • Nhà nghiên cứu học thuật: Cung cấp dữ liệu thực nghiệm về việc so sánh hiệu năng giữa kiến trúc Monolithic và Microservices trong bài toán quản lý tệp tin.

Câu hỏi thường gặp

1. Yêu cầu kỹ thuật tối thiểu để triển khai và chạy hệ thống là gì?

Hệ thống yêu cầu máy chủ cài đặt Java OpenJDK 17 trở lên, hệ quản trị cơ sở dữ liệu MySQL 8.0, cấu hình RAM tối thiểu 8GB để chạy đồng thời các tiến trình Spring Boot của từng service, cùng với chứng chỉ Google Cloud Console đã bật Google Drive REST API v3 và thiết lập OAuth 2.0 Client ID.

2. Giới hạn mở rộng (Scalability) của hệ thống là gì và xử lý như thế nào?

Nhờ kiến trúc Microservices, giới hạn tải của từng dịch vụ là độc lập. Nếu lượng truy cập tìm kiếm và tải tài liệu tăng vọt, quản trị viên chỉ cần scale ngang (horizontal scale) phân hệ DocumentService lên nhiều instance phía sau Load Balancer mà không cần can thiệp vào UserService hay CommentService.

3. Làm thế nào để tích hợp hệ thống với các nền tảng lưu trữ khác ngoài Google Drive?

Cấu trúc mã nguồn được thiết kế theo mẫu giao diện (Interface-driven design). Để hỗ trợ thêm các nền tảng như AWS S3 hay Microsoft OneDrive, lập trình viên chỉ cần tạo class mới hiện thực hóa (implement) StorageService và cấu hình injection mà không làm thay đổi logic nghiệp vụ của DocumentService.

4. Chi phí vận hành và bảo trì hệ thống ước tính như thế nào?

Do tận dụng gói dung lượng đám mây Google Drive và mã nguồn mở (Spring Boot, MySQL Community), chi phí máy chủ hàng tháng giảm đến 50–70% so với việc tự xây dựng cụm lưu trữ SAN/NAS riêng.

5. Cơ chế bảo mật và phân quyền giữa các Microservices hoạt động ra sao?

API Gateway chịu trách nhiệm giải mã và kiểm tra tính hợp lệ của chữ ký số trong JWT Token. Khi hợp lệ, Gateway trích xuất thông tin User ID cùng vai trò (Role) và đính kèm vào HTTP Header (X-User-Id, X-User-Role) chuyển tiếp đến các microservices nội bộ, đảm bảo tính toàn vẹn dữ liệu xuyên suốt.

Kết luận

Đồ án tốt nghiệp "Xây dựng hệ thống chia sẻ tài liệu theo kiến trúc hướng dịch vụ" của sinh viên Phan Quốc Anh đã giải quyết thành công bài toán chia sẻ và quản trị tài nguyên số hóa thông qua việc ứng dụng mô hình kiến trúc Microservices hiện đại. Bằng việc kết hợp sức mạnh của hệ sinh thái Spring Boot, Spring Data JPA, MySQL và Google Drive API, hệ thống không chỉ giải quyết triệt để các bài toán về hiệu năng, tính sẵn sàng và tính mở rộng mà còn mang lại giá trị thực tiễn cao cho các tổ chức giáo dục và doanh nghiệp.

Đây là tài liệu tham khảo kỹ thuật giá trị dành cho các kỹ sư phần mềm, sinh viên ngành Công nghệ Thông tin đang tìm hiểu về kiến trúc hướng dịch vụ, quy trình thiết kế phần mềm phân tán và tích hợp hệ thống đám mây.