### 使用Spring Boot和MySQL构建一个完善的OA招聘管理系统

在企业的日常运作中，招聘管理系统是一个重要的组成部分。本文将介绍如何使用Spring Boot和MySQL构建一个完整的OA招聘管理模块。这个模块包含以下主要功能：

1. **岗位管理**：对岗位进行创建、编辑和删除，并增加岗位状态管理和过滤功能。
2. **招聘需求**：记录企业的人才需求，增加优先级和截止日期等字段，支持查询和筛选。
3. **简历投递**：收集和整理求职者的简历，增加简历状态和文件上传功能。
4. **人员面试**：安排面试时间、地点和面试官，跟踪面试结果，并增加面试反馈和状态管理功能。

### 项目结构

为了保持代码清晰且易于维护，我们将项目组织为如下结构：

```plaintext
oa-recruitment-system
├── src
│   ├── main
│   │   ├── java/com/example/oarecruitmentsystem
│   │   │   ├── controller
│   │   │   │   ├── JobController.java
│   │   │   │   ├── RecruitmentRequestController.java
│   │   │   │   ├── ResumeController.java
│   │   │   │   ├── InterviewController.java
│   │   │   ├── model
│   │   │   │   ├── Job.java
│   │   │   │   ├── RecruitmentRequest.java
│   │   │   │   ├── Resume.java
│   │   │   │   ├── Interview.java
│   │   │   ├── repository
│   │   │   │   ├── JobRepository.java
│   │   │   │   ├── RecruitmentRequestRepository.java
│   │   │   │   ├── ResumeRepository.java
│   │   │   │   ├── InterviewRepository.java
│   │   │   ├── service
│   │   │   │   ├── JobService.java
│   │   │   │   ├── RecruitmentRequestService.java
│   │   │   │   ├── ResumeService.java
│   │   │   │   ├── InterviewService.java
│   │   │   └── OaRecruitmentSystemApplication.java
│   │   └── resources
│   │       ├── application.properties
├── pom.xml
```

### 依赖配置

在`pom.xml`中添加Spring Boot、MySQL和Spring Boot Starter Validation的依赖：

```xml
<dependencies>
    <!-- Spring Boot Dependencies -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- Validation Dependency -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-validation</artifactId>
    </dependency>
    <!-- MySQL Connector -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
</dependencies>
```

### 数据库配置

在`application.properties`文件中配置MySQL数据库连接：

```properties
spring.datasource.url=jdbc:mysql://localhost:3306/oa_recruitment
spring.datasource.username=root
spring.datasource.password=password
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
```

### 模型类

为了表示数据库中的表，创建以下模型类：

**Job.java**

```java
@Entity
public class Job {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String title;
    private String description;
    private String status; // OPEN, CLOSED

    // Getters and setters
}
```

**RecruitmentRequest.java**

```java
@Entity
public class RecruitmentRequest {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String department;
    private String requirement;
    private String priority; // HIGH, MEDIUM, LOW
    private LocalDate deadline;

    // Getters and setters
}
```

**Resume.java**

```java
@Entity
public class Resume {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String applicantName;
    private String contactDetails;
    private String resumeDetails;
    private String status; // VIEWED, NOT_VIEWED

    // Getters and setters
}
```

**Interview.java**

```java
@Entity
public class Interview {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String interviewer;
    private LocalDateTime interviewTime;
    private String interviewLocation;
    private String result;
    private String feedback;
    private String status; // SCHEDULED, COMPLETED, CANCELLED

    // Getters and setters
}
```

### 服务类

服务类负责业务逻辑处理：

**JobService.java**

```java
@Service
public class JobService {
    @Autowired
    private JobRepository jobRepository;

    public Job createJob(Job job) {
        return jobRepository.save(job);
    }

    public List<Job> getAllJobs() {
        return jobRepository.findAll();
    }

    public Job getJobById(Long id) {
        return jobRepository.findById(id).orElse(null);
    }

    public Job updateJob(Long id, Job jobDetails) {
        Job job = jobRepository.findById(id).orElse(null);
        if (job != null) {
            job.setTitle(jobDetails.getTitle());
            job.setDescription(jobDetails.getDescription());
            job.setStatus(jobDetails.getStatus());
            return jobRepository.save(job);
        }
        return null;
    }

    public void deleteJob(Long id) {
        jobRepository.deleteById(id);
    }

    public List<Job> getJobsByStatus(String status) {
        return jobRepository.findByStatus(status);
    }
}
```

