일정 관리 시스템

해당 시스템은 CRUD구현을 연습을 위해 시행되었다. 

 

지금까지 구현된기능은

• 일정 등록(createSchedule)
• 일정 조회(getSchedule)
• 일정 수정(updateSchedule)
• 일정 삭제(deleteSchedule)
• 담당자 등록(createTeacher)
• 담당자 삭제(deleteTeacher)

이렇게 6가지가 있다.

 

이렇게 구현이 가능하게 하기 위하 짜여진 코드에 대해 설명해보도록 하겠다.

다만 아직 3Layer Architecture가 안되어 있기 때문에 코드가 난잡해 있다. 빠른 시일내에 적용해서 다시 올릴 예정이다.

 

controller 패키지 안에 있는 클래스들은 Spring Boot 애플리케이션에서 웹 요청을 처리하고 클라이언트와 상호작용을 관리하는 역할을 맡고 있다. 지금은 API요청은 Postman에서 테스트 용으로만 요청하니 매우 작은 규모의 HTTP요청을 처리한다.

 

package com.sparta.schedule.controller

ScheduleController.class

스케줄과 관련된 HTTP 요청을 처리하는 RESTful API를 구현함.

package com.sparta.schedule.controller;

import com.sparta.schedule.dto.ScheduleRequestDto;
import com.sparta.schedule.dto.ScheduleResponseDto;
import com.sparta.schedule.entity.Schedule;
import com.sparta.schedule.entity.Teacher;
import com.sparta.schedule.manegement.TeacherRepository;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.support.GeneratedKeyHolder;
import org.springframework.jdbc.support.KeyHolder;
import org.springframework.web.bind.annotation.*;

import java.sql.PreparedStatement;
import java.sql.Statement;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Objects;
import java.util.Optional;

@RestController
@RequestMapping("/api")
public class ScheduleController {

    private final JdbcTemplate jdbcTemplate;
    private final TeacherRepository teacherRepository;

    public ScheduleController(JdbcTemplate jdbcTemplate, TeacherRepository teacherRepository) {
        this.jdbcTemplate = jdbcTemplate;
        this.teacherRepository = teacherRepository;
    }

    @PostMapping("/schedules")
    public ScheduleResponseDto createSchedule(@RequestBody ScheduleRequestDto requestDto) {
        Integer teacherId = requestDto.getTeacher_Id();
        if (teacherId == null) {
            throw new IllegalArgumentException("담당자 ID가 제공되지 않았습니다.");
        }

        // RequestDto에서 teacherId를 사용하여 Entity 조회
        Optional<Teacher> teacherOptional = teacherRepository.findById(teacherId);
        if (teacherOptional.isEmpty()) {
            // 로그를 추가하여 문제를 추적할 수 있음
            System.err.println("유효하지 않은 담당자 ID: " + teacherId);
            throw new IllegalArgumentException("유효하지 않은 담당자입니다.");
        }

        Teacher teacher = teacherOptional.get();

        // 추가 유효성 검사 (예: work와 password의 값 검사)
        if (requestDto.getWork() == null || requestDto.getWork().trim().isEmpty()) {
            throw new IllegalArgumentException("작업 내용이 비어있습니다.");
        }

        Schedule schedule = new Schedule();
        schedule.setWork(requestDto.getWork());
        schedule.setTeacher(teacher.getId());
        schedule.setPassword(requestDto.getPassword());

        // DB 저장
        KeyHolder keyHolder = new GeneratedKeyHolder();

        String sql = "INSERT INTO schedule (work, password, teacher_id) VALUES (?, ?, ?)";
        jdbcTemplate.update(con -> {
            PreparedStatement preparedStatement = con.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
            preparedStatement.setString(1, schedule.getWork());
            preparedStatement.setInt(2, schedule.getPassword());
            preparedStatement.setInt(3, teacher.getId());
            return preparedStatement;
        }, keyHolder);

        schedule.setId(Objects.requireNonNull(keyHolder.getKey()).intValue());

        return new ScheduleResponseDto(schedule);
    }

    @GetMapping("/schedules")
    public List<ScheduleResponseDto> getSchedules() {
        String sql = "SELECT s.schedule_id, s.work, s.password, s.createdDate, s.updatedDate, t.id AS teacher_id, t.name AS teacher_name, t.email AS teacher_email "
                + "FROM schedule s JOIN teacher t ON s.teacher_id = t.id "
                + "ORDER BY s.updatedDate DESC";

        List<ScheduleResponseDto> query = jdbcTemplate.query(sql, (rs, rowNum) -> {
            Schedule schedule = new Schedule();
            schedule.setId(rs.getInt("schedule_id"));
            schedule.setWork(rs.getString("work"));
            schedule.setPassword(rs.getInt("password"));
            schedule.setCreatedDate(rs.getObject("createdDate", LocalDateTime.class));
            schedule.setUpdatedDate(rs.getObject("updatedDate", LocalDateTime.class));

            Teacher teacher = new Teacher();
            teacher.setId(rs.getInt("teacher_id")); // 수정된 필드 이름 사용
            teacher.setName(rs.getString("teacher_name")); // 수정된 필드 이름 사용
            teacher.setEmail(rs.getString("teacher_email")); // 수정된 필드 이름 사용

            schedule.setTeacher(teacher.getId());

            return new ScheduleResponseDto(schedule);
        });

        return query;
    }

