🐷 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 void checkAuthentication(User userDetails, AuthenticationToken token) {
+		if (ObjectUtils.isEmpty(userDetails)) {
+			throw new AuthenticationException();
+		}
+
+		if (!userDetails.checkPassword(token.getCredentials())) {
+			throw new AuthenticationException();
+		}
+	}
+
+	public Authentication authenticate(AuthenticationToken authenticationToken) {
+		final String principal = authenticationToken.getPrincipal();
+		final User userDetails = userDetailsService.loadUserByUsername(principal);
+		checkAuthentication(userDetails, authenticationToken);
+
+		return new Authentication(userDetails);
+	}
+}

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/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, source, target);
+        favoriteRepository.save(favorite);
+
+        return FavoriteResponse.of(favorite);
+    }
+
+    public List<FavoriteResponse> findFavoritesOfMine(LoginMember loginMember) {
+        Member member = memberRepository.findById(loginMember.getId()).orElseThrow(RuntimeException::new);
+
+        return member.getFavorites().stream()
+                .map(FavoriteResponse::of)
+                .collect(Collectors.toList());
+    }
+
+    public void deleteFavorite(LoginMember loginMember, Long favoriteId) {
+        Member member = memberRepository.findById(loginMember.getId()).orElseThrow(RuntimeException::new);
+        Favorite favorite = favoriteRepository.findById(favoriteId).orElseThrow(RuntimeException::new);
+
+        member.removeFavorite(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,49 @@
+package nextstep.member.domain;
+
+import nextstep.subway.domain.Station;
+
+import javax.persistence.*;
+
+@Entity
+public class Favorite {
+
+	@Id
+	@GeneratedValue(strategy = GenerationType.IDENTITY)
+	private Long id;
+
+	@ManyToOne(cascade = CascadeType.PERSIST)
+	@JoinColumn(name = "member_id")
+	private Member 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(Member member, Station source, Station target) {
+		this.member = member;
+		this.source = source;
+		this.target = target;
+	}
+
+	public Long getId() {
+		return id;
+	}
+
+	public Member getMember() {
+		return member;
+	}
+
+	public Station getSource() {
+		return source;
+	}
+
+	public Station getTarget() {
+		return target;
+	}
+}

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

@@ -0,0 +1,7 @@
+package nextstep.member.domain;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface FavoriteRepository extends JpaRepository<Favorite, Long> {
+
+}

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

@@ -0,0 +1,27 @@
+package nextstep.member.domain;
+
+import javax.persistence.CascadeType;
+import javax.persistence.Embeddable;
+import javax.persistence.OneToMany;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+@Embeddable
+public class Favorites {
+
+	@OneToMany(mappedBy = "member", cascade = {CascadeType.PERSIST, CascadeType.MERGE}, orphanRemoval = true)
+	private List<Favorite> favorites = new ArrayList<>();
+
+	public void add(Favorite favorite) {
+		this.favorites.add(favorite);
+	}
+
+	public void remove(Favorite favorite) {
+		this.favorites.remove(favorite);
+	}
+
+	public List<Favorite> getFavorites() {
+		return Collections.unmodifiableList(favorites);
+	}
+}