🚀 3단계 - 즐겨찾기 기능 구현

build.gradle

@@ -34,6 +34,9 @@ dependencies {
     implementation 'org.projectlombok:lombok:1.18.24'
     annotationProcessor 'org.projectlombok:lombok:1.18.24'
 
+    // validation
+    implementation 'org.springframework.boot:spring-boot-starter-validation:2.7.3'
+
     runtimeOnly 'com.h2database:h2'
 }
 

src/main/java/nextstep/auth/config/AuthConfig.java

@@ -1,22 +1,22 @@
 package nextstep.auth.config;
 
+import lombok.RequiredArgsConstructor;
 import nextstep.auth.principal.AuthenticationPrincipalArgumentResolver;
 import nextstep.auth.token.JwtTokenProvider;
+import nextstep.auth.validation.AuthorizationValidatorGroup;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
 
 import java.util.List;
 
 @Configuration
+@RequiredArgsConstructor
 public class AuthConfig implements WebMvcConfigurer {
-    private JwtTokenProvider jwtTokenProvider;
-
-    public AuthConfig(JwtTokenProvider jwtTokenProvider) {
-        this.jwtTokenProvider = jwtTokenProvider;
-    }
+    private final JwtTokenProvider jwtTokenProvider;
+    private final AuthorizationValidatorGroup authorizationValidatorGroup;
 
     @Override
     public void addArgumentResolvers(List argumentResolvers) {
-        argumentResolvers.add(new AuthenticationPrincipalArgumentResolver(jwtTokenProvider));
+        argumentResolvers.add(new AuthenticationPrincipalArgumentResolver(jwtTokenProvider, authorizationValidatorGroup));
     }
 }

src/main/java/nextstep/auth/principal/AuthenticationPrincipalArgumentResolver.java

@@ -1,19 +1,18 @@
 package nextstep.auth.principal;
 
-import nextstep.auth.exception.AuthenticationException;
+import lombok.RequiredArgsConstructor;
 import nextstep.auth.token.JwtTokenProvider;
+import nextstep.auth.validation.AuthorizationValidatorGroup;
 import org.springframework.core.MethodParameter;
 import org.springframework.web.bind.support.WebDataBinderFactory;
 import org.springframework.web.context.request.NativeWebRequest;
 import org.springframework.web.method.support.HandlerMethodArgumentResolver;
 import org.springframework.web.method.support.ModelAndViewContainer;
 