    @PutMapping("/schedules/{scheduleId}")
    public Schedule updateSchedule(@PathVariable int scheduleId, @RequestBody ScheduleRequestDto requestDto) {
        // 해당 스케줄이 DB에 존재하는지 확인
        Schedule schedule = findByScheduleId(scheduleId);

        // 비밀번호가 올바른지 확인
        if (schedule == null || !schedule.getPassword().equals(requestDto.getPassword())) {
            throw new IllegalArgumentException("비밀번호가 올바르지 않습니다.");
        }

        // schedule 내용 수정
        String sql = "UPDATE schedule SET updatedDate = ?, work = ? WHERE schedule_id = ? AND Password = ?";
        jdbcTemplate.update(sql, LocalDateTime.now(), requestDto.getWork(), scheduleId, requestDto.getPassword()); // 변경: teacherId를 사용

        return findByScheduleId(scheduleId);
    }

    @DeleteMapping("/schedules/{scheduleId}")
    public Schedule deleteSchedule(@PathVariable int scheduleId, @RequestParam int password) {
        Schedule schedule = findByScheduleId(scheduleId);

            // schedule 삭제
            String sql = "DELETE FROM schedule WHERE schedule_id AND password = ?";
            jdbcTemplate.update(sql, scheduleId, password);

            return null;

    }

    public Schedule findByScheduleId(@RequestParam int scheduleId) {
        String sql = "SELECT * FROM schedule s join teacher t on t.id = s.schedule_id WHERE schedule_id = ?";
        System.out.println("scheduleId = " + scheduleId);

            return jdbcTemplate.queryForObject(sql, (rs, rowNum) -> {
                Schedule schedule = new Schedule();
                schedule.setId(rs.getInt("schedule_id"));
                schedule.setWork(rs.getString("work"));
                schedule.setPassword(rs.getInt("password"));

                int teacherId = rs.getInt("id"); // 변경: 'teacher' 필드를 가져옴
                return schedule;
            }, scheduleId);
    }
}

 

주요 기능

createSchedule

경로 및 메서드: @PostMapping("/schedules")

• HTTP POST 요청을 처리하여 새로운 스케줄을 생성한다.

입력: @RequestBody ScheduleRequestDto requestDto

• HTTP 요청의 본문에서 ScheduleRequestDto 객체를 받는다. 이 객체는 스케줄 생성에 필요한 데이터를 포함한다.

로직:

• 담당자 유효성 검사: TeacherRepository를 통해 teacherId가 유효한지 확인한다. 유효하지 않으면 예외를 발생시킨다.
• 스케줄 객체 생성: Schedule 객체를 생성하고, 요청 DTO에서 받은 데이터를 설정한다.
• 데이터베이스에 저장: JdbcTemplate을 사용하여 INSERT SQL 쿼리를 실행하고, 새 스케줄을 데이터베이스에 저장한다. KeyHolder를 사용하여 자동 생성된 ID를 가져온다.
• 응답: 새로 생성된 Schedule 객체를 ScheduleResponseDto로 변환하여 반환한다.

getSchedules

경로 및 메서드: @GetMapping("/schedules")

• HTTP GET 요청을 처리하여 모든 스케줄을 조회한다.

로직:

• SQL 쿼리 실행: JdbcTemplate을 사용하여 SELECT SQL 쿼리를 실행하고, 스케줄과 관련된 정보를 조회한다. JOIN을 사용하여 스케줄과 담당자 정보를 함께 가져온다.
• 응답 변환: 조회된 데이터를 ScheduleResponseDto로 변환하여 반환한다. 각 스케줄과 관련된 Teacher 정보를 포함한다.

updateSchedule

경로 및 메서드: @PutMapping("/schedules/{scheduleId}")

• HTTP PUT 요청을 처리하여 특정 ID의 스케줄을 업데이트한다.

입력: @PathVariable int scheduleId, @RequestBody ScheduleRequestDto requestDto

• URL 경로에서 scheduleId를 추출하고, 요청 본문에서 ScheduleRequestDto 객체를 받는다.

로직:

• 스케줄 조회: findByScheduleId 메서드를 호출하여 해당 ID의 스케줄을 조회한다.
• 비밀번호 검증: 요청 DTO에서 받은 비밀번호와 스케줄의 비밀번호가 일치하는지 확인한다.
• 스케줄 업데이트: 비밀번호가 맞는 경우, JdbcTemplate을 사용하여 UPDATE SQL 쿼리를 실행하고 스케줄을 수정한다.
• 응답: 업데이트된 스케줄을 findByScheduleId 메서드를 사용하여 다시 조회한 후 반환한다.

deleteSchedule

경로 및 메서드: @DeleteMapping("/schedules/{scheduleId}")

• HTTP DELETE 요청을 처리하여 특정 ID의 스케줄을 삭제한다.

입력: @PathVariable int scheduleId, @RequestParam int password

• URL 경로에서 scheduleId를 추출하고, 쿼리 파라미터로 비밀번호를 받는다.

로직:

• 스케줄 조회: findByScheduleId 메서드를 호출하여 해당 ID의 스케줄을 조회한다.
• 비밀번호 검증: 요청 파라미터에서 받은 비밀번호와 스케줄의 비밀번호가 일치하는지 확인한다.
• 스케줄 삭제: 비밀번호가 맞는 경우, JdbcTemplate을 사용하여 DELETE SQL 쿼리를 실행하고 스케줄을 삭제한다.
• 응답: 삭제된 스케줄의 내용을 반환한다. (여기서 null을 반환하고 있는데, 일반적으로는 성공 응답을 반환하거나 별도의 처리 필요)

