3-2 [Mocktio] 간단한 성적 저장 애플리케이션 구현

- 이전글 확인 -

[💻 FrameWork(프레임워크)/SpringTEST(스프링테스트)] - 3-1 [Mocktio] 간단한 성적 저장 애플리케이션 구현(로컬 환경 구성)

0. 로컬 환경 구성 참조

- 이전 글 확인하여 DB 및 spring 설정을 추가할 수 있습니다.

[💻 FrameWork(프레임워크)/SpringTEST(스프링테스트)] - 3-1 [Mocktio] 간단한 성적 저장 애플리케이션 구현(로컬 환경 구성)

 

1. 성적 저장 애플리케이션 설명

기술스택

• Spring Data JPA
• MySQL 8.0

요구사항

• 학생은 여러개의 시험 성적을 가지고 있습니다
• 학생의 시험 성적 정보를 저장할 수 있습니다
• 평균 점수가 60점 이상이라면 합격자 리스트에 저장됩니다
• 평균 점수가 60점 미만이라면 불합격자 리스트에 저장됩니다

 

  ERD

   API 스펙

• 성적 저장 API
  • 시험마다 학생의 성적을 저장합니다.

PUT /exam/{exam}/score

{
  "studentName" : string,
  "korScore" : integer,
  "englishScore" : integer,
  "mathScore" : integer
}

• 시험 합격자 명단 API
  • 시험의 합격자 명단 리스트를 불러옵니다

GET /exam/{exam}/pass

[
  {
    "studentName" : string,
    "avgScore" : double
  },
  ...
]

• 시험 불합격자 명단 API
  • 시험의 불합격자 명단 리스트를 불러옵니다

GET /exam/{exam}/fail

[
  {
    "studentName" : string,
    "avgScore" : double
  },
  ...
]

 

2. 성적 저장 애플리케이션 구현

1) controller

1] ScoreApi

@RequiredArgsConstructor
@RestController
public class ScoreApi {
    private final StudentScoreService studentScoreService;

    @PutMapping("/exam/{exam}/score")
    public void save(
            @PathVariable("exam") String exam,
            @RequestBody SaveExamScoreRequest request
    ) {
        studentScoreService.saveScore(
                request.getStudentName(),
                exam,
                request.getKorScore(),
                request.getEnglishScore(),
                request.getMathScore()
        );
    }

    @GetMapping("/exam/{exam}/pass")
    public List<ExamPassStudentResponse> pass(@PathVariable("exam") String exam) {
        return studentScoreService.getPassStudentsList(exam);
    }

    @GetMapping("/exam/{exam}/fail")
    public List<ExamFailStudentResponse> fail(@PathVariable("exam") String exam) {
        return studentScoreService.getFailStudentsList(exam);
    }
}

- 실질적인 controller 입니다.

 

2] request.SaveExamScoreRequest

@Getter
@AllArgsConstructor
@NoArgsConstructor(force = true, access = AccessLevel.PROTECTED)
public class SaveExamScoreRequest {
    private final String studentName;
    private final Integer korScore;
    private final Integer englishScore;
    private final Integer mathScore;
}

- 요청 DTO

 

3] response.ExamFailStudentResponse

@Getter
@AllArgsConstructor
public class ExamFailStudentResponse {
    private final String studentName;
    private final Double avgScore;
}

- 응답 DTO

 

4] response.ExamPassStudentResponse

@Getter
@AllArgsConstructor
public class ExamPassStudentResponse {
    private final String studentName;
    private final Double avgScore;
}

- 응답 DTO

 

2) model

- entity(엔티티) 작업을 수행하겠습니다.

1] StudentScore

@Getter
@Builder
@AllArgsConstructor
@NoArgsConstructor
@Table(name = "student_score")
@Entity
public class StudentScore {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "student_score_id")
    private Long id;

    @Column(name = "exam")
    private String exam;

    @Column(name = "student_name")
    private String studentName;

    @Column(name = "kor_score")
    private Integer korScore;

    @Column(name = "english_score")
    private Integer englishScore;

    @Column(name = "math_score")
    private Integer mathScore;
}