+@RequiredArgsConstructor
 public class AuthenticationPrincipalArgumentResolver implements HandlerMethodArgumentResolver {
-    private JwtTokenProvider jwtTokenProvider;
-
-    public AuthenticationPrincipalArgumentResolver(JwtTokenProvider jwtTokenProvider) {
-        this.jwtTokenProvider = jwtTokenProvider;
-    }
+    private final JwtTokenProvider jwtTokenProvider;
+    private final AuthorizationValidatorGroup authorizationValidatorGroup;
 
     @Override
     public boolean supportsParameter(MethodParameter parameter) {
@@ -23,15 +22,9 @@ public boolean supportsParameter(MethodParameter parameter) {
     @Override
     public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
         String authorization = webRequest.getHeader("Authorization");
-        if (!"bearer".equalsIgnoreCase(authorization.split(" ")[0])) {
-            throw new AuthenticationException();
-        }
-        String token = authorization.split(" ")[1];
-
-        if (!jwtTokenProvider.validateToken(token)) {
-            throw new AuthenticationException();
-        }
+        authorizationValidatorGroup.execute(authorization);
 
+        String token = authorization.split(" ")[1];
         String username = jwtTokenProvider.getPrincipal(token);
         String role = jwtTokenProvider.getRoles(token);
 

src/main/java/nextstep/auth/validation/AuthorizationBearerStringValidator.java

@@ -0,0 +1,17 @@
+package nextstep.auth.validation;
+
+import nextstep.auth.exception.AuthenticationException;
+import org.springframework.stereotype.Component;
+
+@Component
+public class AuthorizationBearerStringValidator extends AuthorizationValidator {
+
+    @Override
+    protected void validate(String authorization) {
+        String authPrefix = authorization.split(" ")[0];
+
+        if (!"bearer".equalsIgnoreCase(authPrefix)) {
+            throw new AuthenticationException();
+        }
+    }
+}

src/main/java/nextstep/auth/validation/AuthorizationNullValidator.java

@@ -0,0 +1,15 @@
+package nextstep.auth.validation;
+
+import nextstep.auth.exception.AuthenticationException;
+import org.springframework.stereotype.Component;
+
+@Component
+public class AuthorizationNullValidator extends AuthorizationValidator {
+
+    @Override
+    protected void validate(String authorization) {
+        if (authorization == null) {
+            throw new AuthenticationException();
+        }
+    }
+}

src/main/java/nextstep/auth/validation/AuthorizationTokenValidator.java

@@ -0,0 +1,22 @@
+package nextstep.auth.validation;
+
+import lombok.RequiredArgsConstructor;
+import nextstep.auth.exception.AuthenticationException;
+import nextstep.auth.token.JwtTokenProvider;
+import org.springframework.stereotype.Component;
+
+@RequiredArgsConstructor
+@Component
+public class AuthorizationTokenValidator extends AuthorizationValidator {
+
+    private final JwtTokenProvider jwtTokenProvider;
+
+    @Override
+    protected void validate(String authorization) {
+        String token = authorization.split(" ")[1];
+
+        if (!jwtTokenProvider.validateToken(token)) {
+            throw new AuthenticationException();
+        }
+    }
+}

src/main/java/nextstep/auth/validation/AuthorizationValidator.java

@@ -0,0 +1,20 @@
+package nextstep.auth.validation;
+
+public abstract class AuthorizationValidator {
+
+    private AuthorizationValidator nextValidator = null;
+
+    public AuthorizationValidator setNext(AuthorizationValidator validator) {
+        this.nextValidator = validator;
+        return validator;
+    }
+
+    protected abstract void validate(String authorization);
+
+    public void execute(String authorization) {
+        validate(authorization);
+
+        if (nextValidator != null)
+            nextValidator.execute(authorization);
+    }
+}

src/main/java/nextstep/auth/validation/AuthorizationValidatorGroup.java

@@ -0,0 +1,24 @@
+package nextstep.auth.validation;
+
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+
+@Component
+@RequiredArgsConstructor
+public class AuthorizationValidatorGroup {
+
+    private final AuthorizationNullValidator authorizationNullValidator;
+    private final AuthorizationBearerStringValidator authorizationBearerStringValidator;
+    private final AuthorizationTokenValidator authorizationTokenValidator;
+
+    private void chaining() {
+        authorizationNullValidator
+            .setNext(authorizationBearerStringValidator)
+            .setNext(authorizationTokenValidator);
+    }
+
+    public void execute(String authorization) {
+        chaining();
+        authorizationNullValidator.execute(authorization);
+    }
+}

src/main/java/nextstep/member/domain/Member.java

@@ -31,6 +31,8 @@ public Member(String email, String password, Integer age, String role) {
         this.role = role;
     }
 
+
+
     public Long getId() {
         return id;
     }

src/main/java/nextstep/subway/applicaion/FavoriteService.java

@@ -0,0 +1,44 @@
+package nextstep.subway.applicaion;
+
+import java.util.List;
+import lombok.RequiredArgsConstructor;
+import nextstep.subway.applicaion.dto.FavoriteRequest;
+import nextstep.subway.domain.Favorite;
+import nextstep.subway.domain.FavoriteRepository;
+import nextstep.subway.domain.Station;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.transaction.support.TransactionSynchronizationManager;
+
+@Service
+@RequiredArgsConstructor
+@Transactional(readOnly = true)
+public class FavoriteService {
+
+    private final FavoriteRepository favoriteRepository;
+    private final StationService stationService;
+    private final PathService pathService;
+
+
+    public List<Favorite> getFavorites(Long memberId) {
+        return favoriteRepository.findAllByMemberId(memberId);
+    }
+
+    public Favorite getFavorite(Long id) {
+        return favoriteRepository.findById(id)
+            .orElseThrow(IllegalArgumentException::new);
+    }
+
+    @Transactional
+    public Favorite createFavorite(Long memberId, FavoriteRequest request) {
+        pathService.findPath(request.getSource(), request.getTarget());
+
+        Station source = stationService.findById(request.getSource());
+        Station target = stationService.findById(request.getTarget());
+        return favoriteRepository.save(new Favorite(source, target, memberId));
+    }
+
+    public void deleteFavorite(Long id) {
+        favoriteRepository.deleteById(id);
+    }
+}

src/main/java/nextstep/subway/applicaion/StationService.java

@@ -9,6 +9,7 @@
 
 import java.util.List;
 import java.util.stream.Collectors;
+import org.springframework.transaction.support.TransactionSynchronizationManager;
 
 @Service
 @Transactional(readOnly = true)

src/main/java/nextstep/subway/applicaion/dto/FavoriteRequest.java

@@ -0,0 +1,17 @@
+package nextstep.subway.applicaion.dto;
+
+import javax.validation.constraints.NotNull;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@AllArgsConstructor
+@Getter
+public class FavoriteRequest {
+
+    @NotNull(message = "출발역은 반드시 입력해야합니다.")
+    private Long source;
+
+    @NotNull(message = "도착역은 반드시 입력해야합니다.")
+    private Long target;
+
+}

src/main/java/nextstep/subway/applicaion/dto/FavoriteResponse.java

@@ -0,0 +1,27 @@
+package nextstep.subway.applicaion.dto;
+
+import java.util.List;
+import java.util.stream.Collectors;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import nextstep.subway.domain.Favorite;
+
+@Getter
+@AllArgsConstructor
+public class FavoriteResponse {
+    private Long id;
+    private StationResponse source;
+    private StationResponse target;
+
+    public static FavoriteResponse of(Favorite favorite) {
+        return new FavoriteResponse(favorite.getId(),
+            StationResponse.of(favorite.getSource()),
+            StationResponse.of(favorite.getTarget()));
+    }
+
+    public static List<FavoriteResponse> listOf(List<Favorite> favorites) {
+        return favorites.stream()
+            .map(FavoriteResponse::of)
+            .collect(Collectors.toList());
+    }
+}

src/main/java/nextstep/subway/domain/Favorite.java

@@ -0,0 +1,40 @@
+package nextstep.subway.domain;
+
+import javax.persistence.CascadeType;
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+import javax.persistence.JoinColumn;
+import javax.persistence.OneToOne;
+import lombok.Getter;
+
+@Entity
+@Getter
+public class Favorite {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @OneToOne(cascade = CascadeType.PERSIST)
+    @JoinColumn(name = "source_id")
+    private Station source;
+
+    @OneToOne(cascade = CascadeType.PERSIST)
+    @JoinColumn(name = "target_id")
+    private Station target;
+
+    @JoinColumn(name = "member_id")
+    private Long memberId;
+
+    protected Favorite() {
+
+    }
+
+    public Favorite(Station source, Station target, Long memberId) {
+        this.source = source;
+        this.target = target;
+        this.memberId = memberId;
+    }
+}

src/main/java/nextstep/subway/domain/FavoriteRepository.java

@@ -0,0 +1,10 @@
+package nextstep.subway.domain;
+
+import java.util.List;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface FavoriteRepository extends JpaRepository<Favorite, Long> {
+
+    List<Favorite> findAllByMemberId(Long id);
+
+}

src/main/java/nextstep/subway/domain/Line.java

@@ -14,7 +14,7 @@ public class Line {
     @Embedded
     private Sections sections = new Sections();
 
-    public Line() {
+    protected Line() {
     }
 
     public Line(String name, String color) {

src/main/java/nextstep/subway/domain/Section.java

@@ -24,7 +24,7 @@ public class Section extends DefaultWeightedEdge {
 
     private int distance;
 
-    public Section() {
+    protected Section() {
 
     }
 

src/main/java/nextstep/subway/domain/Sections.java

@@ -14,7 +14,7 @@ public class Sections {
     @OneToMany(mappedBy = "line", cascade = {CascadeType.PERSIST, CascadeType.MERGE}, orphanRemoval = true)
     private List<Section> sections = new ArrayList<>();
 
-    public Sections() {
+    protected Sections() {
     }
 
     public Sections(List<Section> sections) {

src/main/java/nextstep/subway/domain/Station.java

@@ -12,7 +12,7 @@ public class Station {
     private Long id;
     private String name;
 
-    public Station() {
+    protected Station() {
     }
 
     public Station(String name) {

src/main/java/nextstep/subway/domain/SubwayMap.java

@@ -1,5 +1,6 @@
 package nextstep.subway.domain;
 
+import java.util.Optional;
 import org.jgrapht.GraphPath;
 import org.jgrapht.alg.shortestpath.DijkstraShortestPath;
 import org.jgrapht.graph.SimpleDirectedWeightedGraph;
@@ -45,7 +46,8 @@ public Path findPath(Station source, Station target) {
 
         // 다익스트라 최단 경로 찾기
         DijkstraShortestPath<Station, SectionEdge> dijkstraShortestPath = new DijkstraShortestPath<>(graph);
-        GraphPath<Station, SectionEdge> result = dijkstraShortestPath.getPath(source, target);
+        GraphPath<Station, SectionEdge> result = Optional.ofNullable(dijkstraShortestPath.getPath(source, target))
+            .orElseThrow(IllegalArgumentException::new);
 
         List<Section> sections = result.getEdgeList().stream()
                 .map(it -> it.getSection())