@SuppressWarnings("unchecked") protected Map<String, List<Resource>> getMappingLocations(HandlerMapping mapping) throws IllegalAccessException { Map<String, List<Resource>> mappingLocations = new LinkedHashMap<String, List<Resource>>(); if (mapping instanceof SimpleUrlHandlerMapping) { Field locationsField = ReflectionUtils .findField(ResourceHttpRequestHandler.class, "locations"); locationsField.setAccessible(true); for (Map.Entry<String, Object> entry : ((SimpleUrlHandlerMapping) mapping) .getHandlerMap().entrySet()) { ResourceHttpRequestHandler handler = (ResourceHttpRequestHandler) entry .getValue(); mappingLocations.put(entry.getKey(), (List<Resource>) locationsField.get(handler)); } } return mappingLocations; }
protected void detectResourceHandlers(ApplicationContext appContext) { logger.debug("Looking for resource handler mappings"); Map<String, SimpleUrlHandlerMapping> map = appContext.getBeansOfType(SimpleUrlHandlerMapping.class); List<SimpleUrlHandlerMapping> handlerMappings = new ArrayList<SimpleUrlHandlerMapping>(map.values()); AnnotationAwareOrderComparator.sort(handlerMappings); for (SimpleUrlHandlerMapping hm : handlerMappings) { for (String pattern : hm.getHandlerMap().keySet()) { Object handler = hm.getHandlerMap().get(pattern); if (handler instanceof ResourceHttpRequestHandler) { ResourceHttpRequestHandler resourceHandler = (ResourceHttpRequestHandler) handler; if (logger.isDebugEnabled()) { logger.debug("Found resource handler mapping: URL pattern=\"" + pattern + "\", " + "locations=" + resourceHandler.getLocations() + ", " + "resolvers=" + resourceHandler.getResourceResolvers()); } this.handlerMap.put(pattern, resourceHandler); } } } }
private BeanDefinition registerHandlerMapping(ParserContext context, Object source) { if (context.getRegistry().containsBeanDefinition(HANDLER_MAPPING_BEAN_NAME)) { return context.getRegistry().getBeanDefinition(HANDLER_MAPPING_BEAN_NAME); } RootBeanDefinition beanDef = new RootBeanDefinition(SimpleUrlHandlerMapping.class); beanDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE); context.getRegistry().registerBeanDefinition(HANDLER_MAPPING_BEAN_NAME, beanDef); context.registerComponent(new BeanComponentDefinition(beanDef, HANDLER_MAPPING_BEAN_NAME)); beanDef.setSource(source); beanDef.getPropertyValues().add("order", "1"); beanDef.getPropertyValues().add("pathMatcher", MvcNamespaceUtils.registerPathMatcher(null, context, source)); beanDef.getPropertyValues().add("urlPathHelper", MvcNamespaceUtils.registerUrlPathHelper(null, context, source)); RuntimeBeanReference corsConfigurationsRef = MvcNamespaceUtils.registerCorsConfigurations(null, context, source); beanDef.getPropertyValues().add("corsConfigurations", corsConfigurationsRef); return beanDef; }
@Test public void testDefaultServletHandler() throws Exception { loadBeanDefinitions("mvc-config-default-servlet.xml", 6); HttpRequestHandlerAdapter adapter = appContext.getBean(HttpRequestHandlerAdapter.class); assertNotNull(adapter); DefaultServletHttpRequestHandler handler = appContext.getBean(DefaultServletHttpRequestHandler.class); assertNotNull(handler); SimpleUrlHandlerMapping mapping = appContext.getBean(SimpleUrlHandlerMapping.class); assertNotNull(mapping); assertEquals(Ordered.LOWEST_PRECEDENCE, mapping.getOrder()); MockHttpServletRequest request = new MockHttpServletRequest(); request.setRequestURI("/foo.css"); request.setMethod("GET"); HandlerExecutionChain chain = mapping.getHandler(request); assertTrue(chain.getHandler() instanceof DefaultServletHttpRequestHandler); MockHttpServletResponse response = new MockHttpServletResponse(); ModelAndView mv = adapter.handle(request, response, chain.getHandler()); assertNull(mv); }
@Test public void testDefaultServletHandlerWithOptionalAttributes() throws Exception { loadBeanDefinitions("mvc-config-default-servlet-optional-attrs.xml", 6); HttpRequestHandlerAdapter adapter = appContext.getBean(HttpRequestHandlerAdapter.class); assertNotNull(adapter); DefaultServletHttpRequestHandler handler = appContext.getBean(DefaultServletHttpRequestHandler.class); assertNotNull(handler); SimpleUrlHandlerMapping mapping = appContext.getBean(SimpleUrlHandlerMapping.class); assertNotNull(mapping); assertEquals(Ordered.LOWEST_PRECEDENCE, mapping.getOrder()); MockHttpServletRequest request = new MockHttpServletRequest(); request.setRequestURI("/foo.css"); request.setMethod("GET"); HandlerExecutionChain chain = mapping.getHandler(request); assertTrue(chain.getHandler() instanceof DefaultServletHttpRequestHandler); MockHttpServletResponse response = new MockHttpServletResponse(); ModelAndView mv = adapter.handle(request, response, chain.getHandler()); assertNull(mv); }
@Test public void testViewControllersDefaultConfig() { loadBeanDefinitions("mvc-config-view-controllers-minimal.xml", 7); SimpleUrlHandlerMapping hm = this.appContext.getBean(SimpleUrlHandlerMapping.class); assertNotNull(hm); ParameterizableViewController viewController = (ParameterizableViewController) hm.getUrlMap().get("/path"); assertNotNull(viewController); assertEquals("home", viewController.getViewName()); ParameterizableViewController redirectViewController = (ParameterizableViewController) hm.getUrlMap().get("/old"); assertNotNull(redirectViewController); assertThat(redirectViewController.getView(), Matchers.instanceOf(RedirectView.class)); ParameterizableViewController statusViewController = (ParameterizableViewController) hm.getUrlMap().get("/bad"); assertNotNull(statusViewController); assertEquals(404, statusViewController.getStatusCode().value()); BeanNameUrlHandlerMapping beanNameMapping = this.appContext.getBean(BeanNameUrlHandlerMapping.class); assertNotNull(beanNameMapping); assertEquals(2, beanNameMapping.getOrder()); }
@Test public void testPathMatchingHandlerMappings() throws Exception { loadBeanDefinitions("mvc-config-path-matching-mappings.xml", 23); RequestMappingHandlerMapping requestMapping = appContext.getBean(RequestMappingHandlerMapping.class); assertNotNull(requestMapping); assertEquals(TestPathHelper.class, requestMapping.getUrlPathHelper().getClass()); assertEquals(TestPathMatcher.class, requestMapping.getPathMatcher().getClass()); SimpleUrlHandlerMapping viewController = appContext.getBean(VIEWCONTROLLER_BEAN_NAME, SimpleUrlHandlerMapping.class); assertNotNull(viewController); assertEquals(TestPathHelper.class, viewController.getUrlPathHelper().getClass()); assertEquals(TestPathMatcher.class, viewController.getPathMatcher().getClass()); for (SimpleUrlHandlerMapping handlerMapping : appContext.getBeansOfType(SimpleUrlHandlerMapping.class).values()) { assertNotNull(handlerMapping); assertEquals(TestPathHelper.class, handlerMapping.getUrlPathHelper().getClass()); assertEquals(TestPathMatcher.class, handlerMapping.getPathMatcher().getClass()); } }
@Test public void enable() throws Exception { configurer.enable(); SimpleUrlHandlerMapping getHandlerMapping = getHandlerMapping(); SimpleUrlHandlerMapping handlerMapping = getHandlerMapping; DefaultServletHttpRequestHandler handler = (DefaultServletHttpRequestHandler) handlerMapping.getUrlMap().get("/**"); assertNotNull(handler); assertEquals(Integer.MAX_VALUE, handlerMapping.getOrder()); handler.handleRequest(new MockHttpServletRequest(), response); String expected = "default"; assertEquals("The ServletContext was not called with the default servlet name", expected, servletContext.url); assertEquals("The request was not forwarded", expected, response.getForwardedUrl()); }
/** * Return a handler mapping with the mapped ViewControllers; or {@code null} in case * of no registrations. */ public AbstractHandlerMapping getHandlerMapping() { Map<String, Object> urlMap = new LinkedHashMap<>(); for (WebMvcWampWebSocketEndpointRegistration registration : this.registrations) { MultiValueMap<HttpRequestHandler, String> mappings = registration .getMappings(); for (HttpRequestHandler httpHandler : mappings.keySet()) { for (String pattern : mappings.get(httpHandler)) { urlMap.put(pattern, httpHandler); } } } SimpleUrlHandlerMapping hm = new SimpleUrlHandlerMapping(); hm.setUrlMap(urlMap); hm.setOrder(this.order); if (this.urlPathHelper != null) { hm.setUrlPathHelper(this.urlPathHelper); } return hm; }
@Override @Before public void setUp() throws Exception { requestPayload = readResource("request_add.txt"); responsePayload = readResource("response_add.txt"); MockServletContext servletContext = new MockServletContext(new ResourceLoaderSupport()); MockServletConfig servletConfig = new MockServletConfig(servletContext); applicationContext = new XmlWebApplicationContext(); applicationContext.setServletContext(servletContext); applicationContext.setServletConfig(servletConfig); applicationContext.setConfigLocations(new String[] { "src/main/webapp/WEB-INF/exporter-servlet.xml", "src/main/webapp/WEB-INF/applicationContext.xml" }); applicationContext.refresh(); handlerMapping = (SimpleUrlHandlerMapping) applicationContext .getBean("org.springframework.web.servlet.handler.SimpleUrlHandlerMapping"); }
/** * Returns a handler mapping with the mapped ViewControllers; or {@code null} in case of no registrations. */ protected AbstractHandlerMapping getHandlerMapping() { if (registrations.isEmpty()) { return null; } Map<String, Object> urlMap = new LinkedHashMap<String, Object>(); for (ViewControllerRegistration registration : registrations) { urlMap.put(registration.getUrlPath(), registration.getViewController()); } SimpleUrlHandlerMapping handlerMapping = new SimpleUrlHandlerMapping(); handlerMapping.setOrder(order); handlerMapping.setUrlMap(urlMap); return handlerMapping; }
/** * Return a handler mapping with the mapped resource handlers; or {@code null} in case of no registrations. */ protected AbstractHandlerMapping getHandlerMapping() { if (registrations.isEmpty()) { return null; } Map<String, HttpRequestHandler> urlMap = new LinkedHashMap<String, HttpRequestHandler>(); for (ResourceHandlerRegistration registration : registrations) { for (String pathPattern : registration.getPathPatterns()) { ResourceHttpRequestHandler requestHandler = registration.getRequestHandler(); requestHandler.setServletContext(servletContext); requestHandler.setApplicationContext(applicationContext); urlMap.put(pathPattern, requestHandler); } } SimpleUrlHandlerMapping handlerMapping = new SimpleUrlHandlerMapping(); handlerMapping.setOrder(order); handlerMapping.setUrlMap(urlMap); return handlerMapping; }
@Test public void testDefaultServletHandler() throws Exception { loadBeanDefinitions("mvc-config-default-servlet.xml", 5); HttpRequestHandlerAdapter adapter = appContext.getBean(HttpRequestHandlerAdapter.class); assertNotNull(adapter); DefaultServletHttpRequestHandler handler = appContext.getBean(DefaultServletHttpRequestHandler.class); assertNotNull(handler); SimpleUrlHandlerMapping mapping = appContext.getBean(SimpleUrlHandlerMapping.class); assertNotNull(mapping); assertEquals(Ordered.LOWEST_PRECEDENCE, mapping.getOrder()); MockHttpServletRequest request = new MockHttpServletRequest(); request.setRequestURI("/foo.css"); request.setMethod("GET"); HandlerExecutionChain chain = mapping.getHandler(request); assertTrue(chain.getHandler() instanceof DefaultServletHttpRequestHandler); MockHttpServletResponse response = new MockHttpServletResponse(); ModelAndView mv = adapter.handle(request, response, chain.getHandler()); assertNull(mv); }
@Test public void testDefaultServletHandlerWithOptionalAttributes() throws Exception { loadBeanDefinitions("mvc-config-default-servlet-optional-attrs.xml", 5); HttpRequestHandlerAdapter adapter = appContext.getBean(HttpRequestHandlerAdapter.class); assertNotNull(adapter); DefaultServletHttpRequestHandler handler = appContext.getBean(DefaultServletHttpRequestHandler.class); assertNotNull(handler); SimpleUrlHandlerMapping mapping = appContext.getBean(SimpleUrlHandlerMapping.class); assertNotNull(mapping); assertEquals(Ordered.LOWEST_PRECEDENCE, mapping.getOrder()); MockHttpServletRequest request = new MockHttpServletRequest(); request.setRequestURI("/foo.css"); request.setMethod("GET"); HandlerExecutionChain chain = mapping.getHandler(request); assertTrue(chain.getHandler() instanceof DefaultServletHttpRequestHandler); MockHttpServletResponse response = new MockHttpServletResponse(); ModelAndView mv = adapter.handle(request, response, chain.getHandler()); assertNull(mv); }
/** * Add controller to cas servlet handler mapping. * * @param path the path * @param controller the controller */ protected final void addControllerToCasServletHandlerMapping(final String path, final Object controller) { logger.debug("Adding {} to application context for {}", controller, path); final SimpleUrlHandlerMapping handlerMappingC = getCasServletHandlerMapping(); final Map<String, Object> urlMap = (Map<String, Object>) handlerMappingC.getUrlMap(); urlMap.put(path, controller); handlerMappingC.initApplicationContext(); }
@Bean public SimpleUrlHandlerMapping handlerMappingC() { final SimpleUrlHandlerMapping mapping = new SimpleUrlHandlerMapping(); mapping.setOrder(1); mapping.setAlwaysUseFullPath(true); mapping.setRootHandler(rootController()); final Properties properties = new Properties(); properties.put("/*.html", new UrlFilenameViewController()); mapping.setMappings(properties); return mapping; }
@Bean public SimpleUrlHandlerMapping handlerMapping() { final SimpleUrlHandlerMapping mapping = new SimpleUrlHandlerMapping(); final Controller root = rootController(); mapping.setOrder(1); mapping.setAlwaysUseFullPath(true); mapping.setRootHandler(root); final Map urls = new HashMap(); urls.put("/", root); mapping.setUrlMap(urls); return mapping; }
@Bean public SimpleUrlHandlerMapping handlerMapping() { SimpleUrlHandlerMapping mapping = new SimpleUrlHandlerMapping(); Controller root = this.rootController(); mapping.setOrder(1); mapping.setAlwaysUseFullPath(true); mapping.setRootHandler(root); Map urls = new HashMap(); urls.put("/", root); mapping.setUrlMap(urls); return mapping; }
public void setupUrlMapping(SimpleUrlHandlerMapping urlHandlerMapping) { Map<String, Object> urlMap = new HashMap<String, Object>(); for (String url : this.processor.getUrlMapping().keySet()) { if (url.endsWith("/")) { url = url + "**"; } urlMap.put(url, this); } urlHandlerMapping.setUrlMap(urlMap); }
/** * Return a handler mapping instance ordered at {@link Integer#MAX_VALUE} containing the * {@link DefaultServletHttpRequestHandler} instance mapped to {@code "/**"}; or {@code null} if * default servlet handling was not been enabled. */ protected AbstractHandlerMapping getHandlerMapping() { if (handler == null) { return null; } Map<String, HttpRequestHandler> urlMap = new HashMap<String, HttpRequestHandler>(); urlMap.put("/**", handler); SimpleUrlHandlerMapping handlerMapping = new SimpleUrlHandlerMapping(); handlerMapping.setOrder(Integer.MAX_VALUE); handlerMapping.setUrlMap(urlMap); return handlerMapping; }
/** * Return a handler mapping with the mapped resource handlers; or {@code null} in case of no registrations. */ protected AbstractHandlerMapping getHandlerMapping() { if (registrations.isEmpty()) { return null; } Map<String, HttpRequestHandler> urlMap = new LinkedHashMap<String, HttpRequestHandler>(); for (ResourceHandlerRegistration registration : this.registrations) { for (String pathPattern : registration.getPathPatterns()) { ResourceHttpRequestHandler handler = registration.getRequestHandler(); handler.setServletContext(this.servletContext); handler.setApplicationContext(this.appContext); try { handler.afterPropertiesSet(); } catch (Exception e) { throw new BeanInitializationException("Failed to init ResourceHttpRequestHandler", e); } urlMap.put(pathPattern, handler); } } SimpleUrlHandlerMapping handlerMapping = new SimpleUrlHandlerMapping(); handlerMapping.setOrder(order); handlerMapping.setUrlMap(urlMap); return handlerMapping; }
@Override public BeanDefinition parse(Element element, ParserContext parserContext) { Object source = parserContext.extractSource(element); String defaultServletName = element.getAttribute("default-servlet-name"); RootBeanDefinition defaultServletHandlerDef = new RootBeanDefinition(DefaultServletHttpRequestHandler.class); defaultServletHandlerDef.setSource(source); defaultServletHandlerDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE); if (StringUtils.hasText(defaultServletName)) { defaultServletHandlerDef.getPropertyValues().add("defaultServletName", defaultServletName); } String defaultServletHandlerName = parserContext.getReaderContext().generateBeanName(defaultServletHandlerDef); parserContext.getRegistry().registerBeanDefinition(defaultServletHandlerName, defaultServletHandlerDef); parserContext.registerComponent(new BeanComponentDefinition(defaultServletHandlerDef, defaultServletHandlerName)); Map<String, String> urlMap = new ManagedMap<String, String>(); urlMap.put("/**", defaultServletHandlerName); RootBeanDefinition handlerMappingDef = new RootBeanDefinition(SimpleUrlHandlerMapping.class); handlerMappingDef.setSource(source); handlerMappingDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE); handlerMappingDef.getPropertyValues().add("urlMap", urlMap); String handlerMappingBeanName = parserContext.getReaderContext().generateBeanName(handlerMappingDef); parserContext.getRegistry().registerBeanDefinition(handlerMappingBeanName, handlerMappingDef); parserContext.registerComponent(new BeanComponentDefinition(handlerMappingDef, handlerMappingBeanName)); // Ensure BeanNameUrlHandlerMapping (SPR-8289) and default HandlerAdapters are not "turned off" MvcNamespaceUtils.registerDefaultComponents(parserContext, source); return null; }
@Bean public SimpleUrlHandlerMapping simpleUrlHandlerMapping() { ResourceHttpRequestHandler handler = new ResourceHttpRequestHandler(); HashMap<String, ResourceHttpRequestHandler> handlerMap = new HashMap<String, ResourceHttpRequestHandler>(); handlerMap.put("/resources/**", handler); SimpleUrlHandlerMapping hm = new SimpleUrlHandlerMapping(); hm.setUrlMap(handlerMap); return hm; }
@Test @SuppressWarnings("serial") public void simpleUrlHandlerMapping() throws Exception { servlet = new DispatcherServlet() { @Override protected WebApplicationContext createWebApplicationContext(WebApplicationContext parent) throws BeansException { GenericWebApplicationContext wac = new GenericWebApplicationContext(); wac.registerBeanDefinition("controller", new RootBeanDefinition(BookController.class)); RootBeanDefinition hmDef = new RootBeanDefinition(SimpleUrlHandlerMapping.class); hmDef.getPropertyValues().add("mappings", "/book/*=controller\n/book=controller"); wac.registerBeanDefinition("handlerMapping", hmDef); wac.refresh(); return wac; } }; servlet.init(new MockServletConfig()); MockHttpServletRequest request = new MockHttpServletRequest("GET", "/book/list"); MockHttpServletResponse response = new MockHttpServletResponse(); servlet.service(request, response); assertEquals("list", response.getContentAsString()); request = new MockHttpServletRequest("GET", "/book/show"); request.addParameter("id", "12"); response = new MockHttpServletResponse(); servlet.service(request, response); assertEquals("show-id=12", response.getContentAsString()); request = new MockHttpServletRequest("POST", "/book"); response = new MockHttpServletResponse(); servlet.service(request, response); assertEquals("create", response.getContentAsString()); }
@Test public void detectHandlerMappingFromParent() throws ServletException, IOException { // create a parent context that includes a mapping StaticWebApplicationContext parent = new StaticWebApplicationContext(); parent.setServletContext(getServletContext()); parent.registerSingleton("parentHandler", ControllerFromParent.class, new MutablePropertyValues()); MutablePropertyValues pvs = new MutablePropertyValues(); pvs.addPropertyValue(new PropertyValue("mappings", URL_KNOWN_ONLY_PARENT + "=parentHandler")); parent.registerSingleton("parentMapping", SimpleUrlHandlerMapping.class, pvs); parent.refresh(); DispatcherServlet complexDispatcherServlet = new DispatcherServlet(); // will have parent complexDispatcherServlet.setContextClass(ComplexWebApplicationContext.class); complexDispatcherServlet.setNamespace("test"); ServletConfig config = new MockServletConfig(getServletContext(), "complex"); config.getServletContext().setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, parent); complexDispatcherServlet.init(config); MockHttpServletRequest request = new MockHttpServletRequest(getServletContext(), "GET", URL_KNOWN_ONLY_PARENT); MockHttpServletResponse response = new MockHttpServletResponse(); complexDispatcherServlet.service(request, response); assertFalse("Matched through parent controller/handler pair: not response=" + response.getStatus(), response.getStatus() == HttpServletResponse.SC_NOT_FOUND); }
@Test public void testResources() throws Exception { loadBeanDefinitions("mvc-config-resources.xml", 10); HttpRequestHandlerAdapter adapter = appContext.getBean(HttpRequestHandlerAdapter.class); assertNotNull(adapter); ResourceHttpRequestHandler handler = appContext.getBean(ResourceHttpRequestHandler.class); assertNotNull(handler); SimpleUrlHandlerMapping mapping = appContext.getBean(SimpleUrlHandlerMapping.class); assertNotNull(mapping); assertEquals(Ordered.LOWEST_PRECEDENCE - 1, mapping.getOrder()); BeanNameUrlHandlerMapping beanNameMapping = appContext.getBean(BeanNameUrlHandlerMapping.class); assertNotNull(beanNameMapping); assertEquals(2, beanNameMapping.getOrder()); ResourceUrlProvider urlProvider = appContext.getBean(ResourceUrlProvider.class); assertNotNull(urlProvider); MappedInterceptor mappedInterceptor = appContext.getBean(MappedInterceptor.class); assertNotNull(urlProvider); assertEquals(ResourceUrlProviderExposingInterceptor.class, mappedInterceptor.getInterceptor().getClass()); MockHttpServletRequest request = new MockHttpServletRequest(); request.setRequestURI("/resources/foo.css"); request.setMethod("GET"); HandlerExecutionChain chain = mapping.getHandler(request); assertTrue(chain.getHandler() instanceof ResourceHttpRequestHandler); MockHttpServletResponse response = new MockHttpServletResponse(); for (HandlerInterceptor interceptor : chain.getInterceptors()) { interceptor.preHandle(request, response, chain.getHandler()); } ModelAndView mv = adapter.handle(request, response, chain.getHandler()); assertNull(mv); }
@Test public void testResourcesWithOptionalAttributes() throws Exception { loadBeanDefinitions("mvc-config-resources-optional-attrs.xml", 10); SimpleUrlHandlerMapping mapping = appContext.getBean(SimpleUrlHandlerMapping.class); assertNotNull(mapping); assertEquals(5, mapping.getOrder()); assertNotNull(mapping.getUrlMap().get("/resources/**")); ResourceHttpRequestHandler handler = appContext.getBean((String) mapping.getUrlMap().get("/resources/**"), ResourceHttpRequestHandler.class); assertNotNull(handler); assertEquals(3600, handler.getCacheSeconds()); }
@Test public void testResourcesWithResolversTransformers() throws Exception { loadBeanDefinitions("mvc-config-resources-chain.xml", 11); SimpleUrlHandlerMapping mapping = appContext.getBean(SimpleUrlHandlerMapping.class); assertNotNull(mapping); assertNotNull(mapping.getUrlMap().get("/resources/**")); ResourceHttpRequestHandler handler = appContext.getBean((String) mapping.getUrlMap().get("/resources/**"), ResourceHttpRequestHandler.class); assertNotNull(handler); List<ResourceResolver> resolvers = handler.getResourceResolvers(); assertThat(resolvers, Matchers.hasSize(4)); assertThat(resolvers.get(0), Matchers.instanceOf(CachingResourceResolver.class)); assertThat(resolvers.get(1), Matchers.instanceOf(VersionResourceResolver.class)); assertThat(resolvers.get(2), Matchers.instanceOf(WebJarsResourceResolver.class)); assertThat(resolvers.get(3), Matchers.instanceOf(PathResourceResolver.class)); CachingResourceResolver cachingResolver = (CachingResourceResolver) resolvers.get(0); assertThat(cachingResolver.getCache(), Matchers.instanceOf(ConcurrentMapCache.class)); assertEquals("test-resource-cache", cachingResolver.getCache().getName()); VersionResourceResolver versionResolver = (VersionResourceResolver) resolvers.get(1); assertThat(versionResolver.getStrategyMap().get("/**/*.js"), Matchers.instanceOf(FixedVersionStrategy.class)); assertThat(versionResolver.getStrategyMap().get("/**"), Matchers.instanceOf(ContentVersionStrategy.class)); List<ResourceTransformer> transformers = handler.getResourceTransformers(); assertThat(transformers, Matchers.hasSize(3)); assertThat(transformers.get(0), Matchers.instanceOf(CachingResourceTransformer.class)); assertThat(transformers.get(1), Matchers.instanceOf(CssLinkResourceTransformer.class)); assertThat(transformers.get(2), Matchers.instanceOf(AppCacheManifestTransformer.class)); CachingResourceTransformer cachingTransformer = (CachingResourceTransformer) transformers.get(0); assertThat(cachingTransformer.getCache(), Matchers.instanceOf(ConcurrentMapCache.class)); assertEquals("test-resource-cache", cachingTransformer.getCache().getName()); }
@Test public void testResourcesWithResolversTransformersCustom() throws Exception { loadBeanDefinitions("mvc-config-resources-chain-no-auto.xml", 12); SimpleUrlHandlerMapping mapping = appContext.getBean(SimpleUrlHandlerMapping.class); assertNotNull(mapping); assertNotNull(mapping.getUrlMap().get("/resources/**")); ResourceHttpRequestHandler handler = appContext.getBean((String) mapping.getUrlMap().get("/resources/**"), ResourceHttpRequestHandler.class); assertNotNull(handler); assertThat(handler.getCacheControl().getHeaderValue(), Matchers.equalTo(CacheControl.maxAge(1, TimeUnit.HOURS) .sMaxAge(30, TimeUnit.MINUTES).cachePublic().getHeaderValue())); List<ResourceResolver> resolvers = handler.getResourceResolvers(); assertThat(resolvers, Matchers.hasSize(3)); assertThat(resolvers.get(0), Matchers.instanceOf(VersionResourceResolver.class)); assertThat(resolvers.get(1), Matchers.instanceOf(GzipResourceResolver.class)); assertThat(resolvers.get(2), Matchers.instanceOf(PathResourceResolver.class)); VersionResourceResolver versionResolver = (VersionResourceResolver) resolvers.get(0); assertThat(versionResolver.getStrategyMap().get("/**/*.js"), Matchers.instanceOf(FixedVersionStrategy.class)); assertThat(versionResolver.getStrategyMap().get("/**"), Matchers.instanceOf(ContentVersionStrategy.class)); List<ResourceTransformer> transformers = handler.getResourceTransformers(); assertThat(transformers, Matchers.hasSize(2)); assertThat(transformers.get(0), Matchers.instanceOf(CachingResourceTransformer.class)); assertThat(transformers.get(1), Matchers.instanceOf(AppCacheManifestTransformer.class)); }
@Test public void enableWithServletName() throws Exception { configurer.enable("defaultServlet"); SimpleUrlHandlerMapping handlerMapping = getHandlerMapping(); DefaultServletHttpRequestHandler handler = (DefaultServletHttpRequestHandler) handlerMapping.getUrlMap().get("/**"); assertNotNull(handler); assertEquals(Integer.MAX_VALUE, handlerMapping.getOrder()); handler.handleRequest(new MockHttpServletRequest(), response); String expected = "defaultServlet"; assertEquals("The ServletContext was not called with the default servlet name", expected, servletContext.url); assertEquals("The request was not forwarded", expected, response.getForwardedUrl()); }
@Test public void order() { this.registry.addViewController("/path"); SimpleUrlHandlerMapping handlerMapping = getHandlerMapping(); assertEquals(1, handlerMapping.getOrder()); this.registry.setOrder(2); handlerMapping = getHandlerMapping(); assertEquals(2, handlerMapping.getOrder()); }
@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 webSocketHandlerDecorator() throws Exception { ApplicationContext config = createConfig(WebSocketHandlerDecoratorConfig.class); WebSocketHandler handler = config.getBean(SubProtocolWebSocketHandler.class); assertNotNull(handler); SimpleUrlHandlerMapping mapping = (SimpleUrlHandlerMapping) config.getBean("stompWebSocketHandlerMapping"); WebSocketHttpRequestHandler httpHandler = (WebSocketHttpRequestHandler) mapping.getHandlerMap().get("/test"); handler = httpHandler.getWebSocketHandler(); WebSocketSession session = new TestWebSocketSession("id"); handler.afterConnectionEstablished(session); assertEquals(true, session.getAttributes().get("decorated")); }
@Test @SuppressWarnings("unchecked") public void webSocketHandlersAttributes() { loadBeanDefinitions("websocket-config-handlers-attributes.xml"); HandlerMapping handlerMapping = this.appContext.getBean(HandlerMapping.class); assertNotNull(handlerMapping); assertTrue(handlerMapping instanceof SimpleUrlHandlerMapping); SimpleUrlHandlerMapping urlHandlerMapping = (SimpleUrlHandlerMapping) handlerMapping; assertEquals(2, urlHandlerMapping.getOrder()); WebSocketHttpRequestHandler handler = (WebSocketHttpRequestHandler) urlHandlerMapping.getUrlMap().get("/foo"); assertNotNull(handler); unwrapAndCheckDecoratedHandlerType(handler.getWebSocketHandler(), FooWebSocketHandler.class); HandshakeHandler handshakeHandler = handler.getHandshakeHandler(); assertNotNull(handshakeHandler); assertTrue(handshakeHandler instanceof TestHandshakeHandler); List<HandshakeInterceptor> interceptors = handler.getHandshakeInterceptors(); assertThat(interceptors, contains(instanceOf(FooTestInterceptor.class), instanceOf(BarTestInterceptor.class), instanceOf(OriginHandshakeInterceptor.class))); handler = (WebSocketHttpRequestHandler) urlHandlerMapping.getUrlMap().get("/test"); assertNotNull(handler); unwrapAndCheckDecoratedHandlerType(handler.getWebSocketHandler(), TestWebSocketHandler.class); handshakeHandler = handler.getHandshakeHandler(); assertNotNull(handshakeHandler); assertTrue(handshakeHandler instanceof TestHandshakeHandler); interceptors = handler.getHandshakeInterceptors(); assertThat(interceptors, contains(instanceOf(FooTestInterceptor.class), instanceOf(BarTestInterceptor.class), instanceOf(OriginHandshakeInterceptor.class))); }
@Test @SuppressWarnings("unchecked") public void sockJsAttributes() { loadBeanDefinitions("websocket-config-handlers-sockjs-attributes.xml"); SimpleUrlHandlerMapping handlerMapping = appContext.getBean(SimpleUrlHandlerMapping.class); assertNotNull(handlerMapping); SockJsHttpRequestHandler handler = (SockJsHttpRequestHandler) handlerMapping.getUrlMap().get("/test/**"); assertNotNull(handler); unwrapAndCheckDecoratedHandlerType(handler.getWebSocketHandler(), TestWebSocketHandler.class); SockJsService sockJsService = handler.getSockJsService(); assertNotNull(sockJsService); assertThat(sockJsService, instanceOf(TransportHandlingSockJsService.class)); TransportHandlingSockJsService transportService = (TransportHandlingSockJsService) sockJsService; assertThat(transportService.getTaskScheduler(), instanceOf(TestTaskScheduler.class)); assertThat(transportService.getTransportHandlers().values(), containsInAnyOrder( instanceOf(XhrPollingTransportHandler.class), instanceOf(XhrStreamingTransportHandler.class))); assertEquals("testSockJsService", transportService.getName()); assertFalse(transportService.isWebSocketEnabled()); assertFalse(transportService.isSessionCookieNeeded()); assertEquals(2048, transportService.getStreamBytesLimit()); assertEquals(256, transportService.getDisconnectDelay()); assertEquals(1024, transportService.getHttpMessageCacheSize()); assertEquals(20, transportService.getHeartbeatTime()); assertEquals("/js/sockjs.min.js", transportService.getSockJsClientLibraryUrl()); assertEquals(TestMessageCodec.class, transportService.getMessageCodec().getClass()); List<HandshakeInterceptor> interceptors = transportService.getHandshakeInterceptors(); assertThat(interceptors, contains(instanceOf(OriginHandshakeInterceptor.class))); assertTrue(transportService.shouldSuppressCors()); assertTrue(transportService.getAllowedOrigins().contains("http://mydomain1.com")); assertTrue(transportService.getAllowedOrigins().contains("http://mydomain2.com")); }
@Bean public SimpleUrlHandlerMapping urlHandler() { SimpleUrlHandlerMapping handler = new SimpleUrlHandlerMapping(); handler.setOrder(Integer.MAX_VALUE - 2); Properties mappings = new Properties(); mappings.put(journal.getContextPath(), "journalController"); handler.setMappings(mappings); return handler; }