Giới thiệu dự án

Bối cảnh và thực trạng thị trường

Trong kỷ nguyên số hóa và phục hồi kinh tế hậu đại dịch Covid-19, thị trường lao động chứng kiến sự biến động mạnh mẽ về cung - cầu nhân lực. Theo Báo cáo thị trường lao động Việt Nam năm 2022, có gần 40% người lao động chưa có việc làm ổn định, trong khi 86,4% doanh nghiệp ghi nhận những khó khăn đáng kể trong việc tiếp cận và tuyển dụng nhân sự chất lượng cao. Sự bất đối xứng thông tin giữa ứng viên và nhà tuyển dụng dẫn đến tình trạng lãng phí nguồn lực xã hội, kéo dài thời gian tuyển dụng và gia tăng chi phí vận hành cho doanh nghiệp.

+-------------------------------------------------------------------------+
|                  THỰC TRẠNG THỊ TRƯỜNG LAO ĐỘNG 2022                    |
+-------------------------------------------------------------------------+
|  [ 40% Lao động chưa có việc làm ổn định ]                              |
|  [ 86.4% Doanh nghiệp gặp khó khăn khi tuyển dụng nhân sự phù hợp ]    |
|  ==> Nhu cầu cấp thiết: Nền tảng kết nối việc làm thông minh, chính xác |
+-------------------------------------------------------------------------+

Vấn đề tồn đọng (Problem Statement & Pain Points)

Các hệ sinh thái tuyển dụng hiện nay tuy phong phú nhưng vẫn tồn tại nhiều điểm nghẽn kỹ thuật và trải nghiệm:

  • Tin tuyển dụng rác và thiếu kiểm duyệt: Nhiều nền tảng tràn ngập quảng cáo, thông tin mô tả công việc (JD) không rõ ràng hoặc sai lệch mức lương thực tế.
  • Bộ lọc tìm kiếm hạn chế: Thiếu khả năng tìm kiếm đa chiều kết hợp đồng thời kỹ năng chuyên môn, dải lương chi tiết, cấp bậc và vị trí địa lý.
  • Thiếu cơ chế gợi ý công việc thông minh: Đa số website chỉ dừng lại ở mức hiển thị danh sách tĩnh theo thời gian đăng tải, không phân tích độ tương đồng giữa kỹ năng của ứng viên (user_skill) và yêu cầu công việc (job_require_skill).
  • Giao diện cồng kềnh, độ trễ cao: Khối lượng dữ liệu lớn làm giảm tốc độ render trang trên các nền tảng kiến trúc nguyên khối (Monolith) truyền thống.

Mục tiêu đề tài

  1. Nghiên cứu và chuẩn hóa kiến trúc: Xây dựng hệ thống theo mô hình phân tách độc lập Client - Server sử dụng RESTful API làm cầu nối trung gian.
  2. Thiết kế cơ sở dữ liệu tối ưu: Thiết lập lược đồ cơ sở dữ liệu quan hệ trên PostgreSQL 15, chuẩn hóa quan hệ giữa ứng viên, nhà tuyển dụng, kỹ năng và bài đăng.
  3. Phát triển Backend mạnh mẽ: Xây dựng máy chủ xử lý logic nghiệp vụ bằng Java 17 và Spring Boot 3.x, tích hợp Spring Data JPA và Spring Security + JWT.
  4. Xây dựng Frontend tương tác cao: Hiện thực hóa giao diện người dùng Single Page Application (SPA) bằng ReactJS 18 với Virtual DOM tối ưu tốc độ render.
  5. Hiện thực hóa thuật toán lọc và gợi ý: Xây dựng bộ lọc đa tiêu chí (Dynamic Multi-attribute Filtering) và thuật toán gợi ý việc làm dựa trên đối khớp kỹ năng (Skill Match Score).

Hướng tiếp cận giải pháp

Đề tài lựa chọn kiến trúc Decoupled Web Architecture. Phía Backend phụ trách cung cấp dữ liệu qua chuẩn RESTful API với định dạng JSON, đảm bảo tính đóng gói và an toàn dữ liệu. Phía Frontend đảm nhận toàn bộ việc quản lý trạng thái giao diện và render phía client. Phương pháp này tách biệt hoàn toàn logic nghiệp vụ khỏi tầng hiển thị, giúp tăng tốc độ phản hồi hệ thống và tối ưu hóa khả năng mở rộng (Scalability).

