Java 类org.springframework.context.ApplicationContextInitializer 实例源码

@SuppressWarnings("unchecked")
private ApplicationContextInitializer<ConfigurableApplicationContext> loadInitializer(
        String className, ConfigurableApplicationContext wac) {
    try {
        Class<?> initializerClass = ClassUtils.forName(className, wac.getClassLoader());
        Class<?> initializerContextClass =
                GenericTypeResolver.resolveTypeArgument(initializerClass, ApplicationContextInitializer.class);
        if (initializerContextClass != null) {
            Assert.isAssignable(initializerContextClass, wac.getClass(), String.format(
                    "Could not add context initializer [%s] since its generic parameter [%s] " +
                    "is not assignable from the type of application context used by this " +
                    "framework servlet [%s]: ", initializerClass.getName(), initializerContextClass.getName(),
                    wac.getClass().getName()));
        }
        return BeanUtils.instantiateClass(initializerClass, ApplicationContextInitializer.class);
    }
    catch (Exception ex) {
        throw new IllegalArgumentException(String.format("Could not instantiate class [%s] specified " +
                "via 'contextInitializerClasses' init-param", className), ex);
    }
}

@Test
public void pathVarsInModel() throws Exception {
    final Map<String, Object> pathVars = new HashMap<String, Object>();
    pathVars.put("hotel", "42");
    pathVars.put("booking", 21);
    pathVars.put("other", "other");

    WebApplicationContext wac =
        initServlet(new ApplicationContextInitializer<GenericWebApplicationContext>() {
            @Override
            public void initialize(GenericWebApplicationContext context) {
                RootBeanDefinition beanDef = new RootBeanDefinition(ModelValidatingViewResolver.class);
                beanDef.getConstructorArgumentValues().addGenericArgumentValue(pathVars);
                context.registerBeanDefinition("viewResolver", beanDef);
            }
        }, ViewRenderingController.class);

    MockHttpServletRequest request = new MockHttpServletRequest("GET", "/hotels/42;q=1,2/bookings/21-other;q=3;r=R");
    getServlet().service(request, new MockHttpServletResponse());

    ModelValidatingViewResolver resolver = wac.getBean(ModelValidatingViewResolver.class);
    assertEquals(3, resolver.validatedAttrCount);
}

@Test
public void defaultExpressionParameters() throws Exception {
    initServlet(new ApplicationContextInitializer<GenericWebApplicationContext>() {
        @Override
        public void initialize(GenericWebApplicationContext context) {
            RootBeanDefinition ppc = new RootBeanDefinition(PropertyPlaceholderConfigurer.class);
            ppc.getPropertyValues().add("properties", "myKey=foo");
            context.registerBeanDefinition("ppc", ppc);
        }
    }, DefaultExpressionValueParamController.class);

    MockHttpServletRequest request = new MockHttpServletRequest("GET", "/myApp/myPath.do");
    request.setContextPath("/myApp");
    MockHttpServletResponse response = new MockHttpServletResponse();
    System.setProperty("myHeader", "bar");
    try {
        getServlet().service(request, response);
    }
    finally {
        System.clearProperty("myHeader");
    }
    assertEquals("foo-bar-/myApp", response.getContentAsString());
}

@Test
public void typeNestedSetBinding() throws Exception {
    initServlet(new ApplicationContextInitializer<GenericWebApplicationContext>() {
        @Override
        public void initialize(GenericWebApplicationContext context) {
            RootBeanDefinition csDef = new RootBeanDefinition(FormattingConversionServiceFactoryBean.class);
            csDef.getPropertyValues().add("converters", new TestBeanConverter());
            RootBeanDefinition wbiDef = new RootBeanDefinition(ConfigurableWebBindingInitializer.class);
            wbiDef.getPropertyValues().add("conversionService", csDef);
            RootBeanDefinition adapterDef = new RootBeanDefinition(RequestMappingHandlerAdapter.class);
            adapterDef.getPropertyValues().add("webBindingInitializer", wbiDef);
            context.registerBeanDefinition("handlerAdapter", adapterDef);
        }
    }, NestedSetController.class);

    MockHttpServletRequest request = new MockHttpServletRequest("GET", "/myPath.do");
    request.addParameter("testBeanSet", new String[] {"1", "2"});
    MockHttpServletResponse response = new MockHttpServletResponse();
    getServlet().service(request, response);
    assertEquals("[1, 2]-org.springframework.tests.sample.beans.TestBean", response.getContentAsString());
}

@Test
public void pathVariableWithCustomConverter() throws Exception {
    initServlet(new ApplicationContextInitializer<GenericWebApplicationContext>() {
        @Override
        public void initialize(GenericWebApplicationContext context) {
            RootBeanDefinition csDef = new RootBeanDefinition(FormattingConversionServiceFactoryBean.class);
            csDef.getPropertyValues().add("converters", new AnnotatedExceptionRaisingConverter());
            RootBeanDefinition wbiDef = new RootBeanDefinition(ConfigurableWebBindingInitializer.class);
            wbiDef.getPropertyValues().add("conversionService", csDef);
            RootBeanDefinition adapterDef = new RootBeanDefinition(RequestMappingHandlerAdapter.class);
            adapterDef.getPropertyValues().add("webBindingInitializer", wbiDef);
            context.registerBeanDefinition("handlerAdapter", adapterDef);
        }
    }, PathVariableWithCustomConverterController.class);

    MockHttpServletRequest request = new MockHttpServletRequest("GET", "/myPath/1");
    MockHttpServletResponse response = new MockHttpServletResponse();
    getServlet().service(request, response);
    assertEquals(404, response.getStatus());
}