findByScheduleId

로직:

• 스케줄 조회: 주어진 scheduleId로 스케줄을 조회하는 메서드이다. SQL 쿼리를 사용하여 데이터베이스에서 해당 ID의 스케줄을 가져온다.
• 응답 변환: 조회된 스케줄 정보를 Schedule 객체로 변환하여 반환한다.

어노테이션 설명

• @RestController: 이 클래스가 RESTful 웹 서비스의 컨트롤러임을 나타낸다. HTTP 요청을 처리하고, HTTP 응답을 반환하는 기능을 제공한다.
• @RequestMapping("/api"): 클래스의 기본 URL 경로를 설정한다. 모든 메서드는 /api로 시작하는 경로를 갖게 된다.
• @PostMapping("/schedules"): HTTP POST 요청을 처리하며, 스케줄 생성을 담당한다.
• @GetMapping("/schedules"): HTTP GET 요청을 처리하며, 모든 스케줄을 조회하는 기능을 담당한다.
• @PutMapping("/schedules/{scheduleId}"): HTTP PUT 요청을 처리하며, 특정 ID의 스케줄을 업데이트하는 기능을 담당한다.
• @DeleteMapping("/schedules/{scheduleId}"): HTTP DELETE 요청을 처리하며, 특정 ID의 스케줄을 삭제하는 기능을 담당한다.
• @PathVariable: URL 경로에서 변수를 추출하는 데 사용된다. 주로 ID와 같은 동적 값을 메서드의 파라미터로 전달한다.
• @RequestBody: HTTP 요청의 본문을 메서드 파라미터로 변환하는 데 사용된다. 주로 JSON 데이터를 객체로 변환하여 사용한다.
• @RequestParam: HTTP 요청의 쿼리 파라미터를 메서드 파라미터로 변환하는 데 사용된다. 이 코드에서는 scheduleId와 같은 값을 쿼리 파라미터로 받는다.

필드 설명

JdbcTemplate jdbcTemplate

• Spring의 JDBC 템플릿 클래스. SQL 쿼리 실행과 데이터베이스와의 상호작용을 간편하게 해준다. 쿼리 실행, 업데이트, 데이터 조회 등을 지원한다.

TeacherRepository teacherRepository

• Teacher 엔티티를 관리하는 리포지토리 클래스. Teacher 객체의 조회와 저장을 담당하며, 데이터베이스와의 상호작용을 처리한다.

이 클래스는 RESTful API를 제공하여 클라이언트가 스케줄을 생성, 조회, 업데이트, 삭제할 수 있도록 한다. 데이터베이스와의 상호작용은 JdbcTemplate을 통해 처리하며, 비즈니스 로직을 수행하기 위해 TeacherRepository를 사용한다.

 

---

 

package com.sparta.schdule.controller

TeacherController.class

package com.sparta.schedule.controller;

import com.sparta.schedule.dto.ScheduleRequestDto;
import com.sparta.schedule.dto.TeacherRequestDto;
import com.sparta.schedule.entity.Teacher;
import com.sparta.schedule.manegement.TeacherRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

import java.time.LocalDateTime;

@RestController
@RequestMapping("/api/teachers")
public class TeacherController {

    @Autowired
    private TeacherRepository teacherRepository;

    // POST 메서드: 새로운 담당자 추가
    @PostMapping
    public ResponseEntity<Teacher> createTeacher(@Validated @RequestBody TeacherRequestDto requestDto) {
        Teacher teacher = new Teacher();
        teacher.setName(requestDto.getName());
        teacher.setEmail(requestDto.getEmail());
        teacher.setCreatedDate(LocalDateTime.now());
        teacher.setUpdatedDate(LocalDateTime.now());

        Teacher savedTeacher = teacherRepository.save(teacher);
        return ResponseEntity.ok(savedTeacher);
    }

    // DELETE 메서드: 담당자 삭제
    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteTeacher(@PathVariable Long id) {
        if (!teacherRepository.existsById(id)) {
            return ResponseEntity.notFound().build();
        }

        teacherRepository.deleteById(id);
        return ResponseEntity.noContent().build();
    }
}

 

클래스 및 필드 설명

@RestController

• 역할: 이 어노테이션은 Spring MVC에서 RESTful 웹 서비스의 컨트롤러로 역할을 한다. HTTP 요청을 받고, JSON 형식으로 응답을 반환한다.
• 특징: 클래스 내 모든 메서드는 HTTP 요청을 처리하며, 반환되는 객체는 JSON으로 변환되어 응답으로 전송된다.

@RequestMapping("/api/teachers")

• 역할: 클래스의 모든 요청 URL 경로에 /api/teachers를 접두사로 붙인다.
• 예시: /api/teachers로 시작하는 URL이 이 클래스의 메서드에 매핑된다. 예를 들어, /api/teachers는 createTeacher 메서드에, /api/teachers/{id}는 deleteTeacher 메서드에 매핑된다.

필드

@Autowired private TeacherRepository teacherRepository

• 역할: Spring의 의존성 주입 기능을 사용하여 TeacherRepository 객체를 자동으로 주입받는다.
• 용도: 데이터베이스와 상호작용하여 Teacher 객체를 CRUD(생성, 읽기, 업데이트, 삭제) 작업을 처리하는 데 사용된다.
• 특징: TeacherRepository는 데이터베이스 쿼리를 처리하는 DAO(Data Access Object) 역할을 한다.

