🐷 step3 : 즐겨찾기 기능 구현

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

@@ -1,14 +1,13 @@
 package nextstep.auth;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
-import nextstep.auth.authentication.Authorizor;
+import nextstep.auth.authentication.Authorizer;
 import nextstep.auth.authentication.SessionAuthenticationInterceptor;
 import nextstep.auth.authentication.TokenAuthenticationInterceptor;
 import nextstep.auth.authorization.AuthenticationPrincipalArgumentResolver;
 import nextstep.auth.authorization.SessionSecurityContextPersistenceInterceptor;
 import nextstep.auth.authorization.TokenSecurityContextPersistenceInterceptor;
 import nextstep.auth.token.JwtTokenProvider;
-import nextstep.member.application.CustomUserDetailsService;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
 import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@@ -20,19 +19,19 @@ public class AuthConfig implements WebMvcConfigurer {
     private UserDetailsService userDetailsService;
     private JwtTokenProvider jwtTokenProvider;
     private ObjectMapper objectMapper;
-    private Authorizor authorizor;
+    private Authorizer authorizor;
 
-    public AuthConfig(UserDetailsService userDetailsService, JwtTokenProvider jwtTokenProvider) {
+    public AuthConfig(UserDetailsService userDetailsService, JwtTokenProvider jwtTokenProvider, ObjectMapper objectMapper) {
         this.userDetailsService = userDetailsService;
         this.jwtTokenProvider = jwtTokenProvider;
-        this.objectMapper = new ObjectMapper();
-        this.authorizor = new Authorizor();
+        this.objectMapper = objectMapper;
+        this.authorizor = new Authorizer(userDetailsService);
     }
 
     @Override
     public void addInterceptors(InterceptorRegistry registry) {
         registry.addInterceptor(new SessionAuthenticationInterceptor(userDetailsService, authorizor)).addPathPatterns("/login/session");
-        registry.addInterceptor(new TokenAuthenticationInterceptor(userDetailsService, jwtTokenProvider, objectMapper, authorizor))
+        registry.addInterceptor(new TokenAuthenticationInterceptor(jwtTokenProvider, objectMapper, authorizor))
                 .addPathPatterns("/login/token");
         registry.addInterceptor(new SessionSecurityContextPersistenceInterceptor());
         registry.addInterceptor(new TokenSecurityContextPersistenceInterceptor(jwtTokenProvider));

src/main/java/nextstep/auth/authentication/Authorizer.java

@@ -0,0 +1,33 @@
+package nextstep.auth.authentication;
+
+import nextstep.auth.User;
+import nextstep.auth.UserDetailsService;
+import nextstep.auth.context.Authentication;
+import org.springframework.util.ObjectUtils;
+
+public class Authorizer {
+
+	private UserDetailsService userDetailsService;
+
+	public Authorizer(UserDetailsService userDetailsService) {
+		this.userDetailsService = userDetailsService;
+	}
+
+	public Authentication authenticate(AuthenticationToken authenticationToken) {
+		final String principal = authenticationToken.getPrincipal();
+		final User userDetails = userDetailsService.loadUserByUsername(principal);
+		checkAuthentication(userDetails, authenticationToken);
+
+		return new Authentication(userDetails);
+	}
+
+	private void checkAuthentication(User userDetails, AuthenticationToken token) {
+		if (ObjectUtils.isEmpty(userDetails)) {
+			throw new AuthenticationException();
+		}
+
+		if (!userDetails.checkPassword(token.getCredentials())) {
+			throw new AuthenticationException();
+		}
+	}
+}

src/main/java/nextstep/auth/authentication/SessionAuthenticationInterceptor.java

@@ -1,6 +1,5 @@
 package nextstep.auth.authentication;
 
-import nextstep.auth.User;
 import nextstep.auth.UserDetailsService;
 import nextstep.auth.context.Authentication;
 import nextstep.auth.context.SecurityContext;
@@ -20,32 +19,24 @@ public class SessionAuthenticationInterceptor implements HandlerInterceptor, Aut
     public static final String PASSWORD_FIELD = "password";
 
     private UserDetailsService userDetailsService;
-    private Authorizor authorizor;
+    private Authorizer authorizor;
 
-    public SessionAuthenticationInterceptor(UserDetailsService userDetailsService, Authorizor authorizor) {
+    public SessionAuthenticationInterceptor(UserDetailsService userDetailsService, Authorizer authorizor) {
         this.userDetailsService = userDetailsService;
         this.authorizor = authorizor;
     }
 
     @Override
-    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws IOException {
+    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
         AuthenticationToken token = convert(request);
-        Authentication authentication = authenticate(token);
+        Authentication authentication = authorizor.authenticate(token);
 
         HttpSession httpSession = request.getSession();
         httpSession.setAttribute(SPRING_SECURITY_CONTEXT_KEY, new SecurityContext(authentication));
         response.setStatus(HttpServletResponse.SC_OK);
         return false;
     }
 
-    public Authentication authenticate(AuthenticationToken token) {
-        String principal = token.getPrincipal();
-        User userDetails = userDetailsService.loadUserByUsername(principal);
-        authorizor.checkAuthentication(userDetails, token);
-
-        return new Authentication(userDetails);
-    }
-
     @Override
     public AuthenticationToken convert(HttpServletRequest request) {
         Map<String, String[]> paramMap = request.getParameterMap();

src/main/java/nextstep/auth/authentication/TokenAuthenticationInterceptor.java

@@ -1,7 +1,6 @@
 package nextstep.auth.authentication;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
-import nextstep.auth.User;
 import nextstep.auth.UserDetailsService;
 import nextstep.auth.context.Authentication;
 import nextstep.auth.token.JwtTokenProvider;
@@ -16,16 +15,13 @@
 
 public class TokenAuthenticationInterceptor implements HandlerInterceptor, AuthenticationConverter {
 
-    private UserDetailsService userDetailsService;
     private JwtTokenProvider jwtTokenProvider;
     private ObjectMapper objectMapper;
-    private Authorizor authorizor;
+    private Authorizer authorizor;
 
-    public TokenAuthenticationInterceptor(UserDetailsService userDetailsService,
-                                          JwtTokenProvider jwtTokenProvider,
+    public TokenAuthenticationInterceptor(JwtTokenProvider jwtTokenProvider,
                                           ObjectMapper objectMapper,
-                                          Authorizor authorizor) {
-        this.userDetailsService = userDetailsService;
+                                          Authorizer authorizor) {
         this.jwtTokenProvider = jwtTokenProvider;
         this.objectMapper = objectMapper;
         this.authorizor = authorizor;
@@ -34,7 +30,7 @@ public TokenAuthenticationInterceptor(UserDetailsService userDetailsService,
     @Override
     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws IOException {
         AuthenticationToken authenticationToken = convert(request);
-        Authentication authentication = authenticate(authenticationToken);
+        Authentication authentication = authorizor.authenticate(authenticationToken);
 
         final String payload = objectMapper.writeValueAsString(authentication.getPrincipal());
         final String token = jwtTokenProvider.createToken(payload);
@@ -49,14 +45,6 @@ public boolean preHandle(HttpServletRequest request, HttpServletResponse respons
         return false;
     }
 
-    public Authentication authenticate(AuthenticationToken authenticationToken) {
-        final String principal = authenticationToken.getPrincipal();
-        final User userDetails = userDetailsService.loadUserByUsername(principal);
-        authorizor.checkAuthentication(userDetails, authenticationToken);
-
-        return new Authentication(userDetails);
-    }
-
     @Override
     public AuthenticationToken convert(HttpServletRequest request) throws IOException {
         TokenRequest tokenRequest = objectMapper.readValue(request.getInputStream(), TokenRequest.class);

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

@@ -1,8 +1,10 @@
 package nextstep.auth.authorization;
 
+import nextstep.auth.authentication.AuthenticationException;
 import nextstep.auth.context.Authentication;
 import nextstep.auth.context.SecurityContextHolder;
 import org.springframework.core.MethodParameter;
+import org.springframework.util.ObjectUtils;
 import org.springframework.web.bind.support.WebDataBinderFactory;
 import org.springframework.web.context.request.NativeWebRequest;
 import org.springframework.web.method.support.HandlerMethodArgumentResolver;
@@ -20,13 +22,20 @@ public boolean supportsParameter(MethodParameter parameter) {
     @Override
     public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) {
         Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
+        authenticationValidate(authentication);
         if (authentication.getPrincipal() instanceof Map) {
             return extractPrincipal(parameter, authentication);
         }
 
         return authentication.getPrincipal();
     }
 
+    private void authenticationValidate(Authentication authentication) {
+        if (ObjectUtils.isEmpty(authentication)) {
+            throw new AuthenticationException();
+        }
+    }
+
     private Object extractPrincipal(MethodParameter parameter, Authentication authentication) {
         try {
             Map<String, String> principal = (Map) authentication.getPrincipal();

src/main/java/nextstep/member/application/MemberService.java

@@ -1,18 +1,30 @@
 package nextstep.member.application;
 
+import nextstep.member.application.dto.FavoriteRequest;
+import nextstep.member.application.dto.FavoriteResponse;
 import nextstep.member.application.dto.MemberRequest;
 import nextstep.member.application.dto.MemberResponse;
-import nextstep.member.domain.LoginMember;
-import nextstep.member.domain.Member;
-import nextstep.member.domain.MemberRepository;
+import nextstep.member.domain.*;
+import nextstep.subway.applicaion.StationService;
+import nextstep.subway.domain.Station;
 import org.springframework.stereotype.Service;
 
+import java.util.List;
+import java.util.stream.Collectors;
+
 @Service
 public class MemberService {
+
     private MemberRepository memberRepository;
+    private FavoriteRepository favoriteRepository;
+    private StationService stationService;
 
-    public MemberService(MemberRepository memberRepository) {
+    public MemberService(MemberRepository memberRepository,
+                         FavoriteRepository favoriteRepository,
+                         StationService stationService) {
         this.memberRepository = memberRepository;
+        this.favoriteRepository = favoriteRepository;
+        this.stationService = stationService;
     }
 
     public MemberResponse createMember(MemberRequest request) {
@@ -53,4 +65,29 @@ public void deleteMemberOfMine(LoginMember loginMember) {
         Member member = memberRepository.findByEmail(loginMember.getEmail()).orElseThrow(RuntimeException::new);
         memberRepository.delete(member);
     }
+
+    public FavoriteResponse createFavorite(LoginMember loginMember, FavoriteRequest favoriteRequest) {
+        Member member = memberRepository.findById(loginMember.getId()).orElseThrow(RuntimeException::new);
+        Station source = stationService.findById(favoriteRequest.getSource());
+        Station target = stationService.findById(favoriteRequest.getTarget());
+        Favorite favorite = new Favorite(member.getId(), source, target);
+        favoriteRepository.save(favorite);
+
+        return FavoriteResponse.of(favorite);
+    }
+
+    public List<FavoriteResponse> findFavoritesOfMine(LoginMember loginMember) {
+        Member member = memberRepository.findById(loginMember.getId()).orElseThrow(RuntimeException::new);
+        List<Favorite> favorites = favoriteRepository.findByMember(member.getId());
+
+        return favorites.stream()
+                .map(FavoriteResponse::of)
+                .collect(Collectors.toList());
+    }
+
+    public void deleteFavorite(LoginMember loginMember, Long favoriteId) {
+        Favorite favorite = favoriteRepository.findById(favoriteId).orElseThrow(RuntimeException::new);
+
+        favoriteRepository.delete(favorite);
+    }
 }

src/main/java/nextstep/member/application/dto/FavoriteRequest.java

@@ -0,0 +1,15 @@
+package nextstep.member.application.dto;
+
+public class FavoriteRequest {
+
+	private Long source;
+	private Long target;
+
+	public Long getSource() {
+		return source;
+	}
+
+	public Long getTarget() {
+		return target;
+	}
+}

src/main/java/nextstep/member/application/dto/FavoriteResponse.java

@@ -0,0 +1,37 @@
+package nextstep.member.application.dto;
+
+import nextstep.member.domain.Favorite;
+import nextstep.subway.applicaion.dto.StationResponse;
+
+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 FavoriteResponse(Long id, StationResponse source, StationResponse target) {
+		this.id = id;
+		this.source = source;
+		this.target = target;
+	}
+
+	public Long getId() {
+		return id;
+	}
+
+	public StationResponse getSource() {
+		return source;
+	}
+
+	public StationResponse getTarget() {
+		return target;
+	}
+}

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

@@ -0,0 +1,48 @@
+package nextstep.member.domain;
+
+import nextstep.subway.domain.Station;
+
+import javax.persistence.*;
+
+@Entity
+public class Favorite {
+
+	@Id
+	@GeneratedValue(strategy = GenerationType.IDENTITY)
+	private Long id;
+
+	@JoinColumn(name = "member_id")
+	private Long member;
+
+	@ManyToOne(cascade = CascadeType.PERSIST)
+	@JoinColumn(name = "up_station_id")
+	private Station source;
+
+	@ManyToOne(cascade = CascadeType.PERSIST)
+	@JoinColumn(name = "down_station_id")
+	private Station target;
+
+	protected Favorite() {}
+
+	public Favorite(Long memberId, Station source, Station target) {
+		this.member = memberId;
+		this.source = source;
+		this.target = target;
+	}
+
+	public Long getId() {
+		return id;
+	}
+
+	public Long getMember() {
+		return member;
+	}
+
+	public Station getSource() {
+		return source;
+	}
+
+	public Station getTarget() {
+		return target;
+	}
+}