org.springframework.web.servlet.HandlerMapping Java Examples

@Test
public void uriTemplateVarAndRequestParam() throws Exception {
	request.addParameter("age", "35");

	Map<String, String> uriTemplateVars = new HashMap<String, String>();
	uriTemplateVars.put("name", "nameValue");
	uriTemplateVars.put("age", "25");
	request.setAttribute(HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE, uriTemplateVars);

	TestBean target = new TestBean();
	WebDataBinder binder = new ExtendedServletRequestDataBinder(target, "");
	((ServletRequestDataBinder) binder).bind(request);

	assertEquals("nameValue", target.getName());
	assertEquals(35, target.getAge());
}
 

/**
 * Get data and verify token
 *
 * @param request HttpServletRequest object
 * @return If true, authentication is passed, otherwise not
 */
@SuppressWarnings("unchecked")
private boolean verifyRightForResouceAccess(HttpServletRequest request) {
    String token = request.getHeader(ConstantsKeys.TOKEN);
    if (StringUtils.isEmpty(token))
        return false;
    String[] tArray = token.split(ConstantsKeys.VIP.hashCode() + "");
    Map<String, String> pathVariables = (Map<String, String>) request.getAttribute(HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE);
    String productName = pathVariables.get(ConstantsKeys.PRODUCTNAME) == null
            ? request.getParameter(ConstantsKeys.PRODUCTNAME) : pathVariables.get(ConstantsKeys.PRODUCTNAME);
    String version = pathVariables.get(ConstantsKeys.VERSION) == null
            ? request.getParameter(ConstantsKeys.VERSION) : pathVariables.get(ConstantsKeys.VERSION);
    if (!StringUtils.isEmpty(productName) && !StringUtils.isEmpty(version)) {
        String productName_version = tArray[0];
        if (!productName_version.equals((productName + ConstantsChar.UNDERLINE + version).hashCode()+""))
            return false;
    }
    if (token.indexOf(String.valueOf(ConstantsKeys.VIP.hashCode())) <= 0)
        return false;
    return true;
}
 

/**
 * Return a handler mapping ordered at Integer.MAX_VALUE-1 with mapped
 * resource handlers. To configure resource handling, override
 * {@link #addResourceHandlers}.
 */
@Bean
@Nullable
public HandlerMapping resourceHandlerMapping(UrlPathHelper mvcUrlPathHelper,
		PathMatcher mvcPathMatcher,
		ContentNegotiationManager mvcContentNegotiationManager,
		FormattingConversionService mvcConversionService,
		ResourceUrlProvider mvcResourceUrlProvider) {
	Assert.state(this.applicationContext != null, "No ApplicationContext set");
	Assert.state(this.servletContext != null, "No ServletContext set");

	ResourceHandlerRegistry registry = new ResourceHandlerRegistry(this.applicationContext,
			this.servletContext, mvcContentNegotiationManager, mvcUrlPathHelper);
	addResourceHandlers(registry);

	AbstractHandlerMapping handlerMapping = registry.getHandlerMapping();
	if (handlerMapping == null) {
		return null;
	}
	handlerMapping.setPathMatcher(mvcPathMatcher);
	handlerMapping.setUrlPathHelper(mvcUrlPathHelper);
	handlerMapping.setInterceptors(getInterceptors(mvcConversionService, mvcResourceUrlProvider));
	handlerMapping.setCorsConfigurations(getCorsConfigurations());
	return handlerMapping;
}
 

/**
 * Return a handler mapping ordered at 1 to map URL paths directly to
 * view names. To configure view controllers, override
 * {@link #addViewControllers}.
 */
@Bean
@Nullable
public HandlerMapping viewControllerHandlerMapping(PathMatcher mvcPathMatcher,
		UrlPathHelper mvcUrlPathHelper,
		FormattingConversionService mvcConversionService,
		ResourceUrlProvider mvcResourceUrlProvider) {
	ViewControllerRegistry registry = new ViewControllerRegistry(this.applicationContext);
	addViewControllers(registry);

	AbstractHandlerMapping handlerMapping = registry.buildHandlerMapping();
	if (handlerMapping == null) {
		return null;
	}
	handlerMapping.setPathMatcher(mvcPathMatcher);
	handlerMapping.setUrlPathHelper(mvcUrlPathHelper);
	handlerMapping.setInterceptors(getInterceptors(mvcConversionService, mvcResourceUrlProvider));
	handlerMapping.setCorsConfigurations(getCorsConfigurations());
	return handlerMapping;
}
 

