[Spring JDBC] 황승준 미션 제출합니다.

.gitignore

@@ -35,3 +35,5 @@ out/
 
 ### VS Code ###
 .vscode/
+
+/log

README.md

@@ -0,0 +1,25 @@
+# 간단 스프링 어플리케이션
+
+## JDBC
+### 5단계
+- [x] 데이터베이스 설정
+- [x] 데이터베이스 연결
+
+### 6단계
+- [x] 데이터 조회하기
+
+### 7단계
+- [x] 데이터 추가하기
+- [x] 데이터 삭제하기
+- [x] 데이터 삭제 잘못된 요청시 예외처리
+
+### 7 단계 고민
+- Entity id에 setter 함수를 두면 위험성이 크다는 생각이 들어 새로운 객체를 생성해서 return 해야 되겠다 라는 생각을 가지게 되었습니다
+   과연 spring은 새로 db에 생성된 entity에 관해 어떻게 id를 주입하나 궁금함군요 🤔
+
+### 질문사항
+- 어플리케이션 실행중 어디서든 exception이 발생하면 ControllerAdvice를 exception과 관련된 응답을 전달해줍니다. 
+  대부분의 exception을 최종적으로 ControllerAdvice에서 처리를 하다 보니 Service, Repository, Entity 등등 아무데서나 exception을
+  던질 수 있겠다라는 착각을 하게 되는것 같습니다. 혹시 exception은 보통 어느 layer에서 처리를 하는지 궁금하며 예외처리는 어떻게 관리
+  되는지 궁금합니다!
+

build.gradle

@@ -13,11 +13,19 @@ repositories {
 }
 
 dependencies {
+    implementation 'org.springframework.boot:spring-boot-starter-web'
+    implementation 'org.springframework.boot:spring-boot-starter-thymeleaf'
     implementation 'org.springframework.boot:spring-boot-starter'
+    implementation 'org.springframework.boot:spring-boot-starter-validation'
+    implementation 'org.springframework.boot:spring-boot-starter-jdbc'
+
+    runtimeOnly 'com.h2database:h2'
+
     testImplementation 'org.springframework.boot:spring-boot-starter-test'
     testImplementation 'io.rest-assured:rest-assured:5.3.1'
 }
 
+
 test {
     useJUnitPlatform()
 }

src/main/java/roomescape/api/ReservationController.java

@@ -0,0 +1,61 @@
+package roomescape.api;
+
+import jakarta.validation.Valid;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+import roomescape.api.dto.ReservationRequestDto;
+import roomescape.api.dto.ReservationResponseDto;
+import roomescape.entity.Reservation;
+import roomescape.service.ReservationService;
+
+import java.util.List;
+
+@RestController
+public class ReservationController {
+
+    private final ReservationService reservationService;
+
+    public ReservationController(ReservationService reservationService) {
+        this.reservationService = reservationService;
+    }
+
+    @GetMapping("/reservations")
+    public ResponseEntity<List<ReservationResponseDto>> readReservations() {
+        return ResponseEntity
+                .ok()
+                .body(
+                        reservationService.readReservations().stream().
+                                map(ReservationResponseDto::fromEntity)
+                                .toList()
+                );
+    }
+
+    @GetMapping("/reservations/{id}")
+    public ResponseEntity<ReservationResponseDto> readReservations(@PathVariable Long id) {
+        Reservation reservation = reservationService.readReservation(id);
+
+        return ResponseEntity
+                .ok()
+                .body(ReservationResponseDto.fromEntity(reservation));
+    }
+
+    @PostMapping("/reservations")
+    public ResponseEntity<ReservationResponseDto> createReservation(
+            @RequestBody @Valid ReservationRequestDto reservationDto
+    ) {
+        ReservationResponseDto response =
+                ReservationResponseDto.fromEntity(reservationService.createReservation(reservationDto.toEntity()));
+
+        return ResponseEntity
+                .status(HttpStatus.CREATED)
+                .header("Location", "/reservations/"+ response.id())
+                .body(response);
+    }
+
+    @DeleteMapping("/reservations/{id}")
+    public ResponseEntity<Void> deleteReservation(@PathVariable Long id) {
+        reservationService.deleteReservation(id);
+        return ResponseEntity.noContent().build();
+    }
+}

src/main/java/roomescape/api/StaticPageController.java

@@ -0,0 +1,18 @@
+package roomescape.api;
+
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.GetMapping;
+
+@Controller
+public class StaticPageController {
+    @GetMapping("/")
+    public String mainPage() {
+        return "home";
+    }
+
+
+    @GetMapping("/reservation")
+    public String reservationPage() {
+        return "reservation";
+    }
+}

src/main/java/roomescape/api/dto/ReservationRequestDto.java