- 학생 성적을 저장하는 엔티티 입니다(테이블)

 

2] StudentScore

@Getter
@Builder
@AllArgsConstructor
@NoArgsConstructor
@Table(name = "student_pass")
@Entity
public class StudentPass {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "student_pass_id")
    private Long id;

    @Column(name = "exam")
    private String exam;

    @Column(name = "student_name")
    private String studentName;

    @Column(name = "avg_score")
    private Double avgScore;
}

- 합격자 성적을 저장하는 엔티티 입니다(테이블)

 

3] StudentFail

@Getter
@Builder
@AllArgsConstructor
@NoArgsConstructor
@Table(name = "student_fail")
@Entity
public class StudentFail {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "student_fail_id")
    private Long id;

    @Column(name = "exam")
    private String exam;

    @Column(name = "student_name")
    private String studentName;

    @Column(name = "avg_score")
    private Double avgScore;
}

- 불합격자 성적을 저장하는 엔티티 입니다(테이블)

3) repository

- JPA를 사용하기 위해 repository 인터페이스(각 엔티티별)를 구현해야 합니다.

public interface StudentScoreRepository extends JpaRepository<StudentScore, Long> {

}

public interface StudentPassRepository extends JpaRepository<StudentPass, Long> {

}

public interface StudentFailRepository extends JpaRepository<StudentFail, Long> {

}

 

4)  service

- 비지니스 로직이 담겨져 있는 서비스를 구현하겠습니다.

 

1] StudentScoreService

@RequiredArgsConstructor
@Service
public class StudentScoreService {
    private final StudentFailRepository studentFailRepository;
    private final StudentScoreRepository studentScoreRepository;
    private final StudentPassRepository studentPassRepository;

    public void saveScore(
            String studentName,
            String exam,
            Integer korScore,
            Integer englishScore,
            Integer mathScore) {
        StudentScore studentScore = StudentScore.builder()
                .exam(exam)
                .studentName(studentName)
                .korScore(korScore)
                .englishScore(englishScore)
                .mathScore(mathScore)
                .build();

        studentScoreRepository.save(studentScore);

        MyCalculator calculator = new MyCalculator(0.0);
        Double avgScore = calculator.add(korScore.doubleValue())
                .add(englishScore.doubleValue())
                .add(mathScore.doubleValue())
                .divide(3.0)
                .getResult();

        if (avgScore >= 60) {
            studentPassRepository.save(StudentPass.builder()
                    .exam(exam)
                    .studentName(studentName)
                    .avgScore(avgScore)
                    .build());
        } else {
            studentFailRepository.save(StudentFail.builder()
                    .exam(exam)
                    .studentName(studentName)
                    .avgScore(avgScore)
                    .build());
        }
    }

    public List<ExamPassStudentResponse> getPassStudentsList(String exam) {
        List<StudentPass> studentPasses = studentPassRepository.findAll();

        return studentPasses.stream()
                .filter(l -> l.getExam().equals(exam))
                .map(l -> new ExamPassStudentResponse(l.getStudentName(), l.getAvgScore()))
                .toList();
    }

    public List<ExamFailStudentResponse> getFailStudentsList(String exam) {
        List<StudentFail> studentFails = studentFailRepository.findAll();

        return studentFails.stream()
                .filter(l -> l.getExam().equals(exam))
                .map(l -> new ExamFailStudentResponse(l.getStudentName(), l.getAvgScore()))
                .toList();
    }
}

 

- 해당 로직 반영 이후 Api를 요청하면 아래와 같은 결과값을 확인할 수 있습니다.

3. 참조

- RequiredArgsConstructor 어노테이션 관련 설명

[Spring Boot] @RequiredArgsConstructor란?

- 참조 : 개인블로그

 

4. Github으로 확인

전체 파일 확인(현재 변경내역) 
[Github]

[Mocktio] 간단한 성적 프로그램 구현 · pcy4196/dayonetest@1cdaaf5

 

참조 : 인프런 강의 [쥬쥬와 함께 하루만에 끝내는 스프링 테스트]