@Test
public void emptyParameterListHandleMethod() throws Exception {
    initServlet(new ApplicationContextInitializer<GenericWebApplicationContext>() {
        @Override
        public void initialize(GenericWebApplicationContext context) {
            RootBeanDefinition vrDef = new RootBeanDefinition(InternalResourceViewResolver.class);
            vrDef.getPropertyValues().add("suffix", ".jsp");
            context.registerBeanDefinition("viewResolver", vrDef);
        }
    }, EmptyParameterListHandlerMethodController.class);

    MockHttpServletRequest request = new MockHttpServletRequest("GET", "/emptyParameterListHandler");
    MockHttpServletResponse response = new MockHttpServletResponse();

    EmptyParameterListHandlerMethodController.called = false;
    getServlet().service(request, response);
    assertTrue(EmptyParameterListHandlerMethodController.called);
    assertEquals("", response.getContentAsString());
}

@Test
public void formController() throws Exception {
    initServlet(new ApplicationContextInitializer<GenericWebApplicationContext>() {
        @Override
        public void initialize(GenericWebApplicationContext wac) {
            wac.registerBeanDefinition("viewResolver", new RootBeanDefinition(TestViewResolver.class));
        }
    }, MyFormController.class);

    MockHttpServletRequest request = new MockHttpServletRequest("GET", "/myPath.do");
    request.addParameter("name", "name1");
    request.addParameter("age", "value2");
    MockHttpServletResponse response = new MockHttpServletResponse();
    getServlet().service(request, response);
    assertEquals("myView-name1-typeMismatch-tb1-myValue", response.getContentAsString());
}

@Test
public void modelFormController() throws Exception {
    initServlet(new ApplicationContextInitializer<GenericWebApplicationContext>() {
        @Override
        public void initialize(GenericWebApplicationContext wac) {
            wac.registerBeanDefinition("viewResolver", new RootBeanDefinition(TestViewResolver.class));
        }
    }, MyModelFormController.class);

    MockHttpServletRequest request = new MockHttpServletRequest("GET", "/myPath.do");
    request.addParameter("name", "name1");
    request.addParameter("age", "value2");
    MockHttpServletResponse response = new MockHttpServletResponse();
    getServlet().service(request, response);
    assertEquals("myPath-name1-typeMismatch-tb1-myValue-yourValue", response.getContentAsString());
}

@Test
public void proxiedFormController() throws Exception {
    initServlet(new ApplicationContextInitializer<GenericWebApplicationContext>() {
        @Override
        public void initialize(GenericWebApplicationContext wac) {
            wac.registerBeanDefinition("viewResolver", new RootBeanDefinition(TestViewResolver.class));
            DefaultAdvisorAutoProxyCreator autoProxyCreator = new DefaultAdvisorAutoProxyCreator();
            autoProxyCreator.setBeanFactory(wac.getBeanFactory());
            wac.getBeanFactory().addBeanPostProcessor(autoProxyCreator);
            wac.getBeanFactory()
                    .registerSingleton("advisor", new DefaultPointcutAdvisor(new SimpleTraceInterceptor()));
        }
    }, MyFormController.class);

    MockHttpServletRequest request = new MockHttpServletRequest("GET", "/myPath.do");
    request.addParameter("name", "name1");
    request.addParameter("age", "value2");
    MockHttpServletResponse response = new MockHttpServletResponse();
    getServlet().service(request, response);
    assertEquals("myView-name1-typeMismatch-tb1-myValue", response.getContentAsString());
}

@Test
public void commandProvidingFormControllerWithCustomEditor() throws Exception {
    initServlet(new ApplicationContextInitializer<GenericWebApplicationContext>() {
        @Override
        public void initialize(GenericWebApplicationContext wac) {
            wac.registerBeanDefinition("viewResolver", new RootBeanDefinition(TestViewResolver.class));
            RootBeanDefinition adapterDef = new RootBeanDefinition(RequestMappingHandlerAdapter.class);
            adapterDef.getPropertyValues().add("webBindingInitializer", new MyWebBindingInitializer());
            wac.registerBeanDefinition("handlerAdapter", adapterDef);
        }
    }, MyCommandProvidingFormController.class);

    MockHttpServletRequest request = new MockHttpServletRequest("GET", "/myPath.do");
    request.addParameter("defaultName", "myDefaultName");
    request.addParameter("age", "value2");
    request.addParameter("date", "2007-10-02");
    MockHttpServletResponse response = new MockHttpServletResponse();
    getServlet().service(request, response);
    assertEquals("myView-String:myDefaultName-typeMismatch-tb1-myOriginalValue", response.getContentAsString());
}

@Test
public void binderInitializingCommandProvidingFormController() throws Exception {
    initServlet(new ApplicationContextInitializer<GenericWebApplicationContext>() {
        @Override
        public void initialize(GenericWebApplicationContext wac) {
            wac.registerBeanDefinition("viewResolver", new RootBeanDefinition(TestViewResolver.class));
        }
    }, MyBinderInitializingCommandProvidingFormController.class);

    MockHttpServletRequest request = new MockHttpServletRequest("GET", "/myPath.do");
    request.addParameter("defaultName", "myDefaultName");
    request.addParameter("age", "value2");
    request.addParameter("date", "2007-10-02");
    MockHttpServletResponse response = new MockHttpServletResponse();
    getServlet().service(request, response);
    assertEquals("myView-String:myDefaultName-typeMismatch-tb1-myOriginalValue", response.getContentAsString());
}