@@ -0,0 +1,30 @@
+package roomescape.api.dto;
+
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import roomescape.entity.Person;
+import roomescape.entity.Reservation;
+import roomescape.util.CustomDateTimeFormat;
+
+import java.time.LocalDate;
+import java.time.LocalTime;
+
+public record ReservationRequestDto(
+        @NotBlank
+        @NotNull
+        String name,
+        @NotBlank
+        @NotNull
+        String date,
+        @NotBlank
+        @NotNull
+        String time
+) {
+    public Reservation toEntity() {
+        return new Reservation(
+            new Person(this.name),
+            LocalDate.parse(date, CustomDateTimeFormat.dateFormatter),
+            LocalTime.parse(time, CustomDateTimeFormat.timeFormatter)
+        );
+    }
+}

src/main/java/roomescape/api/dto/ReservationResponseDto.java

@@ -0,0 +1,23 @@
+package roomescape.api.dto;
+import roomescape.entity.Reservation;
+import roomescape.util.CustomDateTimeFormat;
+
+public record ReservationResponseDto(
+        Long id,
+        String name,
+        String date,
+        String time
+) {
+    public static ReservationResponseDto fromEntity(Reservation reservation) {
+        if (reservation == null) {
+            return null;
+        }
+
+        return new ReservationResponseDto(
+                reservation.getId(),
+                reservation.getPerson().getName(),
+                reservation.getDate().format(CustomDateTimeFormat.dateFormatter),
+                reservation.getTime().format(CustomDateTimeFormat.timeFormatter)
+        );
+    }
+}

src/main/java/roomescape/entity/Person.java

@@ -0,0 +1,13 @@
+package roomescape.entity;
+
+public class Person {
+    private String name;
+
+    public Person(String name) {
+        this.name = name;
+    }
+
+    public String getName() {
+        return name;
+    }
+}

src/main/java/roomescape/entity/Reservation.java

@@ -0,0 +1,54 @@
+package roomescape.entity;
+
+import java.time.LocalDate;
+import java.time.LocalTime;
+import java.util.Objects;
+
+public class Reservation {
+    private Long id;
+    private Person person;
+    private LocalDate date;
+    private LocalTime time;
+
+    public Reservation(Long id, Person person, LocalDate date, LocalTime time) {
+        this.id = id;
+        this.person = person;
+        this.date = date;
+        this.time = time;
+    }
+    public Reservation(Person person, LocalDate date, LocalTime time) {
+        this.id = 0L;
+        this.person = person;
+        this.date = date;
+        this.time = time;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public Person getPerson() {
+        return person;
+    }
+
+    public LocalDate getDate() {
+        return date;
+    }
+
+    public LocalTime getTime() {
+        return time;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Reservation that = (Reservation) o;
+        return Objects.equals(id, that.id);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(id);
+    }
+}

src/main/java/roomescape/exception/BusinessException.java

@@ -0,0 +1,7 @@
+package roomescape.exception;
+
+public class BusinessException extends RuntimeException {
+    public BusinessException(String message) {
+        super(message);
+    }
+}

src/main/java/roomescape/exception/EntityNotFoundException.java

@@ -0,0 +1,7 @@
+package roomescape.exception;
+
+public class EntityNotFoundException extends BusinessException {
+    public EntityNotFoundException(String message) {
+        super(message);
+    }
+}

src/main/java/roomescape/exception/GlobalExceptionHandler.java

@@ -0,0 +1,52 @@
+package roomescape.exception;
+
+import org.slf4j.Logger;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.MethodArgumentNotValidException;
+import org.springframework.web.bind.annotation.ControllerAdvice;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.context.request.WebRequest;
+import roomescape.util.LoggerUtils;
+
+import java.util.stream.Collectors;
+
+@ControllerAdvice
+public class GlobalExceptionHandler {
+    private final Logger logger = LoggerUtils.logger(GlobalExceptionHandler.class);
+
+    @ExceptionHandler(IllegalArgumentException.class)
+    public ResponseEntity<String> handleIllegalArgumentException(IllegalArgumentException e, WebRequest request) {
+        logger.info(e.getMessage());
+        return ResponseEntity.badRequest().body(e.getMessage());
+    }
+
+    @ExceptionHandler(EntityNotFoundException.class)
+    public ResponseEntity<String> handleExceptionNotFoundException(EntityNotFoundException e) {
+        logger.info(e.getMessage());
+        return ResponseEntity.badRequest().body(e.getMessage());
+    }
+
+    @ExceptionHandler(MethodArgumentNotValidException.class)
+    public ResponseEntity<String> handleMethodArgumentNotValidException(MethodArgumentNotValidException e) {
+        String errorFields = e.getBindingResult().
+                getFieldErrors()
+                .stream()
+                .map(fieldError -> fieldError.getField() + ": " + fieldError.getDefaultMessage())
+                .collect(Collectors.joining(", "));
+
+        logger.info(errorFields);
+        return ResponseEntity.badRequest().body(errorFields);
+    }
+
+    @ExceptionHandler(BusinessException.class)
+    public ResponseEntity<String> handleBusinessException(BusinessException e) {
+        logger.warn(e.getMessage());
+        return ResponseEntity.internalServerError().body(e.getMessage());
+    }
+
+    @ExceptionHandler(Exception.class)
+    public ResponseEntity<String> handleException(Exception e) {
+        logger.error(e.getMessage());
+        return ResponseEntity.internalServerError().body(e.getMessage());
+    }
+}