@SuppressWarnings("unchecked")
private static void validateLocale(HttpServletRequest request, List<String> sourceLocales2)
		throws VIPAPIException {
	Map<String, String> pathVariables = (Map<String, String>) request
			.getAttribute(HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE);
	String locale = pathVariables.get(APIParamName.LOCALE) == null ? request
			.getParameter(APIParamName.LOCALE) : pathVariables
			.get(APIParamName.LOCALE);
	if (StringUtils.isEmpty(locale)) {
		return;
	}
	if (!RegExpValidatorUtils.IsLetterAndNumberAndValidchar(locale)) {
		throw new VIPAPIException(ValidationMsg.LOCALE_NOT_VALIDE);
	}else if (!sourceLocales2.contains(locale)) {
		throw new VIPAPIException(ValidationMsg.LOCALE_NOT_VALIDE);
	}
}
 

@Test
public void uriTemplateVarAndRequestParam() throws Exception {
	request.addParameter("age", "35");

	Map<String, String> uriTemplateVars = new HashMap<>();
	uriTemplateVars.put("name", "nameValue");
	uriTemplateVars.put("age", "25");
	request.setAttribute(HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE, uriTemplateVars);

	TestBean target = new TestBean();
	WebDataBinder binder = new ExtendedServletRequestDataBinder(target, "");
	((ServletRequestDataBinder) binder).bind(request);

	assertEquals("nameValue", target.getName());
	assertEquals(35, target.getAge());
}
 

/**
 * Return a handler mapping ordered at Integer.MAX_VALUE-1 with mapped
 * resource handlers. To configure resource handling, override
 * {@link #addResourceHandlers}.
 */
@Bean
public HandlerMapping resourceHandlerMapping() {
	ResourceHandlerRegistry registry = new ResourceHandlerRegistry(this.applicationContext,
			this.servletContext, mvcContentNegotiationManager());
	addResourceHandlers(registry);

	AbstractHandlerMapping handlerMapping = registry.getHandlerMapping();
	if (handlerMapping != null) {
		handlerMapping.setPathMatcher(mvcPathMatcher());
		handlerMapping.setUrlPathHelper(mvcUrlPathHelper());
		handlerMapping.setInterceptors(new ResourceUrlProviderExposingInterceptor(mvcResourceUrlProvider()));
		handlerMapping.setCorsConfigurations(getCorsConfigurations());
	}
	else {
		handlerMapping = new EmptyHandlerMapping();
	}
	return handlerMapping;
}
 

@Test
public void emptyHandlerMappings() {
	ApplicationContext context = initContext(WebConfig.class);

	Map<String, HandlerMapping> handlerMappings = context.getBeansOfType(HandlerMapping.class);
	assertFalse(handlerMappings.containsKey("viewControllerHandlerMapping"));
	assertFalse(handlerMappings.containsKey("resourceHandlerMapping"));
	assertFalse(handlerMappings.containsKey("defaultServletHandlerMapping"));

	Object nullBean = context.getBean("viewControllerHandlerMapping");
	assertTrue(nullBean.equals(null));

	nullBean = context.getBean("resourceHandlerMapping");
	assertTrue(nullBean.equals(null));

	nullBean = context.getBean("defaultServletHandlerMapping");
	assertTrue(nullBean.equals(null));
}
 

/**
 * Find the {@link HandlerMapping} that would handle the given request and
 * return it as a {@link MatchableHandlerMapping} that can be used to test
 * request-matching criteria.
 * <p>If the matching HandlerMapping is not an instance of
 * {@link MatchableHandlerMapping}, an IllegalStateException is raised.
 * @param request the current request
 * @return the resolved matcher, or {@code null}
 * @throws Exception if any of the HandlerMapping's raise an exception
 */