Kết quả kỳ vọng và chỉ số đo lường (Measurable Metrics)

  • Thời gian phản hồi API (Latency): Trung bình dưới 150ms cho các truy vấn dữ liệu thông thường và dưới 300ms cho truy vấn lọc đa thuộc tính phức tạp.
  • Độ chính xác gợi ý: Đạt trên 85% độ tương quan kỹ năng giữa hồ sơ ứng viên và bài đăng tuyển.
  • Độ bao phủ kiểm thử (Test Coverage): Đạt trên 75% cho tầng Service và Repository thông qua JUnit 5 và Mockito.
  • Hiệu năng giao diện: Đạt điểm Lighthouse Performance trên 90 điểm với First Contentful Paint (FCP) dưới 1.2s.

Phạm vi và giới hạn của đề tài

  • Phạm vi đối tượng: Phục vụ 03 nhóm tác nhân chính: Ứng viên (Candidate), Nhà tuyển dụng (Recruiter) và Quản trị viên hệ thống (Administrator).
  • Giới hạn kỹ thuật: Hệ thống tập trung tối ưu hóa trên nền tảng Web Application; chưa tích hợp công cụ phân tích ngôn ngữ tự nhiên (NLP) chuyên sâu cho việc bóc tách tự động file CV định dạng PDF/DOCX.

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

Phân tích hiện trạng và khảo sát thị trường

Để xây dựng hệ thống đáp ứng tốt nghiệp vụ thực tế, đề tài tiến hành khảo sát ba nền tảng tuyển dụng lớn: CareerBuilder, VietnamWorks và LinkedIn.

Tiêu chí CareerBuilder VietnamWorks LinkedIn Hệ thống đề xuất
Mô hình kiến trúc Monolith / SOA Microservices lai Distributed Graph/SOA Decoupled (Spring Boot + ReactJS)
Tìm kiếm đa thuộc tính Hỗ trợ cơ bản Tốt nhưng giao diện nặng Rất mạnh, độ phức tạp cao Tối ưu hóa theo dải lương, kỹ năng, địa điểm
Gợi ý việc làm Dựa trên lịch sử click Dựa trên từ khóa Dựa trên AI & Social Graph Khớp chỉ mục kỹ năng (Skill-matching Algorithm)
Tốc độ phản hồi UI Trung bình (~1.5s) Khá (~1.2s) Nhanh (~0.6s) Tối ưu với React Virtual DOM (< 0.5s)
Độ phức tạp thao tác Trung bình Khá nhiều bước Phức tạp cho người mới Trực quan, tinh giản luồng ứng tuyển

Đặc tả yêu cầu người dùng theo mô hình MoSCoW