**RecruitmentRequestService.java**

```java
@Service
public class RecruitmentRequestService {
    @Autowired
    private RecruitmentRequestRepository recruitmentRequestRepository;

    public RecruitmentRequest createRecruitmentRequest(RecruitmentRequest request) {
        return recruitmentRequestRepository.save(request);
    }

    public List<RecruitmentRequest> getAllRequests() {
        return recruitmentRequestRepository.findAll();
    }

    public RecruitmentRequest getRequestById(Long id) {
        return recruitmentRequestRepository.findById(id).orElse(null);
    }

    public RecruitmentRequest updateRequest(Long id, RecruitmentRequest requestDetails) {
        RecruitmentRequest request = recruitmentRequestRepository.findById(id).orElse(null);
        if (request != null) {
            request.setDepartment(requestDetails.getDepartment());
            request.setRequirement(requestDetails.getRequirement());
            request.setPriority(requestDetails.getPriority());
            request.setDeadline(requestDetails.getDeadline());
            return recruitmentRequestRepository.save(request);
        }
        return null;
    }

    public void deleteRequest(Long id) {
        recruitmentRequestRepository.deleteById(id);
    }

    public List<RecruitmentRequest> getRequestsByPriority(String priority) {
        return recruitmentRequestRepository.findByPriority(priority);
    }
}
```

**ResumeService.java**

```java
@Service
public class ResumeService {
    @Autowired
    private ResumeRepository resumeRepository;

    public Resume submitResume(Resume resume) {
        return resumeRepository.save(resume);
    }

    public List<Resume> getAllResumes() {
        return resumeRepository.findAll();
    }

    public Resume getResumeById(Long id) {
        return resumeRepository.findById(id).orElse(null);
    }

    public Resume updateResume(Long id, Resume resumeDetails) {
        Resume resume = resumeRepository.findById(id).orElse(null);
        if (resume != null) {
            resume.setApplicantName(resumeDetails.getApplicantName());
            resume.setContactDetails(resumeDetails.getContactDetails());
            resume.setResumeDetails(resumeDetails.getResumeDetails());
            resume.setStatus(resumeDetails.getStatus());
            return resumeRepository.save(resume);
        }
        return null;
    }

    public void deleteResume(Long id) {
        resumeRepository.deleteById(id);
    }

    public List<Resume> getResumesByStatus(String status) {
        return resumeRepository.findByStatus(status);
    }
}
```

**InterviewService.java**

```java
@Service
public class InterviewService {
    @Autowired
    private InterviewRepository interviewRepository;

    public Interview scheduleInterview(Interview interview) {
        return interviewRepository.save(interview);
    }

    public List<Interview> getAllInterviews() {
        return interviewRepository.findAll();
    }

    public Interview getInterviewById(Long id) {
        return interviewRepository.findById(id).orElse(null);
    }

    public Interview updateInterview(Long id, Interview interviewDetails) {
        Interview interview = interviewRepository.findById(id).orElse(null);
        if (interview != null) {
            interview.setInterviewer(interviewDetails.getInterviewer());
            interview.setInterviewTime(interviewDetails.getInterviewTime());
            interview.setInterviewLocation(interviewDetails.getInterviewLocation());
            interview.setResult(interviewDetails.getResult());
            interview.setFeedback(interviewDetails.getFeedback());
            interview.setStatus(interviewDetails.getStatus());
            return interviewRepository.save(interview);
        }
        return null;
    }

    public void deleteInterview(Long id) {
        interviewRepository.deleteById(id);
    }

    public List<Interview> getInterviewsByStatus(String status) {
        return interviewRepository.findByStatus(status);
    }
}
```

### 控制器类

控制器类用于处理HTTP请求：

**JobController.java**

```java
@RestController
@RequestMapping("/api/jobs")
public class JobController {
    @Autowired
    private JobService jobService;

    @PostMapping
    public Job createJob(@RequestBody @Valid Job job) {
        return jobService.createJob(job);
    }

    @GetMapping
    public List<Job> getAllJobs() {
        return jobService.getAllJobs();
    }

    @GetMapping("/{id}")
    public Job getJobById(@PathVariable Long id) {
        return jobService.getJobById(id);
    }

    @PutMapping("/{id}")
    public Job updateJob(@PathVariable Long id, @RequestBody @Valid Job jobDetails) {
        return jobService.updateJob(id, jobDetails);
    }

    @DeleteMapping("/{id}")
    public void deleteJob(@PathVariable Long id) {
        jobService.deleteJob(id);
    }

    @GetMapping("/status/{status}")
    public List<Job> getJobsByStatus(@PathVariable String status) {
        return jobService.getJobsByStatus(status);
    }
}
```