public HandlerExecutionChain getHandlerExecutionChain(HttpServletRequest request) throws Exception {
    Assert.notNull(this.handlerMappings, "Handler mappings not initialized");
    HttpServletRequest wrapper = new RequestAttributeChangeIgnoringWrapper(request);
    for (HandlerMapping handlerMapping : this.handlerMappings) {
        Object handler = handlerMapping.getHandler(wrapper);
        if (handler == null) {
            continue;
        }
        if (handler instanceof HandlerExecutionChain) {
            return (HandlerExecutionChain)handler;
        }
        throw new IllegalStateException("HandlerMapping is not a MatchableHandlerMapping");
    }
    return null;
}
 

@Test
public void resolveArgumentWrappedAsOptional() throws Exception {
	Map<String, String> uriTemplateVars = new HashMap<>();
	uriTemplateVars.put("name", "value");
	request.setAttribute(HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE, uriTemplateVars);

	ConfigurableWebBindingInitializer initializer = new ConfigurableWebBindingInitializer();
	initializer.setConversionService(new DefaultConversionService());
	WebDataBinderFactory binderFactory = new DefaultDataBinderFactory(initializer);

	@SuppressWarnings("unchecked")
	Optional<String> result = (Optional<String>)
			resolver.resolveArgument(paramOptional, mavContainer, webRequest, binderFactory);
	assertEquals("PathVariable not resolved correctly", "value", result.get());

	@SuppressWarnings("unchecked")
	Map<String, Object> pathVars = (Map<String, Object>) request.getAttribute(View.PATH_VARIABLES);
	assertNotNull(pathVars);
	assertEquals(1, pathVars.size());
	assertEquals(Optional.of("value"), pathVars.get("name"));
}
 

@Test
public void resolveArgumentWithExistingPathVars() throws Exception {
	Map<String, String> uriTemplateVars = new HashMap<>();
	uriTemplateVars.put("name", "value");
	request.setAttribute(HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE, uriTemplateVars);

	uriTemplateVars.put("oldName", "oldValue");
	request.setAttribute(View.PATH_VARIABLES, uriTemplateVars);

	String result = (String) resolver.resolveArgument(paramNamedString, mavContainer, webRequest, null);
	assertEquals("PathVariable not resolved correctly", "value", result);

	@SuppressWarnings("unchecked")
	Map<String, Object> pathVars = (Map<String, Object>) request.getAttribute(View.PATH_VARIABLES);
	assertNotNull(pathVars);
	assertEquals(2, pathVars.size());
	assertEquals("value", pathVars.get("name"));
	assertEquals("oldValue", pathVars.get("oldName"));
}
 

@Test
public void partialContentInvalidRangeHeader() throws Exception {
	this.request.addHeader("Range", "bytes= foo bar");
	this.request.setAttribute(HandlerMapping.PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE, "foo.txt");
	this.handler.handleRequest(this.request, this.response);

	assertEquals(416, this.response.getStatus());
	assertEquals("bytes */10", this.response.getHeader("Content-Range"));
	assertEquals("bytes", this.response.getHeader("Accept-Ranges"));
	assertEquals(1, this.response.getHeaders("Accept-Ranges").size());
}
 

@Test
public void mediaTypes() throws Exception {

	// Media type from request
	this.servletRequest.addHeader("Accept", "text/event-stream");
	testSseResponse(true);

	// Media type from "produces" attribute
	Set<MediaType> types = Collections.singleton(MediaType.TEXT_EVENT_STREAM);
	this.servletRequest.setAttribute(HandlerMapping.PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE, types);
	testSseResponse(true);

	// No media type preferences
	testSseResponse(false);
}
 

@Test
public void createAttributeUriTemplateVar() throws Exception {
	Map<String, String> uriTemplateVars = new HashMap<>();
	uriTemplateVars.put("testBean1", "Patty");
	request.setAttribute(HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE, uriTemplateVars);

	// Type conversion from "Patty" to TestBean via TestBean(String) constructor
	TestBean testBean = (TestBean) processor.resolveArgument(
			testBeanModelAttr, mavContainer, webRequest, binderFactory);

	assertEquals("Patty", testBean.getName());
}
 

