Mapping multi-path to a handler method

ExtendPathMapping.java

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.springframework.beans.factory.InitializingBean;
import org.springframework.boot.autoconfigure.web.WebMvcRegistrationsAdapter;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.mvc.condition.PatternsRequestCondition;
import org.springframework.web.servlet.mvc.method.RequestMappingInfo;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping;

@Configuration
public class ExtendPathMapping extends WebMvcRegistrationsAdapter implements
        InitializingBean {
    private Map<String, String> legacyMapping;  // mapping legacy --> current

    @Override
    public RequestMappingHandlerMapping getRequestMappingHandlerMapping() {
        return new CustomRequestMappingHandlerMapping();
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        HashMap<String, String> mapping = new HashMap<>();
        mapping.put("/foo/quz", "/bar/quz");
        this.legacyMapping = Collections.unmodifiableMap(mapping);
    }

    private class CustomRequestMappingHandlerMapping extends
            RequestMappingHandlerMapping {
        @Override
        protected void registerHandlerMethod(Object handler, Method method,
                RequestMappingInfo mapping) {
            super.registerHandlerMethod(handler, method, withLegacyMapping(mapping));
        }

        private RequestMappingInfo withLegacyMapping(RequestMappingInfo mapping) {
            List<String> patterns = combineLegacyPattern(
                    mapping.getPatternsCondition().getPatterns());

            PatternsRequestCondition prc = new PatternsRequestCondition(
                    patterns.toArray(new String[patterns.size()]));
            return new RequestMappingInfo(prc, mapping.getMethodsCondition(),
                                          mapping.getParamsCondition(),
                                          mapping.getHeadersCondition(),
                                          mapping.getConsumesCondition(),
                                          mapping.getProducesCondition(),
                                          mapping.getCustomCondition());
        }

        private List<String> combineLegacyPattern(Set<String> patterns) {
            List<String> result = new ArrayList<>(patterns);

            for (String pattern : patterns) {
                for (Map.Entry<String, String> entry : legacyMapping.entrySet()) {
                    String legacy = entry.getKey();
                    if (getPathMatcher().match(pattern, entry.getValue())) {
                        result.add(legacy);
                    }
                }
            }

            return result;
        }
    }
}