**RecruitmentRequestController.java**

```java
@RestController
@RequestMapping("/api/requests")
public class RecruitmentRequestController {
    @Autowired
    private RecruitmentRequestService requestService;

    @PostMapping
    public RecruitmentRequest createRequest(@RequestBody @Valid RecruitmentRequest request) {
        return requestService.createRecruitmentRequest(request);
    }

    @GetMapping
    public List<RecruitmentRequest> getAllRequests() {
        return requestService.getAllRequests();
    }

    @GetMapping("/{id}")
    public RecruitmentRequest getRequestById(@PathVariable Long id) {
        return requestService.getRequestById(id);
    }

    @PutMapping("/{id}")
    public RecruitmentRequest updateRequest(@PathVariable Long id, @RequestBody @Valid RecruitmentRequest requestDetails) {
        return requestService.updateRequest(id, requestDetails);
    }

    @DeleteMapping("/{id}")
    public void deleteRequest(@PathVariable Long id) {
        requestService.deleteRequest(id);
    }

    @GetMapping("/priority/{priority}")
    public List<RecruitmentRequest> getRequestsByPriority(@PathVariable String priority) {
        return requestService.getRequestsByPriority(priority);
    }
}
```

**ResumeController.java**

```java
@RestController
@RequestMapping("/api/resumes")
public class ResumeController {
    @Autowired
    private ResumeService resumeService;

    @PostMapping
    public Resume submitResume(@RequestBody @Valid Resume resume) {
        return resumeService.submitResume(resume);
    }

    @GetMapping
    public List<Resume> getAllResumes() {
        return resumeService.getAllResumes();
    }

    @GetMapping("/{id}")
    public Resume getResumeById(@PathVariable Long id) {
        return resumeService.getResumeById(id);
    }

    @PutMapping("/{id}")
    public Resume updateResume(@PathVariable Long id, @RequestBody @Valid Resume resumeDetails) {
        return resumeService.updateResume(id, resumeDetails);
    }

    @DeleteMapping("/{id}")
    public void deleteResume(@PathVariable Long id) {
        resumeService.deleteResume(id);
    }

    @GetMapping("/status/{status}")
    public List<Resume> getResumesByStatus(@PathVariable String status) {
        return resumeService.getResumesByStatus(status);
    }
}
```

**InterviewController.java**

```java
@RestController
@RequestMapping("/api/interviews")
public class InterviewController {
    @Autowired
    private InterviewService interviewService;

    @PostMapping
    public Interview scheduleInterview(@RequestBody @Valid Interview interview) {
        return interviewService.scheduleInterview(interview);
    }

    @GetMapping
    public List<Interview> getAllInterviews() {
        return interviewService.getAllInterviews();
    }

    @GetMapping("/{id}")
    public Interview getInterviewById(@PathVariable Long id) {
        return interviewService.getInterviewById(id);
    }

    @PutMapping("/{id}")
    public Interview updateInterview(@PathVariable Long id, @RequestBody @Valid Interview interviewDetails) {
        return interviewService.updateInterview(id, interviewDetails);
    }

    @DeleteMapping("/{id}")
    public void deleteInterview(@PathVariable Long id) {
        interviewService.deleteInterview(id);
    }

    @GetMapping("/status/{status}")
    public List<Interview> getInterviewsByStatus(@PathVariable String status) {
        return interviewService.getInterviewsByStatus(status);
    }
}
```

### 主应用类

**OaRecruitmentSystemApplication.java**

```java
@SpringBootApplication
public class OaRecruitmentSystemApplication {
    public static void main(String[] args) {
        SpringApplication.run(OaRecruitmentSystemApplication.class, args);
    }
}
```

### 结论

通过上述实现，我们构建了一个功能全面的OA招聘管理模块。这个模块不仅涵盖了岗位管理、招聘需求、简历投递和人员面试的功能，还提供了灵活的查询和筛选能力，提高了招聘管理的效率。

---