Feign接口路径

org.springframework.web.servlet.handler.AbstractHandlerMethodMapping#processCandidateBean

    /**
     * Determine the type of the specified candidate bean and call
     * {@link #detectHandlerMethods} if identified as a handler type.
     * <p>This implementation avoids bean creation through checking
     * {@link org.springframework.beans.factory.BeanFactory#getType}
     * and calling {@link #detectHandlerMethods} with the bean name.
     * @param beanName the name of the candidate bean
     * @since 5.1
     * @see #isHandler
     * @see #detectHandlerMethods
     */
    protected void processCandidateBean(String beanName) {
        Class<?> beanType = null;
        try {
            beanType = obtainApplicationContext().getType(beanName);
        }
        catch (Throwable ex) {
            // An unresolvable bean type, probably from a lazy bean - let's ignore it.
            if (logger.isTraceEnabled()) {
                logger.trace("Could not resolve type for bean '" + beanName + "'", ex);
            }
        }
        // 判断是否为handler
        if (beanType != null && isHandler(beanType)) {
            detectHandlerMethods(beanName);
        }
    }

查找父类接口（client）的注解

org.springframework.core.annotation.AnnotatedElementUtils#findMergedAnnotation

    /**
     * Find the first annotation of the specified {@code annotationType} within
     * the annotation hierarchy <em>above</em> the supplied {@code element},
     * merge that annotation's attributes with <em>matching</em> attributes from
     * annotations in lower levels of the annotation hierarchy, and synthesize
     * the result back into an annotation of the specified {@code annotationType}.
     * <p>{@link AliasFor @AliasFor} semantics are fully supported, both
     * within a single annotation and within the annotation hierarchy.
     * <p>This method follows <em>find semantics</em> as described in the
     * {@linkplain AnnotatedElementUtils class-level javadoc}.
     * @param element the annotated element
     * @param annotationType the annotation type to find
     * @return the merged, synthesized {@code Annotation}, or {@code null} if not found
     * @since 4.2
     * @see #findAllMergedAnnotations(AnnotatedElement, Class)
     * @see #findMergedAnnotationAttributes(AnnotatedElement, String, boolean, boolean)
     * @see #getMergedAnnotationAttributes(AnnotatedElement, Class)
     */
    @Nullable
    public static <A extends Annotation> A findMergedAnnotation(AnnotatedElement element, Class<A> annotationType) {
        // Shortcut: directly present on the element, with no merging needed?
        if (AnnotationFilter.PLAIN.matches(annotationType) ||
                AnnotationsScanner.hasPlainJavaAnnotationsOnly(element)) {
            return element.getDeclaredAnnotation(annotationType);
        }
        // Exhaustive retrieval of merged annotations...
        return findAnnotations(element)
                .get(annotationType, null, MergedAnnotationSelectors.firstDirectlyDeclared())
                .synthesize(MergedAnnotation::isPresent).orElse(null);
    }

org.springframework.core.annotation.AnnotationsScanner#processMethodHierarchy

@Nullable
    private static <C, R> R processMethodHierarchy(C context, int[] aggregateIndex,
            Class<?> sourceClass, AnnotationsProcessor<C, R> processor, Method rootMethod,
            boolean includeInterfaces) {

        try {
            R result = processor.doWithAggregate(context, aggregateIndex[0]);
            if (result != null) {
                return result;
            }
            if (hasPlainJavaAnnotationsOnly(sourceClass)) {
                return null;
            }
            boolean calledProcessor = false;
            if (sourceClass == rootMethod.getDeclaringClass()) {
                result = processMethodAnnotations(context, aggregateIndex[0],
                    rootMethod, processor);
                calledProcessor = true;
                if (result != null) {
                    return result;
                }
            }
            else {
                for (Method candidateMethod : getBaseTypeMethods(context, sourceClass)) {
                    if (candidateMethod != null && isOverride(rootMethod, candidateMethod)) {
                        result = processMethodAnnotations(context, aggregateIndex[0],
                            candidateMethod, processor);
                        calledProcessor = true;
                        if (result != null) {
                            return result;
                        }
                    }
                }
            }
            if (Modifier.isPrivate(rootMethod.getModifiers())) {
                return null;
            }
            if (calledProcessor) {
                aggregateIndex[0]++;
            }
            if (includeInterfaces) {
                for (Class<?> interfaceType : sourceClass.getInterfaces()) {
                    R interfacesResult = processMethodHierarchy(context, aggregateIndex,
                        interfaceType, processor, rootMethod, true);
                    if (interfacesResult != null) {
                        return interfacesResult;
                    }
                }
            }
            Class<?> superclass = sourceClass.getSuperclass();
            if (superclass != Object.class && superclass != null) {
                R superclassResult = processMethodHierarchy(context, aggregateIndex,
                    superclass, processor, rootMethod, includeInterfaces);
                if (superclassResult != null) {
                    return superclassResult;
                }
            }
        }
        catch (Throwable ex) {
            AnnotationUtils.handleIntrospectionFailure(rootMethod, ex);
        }
        return null;
    }

1. spring 会扫描bean，并获取所有用@Controller 或@RequestMapping， 注释的类

2.然后扫描类的方法，调用org.springframework.core.annotation.AnnotatedElementUtils#findMergedAnnotation获取方法或者父类的@RequestMapping注释信息，继而获取路径。

3.关联路径和具体的方法，注册进Spring 里面。

4.请求来到就拿相应的路径，去取对应的方法执行。