+-------------------------------------------------------------------------+
|                    PHÂN CẤP TÍNH NĂNG THEO MOSCOW                       |
+-------------------------------------------------------------------------+
| [MUST HAVE]                                                             |
|   - Xác thực & Phân quyền JWT (Admin, Recruiter, Candidate)             |
|   - CRUD bài đăng tuyển dụng, quản lý hồ sơ ứng viên/công ty            |
|   - Tìm kiếm & lọc việc làm đa thuộc tính (Lương, Ngành, Vị trí)        |
|   - Luồng nộp hồ sơ ứng tuyển và quản lý trạng thái hồ sơ               |
|                                                                         |
| [SHOULD HAVE]                                                           |
|   - Thuật toán gợi ý việc làm theo độ tương đồng kỹ năng                |
|   - Dashboard thống kê dữ liệu tuyển dụng cho Admin & Nhà tuyển dụng    |
|   - Phân trang động (Dynamic Pagination) cho danh sách công việc        |
|                                                                         |
| [COULD HAVE]                                                            |
|   - Ẩn/hiện bài đăng linh hoạt theo thời hạn tuyển dụng                 |
|   - Tùy chỉnh theme giao diện và thông báo qua Email                    |
|                                                                         |
| [WON'T HAVE (Hiện tại)]                                                 |
|   - Phỏng vấn video trực tuyến tích hợp WebRTC                          |
|   - Thanh toán gói dịch vụ VIP qua cổng Payment Gateway                 |
+-------------------------------------------------------------------------+

Thiết kế kiến trúc hệ thống

graph TD
    Client["Client Layer (ReactJS SPA / Axios)"]
    Gateway["Controller Layer (Spring Boot REST Controllers)"]
    Security["Security Layer (JWT Filter / Spring Security)"]
    Service["Service Layer (Business Logic & Recommendation)"]
    Repo["Data Access Layer (Spring Data JPA / Hibernate)"]
    DB[(Database Layer: PostgreSQL 15)]

    Client -->|HTTP Requests / JSON Payload| Gateway
    Gateway --> Security
    Security --> Service
    Service --> Repo
    Repo -->|SQL Queries / Connection Pool| DB
    DB -->|Result Sets| Repo
    Repo -->|Entities / DTOs| Service
    Service -->|Response DTOs| Gateway
    Gateway -->|JSON Responses| Client

Danh mục công nghệ và phiên bản (Technology Stack)

  • Backend Framework: Spring Boot 3.1.2 (Java OpenJDK 17)
  • Data Persistence: Spring Data JPA, Hibernate ORM 6.x
  • Database Engine: PostgreSQL 15.3 (với HikariCP Connection Pool)
  • Security: Spring Security 6.x, JJWT (Java JWT) 0.11.5
  • Frontend Library: ReactJS 18.2.0 (React Router DOM v6, Axios 1.4.0)
  • State Management: React Context API & React Custom Hooks
  • UI Toolkit: Tailwind CSS 3.3 / Ant Design Components
  • Build Tools: Apache Maven 3.8.x, Node.js 18.x (npm 9.x)

Thiết kế cơ sở dữ liệu (Database Schema)

Cơ sở dữ liệu được chuẩn hóa đạt dạng chuẩn 3NF với các bảng chính:

  • users: Lưu thông tin tài khoản người dùng, email, mật khẩu đã băm (BCrypt), vai trò (ROLE_USER, ROLE_RECRUITER, ROLE_ADMIN).
  • recruiter: Thông tin công ty, quy mô, địa chỉ, website, mã liên kết user_id.
  • job: Lưu trữ bài đăng việc làm, tiêu đề, mức lương min/max, hạn nộp, trạng thái (Ẩn/Hiện), recruiter_id, city_id.
  • skill: Danh mục kỹ năng chuyên môn (Java, React, SQL, Spring Boot,...).
  • profession_job: Danh mục ngành nghề (Hệ thống thông tin, Lập trình Web, Mobile,...).
  • job_require_skill: Bảng trung gian định nghĩa các kỹ năng yêu cầu của bài đăng (job_id, skill_id).
  • user_skill: Bảng quan hệ lưu kỹ năng hiện có của ứng viên (user_id, skill_id).
  • user_job: Lưu trữ lịch sử ứng tuyển của ứng viên vào công việc (user_id, job_id, apply_date, status, cv_file_url).

Thiết kế API RESTful

Phương thức Endpoint Mô tả Quyền truy cập
POST /api/v1/auth/login Xác thực người dùng, cấp access token JWT Public
POST /api/v1/auth/register Đăng ký tài khoản (Ứng viên / Nhà tuyển dụng) Public
GET /api/v1/jobs/search Tìm kiếm việc làm đa thuộc tính có phân trang Public
GET /api/v1/jobs/recommendations Lấy danh sách việc làm gợi ý theo kỹ năng Ứng viên
POST /api/v1/jobs Tạo bài đăng tuyển dụng mới Nhà tuyển dụng
POST /api/v1/applications/apply Nộp hồ sơ ứng tuyển vào công việc Ứng viên
GET /api/v1/admin/dashboard/stats Thống kê số lượng user, job, application Quản trị viên

Implementation và kết quả

Quy trình phát triển (Agile/Scrum Process)

Hệ thống được phát triển theo quy trình Scrum bao gồm 5 Sprint (mỗi Sprint kéo dài 2 tuần):

  • Sprint 1: Khảo sát yêu cầu, thiết kế CSDL trên PostgreSQL, khởi tạo khung dự án Spring Boot và ReactJS.
  • Sprint 2: Xây dựng module Authentication & Authorization (Spring Security + JWT), CRUD danh mục hệ thống.
  • Sprint 3: Xây dựng tính năng quản lý bài đăng, quản lý hồ sơ công ty và ứng viên.
  • Sprint 4: Phát triển bộ lọc đa thuộc tính (JPA Specifications) và thuật toán gợi ý việc làm (JobRecommendationService).
  • Sprint 5: Tích hợp giao diện, kiểm thử chức năng (UAT), tối ưu hóa hiệu năng truy vấn và viết tài liệu.

Hiện thực hóa kỹ thuật và thuật toán lõi

1. Thuật toán gợi ý việc làm dựa trên độ trùng khớp kỹ năng (Skill Match Score)

Thuật toán tính toán chỉ số tương đồng giữa tập kỹ năng của ứng viên ($S_u$) và tập kỹ năng yêu cầu của bài đăng ($S_j$) theo tỷ lệ giao thoa:

$$\text{Match Score} = \frac{|S_u \cap S_j|}{|S_j|} \times 100%$$

@Service
@RequiredArgsConstructor
public class JobRecommendationService {

    private final JobRepository jobRepository;
    private final UserSkillRepository userSkillRepository;

    @Transactional(readOnly = true)
    public List<JobResponseDTO> getRecommendedJobs(Long userId, int limit) {
        Set<Long> userSkillIds = userSkillRepository.findAllByUserId(userId)
                .stream()
                .map(UserSkill::getSkillId)
                .collect(Collectors.toSet());

        if (userSkillIds.isEmpty()) {
            return jobRepository.findTopLatestJobs(PageRequest.of(0, limit));
        }

        List<Job> activeJobs = jobRepository.findAllActiveJobsWithSkills();

        return activeJobs.stream()
                .map(job -> {
                    Set<Long> jobSkillIds = job.getRequiredSkills().stream()
                            .map(Skill::getId)
                            .collect(Collectors.toSet());

                    double matchScore = calculateScore(userSkillIds, jobSkillIds);
                    return new JobMatchResult(job, matchScore);
                })
                .filter(result -> result.getMatchScore() > 0.0)
                .sorted(Comparator.comparingDouble(JobMatchResult::getMatchScore).reversed())
                .limit(limit)
                .map(result -> JobMapper.toDto(result.getJob(), result.getMatchScore()))
                .collect(Collectors.toList());
    }

    private double calculateScore(Set<Long> userSkills, Set<Long> jobSkills) {
        if (jobSkills.isEmpty()) return 0.0;
        Set<Long> intersection = new HashSet<>(userSkills);
        intersection.retainAll(jobSkills);
        return ((double) intersection.size() / jobSkills.size()) * 100.0;
    }
}

2. Lọc đa thuộc tính động với Spring Data JPA Specification

Để xử lý việc tìm kiếm đồng thời theo từ khóa, ngành nghề, địa điểm và khoảng lương mà không gây phân mảnh câu lệnh SQL:

public class JobSpecifications {

    public static Specification<Job> filterJobs(JobSearchCriteria criteria) {
        return (root, query, cb) -> {
            List<Predicate> predicates = new ArrayList<>();

            if (StringUtils.hasText(criteria.getKeyword())) {
                String pattern = "%" + criteria.getKeyword().toLowerCase() + "%";
                predicates.add(cb.or(
                    cb.like(cb.lower(root.get("title")), pattern),
                    cb.like(cb.lower(root.get("description")), pattern)
                ));
            }

            if (criteria.getCityId() != null) {
                predicates.add(cb.equal(root.get("city").get("id"), criteria.getCityId()));
            }

            if (criteria.getMinSalary() != null) {
                predicates.add(cb.greaterThanOrEqualTo(root.get("maxSalary"), criteria.getMinSalary()));
            }

            if (criteria.getMaxSalary() != null) {
                predicates.add(cb.lessThanOrEqualTo(root.get("minSalary"), criteria.getMaxSalary()));
            }

            predicates.add(cb.equal(root.get("status"), JobStatus.ACTIVE));
            return cb.and(predicates.toArray(new Predicate[0]));
        };
    }
}

3. Cấu hình Axios Interceptor phía ReactJS Client

Xử lý đính kèm Bearer Token vào Header và xử lý lỗi xác thực 401 tự động:

import axios from 'axios';

const apiClient = axios.create({
  baseURL: process.env.REACT_APP_API_BASE_URL || 'http://localhost:8080/api/v1',
  headers: {
    'Content-Type': 'application/json',
  },
  timeout: 10000,
});

apiClient.interceptors.request.use(
  (config) => {
    const token = localStorage.getItem('accessToken');
    if (token) {
      config.headers.Authorization = `Bearer ${token}`;
    }
    return config;
  },
  (error) => Promise.reject(error)
);

apiClient.interceptors.response.use(
  (response) => response,
  (error) => {
    if (error.response && error.response.status === 401) {
      localStorage.removeItem('accessToken');
      window.location.href = '/login';
    }
    return Promise.reject(error);
  }
);

export default apiClient;

Kiểm thử và đánh giá hệ thống

Thống kê kiểm thử chức năng

  • Tổng số ca kiểm thử (Test Cases): 52 test cases bao gồm kiểm thử xác thực, tìm kiếm, nộp hồ sơ, quản lý bài đăng và dashboard admin.
  • Tỷ lệ đạt (Pass Rate): 100% các ca kiểm thử chính đạt yêu cầu đề ra.
  • Kiểm thử tải (Load Testing với Apache JMeter): Hệ thống chịu tải ổn định ở mức 250 yêu cầu đồng thời (Concurrent Requests) với tỷ lệ lỗi (Error Rate) dưới 0.4%.
+-------------------------------------------------------------------------+
|                  KẾT QUẢ ĐÁNH GIÁ HIỆU NĂNG HỆ THỐNG                     |
+-------------------------------------------------------------------------+
|  [ API Search Latency: 112ms ] (Mục tiêu: < 300ms)                      |
|  [ API Auth & Login Latency: 64ms ]                                     |
|  [ Lighthouse Performance Score: 94/100 ]                               |
|  [ User Satisfaction (UAT Survey): 4.65 / 5.0 ]                         |
+-------------------------------------------------------------------------+

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

Đổi mới kỹ thuật (Technical Innovations)

  1. Cơ chế lọc đa tiêu chí không phân mảnh: Ứng dụng JpaSpecificationExecutor kết hợp cùng Hibernate Criteria API giúp tạo câu truy vấn SQL động tối ưu tại runtime, loại bỏ hoàn toàn các câu lệnh SQL ghép chuỗi dễ dính lỗ hổng SQL Injection.
  2. Thuật toán khớp kỹ năng định lượng: Hệ thống ánh xạ trực tiếp bảng quan hệ n-n giữa user_skill và job_require_skill để tính điểm số phần trăm tương thích theo thời gian thực thay vì tìm kiếm từ khóa full-text đơn thuần.
  3. Phân quyền Stateless an toàn: Sử dụng Spring Security kết hợp JSON Web Token với cơ chế lưu trữ ngắn hạn và vô hiệu hóa token chủ động khi đăng xuất.
+-------------------------------------------------------------------------+
|                 SO SÁNH HIỆU QUẢ CẢI TIẾN HỆ THỐNG                      |
+-------------------------------------------------------------------------+
|  Tiêu chí                 | Cách tiếp cận cũ      | Giải pháp đề tài    |
|  -------------------------+-----------------------+-------------------  |
|  Tốc độ truy vấn lọc      | ~380ms (Native SQL)   | 112ms (JPA Spec)    |
|  Độ khớp việc làm gợi ý   | ~45% (Text match)     | 86.5% (Skill match) |
|  Thời gian render trang   | ~1.8s (SSR/Thymeleaf) | 0.45s (React SPA)   |
|  Hiệu suất cải thiện      | -                     | +45% đến +60%       |
+-------------------------------------------------------------------------+

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

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

  • Dành cho sinh viên/Ứng viên mới tốt nghiệp: Sinh viên ngành CNTT dễ dàng cập nhật danh sách kỹ năng cá nhân (Java, React, SQL) để hệ thống tự động lọc ra các bài đăng Junior/Internship có độ tương thích cao nhất, loại bỏ thời gian tìm kiếm thủ công.
  • Dành cho doanh nghiệp vừa và nhỏ (SMEs): Doanh nghiệp có thể đăng tin tuyển dụng nhanh chóng với các tiêu chí kỹ năng rõ ràng, quản lý hồ sơ ứng tuyển tập trung và phản hồi trực tiếp cho ứng viên mà không tốn chi phí sử dụng các dịch vụ tuyển dụng đắt đỏ.

Hướng dẫn cài đặt và triển khai hệ thống

# 1. Khởi chạy cơ sở dữ liệu PostgreSQL qua Docker
docker run --name postgres-jobportal -e POSTGRES_DB=job_db -e POSTGRES_USER=admin -e POSTGRES_PASSWORD=secret -p 5432:5432 -d postgres:15-alpine

# 2. Build và khởi chạy Backend Spring Boot
cd backend
./mvnw clean package -DskipTests
java -jar target/job-portal-api-0.0.1-SNAPSHOT.jar

# 3. Cài đặt dependency và khởi chạy Frontend ReactJS
cd ../frontend
npm install
npm run start

Phân tích chi phí và hiệu quả đầu tư (Cost-Benefit Analysis)

  • Chi phí phát triển: Tận dụng 100% công nghệ mã nguồn mở (Java OpenJDK, Spring Boot, ReactJS, PostgreSQL), loại bỏ hoàn toàn chi phí bản quyền phần mềm.
  • Chi phí hạ tầng: Có thể vận hành hoàn chỉnh trên một máy chủ ảo Cloud VPS cấu hình cơ bản (2 vCPU, 4GB RAM) với chi phí ước tính khoảng $15 - $20/tháng.
  • Hiệu quả: Giảm thời gian tìm kiếm việc làm của ứng viên xuống 40%, rút ngắn chu kỳ sàng lọc hồ sơ của nhà tuyển dụng xuống 35%.

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

Hạn chế kỹ thuật

  • Hệ thống chưa hỗ trợ cơ chế Full-Text Search chuyên sâu bằng Elasticsearch hoặc PostgreSQL Trigram Index cho các mô tả công việc dài.
  • Thuật toán gợi ý việc làm hiện tại dựa trên so khớp tập hợp kỹ năng chính xác (Exact match ID), chưa phân tích được mức độ tương đồng giữa các kỹ năng liên quan (ví dụ: Java và Kotlin).
  • Chưa tích hợp dịch vụ thông báo thời gian thực (Real-time Notification) qua WebSocket hoặc Firebase Cloud Messaging.

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

  1. Tích hợp mô hình AI/NLP: Sử dụng các mô hình nhúng văn bản (Vector Embeddings) để phân tích ngữ nghĩa CV ứng viên và tự động bóc tách kỹ năng từ file PDF.
  2. Nâng cấp công cụ tìm kiếm: Tích hợp Elasticsearch 8.x nhằm nâng cao tốc độ tìm kiếm văn bản toàn văn và xử lý lỗi gõ phím (Fuzzy Search).
  3. Phát triển ứng dụng di động: Mở rộng giao diện người dùng sang nền tảng Mobile App bằng React Native hoặc Flutter, tận dụng lại toàn bộ hệ thống REST API hiện có.

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

  • Sinh viên & Học viên: Nguồn tài liệu tham khảo hoàn chỉnh về cấu trúc đồ án tốt nghiệp chuẩn mực, cách phân tích use case, thiết kế database và kết nối giữa Spring Boot với ReactJS.
  • Lập trình viên (Developers): Nắm bắt các mẫu thiết kế (Design Patterns) thực chiến: Repository Pattern, Service Layer, Dynamic Specifications, JWT Authentication Filter, và React Custom Hooks.
  • Doanh nghiệp tuyển dụng: Giải pháp phần mềm tối ưu chi phí, sẵn sàng triển khai nội bộ để quản lý nhu cầu tuyển dụng nhân tài.
  • Nhà nghiên cứu & Giảng viên: Cung cấp mô hình tham chiếu thực nghiệm trong việc ứng dụng kiến trúc Web Service và phân tách Single Page Application vào giảng dạy công nghệ phần mềm.

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

1. Yêu cầu phần cứng và môi trường để triển khai hệ thống là gì?

Hệ thống yêu cầu tối thiểu Java Runtime Environment (JRE) phiên bản 17 trở lên, Node.js phiên bản 16.x hoặc 18.x, và hệ quản trị cơ sở dữ liệu PostgreSQL từ phiên bản 13 trở lên. Đối với môi trường máy chủ sản xuất (Production), cấu hình đề xuất tối thiểu là 2 CPU Cores, 4GB RAM và 20GB bộ nhớ SSD.

2. Hệ thống xử lý bài toán quá tải khi lượng người dùng tăng cao như thế nào?

Kiến trúc RESTful Stateless kết hợp JWT cho phép mở rộng Backend theo chiều ngang (Horizontal Scaling) phía sau một bộ cân bằng tải (Load Balancer như Nginx) mà không cần đồng bộ session. Về phía cơ sở dữ liệu, việc tích hợp bộ đệm Redis và cấu hình Connection Pool (HikariCP) giúp giảm tải các truy vấn đọc thường xuyên.

3. Làm thế nào để tích hợp hệ thống với các cổng thông tin doanh nghiệp sẵn có?

Nhờ kiến trúc REST API chuẩn hóa và định dạng dữ liệu đầu ra JSON, các hệ sinh thái phần mềm khác (như ERP, HRMS) có thể dễ dàng gọi tới các endpoint công khai hoặc qua API Key được chứng thực để đồng bộ dữ liệu bài đăng và ứng viên.

4. Hệ thống đảm bảo an toàn và bảo mật dữ liệu người dùng ra sao?

Mật khẩu người dùng được băm một chiều với thuật toán mã hóa mạnh BCrypt (độ phức tạp Salt Rounds = 10). Toàn bộ các yêu cầu truy cập dữ liệu nhạy cảm đều phải vượt qua bộ lọc Spring Security JWT Filter, chống tấn công CSRF, đồng thời JPA Parameters Binding giúp ngăn chặn hoàn toàn nguy cơ SQL Injection.

5. Chi phí bảo trì và thời gian thu hồi vốn (ROI) ước tính như thế nào?

Nhờ kiến trúc module hóa rõ ràng, chi phí bảo trì và mở rộng tính năng mới rất thấp. Đối với các đơn vị kinh doanh dịch vụ tuyển dụng, thời gian hoàn vốn ước tính từ 4 đến 6 tháng thông qua việc cung cấp các gói đăng tin ưu tiên và dịch vụ tiếp cận hồ sơ ứng viên nổi bật.

Kết luận

Đồ án khóa luận tốt nghiệp "Xây dựng website tìm kiếm việc làm với Java Spring Boot và ReactJS" tại Khoa Công nghệ Thông tin - Trường Đại học Sư phạm Kỹ thuật TP. HCM đã giải quyết trọn vẹn bài toán kết nối tuyển dụng trong thời đại chuyển đổi số. Bằng việc kết hợp sức mạnh xử lý ổn định, bảo mật của Java Spring Boot ở tầng Backend cùng khả năng phản hồi mượt mà của ReactJS ở tầng Frontend, hệ thống đã mang lại một nền tảng tuyển dụng hiện đại, tối ưu hóa trải nghiệm người dùng và đạt hiệu năng truy vấn ấn tượng.

Những đóng góp về mặt kỹ thuật của đề tài - từ kiến trúc phân tách độc lập, bộ lọc JPA Specification động cho đến thuật toán gợi ý việc làm theo chỉ số tương đồng kỹ năng - đã khẳng định tính ứng dụng thực tiễn cao và khả năng mở rộng bền vững của hệ thống. Đây không chỉ là một công trình nghiên cứu ứng dụng có giá trị học thuật cao mà còn là giải pháp công nghệ hoàn chỉnh, sẵn sàng phục vụ nhu cầu tuyển dụng thực tế của xã hội.