@Test
public void specificBinderInitializingCommandProvidingFormController() throws Exception {
    initServlet(new ApplicationContextInitializer<GenericWebApplicationContext>() {
        @Override
        public void initialize(GenericWebApplicationContext wac) {
            wac.registerBeanDefinition("viewResolver", new RootBeanDefinition(TestViewResolver.class));
        }
    }, MySpecificBinderInitializingCommandProvidingFormController.class);

    MockHttpServletRequest request = new MockHttpServletRequest("GET", "/myPath.do");
    request.addParameter("defaultName", "myDefaultName");
    request.addParameter("age", "value2");
    request.addParameter("date", "2007-10-02");
    MockHttpServletResponse response = new MockHttpServletResponse();
    getServlet().service(request, response);
    assertEquals("myView-String:myDefaultName-typeMismatch-tb1-myOriginalValue", response.getContentAsString());
}

@Test
public void responseBodyNoAcceptableMediaType() throws ServletException, IOException {
    initServlet(new ApplicationContextInitializer<GenericWebApplicationContext>() {
        @Override
        public void initialize(GenericWebApplicationContext wac) {
            RootBeanDefinition adapterDef = new RootBeanDefinition(RequestMappingHandlerAdapter.class);
            StringHttpMessageConverter converter = new StringHttpMessageConverter();
            adapterDef.getPropertyValues().add("messageConverters", converter);
            wac.registerBeanDefinition("handlerAdapter", adapterDef);
        }
    }, RequestResponseBodyProducesController.class);

    MockHttpServletRequest request = new MockHttpServletRequest("PUT", "/something");
    String requestBody = "Hello World";
    request.setContent(requestBody.getBytes("UTF-8"));
    request.addHeader("Content-Type", "text/plain; charset=utf-8");
    request.addHeader("Accept", "application/pdf, application/msword");
    MockHttpServletResponse response = new MockHttpServletResponse();
    getServlet().service(request, response);
    assertEquals(406, response.getStatus());
}

@Test
public void unsupportedRequestBody() throws ServletException, IOException {
    initServlet(new ApplicationContextInitializer<GenericWebApplicationContext>() {
        @Override
        public void initialize(GenericWebApplicationContext wac) {
            RootBeanDefinition adapterDef = new RootBeanDefinition(RequestMappingHandlerAdapter.class);
            adapterDef.getPropertyValues().add("messageConverters", new ByteArrayHttpMessageConverter());
            wac.registerBeanDefinition("handlerAdapter", adapterDef);
        }
    }, RequestResponseBodyController.class);

    MockHttpServletRequest request = new MockHttpServletRequest("PUT", "/something");
    String requestBody = "Hello World";
    request.setContent(requestBody.getBytes("UTF-8"));
    request.addHeader("Content-Type", "application/pdf");
    MockHttpServletResponse response = new MockHttpServletResponse();
    getServlet().service(request, response);
    assertEquals(415, response.getStatus());
    assertNotNull("No Accept response header set", response.getHeader("Accept"));
}

@Test
public void badRequestRequestBody() throws ServletException, IOException {
    initServlet(new ApplicationContextInitializer<GenericWebApplicationContext>() {
        @Override
        public void initialize(GenericWebApplicationContext wac) {
            RootBeanDefinition adapterDef = new RootBeanDefinition(RequestMappingHandlerAdapter.class);
            adapterDef.getPropertyValues().add("messageConverters", new NotReadableMessageConverter());
            wac.registerBeanDefinition("handlerAdapter", adapterDef);
        }
    }, RequestResponseBodyController.class);

    MockHttpServletRequest request = new MockHttpServletRequest("PUT", "/something");
    String requestBody = "Hello World";
    request.setContent(requestBody.getBytes("UTF-8"));
    request.addHeader("Content-Type", "application/pdf");
    MockHttpServletResponse response = new MockHttpServletResponse();
    getServlet().service(request, response);
    assertEquals("Invalid response status code", HttpServletResponse.SC_BAD_REQUEST, response.getStatus());
}

@Test
public void overlappingMessageConvertersRequestBody() throws ServletException, IOException {
    initServlet(new ApplicationContextInitializer<GenericWebApplicationContext>() {
        @Override
        public void initialize(GenericWebApplicationContext wac) {
            RootBeanDefinition adapterDef = new RootBeanDefinition(RequestMappingHandlerAdapter.class);
            List<HttpMessageConverter<?>> messageConverters = new ArrayList<HttpMessageConverter<?>>();
            messageConverters.add(new StringHttpMessageConverter());
            messageConverters
                    .add(new SimpleMessageConverter(new MediaType("application","json"), MediaType.ALL));
            adapterDef.getPropertyValues().add("messageConverters", messageConverters);
            wac.registerBeanDefinition("handlerAdapter", adapterDef);
        }
    }, RequestResponseBodyController.class);

    MockHttpServletRequest request = new MockHttpServletRequest("PUT", "/something");
    request.setContent("Hello World".getBytes("UTF-8"));
    request.addHeader("Content-Type", "text/plain; charset=utf-8");
    request.addHeader("Accept", "application/json, text/javascript, */*");
    MockHttpServletResponse response = new MockHttpServletResponse();
    getServlet().service(request, response);
    assertEquals("Invalid content-type", "application/json", response.getHeader("Content-Type"));
}

