Java RequestMappingHandlerMapping.getHandlerMethods方法代码示例

import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping; //导入方法依赖的package包/类
@Override
public void onApplicationEvent ( ContextRefreshedEvent event ) {
	final RequestMappingHandlerMapping requestMappingHandlerMapping =
		applicationContext.getBean( RequestMappingHandlerMapping.class );
	final Map< RequestMappingInfo, HandlerMethod > handlerMethods =
		requestMappingHandlerMapping.getHandlerMethods();

	this.handlerMethods = handlerMethods;

	handlerMethods.keySet().forEach( mappingInfo -> {
		Map< Set< String >, Set< RequestMethod > > mapping = Collections.singletonMap(
			mappingInfo.getPatternsCondition().getPatterns() ,
			this.getMethods( mappingInfo.getMethodsCondition().getMethods() )
		);
		requestMappingInfos.add( mapping );
	} );

	requestMappingUris.addAll(
		handlerMethods.keySet()
					  .parallelStream()
					  .map( mappingInfo -> mappingInfo.getPatternsCondition().getPatterns() )
					  .collect( Collectors.toList() )
	);

}
 

import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping; //导入方法依赖的package包/类
/**
 * key 是handle 方法,value 是 RequestMappingInfo 信息.
 *
 * @param requestMappingHandlerMapping
 *            the request mapping handler mapping
 * @return the map< string, request mapping info>
 * @see org.springframework.web.servlet.mvc.method.RequestMappingInfo
 * @see org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping#createRequestMappingInfo(RequestMapping,
 *      RequestCondition)
 * @since 1.5.4
 */
private static Map<String, RequestMappingInfo> buildMethodAndRequestMappingInfoMap(
                RequestMappingHandlerMapping requestMappingHandlerMapping){
    Map<String, RequestMappingInfo> methodAndRequestMappingInfoMap = newLinkedHashMap();

    //---------------------------------------------------------------
    Map<RequestMappingInfo, HandlerMethod> handlerMethods = requestMappingHandlerMapping.getHandlerMethods();
    for (Map.Entry<RequestMappingInfo, HandlerMethod> entry : handlerMethods.entrySet()){
        RequestMappingInfo requestMappingInfo = entry.getKey();
        HandlerMethod handlerMethod = entry.getValue();

        methodAndRequestMappingInfoMap.put(handlerMethod.toString(), requestMappingInfo);
    }

    if (LOGGER.isInfoEnabled()){
        Collection<RequestMappingInfo> requestMappingInfoCollection = methodAndRequestMappingInfoMap.values();
        String format = JsonUtil.format(getPropertyValueList(requestMappingInfoCollection, "patternsCondition.patterns"));
        LOGGER.info("all requestMapping value:{}", format);
    }
    return methodAndRequestMappingInfoMap;
}
 

import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping; //导入方法依赖的package包/类
public static HomeModuleExtension create(RequestMappingHandlerMapping mapping) {
	HomeModuleExtension ext = new HomeModuleExtension();

	Map<RequestMappingInfo, HandlerMethod> handlerMethods = mapping.getHandlerMethods();
	for (RequestMappingInfo info : handlerMethods.keySet()) {
		Set<String> patterns = info.getPatternsCondition().getPatterns();
		for (String pattern : patterns) {
			ext.addPath(pattern);
		}
	}

	return ext;
}
 

import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping; //导入方法依赖的package包/类
/**
 * Builds the handler methods.
 *
 * @param applicationContext
 *            the application context
 * @return 如果取不到 <code>RequestMappingHandlerMapping</code>,返回 {@link Collections#emptyMap()}<br>
 * @throws BeansException
 *             the beans exception
 */
