Spring 웹 애플리케이션에서 사용하지 않는 API를 찾아보자

@Controller
public class OrderController {
	@GetMapping("/v1/orders/{id}")
	public OrderInfo getOrderInfo(@PathVariable("id") String id) {
	    // 블라블라
	}
}

@ToString
@Getter
public class ControllerLog {
    private String httpMethod;
    private String urlPattern;
    private ZonedDateTime requestedAt;

    public ControllerLog(String method, String urlPattern, ZonedDateTime requestedAt) {
        this.httpMethod = httpMethod;
        this.urlPattern = urlPattern;
        this.requestedAt = requestedAt;
    }
}

@Slf4j
@Component
public class ControllerLogInterceptor extends HandlerInterceptorAdapter {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        ControllerLog controllerLog = new ControllerLog(
            request.getMethod(),
            (String) request.getAttribute(HandlerMapping.BEST_MATCHING_PATTERN_ATTRIBUTE), // .bestMatchingPattern
            ZonedDateTime.now()
        );

        log.info(contollerLog.toString());

        return super.preHandle(request, response, handler);
    }

}

@Configuration
public class ControllerLogConfig {
    @Bean
    public EmitterProcessor<ControllerLog> controllerLogEmitterProcessor() {
        return EmitterProcessor.create();
    }

    @Bean
    public FluxSink<ControllerLog> controllerLogSink(EmitterProcessor<ControllerLog> controllerLogEmitterProcessor) {
        return emitterProcessor.sink(FluxSink.OverflowStrategy.DROP);
    }

    @Bean
    public Flux<ControllerLog> controllerLogFlux(EmitterProcessor<ControllerLog> controllerLogEmitterProcessor) {
        return emitterProcessor.publishOn(Schedulers.elastic());
    }
}

@Component
public class ControllerLogInterceptor extends HandlerInterceptorAdapter {
    private final FluxSink<ControllerLog> controllerLogSink;

    public ControllerLogInterceptor(FluxSink<ControllerLog> controllerLogSink) {
        this.controllerLogSink = controllerLogSink;
    }

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        ControllerLog controllerLog = new ControllerLog(
            request.getMethod(),
            (String) request.getAttribute(HandlerMapping.BEST_MATCHING_PATTERN_ATTRIBUTE),
            ZonedDateTime.now()
        );

        controllerLogSink.next(controllerLog);

        return super.preHandle(request, response, handler);
    }
}

@Slf4j
@Component
public class Slf4jControllerLogProcessor {

    private final Flux<ControllerLog> controllerLogFlux;

    private Disposable disposable;

    public Slf4jControllerLogProcessor(Flux<ControllerLog> controllerLogFlux) {
        this.controllerLogFlux = controllerLogFlux;
    }

    @PostConstruct
    public void init() {
        disposable = controllerLogFlux.subscribe(it -> log.info(it.toString()));
    }

    @PreDestroy
    public void destroy() {
        if (disposable != null) {
            disposable.dispose();
        }
    }
}

@Slf4j
@Component
public class EsControllerLogProcessor {    
    private final Flux<ControllerLog> controllerLogFlux;

    private final EsLogSender esLogSender;

    private Disposable disposable;

    public EsControllerLogProcessor(Flux<ControllerLog> EsLogSender esLogSender) {
        this.controllerLogFlux = controllerLogFlux;
        this.esLogSender = esLogSender;
    }

    @PostConstruct
    public void init() {
        disposable = logFlux.bufferTimeout(1000, Duration.ofSeconds(30), Schedulers.elastic()) 
                .filter(it -> !CollectionUtils.isEmpty(it))
                .subscribe(esLogSender::send);
    }

    @PreDestroy
    public void destroy() {
        if (disposable != null) {
            disposable.dispose();
        }
    }
}

@Slf4j
@Component
public class EsLogSender {
    public static final DateTimeFormatter FORMATTER = DateTimeFormatter.ofPattern("yyyyMMdd");
    
    private final RestHighLevelClient client;

    private final ObjectMapper mapper;

    public EsLogSender(RestHighLevelClient client, ObjectMapper mapper) {
        this.client = client;
        this.mapper = mapper;
    }

    public void send(List<ControllerLog> list) {
        try {
            String indexName = "controller-log-" + LocalDate.now().format(FORMATTER);
            BulkRequest request = new BulkRequest();
            for (ControllerLog each : list) {
                request.add(new IndexRequest(indexName, "doc").source(mapper.writeValueAsBytes(each), XContentType.JSON));
            }

            client.bulkAsync(request, RequestOptions.DEFAULT, new ActionListener<BulkResponse>() {
                @Override
                public void onResponse(BulkResponse response) {
                    log.debug("Send to logs to ES.");
                }

                @Override
                public void onFailure(Exception e) {
                    log.warn("Exception in send to logs to ES.", e);
                }
            });
        } catch (Exception e) {
            log.warn("Exception in send to logs to ES.", e);
        }
    }
}

@Slf4j
public class ApiCountTest extends SpringTestContext {
    @Autowired
    List<RequestMappingHandlerMapping> handlerMappings;

    @Autowired
    RestHighLevelClient client;

    @Test
    public void test() {
        handlerMappings.stream()
                .flatMap(it -> it.getHandlerMethods().keySet().stream())
                .forEach(this::print);
    }

    private void print(RequestMappingInfo requestMappingInfo) {
        for (RequestMethod method : requestMappingInfo.getMethodsCondition().getMethods()) {
            for (String pattern : requestMappingInfo.getPatternsCondition().getPatterns()) {
                long count = getCount(method.name(), pattern);
                if (count > 0) {
                    log.info("method={}, pattern={}, count={}", method, pattern, count);
                } else {
                    log.warn("method={}, pattern={} is not occurred.", method, pattern);
                }
            }
        }
    }

    private long getCount(String method, String pattern) {
        CountRequest countRequest = new CountRequest();
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        BoolQueryBuilder bool = QueryBuilders.boolQuery();
        List<QueryBuilder> must = bool.must();
        must.add(QueryBuilders.matchQuery("httpMethod.keyword", method));
        must.add(QueryBuilders.matchQuery("urlPattern.keyword", pattern));
        searchSourceBuilder.query(bool);
        countRequest.source(searchSourceBuilder);
        countRequest.indices("controller-log-*");

        try {
            return client.count(countRequest, RequestOptions.DEFAULT).getCount();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}