📚 atdd-subway-path 미션 정리

@Configuration
public class AuthenticationPrincipalConfig implements WebMvcConfigurer {
    private final AuthService authService;

    public AuthenticationPrincipalConfig(AuthService authService) {
        this.authService = authService;
    }

    @Override
    public void addArgumentResolvers(List argumentResolvers) {
        argumentResolvers.add(createAuthenticationPrincipalArgumentResolver());
    }

    @Bean
    public AuthenticationPrincipalArgumentResolver createAuthenticationPrincipalArgumentResolver() {
        return new AuthenticationPrincipalArgumentResolver(authService);
    }
}

public class AuthenticationPrincipalArgumentResolver implements HandlerMethodArgumentResolver {
    private final AuthService authService;

    public AuthenticationPrincipalArgumentResolver(AuthService authService) {
        this.authService = authService;
    }

    // resolveArgument 메서드가 동작하는 조건을 정의하는 메서드
    @Override
    public boolean supportsParameter(MethodParameter parameter) {
        // 파라미터 중 @AuthenticationPrincipal이 붙은 경우 동작하게 설정
        return parameter.hasParameterAnnotation(AuthenticationPrincipal.class);
    }

    // supportsParameter가 true인 경우 동작
    @Override
    public Member resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) {
        String token = AuthorizationExtractor.extract((HttpServletRequest) webRequest.getNativeRequest());
        return authService.findMemberByToken(token);
    }
}

@Component
public class AuthInterceptor implements HandlerInterceptor {
    private final AuthService authService;

    public AuthInterceptor(AuthService authService) {
        this.authService = authService;
    }

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String token = AuthorizationExtractor.extract(request);
        authService.validateToken(token);
        return true;
    }
}

public class Graph {
    private final WeightedMultigraph<Station, DefaultWeightedEdge> graph = new WeightedMultigraph(DefaultWeightedEdge.class);

    public Graph(List<Section> sections) {
        initPath(sections);
    }

    private void initPath(List<Section> sections) {
        for (Section section : sections) {
            initEdge(section);
        }
    }

    private void initEdge(Section section) {
        addVertex(section.getUpStation());
        addVertex(section.getDownStation());
        graph.setEdgeWeight(graph.addEdge(section.getUpStation(), section.getDownStation()), section.getDistance());
    }

    private void addVertex(Station station) {
        if (!graph.containsVertex(station)) {
            graph.addVertex(station);
        }
    }

    public Path shortestPath(Station source, Station target) {
        DijkstraShortestPath<Station, DefaultWeightedEdge> dijkstraShortestPath = new DijkstraShortestPath<>(graph);
        return new Path(dijkstraShortestPath.getPath(source, target).getVertexList(), dijkstraShortestPath.getPathWeight(source, target));
    }
}

public class Path {
    private final List<Station> stations;
    private final double distance;

    public Path(List<Station> stations, double distance) {
        this.stations = stations;
        this.distance = distance;
    }

    public List<Station> stations() {
        return stations;
    }

    public double distance() {
        return distance;
    }
}

public PathResponse findPath(Long sourceId, Long targetId) {
        List<Line> lines = lineDao.findAll();
        Graph graph = new Graph(lines);
        Path path = graph.shortestPath(stationDao.findById(sourceId), stationDao.findById(targetId));
        return new PathResponse(StationResponse.listOf(path.stations()), (int) path.distance());
    }

@Service
public class PathService {
    private final SectionDao sectionDao;
    private final StationDao stationDao;

    public PathService(SectionDao sectionDao, StationDao stationDao) {
        this.sectionDao = sectionDao;
        this.stationDao = stationDao;
    }

    public PathResponse findPath(Long sourceId, Long targetId) {
        List<Section> sections = sectionDao.findByStationIds(Arrays.asList(sourceId, targetId));
        Graph graph = new Graph(sections);
        Path path = graph.shortestPath(new Station(sourceId), new Station(targetId));
        return new PathResponse(StationResponse.listOf(combineStationById(path)), (int) path.distance());
    }

    private List<Station> combineStationById(Path path) {
        List<Long> stationIds = path.stations()
                .stream()
                .map(Station::getId)
                .collect(Collectors.toList());
        return stationDao.findByIds(stationIds).sortedStation(stationIds);
    }
}