private static Map<RequestMappingInfo, HandlerMethod> buildHandlerMethods(ApplicationContext applicationContext){
    RequestMappingHandlerMapping requestMappingHandlerMapping = applicationContext.getBean(RequestMappingHandlerMapping.class);//通过上下文对象获取RequestMappingHandlerMapping实例对象  

    if (null == requestMappingHandlerMapping){
        return emptyMap();
    }

    return requestMappingHandlerMapping.getHandlerMethods();
}
 

import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping; //导入方法依赖的package包/类
/**
 * Returns all RequestMappingInfo instances from type and
 * method-level @RequestMapping annotations in @Controller classes.
 *
 * @param requestMappingHandlerMapping
 *            The RequestMappingInfo collection of Spring
 * @return A set of RequestMappingInfo
 */
@PreAuthorize("hasRole(@configHolder.getSuperAdminRoleName())")
public Set<RequestMappingInfo> getEndpoints(RequestMappingHandlerMapping requestMappingHandlerMapping) {

	if (requestMappingHandlerMapping.getHandlerMethods() != null) {
		return requestMappingHandlerMapping.getHandlerMethods().keySet();
	}

	return null;
}
 

import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping; //导入方法依赖的package包/类
/**
 * Generates a WadlApplication from Spring MVC request mappings.
 * 
 * Supported Spring MVC annotations:
 * 
 * <code>RequestMapping</code>
 *   Mapped to a WADL <code>application/resources/resource</code> element 
 * 
 *   Parameters:
 *    - value: mapped to <code>resource/@path<code>
 *    - method: mapped to <code>resource/method/@name<code>
 *    - produces: mapped to <code>resource/response/representation/@mediaType<code>
 *    - consumes: mapped to <code>resource/request/representation/@mediaType<code>
 * 
 * <code>PathVariable</code>
 *   Mapped to a WADL <code>application/resources/resource/method/request/param</code>
 *   element with <code>@style="template" @required="true"</code>
 *   
 *   Parameters:
 *    - value: mapped to <code>param/@name<code> 
 * 
 * <code>RequestParam</code>
 *   Mapped to a WADL <code>application/resources/resource/method/request/param</code>
 *   element with <code>@style="query"</code>
 *   
 *   Parameters:
 *    - value: mapped to <code>param/@name<code> 
 *    - required: mapped to <code>param/@required<code>
 *    - defaultValue: mapped to <code>param/@default<code>
 * 
 * @param handlerMapping the Spring MVC request mappings
 * @param request the HTTP request to retrieve the WADL
 * @param applicationName name of the application
 * @param ignoreControllers list of controller classes to ignore
 * @param wadlTypeMapper custom WADL type mapper to use
 * 
 * @return a WadlApplication describing the application's API
 */
public static WadlApplication generate(RequestMappingHandlerMapping handlerMapping,
		HttpServletRequest request, String applicationName, List<Class<?>> ignoreControllers,
		WadlTypeMapper wadlTypeMapper) {

	WadlApplication result = new WadlApplication();

	WadlDoc doc = createWadlDoc(applicationName);
	result.getDoc().add(doc);

	WadlResources wadlResources = new WadlResources();

	String baseUrl = getBaseUrl(request);
	wadlResources.setBase(baseUrl);

	Map<RequestMappingInfo, HandlerMethod> handletMethods = handlerMapping.getHandlerMethods();
	for (Map.Entry<RequestMappingInfo, HandlerMethod> entry : handletMethods.entrySet()) {
		RequestMappingInfo mappingInfo = entry.getKey();
		HandlerMethod handlerMethod = entry.getValue();
		
		Class<?> controllerClass = handlerMethod.getBeanType();
		if (ignoreControllers.contains(controllerClass)) {
			if (log.isDebugEnabled()) {
				log.debug("Ignoring controller class: " + controllerClass);
			}
			
			continue;  // skip
		}

		WadlResource wadlResource = mapToWadlResource(mappingInfo, handlerMethod, wadlTypeMapper);
		wadlResources.getResource().add(wadlResource);
	}

	result.getResources().add(wadlResources);

	return result;
}