@Test
public void responseBodyArgMismatch() throws ServletException, IOException {
    initServlet(new ApplicationContextInitializer<GenericWebApplicationContext>() {
        @Override
        public void initialize(GenericWebApplicationContext wac) {
            Jaxb2Marshaller marshaller = new Jaxb2Marshaller();
            marshaller.setClassesToBeBound(A.class, B.class);
            try {
                marshaller.afterPropertiesSet();
            }
            catch (Exception ex) {
                throw new BeanCreationException(ex.getMessage(), ex);
            }
            MarshallingHttpMessageConverter messageConverter = new MarshallingHttpMessageConverter(marshaller);

            RootBeanDefinition adapterDef = new RootBeanDefinition(RequestMappingHandlerAdapter.class);
            adapterDef.getPropertyValues().add("messageConverters", messageConverter);
            wac.registerBeanDefinition("handlerAdapter", adapterDef);
        }
    }, RequestBodyArgMismatchController.class);

    MockHttpServletRequest request = new MockHttpServletRequest("PUT", "/something");
    String requestBody = "<b/>";
    request.setContent(requestBody.getBytes("UTF-8"));
    request.addHeader("Content-Type", "application/xml; charset=utf-8");
    MockHttpServletResponse response = new MockHttpServletResponse();
    getServlet().service(request, response);
    assertEquals(400, response.getStatus());
}

@Test
public void mavResolver() throws ServletException, IOException {
    initServlet(new ApplicationContextInitializer<GenericWebApplicationContext>() {
        @Override
        public void initialize(GenericWebApplicationContext wac) {
            RootBeanDefinition adapterDef = new RootBeanDefinition(RequestMappingHandlerAdapter.class);
            ModelAndViewResolver[] mavResolvers = new ModelAndViewResolver[] {new MyModelAndViewResolver()};
            adapterDef.getPropertyValues().add("modelAndViewResolvers", mavResolvers);
            wac.registerBeanDefinition("handlerAdapter", adapterDef);
        }
    }, ModelAndViewResolverController.class);

    MockHttpServletRequest request = new MockHttpServletRequest("GET", "/");
    MockHttpServletResponse response = new MockHttpServletResponse();
    getServlet().service(request, response);
    assertEquals("myValue", response.getContentAsString());

}

@Test
public void requestMappingInterfaceWithProxy() throws Exception {
    initServlet(new ApplicationContextInitializer<GenericWebApplicationContext>() {
        @Override
        public void initialize(GenericWebApplicationContext wac) {
            DefaultAdvisorAutoProxyCreator autoProxyCreator = new DefaultAdvisorAutoProxyCreator();
            autoProxyCreator.setBeanFactory(wac.getBeanFactory());
            wac.getBeanFactory().addBeanPostProcessor(autoProxyCreator);
            wac.getBeanFactory().registerSingleton("advisor", new DefaultPointcutAdvisor(new SimpleTraceInterceptor()));
        }
    }, IMyControllerImpl.class);

    MockHttpServletRequest request = new MockHttpServletRequest("GET", "/handle");
    MockHttpServletResponse response = new MockHttpServletResponse();
    getServlet().service(request, response);
    assertEquals("handle null", response.getContentAsString());

    request = new MockHttpServletRequest("GET", "/handle");
    request.addParameter("p", "value");
    response = new MockHttpServletResponse();
    getServlet().service(request, response);
    assertEquals("handle value", response.getContentAsString());
}

@Test
public void parameterCsvAsStringArray() throws Exception {
    initServlet(new ApplicationContextInitializer<GenericWebApplicationContext>() {
        @Override
        public void initialize(GenericWebApplicationContext wac) {
            RootBeanDefinition csDef = new RootBeanDefinition(FormattingConversionServiceFactoryBean.class);
            RootBeanDefinition wbiDef = new RootBeanDefinition(ConfigurableWebBindingInitializer.class);
            wbiDef.getPropertyValues().add("conversionService", csDef);
            RootBeanDefinition adapterDef = new RootBeanDefinition(RequestMappingHandlerAdapter.class);
            adapterDef.getPropertyValues().add("webBindingInitializer", wbiDef);
            wac.registerBeanDefinition("handlerAdapter", adapterDef);
        }
    }, CsvController.class);

    MockHttpServletRequest request = new MockHttpServletRequest();
    request.setRequestURI("/integerArray");
    request.setMethod("POST");
    request.addParameter("content", "1,2");
    MockHttpServletResponse response = new MockHttpServletResponse();
    getServlet().service(request, response);
    assertEquals("1-2", response.getContentAsString());
}

@Test
public void prototypeController() throws Exception {
    initServlet(new ApplicationContextInitializer<GenericWebApplicationContext>() {
        @Override
        public void initialize(GenericWebApplicationContext context) {
            RootBeanDefinition beanDef = new RootBeanDefinition(PrototypeController.class);
            beanDef.setScope(BeanDefinition.SCOPE_PROTOTYPE);
            context.registerBeanDefinition("controller", beanDef);
        }
    });

    MockHttpServletRequest request = new MockHttpServletRequest("GET", "/");
    request.addParameter("param", "1");
    MockHttpServletResponse response = new MockHttpServletResponse();
    getServlet().service(request, response);

    assertEquals("count:3", response.getContentAsString());

    response = new MockHttpServletResponse();
    getServlet().service(request, response);

    assertEquals("count:3", response.getContentAsString());
}