메서드 상세 설명

createTeacher

경로 및 메서드: @PostMapping

• 역할: HTTP POST 요청을 처리하여 새로운 Teacher 객체를 데이터베이스에 저장한다.
• 경로: /api/teachers
• HTTP 메서드: POST (리소스를 생성하는 데 사용)

입력: @Validated @RequestBody TeacherRequestDto requestDto

• @Validated: DTO에 대한 유효성 검사를 수행한다. 유효성 검사가 실패하면 자동으로 예외를 발생시킨다.
• @RequestBody: HTTP 요청의 본문에서 TeacherRequestDto 객체를 읽어온다.

로직:

1. DTO 유효성 검사: TeacherRequestDto에서 name과 email을 가져오고 유효성 검사를 수행한다.
2. Teacher 객체 생성: DTO에서 정보를 읽어와 새로운 Teacher 객체를 생성한다.
3. 날짜 설정: createdDate와 updatedDate를 현재 시간으로 설정한다.
4. 저장: teacherRepository.save(teacher)를 호출하여 데이터베이스에 Teacher 객체를 저장한다.
5. 응답 생성: 저장된 Teacher 객체를 ResponseEntity.ok(savedTeacher)로 반환한다. HTTP 상태 코드 200 OK와 함께 반환된다.

deleteTeacher

경로 및 메서드: @DeleteMapping("/{id}")

• 역할: HTTP DELETE 요청을 처리하여 특정 ID의 Teacher 객체를 삭제한다.
• 경로: /api/teachers/{id}
• HTTP 메서드: DELETE (리소스를 삭제하는 데 사용)

입력: @PathVariable Long id

• @PathVariable: URL 경로에서 id를 추출하여 메서드 인자로 전달한다.

로직:

1. 존재 여부 확인: teacherRepository.existsById(id)를 사용하여 해당 ID의 Teacher가 데이터베이스에 존재하는지 확인한다.
2. 존재하지 않을 경우: ResponseEntity.notFound().build()를 호출하여 HTTP 상태 코드 404 Not Found를 반환한다.
3. 삭제: teacherRepository.deleteById(id)를 호출하여 데이터베이스에서 Teacher 객체를 삭제한다.
4. 응답 생성: 삭제가 완료되면 ResponseEntity.noContent().build()를 호출하여 HTTP 상태 코드 204 No Content를 반환한다. 이 상태 코드는 요청이 성공적으로 처리되었지만 반환할 내용이 없음을 나타낸다.

---

 

package com.sparta.schedule.dto

ScheduleRequestDto.class

 

해당 클래스는 클라이언트로부터 전송된 데이터가 컨트롤러로 전달되기 전에 매핑되는 데이터 전송 객체(Data Transfer Object)이다. 이 DTO클래스는 주로 HTTP 요청 본문에서 데이터를 수집하는데 사용된다.

 

@Getter 및 @Setter 어노테이션

• @Getter: Lombok 라이브러리의 어노테이션으로, 클래스의 모든 필드에 대한 getter 메서드를 자동으로 생성한다.
• @Setter: Lombok 라이브러리의 어노테이션으로, 클래스의 모든 필드에 대한 setter 메서드를 자동으로 생성한다.

이 어노테이션들은 클래스의 필드를 직접 접근하지 않고, getter와 setter 메서드를 통해 데이터를 읽고 쓸 수 있게 해준다.

필드 설명

private String work;

• 기능: 스케줄의 작업 내용을 저장하는 필드이다.
• 용도: 클라이언트가 제공하는 작업 내용을 담는다. 예를 들어, 수업의 주제나 과제를 저장할 수 있다.

private Integer teacher_Id;

• 기능: 스케줄에 해당하는 담당자의 ID를 저장하는 필드이다.
• 용도: 요청된 스케줄과 연결된 담당자의 식별자(ID)를 지정한다. 데이터베이스에서 해당 ID로 담당자를 조회하거나 확인할 때 사용된다.

private Integer password;

• 기능: 스케줄을 수정하거나 삭제할 때 사용할 비밀번호를 저장하는 필드이다.
• 용도: 스케줄의 보안을 위한 비밀번호를 클라이언트로부터 받는다. 수정 또는 삭제 요청 시 이 비밀번호를 검증하는 데 사용된다.

private LocalDateTime createdDatetime;

• 기능: 스케줄이 생성된 날짜와 시간을 저장하는 필드이다.
• 용도: 데이터베이스에서 자동으로 생성된 날짜와 시간을 기록할 때 사용되며, 요청 시 클라이언트가 제공한 경우에는 클라이언트의 데이터와 일치하도록 한다.

private LocalDateTime updatedDatetime;

• 기능: 스케줄이 마지막으로 업데이트된 날짜와 시간을 저장하는 필드이다.
• 용도: 데이터베이스에서 자동으로 업데이트된 날짜와 시간을 기록할 때 사용되며, 클라이언트가 제공하는 경우에는 해당 데이터와 일치하도록 한다.

---

package com.sparta.schedule.dto

ScheduleResponseDto.class

Schedule 엔티티 객체를 클라이언트에게 반환할 때 사용되는 데이터 전송 객체(Data Transfer Object)이다. 이 DTO는 엔티티의 데이터를 클라이언트에게 전달할 때 필요한 형식으로 변환한다.

 

package com.sparta.schedule.dto;

import com.sparta.schedule.entity.Schedule;
import lombok.Getter;
import lombok.Setter;

