上一节主要阅读了BeanNameUrlHandlerMapping类，并理清了它的父类关系，值得注意的是它的爷爷的爸爸也就是AbstractHandlerMapping实现了HandlerMapping接口，而继承了WebApplicationObjectSupport类，在AbstractDetectingUrlHandlerMapping类中，有这样一个方法：
/**
* Calls the {@link #detectHandlers()} method in addition to the
* superclass's initialization.
*/
@Override
public void initApplicationContext() throws ApplicationContextException {
super.initApplicationContext();
detectHandlers();
}
上一节没有说明这个，经过我翻WebApplicationObjectSupport类和它的父类ApplicationObjectSupport发现有一个setApplicationContext(ApplicationContext context)方法，在其中调用了initApplicationContext方法，前面的setter肯定是在bean构造时用到的，更上层的以后再去阅读理解吧，到这里就追溯到了handler探测的本源。
DefaultAnnoationHandlerMapping类也是继承自AbstractDetectingUrlHandlerMapping类，则必然实现了它的抽象方法：
/** * Determine the URLs for the given handler bean. * @param beanName the name of the candidate bean * @return the URLs determined for the bean, * or <code>null</code> or an empty array if none */ protected abstract String[] determineUrlsForHandler(String beanName);
那么detectHandler接下来的执行顺序就和上一节的顺序相同，这时我们跳到了DefaultAnnoationHandlerMapping类中的该方法：
/**
* Checks for presence of the {@link org.springframework.web.bind.annotation.RequestMapping}
* annotation on the handler class and on any of its methods.
*/
@Override
protected String[] determineUrlsForHandler(String beanName) {
ApplicationContext context = getApplicationContext();
Class<?> handlerType = context.getType(beanName);
RequestMapping mapping = context.findAnnotationOnBean(beanName, RequestMapping.class);
if (mapping != null) {
// @RequestMapping found at type level
this.cachedMappings.put(handlerType, mapping);
Set<String> urls = new LinkedHashSet<String>();
String[] typeLevelPatterns = mapping.value();
if (typeLevelPatterns.length > 0) {
// @RequestMapping specifies paths at type level
String[] methodLevelPatterns = determineUrlsForHandlerMethods(handlerType);
for (String typeLevelPattern : typeLevelPatterns) {
if (!typeLevelPattern.startsWith("/")) {
typeLevelPattern = "/" + typeLevelPattern;
}
for (String methodLevelPattern : methodLevelPatterns) {
String combinedPattern = getPathMatcher().combine(typeLevelPattern, methodLevelPattern);
addUrlsForPath(urls, combinedPattern);
}
addUrlsForPath(urls, typeLevelPattern);
}
return StringUtils.toStringArray(urls);
}
else {
// actual paths specified by @RequestMapping at method level
return determineUrlsForHandlerMethods(handlerType);
}
}
else if (AnnotationUtils.findAnnotation(handlerType, Controller.class) != null) {
// @RequestMapping to be introspected at method level
return determineUrlsForHandlerMethods(handlerType);
}
else {
return null;
}
}
既然是默认注解支持的HandlerMapping，那么它必然是去探测@RequestMapping所注解的Handler和Method。这里就有必要来看看RequestMapping接口的定义：
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Mapping
public @interface RequestMapping {
String[] value() default {};
RequestMethod[] method() default {};
String[] params() default {};
String[] headers() default {};
}
value数组显然是存储所有该Handler中的url，method则是POST GET等方法，RequestMethod是一个enum类型
public enum RequestMethod {
GET, HEAD, POST, PUT, DELETE, OPTIONS, TRACE
}
context.findAnnotationOnBean(beanName, RequestMapping.class)显然是查找了该Handler上所有使用了@RequestMapping的注解，将它们的value,method取出，再封装到RequestMapping类对象中。接下来的加入缓存语句就不用解释了。
我们来看看determineUrlsForHandlerMethods方法的源码：
/**
* Derive URL mappings from the handler's method-level mappings.
* @param handlerType the handler type to introspect
* @return the array of mapped URLs
*/
protected String[] determineUrlsForHandlerMethods(Class<?> handlerType) {
final Set<String> urls = new LinkedHashSet<String>();
Class<?>[] handlerTypes =
Proxy.isProxyClass(handlerType) ? handlerType.getInterfaces() : new Class<?>[]{handlerType};
for (Class<?> currentHandlerType : handlerTypes) {
ReflectionUtils.doWithMethods(currentHandlerType, new ReflectionUtils.MethodCallback() {
public void doWith(Method method) {
RequestMapping mapping = AnnotationUtils.findAnnotation(method, RequestMapping.class);
if (mapping != null) {
String[] mappedPaths = mapping.value();
for (String mappedPath : mappedPaths) {
addUrlsForPath(urls, mappedPath);
}
}
}
});
}
return StringUtils.toStringArray(urls);
}
这里就比较麻烦了，先从字面意思理解就是查询类中的方法，找到方法对应的RequestMapping的所包含的value，组成一个url数组。
接下来看它的实现，首先是检查了handlerType是否是一个代理类
/**
* Returns true if and only if the specified class was dynamically
* generated to be a proxy class.
*/
public static boolean isProxyClass(Class<?> cl) {
if (cl == null) {
throw new NullPointerException();
}
return proxyClasses.containsKey(cl);
}
/** set of all generated proxy classes, for isProxyClass implementation */
private static Map proxyClasses =
Collections.synchronizedMap(new WeakHashMap());
接下来是反射和回调，我也看到云里雾里的。。。。理解不来，以后再想吧，直到它最后是得到的url就行了。
handlerType.getInterfaces();
用于得到所有handlerType实现的接口的Class对象
new Class<?>[]{handlerType}
得到的还只是handlerType的Class对象
所以这里就有些不懂为什么要这么做，希望有高手看到我的文章 帮我解答下疑惑