@Test
public void responseBodyAsHtml() throws Exception {
    initServlet(new ApplicationContextInitializer<GenericWebApplicationContext>() {
        @Override
        public void initialize(GenericWebApplicationContext wac) {
            ContentNegotiationManagerFactoryBean factoryBean = new ContentNegotiationManagerFactoryBean();
            factoryBean.afterPropertiesSet();
            RootBeanDefinition adapterDef = new RootBeanDefinition(RequestMappingHandlerAdapter.class);
            adapterDef.getPropertyValues().add("contentNegotiationManager", factoryBean.getObject());
            wac.registerBeanDefinition("handlerAdapter", adapterDef);
        }
    }, TextRestController.class);

    byte[] content = "alert('boo')".getBytes(Charset.forName("ISO-8859-1"));
    MockHttpServletRequest request = new MockHttpServletRequest("GET", "/a1.html");
    request.setContent(content);
    MockHttpServletResponse response = new MockHttpServletResponse();

    getServlet().service(request, response);

    assertEquals(200, response.getStatus());
    assertEquals("text/html", response.getContentType());
    assertEquals("inline;filename=f.txt", response.getHeader("Content-Disposition"));
    assertArrayEquals(content, response.getContentAsByteArray());
}

@Test
public void responseBodyAsHtmlWithSuffixPresent() throws Exception {
    initServlet(new ApplicationContextInitializer<GenericWebApplicationContext>() {
        @Override
        public void initialize(GenericWebApplicationContext wac) {
            ContentNegotiationManagerFactoryBean factoryBean = new ContentNegotiationManagerFactoryBean();
            factoryBean.afterPropertiesSet();
            RootBeanDefinition adapterDef = new RootBeanDefinition(RequestMappingHandlerAdapter.class);
            adapterDef.getPropertyValues().add("contentNegotiationManager", factoryBean.getObject());
            wac.registerBeanDefinition("handlerAdapter", adapterDef);
        }
    }, TextRestController.class);

    byte[] content = "alert('boo')".getBytes(Charset.forName("ISO-8859-1"));
    MockHttpServletRequest request = new MockHttpServletRequest("GET", "/a2.html");
    request.setContent(content);
    MockHttpServletResponse response = new MockHttpServletResponse();

    getServlet().service(request, response);

    assertEquals(200, response.getStatus());
    assertEquals("text/html", response.getContentType());
    assertNull(response.getHeader("Content-Disposition"));
    assertArrayEquals(content, response.getContentAsByteArray());
}

@Test
public void responseBodyAsHtmlWithProducesCondition() throws Exception {
    initServlet(new ApplicationContextInitializer<GenericWebApplicationContext>() {
        @Override
        public void initialize(GenericWebApplicationContext wac) {
            ContentNegotiationManagerFactoryBean factoryBean = new ContentNegotiationManagerFactoryBean();
            factoryBean.afterPropertiesSet();
            RootBeanDefinition adapterDef = new RootBeanDefinition(RequestMappingHandlerAdapter.class);
            adapterDef.getPropertyValues().add("contentNegotiationManager", factoryBean.getObject());
            wac.registerBeanDefinition("handlerAdapter", adapterDef);
        }
    }, TextRestController.class);

    byte[] content = "alert('boo')".getBytes(Charset.forName("ISO-8859-1"));
    MockHttpServletRequest request = new MockHttpServletRequest("GET", "/a3.html");
    request.setContent(content);
    MockHttpServletResponse response = new MockHttpServletResponse();

    getServlet().service(request, response);

    assertEquals(200, response.getStatus());
    assertEquals("text/html", response.getContentType());
    assertNull(response.getHeader("Content-Disposition"));
    assertArrayEquals(content, response.getContentAsByteArray());
}

@Test
public void responseBodyAsTextWithCssExtension() throws Exception {
    initServlet(new ApplicationContextInitializer<GenericWebApplicationContext>() {
        @Override
        public void initialize(GenericWebApplicationContext wac) {
            ContentNegotiationManagerFactoryBean factoryBean = new ContentNegotiationManagerFactoryBean();
            factoryBean.afterPropertiesSet();
            RootBeanDefinition adapterDef = new RootBeanDefinition(RequestMappingHandlerAdapter.class);
            adapterDef.getPropertyValues().add("contentNegotiationManager", factoryBean.getObject());
            wac.registerBeanDefinition("handlerAdapter", adapterDef);
        }
    }, TextRestController.class);

    byte[] content = "body".getBytes(Charset.forName("ISO-8859-1"));
    MockHttpServletRequest request = new MockHttpServletRequest("GET", "/a4.css");
    request.setContent(content);
    MockHttpServletResponse response = new MockHttpServletResponse();

    getServlet().service(request, response);

    assertEquals(200, response.getStatus());
    assertEquals("text/css", response.getContentType());
    assertNull(response.getHeader("Content-Disposition"));
    assertArrayEquals(content, response.getContentAsByteArray());
}

/**
 * Customize the {@link ConfigurableWebApplicationContext} created by this
 * ContextLoader after config locations have been supplied to the context
 * but before the context is <em>refreshed</em>.
 * <p>The default implementation {@linkplain #determineContextInitializerClasses(ServletContext)
 * determines} what (if any) context initializer classes have been specified through
 * {@linkplain #CONTEXT_INITIALIZER_CLASSES_PARAM context init parameters} and
 * {@linkplain ApplicationContextInitializer#initialize invokes each} with the
 * given web application context.
 * <p>Any {@code ApplicationContextInitializers} implementing
 * {@link org.springframework.core.Ordered Ordered} or marked with @{@link
 * org.springframework.core.annotation.Order Order} will be sorted appropriately.
 * @param sc the current servlet context
 * @param wac the newly created application context
 * @see #CONTEXT_INITIALIZER_CLASSES_PARAM
 * @see ApplicationContextInitializer#initialize(ConfigurableApplicationContext)
 */