import java.time.LocalDateTime;

@Getter
@Setter
public class ScheduleResponseDto {
    private int schedule_id; // Schedule의 ID 필드를 매핑
    private String work;
    private int teacherId; // 변환된 teacher ID 필드
    private Integer password;
    private LocalDateTime createdDatetime; // 변환된 createdDate 필드
    private LocalDateTime updatedDatetime; // 변환된 updatedDate 필드

    // Schedule 엔티티를 기반으로 DTO를 생성
    public ScheduleResponseDto(Schedule schedule) {
        this.schedule_id = schedule.getSchedule_id();
        this.work = schedule.getWork();
        this.teacherId = schedule.getTeacher();
        this.password = schedule.getPassword();
        this.createdDatetime = schedule.getCreatedDate();
        this.updatedDatetime = schedule.getUpdatedDate();
    }

    // 이 생성자는 필요하지 않거나 적절한 위치에 맞게 수정해야 함
    public ScheduleResponseDto(String work, int teacherId, Integer password, LocalDateTime createdDatetime, LocalDateTime updatedDatetime) {
        this.work = work;
        this.teacherId = teacherId; // int로 수정
        this.password = password;
        this.createdDatetime = createdDatetime;
        this.updatedDatetime = updatedDatetime;
    }
}

 

필드 설명

private int schedule_id;

• 기능: 스케줄의 고유 ID를 저장하는 필드이다.
• 설명: Schedule 엔티티의 schedule_id 필드를 매핑하여 클라이언트에게 스케줄의 식별자를 제공한다.

private String work;

• 기능: 스케줄의 작업 내용을 저장하는 필드이다.
• 설명: Schedule 엔티티의 work 필드를 매핑하여 작업의 내용을 클라이언트에게 전달한다.

private int teacherId;

• 기능: 스케줄과 연결된 담당자의 ID를 저장하는 필드이다.
• 설명: Schedule 엔티티의 teacher 필드를 매핑하여 스케줄을 담당하는 교사의 ID를 제공한다.

private Integer password;

• 기능: 스케줄의 비밀번호를 저장하는 필드이다.
• 설명: Schedule 엔티티의 password 필드를 매핑하여 클라이언트에게 비밀번호를 전달한다. 비밀번호는 Integer로 설정되어 선택적으로 사용할 수 있다.

private LocalDateTime createdDatetime;

• 기능: 스케줄이 생성된 날짜와 시간을 저장하는 필드이다.
• 설명: Schedule 엔티티의 createdDate 필드를 매핑하여 스케줄이 생성된 날짜와 시간을 클라이언트에게 전달한다.

private LocalDateTime updatedDatetime;

• 기능: 스케줄이 마지막으로 업데이트된 날짜와 시간을 저장하는 필드이다.
• 설명: Schedule 엔티티의 updatedDate 필드를 매핑하여 스케줄이 마지막으로 수정된 날짜와 시간을 클라이언트에게 제공한다.

생성자

public ScheduleResponseDto(Schedule schedule)

• 기능: Schedule 엔티티 객체를 기반으로 ScheduleResponseDto 객체를 생성하는 생성자이다.
• 설명: 엔티티의 각 필드를 DTO의 필드에 매핑하여, 클라이언트에게 반환할 형식으로 변환한다.

public ScheduleResponseDto(String work, int teacherId, Integer password, LocalDateTime createdDatetime, LocalDateTime updatedDatetime)

• 기능: 각 필드를 직접 설정하여 ScheduleResponseDto 객체를 생성하는 생성자이다.
• 설명: 이 생성자는 DTO를 초기화할 때 유용하지만, Schedule 엔티티에서 직접 데이터를 변환하는 경우에는 필요하지 않을 수 있다. 엔티티에서 DTO를 변환하는 로직을 직접 사용하는 것이 일반적이다.

---

pacakage com.sparta.schedule.dto

TeacheRequestDto.class

클라이언트가 새로운 Teacher(담당자) 객체를 생성하거나 업데이트할 때 필요한 데이터를 포함하는 DTO(Data Transfer Object)이다. 이 클래스는 Spring Boot 애플리케이션에서 REST API 요청을 처리할 때 사용된다.

 

package com.sparta.schedule.dto;

import lombok.Getter;
import lombok.Setter;

@Getter
@Setter
public class TeacherRequestDto {
    private String name;

    private String email;
}

 

클래스 설명

필드

private String name;

• 기능: 담당자의 이름을 저장하는 필드이다.
• 설명: 클라이언트로부터 전달받은 담당자의 이름을 저장한다. 이 값은 Teacher 엔티티의 name 필드에 매핑된다.

private String email;

• 기능: 담당자의 이메일 주소를 저장하는 필드이다.
• 설명: 클라이언트로부터 전달받은 담당자의 이메일 주소를 저장한다. 이 값은 Teacher 엔티티의 email 필드에 매핑된다.

주요 기능

• 요청 데이터 캡처: 클라이언트가 POST 또는 PUT 요청을 통해 전송하는 담당자 정보를 캡처하여 컨트롤러에서 사용할 수 있도록 한다.
• 유효성 검사: 클래스 내부에 유효성 검사를 추가하여 필드 값이 올바른지 확인할 수 있다. (예: @NotBlank, @Email 등의 어노테이션을 사용할 수 있다.)
• DTO 변환: 요청 본문을 처리하고, 이 DTO 객체를 통해 Teacher 엔티티 객체로 변환하여 데이터베이스에 저장하거나 업데이트할 수 있다.

