public abstract class AbstractControllerUrlHandlerMapping extends AbstractDetectingUrlHandlerMapping  {

	// 通过控制器接口类型或者控制器注解类型查找简单控制器和注解控制器的实用类
	private ControllerTypePredicate predicate = new AnnotationControllerTypePredicate();

	// 声明的包中的控制器不会作为处理器进行注册
	private Set<String> excludedPackages = Collections.singleton("org.springframework.web.servlet.mvc");

	// 声明的类不会作为处理器进行注册
	private Set<Class> excludedClasses = Collections.emptySet();

	// 实现根据Bean映射出URL的逻辑
	@Override
	protected String[] determineUrlsForHandler(String beanName) {
		// 取得Bean的类型
		Class beanClass = getApplicationContext().getType(beanName);
		
		// 判断是否Bean可以作为控制器处理器
		if (isEligibleForMapping(beanName, beanClass)) {
			// 根据Bean名字或者类型名映射出URL的逻辑
			return buildUrlsForHandler(beanName, beanClass);
		}
		else {
			return null;
		}
	}


	protected boolean isEligibleForMapping(String beanName, Class beanClass) {
		// 如果Bean类型是空，则不映射此Bean
		if (beanClass == null) {
			if (logger.isDebugEnabled()) {
				logger.debug("Excluding controller bean '" + beanName + "' from class name mapping " +
						"because its bean type could not be determined");
			}
			return false;
		}
		
		// 如果Bean的包配置为排除包，则不映射此Bean
		if (this.excludedClasses.contains(beanClass)) {
			if (logger.isDebugEnabled()) {
				logger.debug("Excluding controller bean '" + beanName + "' from class name mapping " +
						"because its bean class is explicitly excluded: " + beanClass.getName());
			}
			return false;
		}
		
		// 如果Bean的包配置为排除类，则不映射此Bean
		String beanClassName = beanClass.getName();
		for (String packageName : this.excludedPackages) {
			if (beanClassName.startsWith(packageName)) {
				if (logger.isDebugEnabled()) {
					logger.debug("Excluding controller bean '" + beanName + "' from class name mapping " +
							"because its bean class is defined in an excluded package: " + beanClass.getName());
				}
				return false;
			}
		}
		
		// 必须是控制器类型，才映射作为控制器处理器
		return isControllerType(beanClass);
	}


	protected boolean isControllerType(Class beanClass) {
		return this.predicate.isControllerType(beanClass);
	}


	protected boolean isMultiActionControllerType(Class beanClass) {
		return this.predicate.isMultiActionControllerType(beanClass);
	}


	// 子类可以选择根据Bean名字还是根据Bean类来映射URL Pattern
	protected abstract String[] buildUrlsForHandler(String beanName, Class beanClass);

}

public class ControllerClassNameHandlerMapping extends AbstractControllerUrlHandlerMapping {
	// 控制器名的后缀
	private static final String CONTROLLER_SUFFIX = "Controller";

	// 通过类型映射的路径是否保持大写字母的存在
	private boolean caseSensitive = false;

	private String pathPrefix;

	private String basePackage;

	public void setPathPrefix(String prefixPath) {
		this.pathPrefix = prefixPath;
		
		// 一个路径应该保证有斜线(/)开头，但是没有斜线(/)结尾
		if (StringUtils.hasLength(this.pathPrefix)) {
			if (!this.pathPrefix.startsWith("/")) {
				this.pathPrefix = "/" + this.pathPrefix;
			}
			if (this.pathPrefix.endsWith("/")) {
				this.pathPrefix = this.pathPrefix.substring(0, this.pathPrefix.length() - 1);
			}
		}
	}


	public void setBasePackage(String basePackage) {
		this.basePackage = basePackage;
		
		// 设置缺省的包前缀
		if (StringUtils.hasLength(this.basePackage) && !this.basePackage.endsWith(".")) {
			this.basePackage = this.basePackage + ".";
		}
	}