protected void customizeContext(ServletContext sc, ConfigurableWebApplicationContext wac) {
    List<Class<ApplicationContextInitializer<ConfigurableApplicationContext>>> initializerClasses =
            determineContextInitializerClasses(sc);

    for (Class<ApplicationContextInitializer<ConfigurableApplicationContext>> initializerClass : initializerClasses) {
        Class<?> initializerContextClass =
                GenericTypeResolver.resolveTypeArgument(initializerClass, ApplicationContextInitializer.class);
        if (initializerContextClass != null) {
            Assert.isAssignable(initializerContextClass, wac.getClass(), String.format(
                    "Could not add context initializer [%s] since its generic parameter [%s] " +
                    "is not assignable from the type of application context used by this " +
                    "context loader [%s]: ", initializerClass.getName(), initializerContextClass.getName(),
                    wac.getClass().getName()));
        }
        this.contextInitializers.add(BeanUtils.instantiateClass(initializerClass));
    }

    AnnotationAwareOrderComparator.sort(this.contextInitializers);
    for (ApplicationContextInitializer<ConfigurableApplicationContext> initializer : this.contextInitializers) {
        initializer.initialize(wac);
    }
}

/**
 * Resolve the set of merged {@code ApplicationContextInitializer} classes for the
 * supplied list of {@code ContextConfigurationAttributes}.
 *
 * <p>Note that the {@link ContextConfiguration#inheritInitializers inheritInitializers}
 * flag of {@link ContextConfiguration @ContextConfiguration} will be taken into
 * consideration. Specifically, if the {@code inheritInitializers} flag is set to
 * {@code true} for a given level in the class hierarchy represented by the provided
 * configuration attributes, context initializer classes defined at the given level
 * will be merged with those defined in higher levels of the class hierarchy.
 *
 * @param configAttributesList the list of configuration attributes to process; must
 * not be {@code null} or <em>empty</em>; must be ordered <em>bottom-up</em>
 * (i.e., as if we were traversing up the class hierarchy)
 * @return the set of merged context initializer classes, including those from
 * superclasses if appropriate (never {@code null})
 * @since 3.2
 */
static Set<Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>> resolveInitializerClasses(
        List<ContextConfigurationAttributes> configAttributesList) {
    Assert.notEmpty(configAttributesList, "ContextConfigurationAttributes list must not be empty");

    final Set<Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>> initializerClasses = //
    new HashSet<Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>>();

    for (ContextConfigurationAttributes configAttributes : configAttributesList) {
        if (logger.isTraceEnabled()) {
            logger.trace(String.format("Processing context initializers for context configuration attributes %s",
                configAttributes));
        }

        initializerClasses.addAll(Arrays.asList(configAttributes.getInitializers()));

        if (!configAttributes.isInheritInitializers()) {
            break;
        }
    }

    return initializerClasses;
}

@Test
public void hashCodeWithSameInitializers() {
    Set<Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>> initializerClasses1 =
            new HashSet<Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>>();
    initializerClasses1.add(FooInitializer.class);
    initializerClasses1.add(BarInitializer.class);

    Set<Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>> initializerClasses2 =
            new HashSet<Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>>();
    initializerClasses2.add(BarInitializer.class);
    initializerClasses2.add(FooInitializer.class);

    MergedContextConfiguration mergedConfig1 = new MergedContextConfiguration(getClass(),
            EMPTY_STRING_ARRAY, EMPTY_CLASS_ARRAY, initializerClasses1, EMPTY_STRING_ARRAY, loader);
    MergedContextConfiguration mergedConfig2 = new MergedContextConfiguration(getClass(),
            EMPTY_STRING_ARRAY, EMPTY_CLASS_ARRAY, initializerClasses2, EMPTY_STRING_ARRAY, loader);
    assertEquals(mergedConfig1.hashCode(), mergedConfig2.hashCode());
}

@Test
public void hashCodeWithDifferentInitializers() {
    Set<Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>> initializerClasses1 =
            new HashSet<Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>>();
    initializerClasses1.add(FooInitializer.class);

    Set<Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>> initializerClasses2 =
            new HashSet<Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>>();
    initializerClasses2.add(BarInitializer.class);

    MergedContextConfiguration mergedConfig1 = new MergedContextConfiguration(getClass(),
            EMPTY_STRING_ARRAY, EMPTY_CLASS_ARRAY, initializerClasses1, EMPTY_STRING_ARRAY, loader);
    MergedContextConfiguration mergedConfig2 = new MergedContextConfiguration(getClass(),
            EMPTY_STRING_ARRAY, EMPTY_CLASS_ARRAY, initializerClasses2, EMPTY_STRING_ARRAY, loader);
    assertNotEquals(mergedConfig1.hashCode(), mergedConfig2.hashCode());
}