---

 

package com.sparta.schedule.entity

Schedule.class

일정 관리를 위한 엔티티 클래스로, 일정 데이터를 관리하고 다른 DTO(Data Transfer Object)클래스와 상호 작용할 수 있는 메서드 제공. 이 클래스는 Lombok annotation을 사용하여 Getter, Setter, 기본 생성자를 자동으로 생성한다.

 

package com.sparta.schedule.entity;

import com.sparta.schedule.dto.ScheduleRequestDto;
import com.sparta.schedule.dto.ScheduleResponseDto;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;

import java.time.LocalDateTime;

@Getter
@Setter
@NoArgsConstructor
public class Schedule {
    private int id;
    private String work;
    private int teacher; //
    private Integer password;
    private LocalDateTime createdDate;
    private LocalDateTime updatedDate;
    private int schedule_id;

    // ScheduleRequestDto를 기반으로 Schedule 객체 생성
    public Schedule(ScheduleRequestDto requestDto) {
        this.work = requestDto.getWork();
        this.teacher = requestDto.getTeacher_Id(); // teacherId로 수정
        this.password = requestDto.getPassword();
    }

    // ScheduleRequestDto를 기반으로 Schedule 객체 업데이트
    public void update(ScheduleRequestDto requestDto) {
        this.work = requestDto.getWork();
        this.teacher = requestDto.getTeacher_Id(); // teacherId로 수정
        this.password = requestDto.getPassword();
    }
}

필드

private int id;

• 기능: 스케줄의 고유 ID를 저장한다.
• 설명: 데이터베이스에서 자동 생성되거나 수동으로 할당되는 고유 식별자 역할을 한다.

private String work;

• 기능: 스케줄에 할당된 작업 내용을 저장한다.
• 설명: 어떤 작업이 이 스케줄에 포함되는지를 나타내는 텍스트 필드이다.

private int teacher;

• 기능: 이 스케줄을 담당하는 담당자(teacher)의 ID를 저장한다.
• 설명: 외래 키(Foreign Key)로, Teacher 엔티티와 연관된 담당자 ID를 저장한다.

private Integer password;

• 기능: 스케줄을 보호하기 위한 비밀번호를 저장한다.
• 설명: 스케줄 삭제나 수정 시 확인용으로 사용되는 비밀번호이다.

private LocalDateTime createdDate;

• 기능: 스케줄이 생성된 날짜와 시간을 저장한다.
• 설명: 스케줄이 처음 생성된 시간 정보를 나타낸다.

private LocalDateTime updatedDate;

• 기능: 스케줄이 마지막으로 수정된 날짜와 시간을 저장한다.
• 설명: 스케줄이 마지막으로 변경된 시간 정보를 나타낸다.

private int schedule_id;

• 기능: 스케줄의 고유 ID를 저장한다.
• 설명: id와 중복되는 의미를 가질 수 있지만, 특정 요구 사항에 따라 두 개의 필드가 존재할 수 있다.

생성자 및 메서드

기본 생성자 (@NoArgsConstructor)

• 기능: Lombok의 @NoArgsConstructor 어노테이션을 사용해 기본 생성자를 자동으로 생성한다.
• 설명: 매개변수가 없는 기본 생성자로, 빈 객체를 만들 때 사용된다.

public Schedule(ScheduleRequestDto requestDto)

• 기능: ScheduleRequestDto 객체를 받아 Schedule 객체를 초기화한다.
• 설명: 클라이언트로부터 전달받은 ScheduleRequestDto를 기반으로 Schedule 객체를 생성할 때 사용된다. 여기서 work, teacher, password 필드를 초기화한다.

public void update(ScheduleRequestDto requestDto)

• 기능: ScheduleRequestDto 객체의 데이터를 사용해 현재 Schedule 객체를 업데이트한다.
• 설명: 스케줄의 내용을 수정할 때 사용되는 메서드로, 기존 객체의 필드 값을 새로운 값으로 대체한다.

주요 역할 요약

• 데이터 캡슐화: 이 클래스는 스케줄과 관련된 데이터를 캡슐화하여 객체 지향적인 방식으로 관리한다.
• DTO 변환: 이 클래스는 DTO에서 받은 데이터를 기반으로 엔티티 객체를 생성하거나 업데이트하는 메서드를 제공한다.
• Lombok 어노테이션 활용: @Getter, @Setter, @NoArgsConstructor 등을 통해 코드의 양을 줄이고 가독성을 높인다.

---

package com.sparta.schedule.entity

Teacher.class

담당자(Teacher)정보를 관리하는 엔티티 클래스로, 일정 관리 애플리케이션에서 담당자의 데이터(아이디, 이메일, 이름, 등록 날짜)를 다루는 역할을 한다.

 

package com.sparta.schedule.entity;

import lombok.Getter;
import lombok.Setter;
import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.data.annotation.Id;

import java.time.LocalDateTime;

@Setter
@Getter
public class Teacher {
    private int id;
    private String name;
    private String email;
    private LocalDateTime createdDate;
    private LocalDateTime updatedDate;
}

필드

private int id;

• 기능: 담당자의 고유 ID를 저장한다.
• 설명: 데이터베이스에서 자동 생성되거나 수동으로 할당되는 고유 식별자이다. 이 필드는 담당자(Teacher) 레코드를 유일하게 식별할 수 있게 한다.

private String name;