@SuppressWarnings("unchecked")
private List<MediaType> getProducibleMediaTypes(HttpServletRequest request) {
	Set<MediaType> mediaTypes = (Set<MediaType>)
			request.getAttribute(HandlerMapping.PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE);
	if (!CollectionUtils.isEmpty(mediaTypes)) {
		return new ArrayList<MediaType>(mediaTypes);
	}
	else {
		return Collections.singletonList(MediaType.ALL);
	}
}
 

@Test
public void createBinder() throws Exception {
	Map<String, String> uriTemplateVars = new HashMap<>();
	uriTemplateVars.put("name", "nameValue");
	uriTemplateVars.put("age", "25");
	request.setAttribute(HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE, uriTemplateVars);

	TestBean target = new TestBean();
	WebDataBinder binder = new ExtendedServletRequestDataBinder(target, "");
	((ServletRequestDataBinder) binder).bind(request);

	assertEquals("nameValue", target.getName());
	assertEquals(25, target.getAge());
}
 

@Test
public void handlerMapping() {
	ApplicationContext config = createConfig(TestChannelConfig.class, TestConfigurer.class);
	SimpleUrlHandlerMapping hm = (SimpleUrlHandlerMapping) config.getBean(HandlerMapping.class);
	assertEquals(1, hm.getOrder());

	Map<String, Object> handlerMap = hm.getHandlerMap();
	assertEquals(1, handlerMap.size());
	assertNotNull(handlerMap.get("/simpleBroker"));
}
 

@Test
public void testRequestAttributeMatcher() throws Exception {

	String producibleMediaTypes = HandlerMapping.PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE;

	this.mockMvc.perform(get("/1"))
		.andExpect(request().attribute(producibleMediaTypes, hasItem(MediaType.APPLICATION_JSON)))
		.andExpect(request().attribute(producibleMediaTypes, not(hasItem(MediaType.APPLICATION_XML))));
}
 

@SuppressWarnings("unchecked")
private MultiValueMap<String, String> getVariablesFor(String pathVarName) {
	Map<String, MultiValueMap<String, String>> matrixVariables =
			(Map<String, MultiValueMap<String, String>>) this.request.getAttribute(
					HandlerMapping.MATRIX_VARIABLES_ATTRIBUTE);

	MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
	matrixVariables.put(pathVarName, params);
	return params;
}
 

private HandlerExecutionChain getHandler(HandlerMapping hm, MockHttpServletRequest req) throws Exception {
	HandlerExecutionChain hec = hm.getHandler(req);
	HandlerInterceptor[] interceptors = hec.getInterceptors();
	if (interceptors != null) {
		for (HandlerInterceptor interceptor : interceptors) {
			interceptor.preHandle(req, null, hec.getHandler());
		}
	}
	return hec;
}
 

@Override
public CorsConfiguration getCorsConfiguration(HttpServletRequest request) {
	Assert.notNull(this.handlerMappings, "Handler mappings not initialized");
	HttpServletRequest wrapper = new RequestAttributeChangeIgnoringWrapper(request);
	for (HandlerMapping handlerMapping : this.handlerMappings) {
		HandlerExecutionChain handler = null;
		try {
			handler = handlerMapping.getHandler(wrapper);
		}
		catch (Exception ex) {
			// Ignore
		}
		if (handler == null) {
			continue;
		}
		if (handler.getInterceptors() != null) {
			for (HandlerInterceptor interceptor : handler.getInterceptors()) {
				if (interceptor instanceof CorsConfigurationSource) {
					return ((CorsConfigurationSource) interceptor).getCorsConfiguration(wrapper);
				}
			}
		}
		if (handler.getHandler() instanceof CorsConfigurationSource) {
			return ((CorsConfigurationSource) handler.getHandler()).getCorsConfiguration(wrapper);
		}
	}
	return null;
}
 

private void testResolvePathWithTraversal(Resource location, String requestPath) throws Exception {
	this.request.setAttribute(HandlerMapping.PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE, requestPath);
	this.response = new MockHttpServletResponse();
	this.handler.handleRequest(this.request, this.response);
	if (!location.createRelative(requestPath).exists() && !requestPath.contains(":")) {
		fail(requestPath + " doesn't actually exist as a relative path");
	}
	assertEquals(HttpStatus.NOT_FOUND.value(), this.response.getStatus());
}
 