@Test
public void equalsWithSameInitializers() {
    Set<Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>> initializerClasses1 =
            new HashSet<Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>>();
    initializerClasses1.add(FooInitializer.class);
    initializerClasses1.add(BarInitializer.class);

    Set<Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>> initializerClasses2 =
            new HashSet<Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>>();
    initializerClasses2.add(BarInitializer.class);
    initializerClasses2.add(FooInitializer.class);

    MergedContextConfiguration mergedConfig1 = new MergedContextConfiguration(getClass(),
            EMPTY_STRING_ARRAY, EMPTY_CLASS_ARRAY, initializerClasses1, EMPTY_STRING_ARRAY, loader);
    MergedContextConfiguration mergedConfig2 = new MergedContextConfiguration(getClass(),
            EMPTY_STRING_ARRAY, EMPTY_CLASS_ARRAY, initializerClasses2, EMPTY_STRING_ARRAY, loader);
    assertEquals(mergedConfig1, mergedConfig2);
}

void assertMergedConfig(
        MergedContextConfiguration mergedConfig,
        Class<?> expectedTestClass,
        String[] expectedLocations,
        Class<?>[] expectedClasses,
        Set<Class<? extends ApplicationContextInitializer<? extends ConfigurableApplicationContext>>> expectedInitializerClasses,
        Class<? extends ContextLoader> expectedContextLoaderClass) {

    assertNotNull(mergedConfig);
    assertEquals(expectedTestClass, mergedConfig.getTestClass());
    assertNotNull(mergedConfig.getLocations());
    assertArrayEquals(expectedLocations, mergedConfig.getLocations());
    assertNotNull(mergedConfig.getClasses());
    assertArrayEquals(expectedClasses, mergedConfig.getClasses());
    assertNotNull(mergedConfig.getActiveProfiles());
    if (expectedContextLoaderClass == null) {
        assertNull(mergedConfig.getContextLoader());
    }
    else {
        assertEquals(expectedContextLoaderClass, mergedConfig.getContextLoader().getClass());
    }
    assertNotNull(mergedConfig.getContextInitializerClasses());
    assertEquals(expectedInitializerClasses, mergedConfig.getContextInitializerClasses());
}

@Test
public void specificApplicationContextInitializer() throws Exception {
    SpringApplication application = new SpringApplication(ExampleConfig.class);
    application.setWebEnvironment(false);
    final AtomicReference<ApplicationContext> reference = new AtomicReference<ApplicationContext>();
    application.setInitializers(Arrays.asList(
            new ApplicationContextInitializer<ConfigurableApplicationContext>() {
                @Override
                public void initialize(ConfigurableApplicationContext context) {
                    reference.set(context);
                }
            }));
    this.context = application.run("--foo=bar");
    assertThat(this.context).isSameAs(reference.get());
    // Custom initializers do not switch off the defaults
    assertThat(getEnvironment().getProperty("foo")).isEqualTo("bar");
}

@Override
public ApplicationContext loadContext(final MergedContextConfiguration config)
        throws Exception {
    assertValidAnnotations(config.getTestClass());
    SpringApplication application = getSpringApplication();
    application.setMainApplicationClass(config.getTestClass());
    application.setSources(getSources(config));
    ConfigurableEnvironment environment = new StandardEnvironment();
    if (!ObjectUtils.isEmpty(config.getActiveProfiles())) {
        setActiveProfiles(environment, config.getActiveProfiles());
    }
    Map<String, Object> properties = getEnvironmentProperties(config);
    addProperties(environment, properties);
    application.setEnvironment(environment);
    List<ApplicationContextInitializer<?>> initializers = getInitializers(config,
            application);
    if (config instanceof WebMergedContextConfiguration) {
        new WebConfigurer().configure(config, application, initializers);
    }
    else {
        application.setWebEnvironment(false);
    }
    application.setInitializers(initializers);
    ConfigurableApplicationContext applicationContext = application.run();
    return applicationContext;
}

@Test
public void specificApplicationContextInitializer() throws Exception {
    SpringApplication application = new SpringApplication(ExampleConfig.class);
    application.setWebEnvironment(false);
    final AtomicReference<ApplicationContext> reference = new AtomicReference<ApplicationContext>();
    application.setInitializers(Arrays.asList(
            new ApplicationContextInitializer<ConfigurableApplicationContext>() {
                @Override
                public void initialize(ConfigurableApplicationContext context) {
                    reference.set(context);
                }
            }));
    this.context = application.run("--foo=bar");
    assertThat(this.context).isSameAs(reference.get());
    // Custom initializers do not switch off the defaults
    assertThat(getEnvironment().getProperty("foo")).isEqualTo("bar");
}

@Override
public ApplicationContext loadContext(final MergedContextConfiguration config)
        throws Exception {
    assertValidAnnotations(config.getTestClass());
    SpringApplication application = getSpringApplication();
    application.setMainApplicationClass(config.getTestClass());
    application.setSources(getSources(config));
    ConfigurableEnvironment environment = new StandardEnvironment();
    if (!ObjectUtils.isEmpty(config.getActiveProfiles())) {
        setActiveProfiles(environment, config.getActiveProfiles());
    }
    Map<String, Object> properties = getEnvironmentProperties(config);
    addProperties(environment, properties);
    application.setEnvironment(environment);
    List<ApplicationContextInitializer<?>> initializers = getInitializers(config,
            application);
    if (config instanceof WebMergedContextConfiguration) {
        new WebConfigurer().configure(config, application, initializers);
    }
    else {
        application.setWebEnvironment(false);
    }
    application.setInitializers(initializers);
    ConfigurableApplicationContext applicationContext = application.run();
    return applicationContext;
}

