Java 类org.springframework.web.servlet.handler.SimpleUrlHandlerMapping 实例源码

项目：https-github.com-g0t4-jenkins2-course-spring-boot 文件：WebMvcAutoConfigurationTests.java

@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;
}

项目：spring4-understanding 文件：ResourceUrlProvider.java

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);
            }
        }
    }
}

项目：spring4-understanding 文件：ViewControllerBeanDefinitionParser.java

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;
}

项目：spring4-understanding 文件：MvcNamespaceTests.java

@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);
}

项目：spring4-understanding 文件：MvcNamespaceTests.java

@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);
}

项目：spring4-understanding 文件：MvcNamespaceTests.java

@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());
}

项目：spring4-understanding 文件：MvcNamespaceTests.java

@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());
    }
}

项目：spring4-understanding 文件：DefaultServletHandlerConfigurerTests.java

@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());
}

项目：spring-boot-concourse 文件：WebMvcAutoConfigurationTests.java

@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;
}

项目：contestparser 文件：WebMvcAutoConfigurationTests.java

@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;
}

项目：wampspring 文件：WebMvcWampEndpointRegistry.java

/**
 * 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;
}

项目：gwt-sl 文件：TestRPCExporter.java

@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");
}

项目：class-guard 文件：ViewControllerRegistry.java

/**
 * 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;
}

项目：class-guard 文件：ResourceHandlerRegistry.java

/**
 * 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;
}

项目：class-guard 文件：MvcNamespaceTests.java

@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);
}

项目：class-guard 文件：MvcNamespaceTests.java

@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);
}

项目：class-guard 文件：DefaultServletHandlerConfigurerTests.java

@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());
}

项目：springboot-shiro-cas-mybatis 文件：AbstractServletContextInitializer.java

/**
 * 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();

}

项目：cas-5.1.0 文件：CasManagementWebAppConfiguration.java

@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;
}

项目：cas-5.1.0 文件：CasWebAppConfiguration.java

@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;
}

项目：TARA-Server 文件：CasWebAppConfiguration.java

@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;
}

项目：cas-server-4.2.1 文件：AbstractServletContextInitializer.java

/**
 * 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();

}

项目：validator-web 文件：ValidatorController.java

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);
}

项目：spring4-understanding 文件：DefaultServletHandlerConfigurer.java

/**
 * 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;
}

项目：spring4-understanding 文件：ResourceHandlerRegistry.java

/**
 * 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;
}

项目：spring4-understanding 文件：DefaultServletHandlerBeanDefinitionParser.java

@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;
}

项目：spring4-understanding 文件：ResourceUrlProviderTests.java

@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;
}

项目：spring4-understanding 文件：ServletAnnotationControllerTests.java

@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());
}

项目：spring4-understanding 文件：DispatcherServletTests.java

@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);
}

项目：spring4-understanding 文件：MvcNamespaceTests.java

@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);
}

项目：spring4-understanding 文件：MvcNamespaceTests.java

@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());
}

项目：spring4-understanding 文件：MvcNamespaceTests.java

@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());
}

项目：spring4-understanding 文件：MvcNamespaceTests.java

@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));
}

项目：spring4-understanding 文件：DefaultServletHandlerConfigurerTests.java

@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());
}

项目：spring4-understanding 文件：ViewControllerRegistryTests.java

@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());
}

项目：spring4-understanding 文件：WebSocketMessageBrokerConfigurationSupportTests.java

@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"));
}

项目：spring4-understanding 文件：WebSocketMessageBrokerConfigurationSupportTests.java

@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"));
}

项目：spring4-understanding 文件：HandlersBeanDefinitionParserTests.java

@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)));
}

项目：spring4-understanding 文件：HandlersBeanDefinitionParserTests.java

@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"));
}

项目：pro-spring-boot 文件：JournalAutoConfiguration.java

@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;
}