• 기능: 담당자의 이름을 저장한다.
• 설명: 담당자의 실제 이름을 저장하며, 이를 통해 담당자를 식별하거나 표시할 수 있다.

private String email;

• 기능: 담당자의 이메일 주소를 저장한다.
• 설명: 담당자의 연락처 정보를 저장하며, 알림이나 기타 이메일 관련 기능에서 사용될 수 있다.

private LocalDateTime createdDate;

• 기능: 담당자가 생성된 날짜와 시간을 저장한다.
• 설명: 담당자 정보가 처음 데이터베이스에 추가된 시점을 기록한다.

private LocalDateTime updatedDate;

• 기능: 담당자 정보가 마지막으로 수정된 날짜와 시간을 저장한다.
• 설명: 담당자 정보가 마지막으로 변경된 시점을 기록하며, 데이터를 최신 상태로 유지하는 데 도움을 준다.

어노테이션

@Getter, @Setter (from Lombok)

• 기능: Lombok 라이브러리를 사용하여 각 필드에 대해 getter와 setter 메서드를 자동으로 생성한다.
• 설명: 이 어노테이션을 사용하면 수동으로 getter와 setter 메서드를 작성할 필요가 없으며, 코드의 양이 줄어들고 가독성이 높아진다.

@Id (Spring Data Annotation)

• 기능: id 필드를 엔티티의 고유 식별자로 지정한다.
• 설명: 이 어노테이션은 해당 필드가 데이터베이스에서 엔티티를 식별하는 기본 키임을 나타낸다. Spring Data JPA에서는 @Id 어노테이션을 통해 엔티티의 식별자를 명시한다.

@EntityScan (Spring Boot Annotation)

• 기능: 애플리케이션이 특정 패키지에서 엔티티 클래스를 스캔하도록 설정한다.
• 설명: 이 어노테이션은 Spring Boot 애플리케이션에서 엔티티 클래스를 자동으로 감지하고 관리할 수 있도록 돕는다. 주로 Spring Data JPA와 함께 사용된다.

주요 역할 요약

• 데이터 캡슐화: 이 클래스는 담당자(Teacher)와 관련된 데이터를 캡슐화하여 객체 지향적인 방식으로 관리한다.
• Lombok을 통한 간결성: Lombok의 @Getter와 @Setter 어노테이션을 사용해 필드 접근 메서드를 자동으로 생성하여 코드를 간결하게 유지한다.
• 식별자 관리: id 필드를 통해 각 담당자를 고유하게 식별할 수 있다.

---

package com.sparts.schedule.management

TeacherRepository.class

Teacher 엔티티와 관련된 데이터베이스 작업을 수행하는 리포지토리 클래스다. 이 클래스는 Spring의 JdbcTemplate을 사용하여 데이터베이스와 상호작용하며, 주로 Teacher 정보를 조회, 저장, 삭제하는 기능을 제공한다.

package com.sparta.schedule.management;

import com.sparta.schedule.entity.Teacher;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Repository;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.time.LocalDateTime;
import java.util.*;

@Repository
public class TeacherRepository {

    private final JdbcTemplate jdbcTemplate;

    public TeacherRepository(JdbcTemplate jdbcTemplate){
        this.jdbcTemplate = jdbcTemplate;
    }

    public Optional<Teacher> findById(int id){
        String sql = "SELECT*FROM teacher WHERE id =?";
        try{
            Teacher teacher = jdbcTemplate.queryForObject(sql, new TeacherRowMapper(), id);
            return Optional.of(teacher);
        }catch (Exception e){
            return Optional.empty();
        }
    }

    public Teacher save(Teacher teacher){
        String sql = "INSERT INTO teacher (name, email, createdDate, updatedDate) VALUES (?, ?, ?, ?)";
        jdbcTemplate.update(sql, teacher.getName(), teacher.getEmail(), teacher.getCreatedDate(), teacher.getUpdatedDate());
        return teacher;
    }

    public boolean existsById(Long id) {
        return false;
    }

    public void deleteById(Long id) {
    }

    private static class TeacherRowMapper implements RowMapper<Teacher>{
        @Override
        public Teacher mapRow(ResultSet rs, int rowNum) throws SQLException {
            Teacher teacher = new Teacher();
            teacher.setId(rs.getInt("id"));
            teacher.setName(rs.getString("name"));
            teacher.setEmail(rs.getString("email"));
            teacher.setCreatedDate(rs.getObject("createdDate", LocalDateTime.class));
            teacher.setUpdatedDate(rs.getObject("updatedDate", LocalDateTime.class));

            return teacher;
        }
    }
}

 

클래스 구성 요소 및 역할

필드

private final JdbcTemplate jdbcTemplate;

• 기능: 데이터베이스와 상호작용하는데 사용된다.
• 설명: Spring에서 제공하는 JdbcTemplate은 SQL 쿼리를 실행하고 결과를 매핑하는 데 도움을 주는 클래스다. 이 클래스를 통해 데이터베이스와의 직접적인 상호작용이 이루어진다.

생성자

public TeacherRepository(JdbcTemplate jdbcTemplate)

• 기능: TeacherRepository 클래스의 인스턴스를 생성한다.
• 설명: JdbcTemplate 객체를 주입받아 jdbcTemplate 필드를 초기화한다. 이를 통해 이후의 메서드에서 데이터베이스 작업을 수행할 수 있게 된다.

메서드

public Optional<Teacher> findById(int id)