public TokenResponse createToken(TokenRequest tokenRequest) {
    Member member = memberDao.findByEmailAndPassword(tokenRequest.getEmail(), tokenRequest.getPassword())
            .orElseThrow(() -> new AuthorizationException("로그인 실패입니다."));
    String accessToken = jwtTokenProvider.createToken(String.valueOf(member.getId()));
    return new TokenResponse(accessToken);
}

PasswordEncoder encoder = new BCryptPasswordEncoder();
String 원문 = "qwe123";
String 암호화된_원문 = encoder.encode(원문);
String 암호화된_원문_2 = encoder.encode(원문);

encorder.matches(원문, 암호화된 원문); // true
암호화된_원문.equals(암호화된_원문2); //false

public class AuthenticationPrincipalArgumentResolver implements HandlerMethodArgumentResolver {
    private final AuthService authService;

    public AuthenticationPrincipalArgumentResolver(AuthService authService) {
        this.authService = authService;
    }

    @Override
    public boolean supportsParameter(MethodParameter parameter) {
        return parameter.hasParameterAnnotation(AuthenticationPrincipal.class);
    }

    @Override
    public LoginMember resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) {
        String token = AuthorizationExtractor.extract((HttpServletRequest) webRequest.getNativeRequest());
        return authService.findLoginMemberByToken(token);
    }
}

public class LoginMember {
    private Long id;
    private String email;
    private int age;

    public LoginMember(Member member) {
        this(member.getId(), member.getEmail(), member.getAge());
    }

public TokenResponse createToken(TokenRequest tokenRequest) {
    Member member = findMember(tokenRequest);
    if (member.isInvalidPassword(tokenRequest.getPassword())) {
        throw new AuthorizationException("로그인 실패입니다.");
    }
    String accessToken = jwtTokenProvider.createToken(String.valueOf(member.getId()));
    return new TokenResponse(accessToken);
}

private Member findMember(TokenRequest tokenRequest) {
    return memberDao.findByEmail(tokenRequest.getEmail())
            .orElseThrow(() -> new AuthorizationException("로그인 실패입니다."));
}

public class SubwayGraph {
    private final WeightedMultigraph<Station, DefaultWeightedEdge> graph;

    public SubwayGraph(WeightedMultigraph<Station, DefaultWeightedEdge> graph, List<Section> sections) {
        this.graph = graph;
        initPath(sections);
    }
   // ...

public interface ShortestPathStrategy {
    List<Station> getVertexList(Station source, Station target);

    double getPathWeight(Station source, Station target);
}

public class DijkstraShortestPathStrategy implements ShortestPathStrategy {
    private final ShortestPathAlgorithm<Station, DefaultWeightedEdge> shortestPathAlgorithm;

    public DijkstraShortestPathStrategy(SubwayGraph subwayGraph) {
        this.shortestPathAlgorithm = new DijkstraShortestPath<>(subwayGraph.getGraph());
    }

    @Override
    public List<Station> getVertexList(Station source, Station target) {
        return shortestPathAlgorithm.getPath(source, target).getVertexList();
    }

    @Override
    public double getPathWeight(Station source, Station target) {
        return shortestPathAlgorithm.getPathWeight(source, target);
    }
}

public class ShortestPathFinder {
    private final ShortestPathStrategy shortestPathStrategy;

    public ShortestPathFinder(ShortestPathStrategy shortestPathStrategy) {
        this.shortestPathStrategy = shortestPathStrategy;
    }

    public Path findShortestPath(Station source, Station target) {
        return new Path(shortestPathStrategy.getVertexList(source, target), shortestPathStrategy.getPathWeight(source, target));
    }
}

public PathResponse findPath(Long sourceId, Long targetId) {
    List<Section> sections = sectionDao.findByStationIds(Arrays.asList(sourceId, targetId));
    SubwayGraph subwayGraph = new SubwayGraph(new WeightedMultigraph<>(DefaultWeightedEdge.class), sections);
    ShortestPathFinder shortestPathFinder = new ShortestPathFinder(new DijkstraShortestPathStrategy(subwayGraph));
    Path shortestPath = shortestPathFinder.findShortestPath(new Station(sourceId), new Station(targetId));
    return new PathResponse(StationResponse.listOf(combineStationById(shortestPath)), (int) shortestPath.distance());
}

private List<Station> combineStationById(Path path) {
    List<Long> stationIds = path.stations()
            .stream()
            .map(Station::getId)
            .collect(Collectors.toList());
    return stationDao.findByIds(stationIds).sortedStation(stationIds);
}