@SuppressWarnings("unchecked")
private void validateComponent(HttpServletRequest request)
		throws ValidationException {
	Map<String, String> pathVariables = (Map<String, String>) request
			.getAttribute(HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE);
	String component = pathVariables.get(APIParamName.COMPONENT) == null ? request
			.getParameter(APIParamName.COMPONENT) : pathVariables
			.get(APIParamName.COMPONENT);
	if (StringUtils.isEmpty(component)) {
		return;
	}
	if (!RegExpValidatorUtils.IsLetterAndNumberAndValidchar(component)) {
		throw new ValidationException(ValidationMsg.COMPONENT_NOT_VALIDE);
	}
}
 

@Test
public void directMatch() throws Exception {
	String key = "foo";
	this.mapping.registerMapping(key, this.handler, this.method1);

	MockHttpServletRequest request = new MockHttpServletRequest("GET", key);
	HandlerMethod result = this.mapping.getHandlerInternal(request);
	assertEquals(method1, result.getMethod());
	assertEquals(result, request.getAttribute(HandlerMapping.BEST_MATCHING_HANDLER_ATTRIBUTE));
}
 

public void defaultHandlerMappings() throws Exception {
	StaticWebApplicationContext cxt = new StaticWebApplicationContext();
	cxt.refresh();

	List<HandlerMapping> actual = getIntrospector(cxt).getHandlerMappings();
	assertEquals(2, actual.size());
	assertEquals(BeanNameUrlHandlerMapping.class, actual.get(0).getClass());
	assertEquals(RequestMappingHandlerMapping.class, actual.get(1).getClass());
}
 

@Test
public void getResourceFromSubDirectory() throws Exception {
	this.request.setAttribute(HandlerMapping.PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE, "js/foo.js");
	this.handler.handleRequest(this.request, this.response);

	assertEquals("text/javascript", this.response.getContentType());
	assertEquals("function foo() { console.log(\"hello world\"); }", this.response.getContentAsString());
}
 

@Test
public void getResourceFromSubDirectoryOfAlternatePath() throws Exception {
	this.request.setAttribute(HandlerMapping.PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE, "js/baz.js");
	this.handler.handleRequest(this.request, this.response);

	assertEquals("text/javascript", this.response.getContentType());
	assertEquals("function foo() { console.log(\"hello world\"); }", this.response.getContentAsString());
}
 

@Test
public void getResourceFromAlternatePath() throws Exception {
	this.request.setAttribute(HandlerMapping.PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE, "baz.css");
	this.handler.handleRequest(this.request, this.response);

	assertEquals("text/css", this.response.getContentType());
	assertEquals(17, this.response.getContentLength());
	assertEquals("max-age=3600", this.response.getHeader("Cache-Control"));
	assertTrue(this.response.containsHeader("Last-Modified"));
	assertEquals(resourceLastModified("testalternatepath/baz.css") / 1000,
			this.response.getDateHeader("Last-Modified") / 1000);
	assertEquals("bytes", this.response.getHeader("Accept-Ranges"));
	assertEquals(1, this.response.getHeaders("Accept-Ranges").size());
	assertEquals("h1 { color:red; }", this.response.getContentAsString());
}
 

@Test  // SPR-14005
public void doOverwriteExistingCacheControlHeaders() throws Exception {
	this.request.setAttribute(HandlerMapping.PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE, "foo.css");
	this.response.setHeader("Cache-Control", "no-store");

	this.handler.handleRequest(this.request, this.response);

	assertEquals("max-age=3600", this.response.getHeader("Cache-Control"));
}
 

@Test
public void createAttributeUriTemplateVarCannotConvert() throws Exception {
	Map<String, String> uriTemplateVars = new HashMap<>();
	uriTemplateVars.put("testBean2", "Patty");
	request.setAttribute(HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE, uriTemplateVars);

	TestBeanWithoutStringConstructor testBean = (TestBeanWithoutStringConstructor) processor.resolveArgument(
			testBeanWithoutStringConstructorModelAttr, mavContainer, webRequest, binderFactory);

	assertNotNull(testBean);
}