	@Override
	protected String[] buildUrlsForHandler(String beanName, Class beanClass) {
		// 仅仅使用类名进行映射
		return generatePathMappings(beanClass);
	}

	protected String[] generatePathMappings(Class beanClass) {
		// 产生路径前缀
		StringBuilder pathMapping = buildPathPrefix(beanClass);
		
		// 取得不包含包名的类名
		String className = ClassUtils.getShortName(beanClass);
		
		// 如果以控制器后缀(Controller)结尾，则移除控制器后缀
		String path = (className.endsWith(CONTROLLER_SUFFIX) ?
				className.substring(0, className.lastIndexOf(CONTROLLER_SUFFIX)) : className);
		
		if (path.length() > 0) {
			// 如果保持路径大小写，则把类名的第一个字符小写
			if (this.caseSensitive) {
				pathMapping.append(path.substring(0, 1).toLowerCase()).append(path.substring(1));
			}
			// 否则使所有路径字符变成小写
			else {
				pathMapping.append(path.toLowerCase());
			}
		}
		
		// 如果是多行为控制器类型，则加URL本身和所有的子URL
		if (isMultiActionControllerType(beanClass)) {
			return new String[] {pathMapping.toString(), pathMapping.toString() + "/*"};
		}
		// 否则只加URL本身
		else {
			return new String[] {pathMapping.toString() + "*"};
		}
	}


	private StringBuilder buildPathPrefix(Class beanClass) {
		StringBuilder pathMapping = new StringBuilder();
		
		// 第一部分是路径前缀
		if (this.pathPrefix != null) {
			pathMapping.append(this.pathPrefix);
			pathMapping.append("/");
		}
		else {
			pathMapping.append("/");
		}
		
		// 第二部分是包名中逗点替换成斜线的结果
		if (this.basePackage != null) {
			String packageName = ClassUtils.getPackageName(beanClass);
			if (packageName.startsWith(this.basePackage)) {
				String subPackage = packageName.substring(this.basePackage.length()).replace('.', '/');
				pathMapping.append(this.caseSensitive ? subPackage : subPackage.toLowerCase());
				pathMapping.append("/");
			}
		}
		return pathMapping;
	}

}

public class SimpleUrlHandlerMapping extends AbstractUrlHandlerMapping {
	
	private final Map<String, Object> urlMap = new HashMap<String, Object>();

	// 通过属性配置URL到Bean名的映射
	public void setMappings(Properties mappings) {
		CollectionUtils.mergePropertiesIntoMap(mappings, this.urlMap);
	}

	// 配置URL到Bean的映射
	public void setUrlMap(Map<String, ?> urlMap) {
		this.urlMap.putAll(urlMap);
	}

	public Map<String, ?> getUrlMap() {
		return this.urlMap;
	}

	@Override
	public void initApplicationContext() throws BeansException {
		super.initApplicationContext();
		// 初始化的时候注册处理器
		registerHandlers(this.urlMap);
	}

	protected void registerHandlers(Map<String, Object> urlMap) throws BeansException {
		// 如果配置的处理器映射为空，则警告
		if (urlMap.isEmpty()) {
			logger.warn("Neither 'urlMap' nor 'mappings' set on SimpleUrlHandlerMapping");
		}
		else {
			// 对于没一个配置的URL到处理器的映射，如果URL不是以斜线(/)开头，则追加斜线开头，则注册处理器
			for (Map.Entry<String, Object> entry : urlMap.entrySet()) {
				String url = entry.getKey();
				Object handler = entry.getValue();
				// Prepend with slash if not already present.
				if (!url.startsWith("/")) {
					url = "/" + url;
				}
				// Remove whitespace from handler bean name.
				if (handler instanceof String) {
					handler = ((String) handler).trim();
				}
				registerHandler(url, handler);
			}
		}
	}

}