• 기능: 주어진 ID로 Teacher를 조회한다.
• 설명: SQL 쿼리 "SELECT * FROM teacher WHERE id = ?"를 실행하여 해당 ID를 가진 Teacher 엔티티를 데이터베이스에서 검색한다. 결과가 있으면 Optional.of(teacher)로 반환하고, 없거나 예외가 발생하면 Optional.empty()를 반환한다.
• 실행 과정: jdbcTemplate.queryForObject를 사용하여 쿼리를 실행하고, 결과를 TeacherRowMapper를 통해 Teacher 객체로 매핑한다.

public Teacher save(Teacher teacher)

• 기능: 새로운 Teacher를 데이터베이스에 저장한다.
• 설명: SQL 쿼리 "INSERT INTO teacher (name, email, createdDate, updatedDate) VALUES (?, ?, ?, ?)"를 실행하여 Teacher 객체의 필드를 데이터베이스에 저장한다. 저장된 Teacher 객체를 그대로 반환한다.
• 실행 과정: jdbcTemplate.update를 사용하여 INSERT 쿼리를 실행한다.

public boolean existsById(Long id)

• 기능: 주어진 ID가 데이터베이스에 존재하는지 확인한다.
• 설명: 현재 이 메서드는 항상 false를 반환하지만, 실제 구현에서는 데이터베이스에 해당 ID가 존재하는지 확인하는 로직이 추가되어야 한다.

public void deleteById(Long id)

• 기능: 주어진 ID의 Teacher를 데이터베이스에서 삭제한다.
• 설명: 이 메서드는 현재 구현이 되어 있지 않으며, 실제 삭제 로직이 추가되어야 한다.

내부 클래스

private static class TeacherRowMapper implements RowMapper<Teacher>

• 기능: ResultSet에서 Teacher 객체를 매핑한다.
• 설명: RowMapper 인터페이스를 구현하여, SQL 쿼리의 결과를 Teacher 객체로 변환하는 역할을 한다. 이 클래스는 mapRow 메서드를 통해 ResultSet의 각 행을 Teacher 객체로 변환한다.
• 실행 과정: 쿼리 실행 후 ResultSet에서 데이터를 꺼내어 Teacher 객체의 각 필드에 값을 설정한다.

주요 역할 요약

• 데이터베이스 상호작용: 이 리포지토리는 데이터베이스와의 상호작용을 추상화하여 Teacher 엔티티와 관련된 데이터를 쉽게 처리할 수 있게 한다.
• SQL 쿼리 처리: JdbcTemplate을 사용하여 SQL 쿼리를 실행하고, 결과를 객체로 매핑하여 반환하는 기능을 수행한다.
• 데이터베이스 예외 처리: 데이터베이스에서 조회나 삽입 시 발생할 수 있는 예외를 처리하여 안정적인 데이터베이스 연동을 지원한다.

---

package com.sparta.schedule

ScheduleApplication.class

Spring Boot 애플리케이션의 진입점(Entry Point) 역할을 하는 기본 클래스다. 이 클래스는 프로젝트가 시작될 때 가장 먼저 실행되며, Spring Boot 애플리케이션의 설정 및 구동을 담당한다.

package com.sparta.schedule;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ScheduleApplication {

    public static void main(String[] args) {
        SpringApplication.run(ScheduleApplication.class, args);
    }

}

 

클래스 구성 요소 및 역할

어노테이션

@SpringBootApplication

기능: 이 어노테이션은 여러 다른 중요한 어노테이션들을 포함하고 있어, Spring Boot 애플리케이션이 자동 설정(Autoconfiguration), 컴포넌트 스캔(Component Scan), 그리고 Spring의 부트스트랩 클래스 역할을 할 수 있도록 해준다.

설명:

• @SpringBootConfiguration: Spring 설정 클래스로 현재 클래스를 사용한다는 의미다.
• @EnableAutoConfiguration: Spring Boot가 클래스패스에 있는 라이브러리들을 기반으로 자동으로 설정을 구성한다.
• @ComponentScan: 이 어노테이션이 붙은 클래스가 있는 패키지 및 그 하위 패키지에 있는 모든 스프링 컴포넌트를 스캔하고, 스프링 빈으로 등록한다.

메서드

public static void main(String[] args)

기능: 애플리케이션을 시작하는 메인 메서드다. Java 애플리케이션의 진입점으로 작동한다.

설명: SpringApplication.run(ScheduleApplication.class, args);

• 이 메서드는 Spring Boot 애플리케이션을 실행하는 역할을 한다. 여기서 ScheduleApplication.class는 애플리케이션의 주요 설정 클래스(Main Configuration Class)를 가리킨다.
• 이 메서드를 통해 Spring 컨테이너가 초기화되고, 내장 서버(예: Tomcat)가 시작되며, 웹 애플리케이션이 실행된다.

주요 역할 요약

• 애플리케이션 시작점: 이 클래스는 Spring Boot 애플리케이션이 시작되는 지점으로, main 메서드를 통해 JVM이 실행하게 된다.
• 자동 설정 및 컴포넌트 스캔: @SpringBootApplication 어노테이션을 통해 Spring Boot의 자동 설정과 컴포넌트 스캔 기능을 활성화하여, 프로젝트 내의 스프링 컴포넌트들을 자동으로 감지하고 설정하게 된다.
• 서버 실행: 내장된 서블릿 컨테이너(Tomcat 등)를 실행하여, 웹 애플리케이션을 서빙할 수 있는 환경을 제공한다.