/**
 * Customize the {@link ConfigurableWebApplicationContext} created by this
 * ContextLoader after config locations have been supplied to the context
 * but before the context is <em>refreshed</em>.
 * <p>The default implementation {@linkplain #determineContextInitializerClasses(ServletContext)
 * determines} what (if any) context initializer classes have been specified through
 * {@linkplain #CONTEXT_INITIALIZER_CLASSES_PARAM context init parameters} and
 * {@linkplain ApplicationContextInitializer#initialize invokes each} with the
 * given web application context.
 * <p>Any {@code ApplicationContextInitializers} implementing
 * {@link org.springframework.core.Ordered Ordered} or marked with @{@link
 * org.springframework.core.annotation.Order Order} will be sorted appropriately.
 * @param sc the current servlet context
 * @param wac the newly created application context
 * @see #createWebApplicationContext(ServletContext, ApplicationContext)
 * @see #CONTEXT_INITIALIZER_CLASSES_PARAM
 * @see ApplicationContextInitializer#initialize(ConfigurableApplicationContext)
 */
protected void customizeContext(ServletContext sc, ConfigurableWebApplicationContext wac) {
    List<Class<ApplicationContextInitializer<ConfigurableApplicationContext>>> initializerClasses =
            determineContextInitializerClasses(sc);
    if (initializerClasses.isEmpty()) {
        // no ApplicationContextInitializers have been declared -> nothing to do
        return;
    }

    ArrayList<ApplicationContextInitializer<ConfigurableApplicationContext>> initializerInstances =
            new ArrayList<ApplicationContextInitializer<ConfigurableApplicationContext>>();

    for (Class<ApplicationContextInitializer<ConfigurableApplicationContext>> initializerClass : initializerClasses) {
        Class<?> initializerContextClass =
                GenericTypeResolver.resolveTypeArgument(initializerClass, ApplicationContextInitializer.class);
        if (initializerContextClass != null) {
            Assert.isAssignable(initializerContextClass, wac.getClass(), String.format(
                    "Could not add context initializer [%s] since its generic parameter [%s] " +
                    "is not assignable from the type of application context used by this " +
                    "context loader [%s]: ", initializerClass.getName(), initializerContextClass.getName(),
                    wac.getClass().getName()));
        }
        initializerInstances.add(BeanUtils.instantiateClass(initializerClass));
    }

    AnnotationAwareOrderComparator.sort(initializerInstances);
    for (ApplicationContextInitializer<ConfigurableApplicationContext> initializer : initializerInstances) {
        initializer.initialize(wac);
    }
}

@SuppressWarnings("unchecked")
private Class<ApplicationContextInitializer<ConfigurableApplicationContext>> loadInitializerClass(String className) {
    try {
        Class<?> clazz = ClassUtils.forName(className, ClassUtils.getDefaultClassLoader());
        Assert.isAssignable(ApplicationContextInitializer.class, clazz);
        return (Class<ApplicationContextInitializer<ConfigurableApplicationContext>>) clazz;
    }
    catch (ClassNotFoundException ex) {
        throw new ApplicationContextException("Failed to load context initializer class [" + className + "]", ex);
    }
}

public static SpringBatchApplicationContext instance(String jobPath) throws ClassNotFoundException {
    SpringBatchApplicationContext context = new SpringBatchApplicationContext();
    ApplicationContextInitializer initializer = new BatchApplicationContextInitializer();
    initializer.initialize(context);

    try{
        context.registerAnnotationClasses(Class.forName(jobPath));
    }catch (ClassNotFoundException cnfe){
        context.registerXmlClasses(jobPath);
    }

    context.refresh();
    return context;
}

/**
 * Specify which {@link ApplicationContextInitializer} instances should be used
 * to initialize the application context used by this {@code FrameworkServlet}.
 * @see #configureAndRefreshWebApplicationContext
 * @see #applyInitializers
 */
@SuppressWarnings("unchecked")
public void setContextInitializers(ApplicationContextInitializer<?>... initializers) {
    if (initializers != null) {
        for (ApplicationContextInitializer<?> initializer : initializers) {
            this.contextInitializers.add((ApplicationContextInitializer<ConfigurableApplicationContext>) initializer);
        }
    }
}

@SuppressWarnings("rawtypes")
@Test
public void sessionAttributeExposure() throws Exception {
    initServlet(new ApplicationContextInitializer<GenericWebApplicationContext>() {
        @Override
        public void initialize(GenericWebApplicationContext context) {
            context.registerBeanDefinition("viewResolver", new RootBeanDefinition(ModelExposingViewResolver.class));
        }
    }, MySessionAttributesController.class);

    MockHttpServletRequest request = new MockHttpServletRequest("GET", "/myPage");
    MockHttpServletResponse response = new MockHttpServletResponse();
    getServlet().service(request, response);
    assertEquals("page1", request.getAttribute("viewName"));
    HttpSession session = request.getSession();
    assertTrue(session.getAttribute("object1") != null);
    assertTrue(session.getAttribute("object2") != null);
    assertTrue(((Map) session.getAttribute("model")).containsKey("object1"));
    assertTrue(((Map) session.getAttribute("model")).containsKey("object2"));

    request = new MockHttpServletRequest("POST", "/myPage");
    request.setSession(session);
    response = new MockHttpServletResponse();
    getServlet().service(request, response);
    assertEquals("page2", request.getAttribute("viewName"));
    assertTrue(session.getAttribute("object1") != null);
    assertTrue(session.getAttribute("object2") != null);
    assertTrue(((Map) session.getAttribute("model")).containsKey("object1"));
    assertTrue(((Map) session.getAttribute("model")).containsKey("object2"));
}