/** * Load a Spring {@link WebApplicationContext} from the supplied {@link * MergedContextConfiguration}. * * <p>Implementation details: * * <ul> * <li>Creates a {@link GenericWebApplicationContext} instance. * <li>Delegates to {@link #configureWebResources} to create the {@link MockServletContext} and * set it in the {@code WebApplicationContext}. * <li>Calls {@link #prepareContext} to allow for customizing the context before bean * definitions are loaded. * <li>Calls {@link #customizeBeanFactory} to allow for customizing the context's {@code * DefaultListableBeanFactory}. * <li>Delegates to {@link #loadBeanDefinitions} to populate the context from the locations or * classes in the supplied {@code MergedContextConfiguration}. * <li>Delegates to {@link AnnotationConfigUtils} for {@linkplain * AnnotationConfigUtils#registerAnnotationConfigProcessors registering} annotation * configuration processors. * <li>Calls {@link #customizeContext} to allow for customizing the context before it is * refreshed. * <li>{@link ConfigurableApplicationContext#refresh Refreshes} the context and registers a JVM * shutdown hook for it. * </ul> * * @return a new web application context * @see * org.springframework.test.context.SmartContextLoader#loadContext(MergedContextConfiguration) * @see GenericWebApplicationContext */ @Override public final ConfigurableApplicationContext loadContext(MergedContextConfiguration mergedConfig) throws Exception { if (!(mergedConfig instanceof WebMergedContextConfiguration)) { throw new IllegalArgumentException( String.format( "Cannot load WebApplicationContext from non-web merged context configuration %s. " + "Consider annotating your test class with @WebAppConfiguration.", mergedConfig)); } WebMergedContextConfiguration webMergedConfig = (WebMergedContextConfiguration) mergedConfig; if (logger.isDebugEnabled()) { logger.debug( String.format( "Loading WebApplicationContext for merged context configuration %s.", webMergedConfig)); } GenericWebApplicationContext context = new GenericWebApplicationContext(); configureWebResources(context, webMergedConfig); prepareContext(context, webMergedConfig); customizeBeanFactory(context.getDefaultListableBeanFactory(), webMergedConfig); loadBeanDefinitions(context, webMergedConfig); AnnotationConfigUtils.registerAnnotationConfigProcessors(context); customizeContext(context, webMergedConfig); context.refresh(); context.registerShutdownHook(); return context; }
@Override protected WebApplicationContext initApplicationContext() { MockServletContext servletContext = new MockServletContext(); applicationContext = new GenericWebApplicationContext(servletContext); applicationContext.refresh(); applicationContext.getAutowireCapableBeanFactory().initializeBean(validator, "validator"); return applicationContext; }
@Test public void testMessageConverters() { loadBeanDefinitions("mvc-config-message-converters.xml"); verifyMessageConverters(appContext.getBean(RequestMappingHandlerAdapter.class), true); verifyMessageConverters(appContext.getBean(ExceptionHandlerExceptionResolver.class), true); verifyResponseBodyAdvice(appContext.getBean(RequestMappingHandlerAdapter.class)); verifyResponseBodyAdvice(appContext.getBean(ExceptionHandlerExceptionResolver.class)); }
private WebApplicationContext initApplicationContext(String scope) { MockServletContext sc = new MockServletContext(); GenericWebApplicationContext ac = new GenericWebApplicationContext(sc); GenericBeanDefinition bd = new GenericBeanDefinition(); bd.setBeanClass(DerivedTestBean.class); bd.setScope(scope); ac.registerBeanDefinition(NAME, bd); ac.refresh(); return ac; }
@Test public void sockJsAttributesSupport() { loadBeanDefinitions("websocket-config-handlers-sockjs-attributes.xml"); SimpleUrlHandlerMapping handlerMapping = appContext.getBean(SimpleUrlHandlerMapping.class); assertNotNull(handlerMapping); SockJsHttpRequestHandler handler = (SockJsHttpRequestHandler) handlerMapping.getUrlMap().get("/test/**"); assertNotNull(handler); checkDelegateHandlerType(handler.getWebSocketHandler(), TestWebSocketHandler.class); SockJsService sockJsService = handler.getSockJsService(); assertNotNull(sockJsService); assertThat(sockJsService, Matchers.instanceOf(TransportHandlingSockJsService.class)); TransportHandlingSockJsService defaultSockJsService = (TransportHandlingSockJsService) sockJsService; assertThat( defaultSockJsService.getTaskScheduler(), Matchers.instanceOf(TestTaskScheduler.class)); assertThat( defaultSockJsService.getTransportHandlers().values(), Matchers.containsInAnyOrder( Matchers.instanceOf(XhrPollingTransportHandler.class), Matchers.instanceOf(XhrStreamingTransportHandler.class))); assertEquals("testSockJsService", defaultSockJsService.getName()); assertFalse(defaultSockJsService.isWebSocketEnabled()); assertFalse(defaultSockJsService.isSessionCookieNeeded()); assertEquals(2048, defaultSockJsService.getStreamBytesLimit()); assertEquals(256, defaultSockJsService.getDisconnectDelay()); assertEquals(1024, defaultSockJsService.getHttpMessageCacheSize()); assertEquals(20, defaultSockJsService.getHeartbeatTime()); }
@Test public void beanNameUrlHandlerMapping() { loadBeanDefinitions("mvc-config.xml"); BeanNameUrlHandlerMapping mapping = appContext.getBean(BeanNameUrlHandlerMapping.class); assertNotNull(mapping); assertEquals(2, mapping.getOrder()); }
private void loadBeanDefinitions(String fileName) { XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(appContext); ClassPathResource resource = new ClassPathResource(fileName, AnnotationDrivenBeanDefinitionParserTests.class); reader.loadBeanDefinitions(resource); appContext.refresh(); }
public ApplicationContext loadContext(String... locations) throws Exception { if (logger.isDebugEnabled()) { logger.debug( "Loading ApplicationContext for locations [" + StringUtils.arrayToCommaDelimitedString(locations) + "]."); } GenericWebApplicationContext context = new GenericWebApplicationContext(); prepareContext(context); customizeBeanFactory(context.getDefaultListableBeanFactory()); createBeanDefinitionReader(context).loadBeanDefinitions(locations); AnnotationConfigUtils.registerAnnotationConfigProcessors(context); customizeContext(context); context.refresh(); context.registerShutdownHook(); return context; }
@Override protected void onRefresh() { super.onRefresh(); try { initPropertySources(); } catch (Throwable ex) { throw new ApplicationContextException("Unable to start embedded container", ex); } }
public ApplicationContext loadContext(MergedContextConfiguration config) throws Exception { GenericWebApplicationContext context = new GenericWebApplicationContext(); // Commented out until SPR-10392 is fixed and we can upgrade to Spring 3.2.3.RELEASE or higher // ApplicationContext parent = config.getParentApplicationContext(); // if(parent != null) { // context.setParent(parent); // } prepareContext(context); prepareContext(context, config); customizeBeanFactory(context.getDefaultListableBeanFactory()); createBeanDefinitionReader(context).loadBeanDefinitions(config.getLocations()); AnnotationConfigUtils.registerAnnotationConfigProcessors(context); customizeContext(context); context.refresh(); context.registerShutdownHook(); return context; }
@AfterClass public static void afterClassClearContextBaseResourceProviderDstu3Test() throws Exception { ourServer.stop(); ourHttpClient.close(); ourServer = null; ourHttpClient = null; myValidationSupport.flush(); myValidationSupport = null; ourWebApplicationContext.close(); ourWebApplicationContext = null; TestUtil.clearAllStaticFieldsForUnitTest(); }
@SuppressWarnings("unchecked") @Test public void testReturnValueHandlers() { loadBeanDefinitions("mvc-config-return-value-handlers.xml"); RequestMappingHandlerAdapter adapter = appContext.getBean(RequestMappingHandlerAdapter.class); assertNotNull(adapter); Object value = new DirectFieldAccessor(adapter).getPropertyValue("customReturnValueHandlers"); assertNotNull(value); assertTrue(value instanceof List); List<HandlerMethodReturnValueHandler> handlers = (List<HandlerMethodReturnValueHandler>) value; assertEquals(1, handlers.size()); assertEquals(TestHandlerMethodReturnValueHandler.class, handlers.get(0).getClass()); }
/** * Configures web resources for the supplied web application context. * * <p>Implementation details: * * <ul> * <li>The resource base path is retrieved from the supplied {@code * WebMergedContextConfiguration}. * <li>A {@link ResourceLoader} is instantiated for the {@link MockServletContext}: if the * resource base path is prefixed with "{@code classpath:}", a {@link DefaultResourceLoader} * will be used; otherwise, a {@link FileSystemResourceLoader} will be used. * <li>A {@code MockServletContext} will be created using the resource base path and resource * loader. * <li>The supplied {@link GenericWebApplicationContext} is then stored in the {@code * MockServletContext} under the {@link * WebApplicationContext#ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE} key. * <li>Finally, the {@code MockServletContext} is set in the {@code WebApplicationContext}. * * @param context the web application context for which to configure the web resources * @param webMergedConfig the merged context configuration to use to load the web application * context */ protected void configureWebResources( GenericWebApplicationContext context, WebMergedContextConfiguration webMergedConfig) { String resourceBasePath = webMergedConfig.getResourceBasePath(); ResourceLoader resourceLoader = resourceBasePath.startsWith(ResourceLoader.CLASSPATH_URL_PREFIX) ? new DefaultResourceLoader() : new FileSystemResourceLoader(); ServletContext servletContext = new MockServletContext(resourceBasePath, resourceLoader); servletContext.setAttribute( WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, context); context.setServletContext(servletContext); }
@Test public void testPathMatchingConfiguration() { loadBeanDefinitions("mvc-config-path-matching.xml"); RequestMappingHandlerMapping hm = appContext.getBean(RequestMappingHandlerMapping.class); assertNotNull(hm); assertTrue(hm.useSuffixPatternMatch()); assertFalse(hm.useTrailingSlashMatch()); assertTrue(hm.useRegisteredSuffixPatternMatch()); assertThat(hm.getUrlPathHelper(), Matchers.instanceOf(TestPathHelper.class)); assertThat(hm.getPathMatcher(), Matchers.instanceOf(TestPathMatcher.class)); List<String> fileExtensions = hm.getContentNegotiationManager().getAllFileExtensions(); assertThat(fileExtensions, Matchers.contains("xml")); assertThat(fileExtensions, Matchers.hasSize(1)); }
@Test public void testMessageCodesResolver() { loadBeanDefinitions("mvc-config-message-codes-resolver.xml"); RequestMappingHandlerAdapter adapter = appContext.getBean(RequestMappingHandlerAdapter.class); assertNotNull(adapter); Object initializer = adapter.getWebBindingInitializer(); assertNotNull(initializer); MessageCodesResolver resolver = ((ConfigurableWebBindingInitializer) initializer).getMessageCodesResolver(); assertNotNull(resolver); assertEquals(TestMessageCodesResolver.class, resolver.getClass()); assertEquals( false, new DirectFieldAccessor(adapter).getPropertyValue("ignoreDefaultModelOnRedirect")); }
@SuppressWarnings("unchecked") @Test public void testArgumentResolvers() { loadBeanDefinitions("mvc-config-argument-resolvers.xml"); RequestMappingHandlerAdapter adapter = appContext.getBean(RequestMappingHandlerAdapter.class); assertNotNull(adapter); Object value = new DirectFieldAccessor(adapter).getPropertyValue("customArgumentResolvers"); assertNotNull(value); assertTrue(value instanceof List); List<HandlerMethodArgumentResolver> resolvers = (List<HandlerMethodArgumentResolver>) value; assertEquals(2, resolvers.size()); assertTrue(resolvers.get(0) instanceof ServletWebArgumentResolverAdapter); assertTrue(resolvers.get(1) instanceof TestHandlerMethodArgumentResolver); }
@Test @SuppressWarnings("unchecked") public void websocketHandlersAttributes() { loadBeanDefinitions("websocket-config-handlers-attributes.xml"); HandlerMapping handlerMapping = 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); checkDelegateHandlerType(handler.getWebSocketHandler(), FooWebSocketHandler.class); HandshakeHandler handshakeHandler = (HandshakeHandler) new DirectFieldAccessor(handler).getPropertyValue("handshakeHandler"); assertNotNull(handshakeHandler); assertTrue(handshakeHandler instanceof TestHandshakeHandler); List<HandshakeInterceptor> handshakeInterceptorList = (List<HandshakeInterceptor>) new DirectFieldAccessor(handler).getPropertyValue("interceptors"); assertNotNull(handshakeInterceptorList); assertThat( handshakeInterceptorList, Matchers.contains( Matchers.instanceOf(FooTestInterceptor.class), Matchers.instanceOf(BarTestInterceptor.class))); handler = (WebSocketHttpRequestHandler) urlHandlerMapping.getUrlMap().get("/test"); assertNotNull(handler); checkDelegateHandlerType(handler.getWebSocketHandler(), TestWebSocketHandler.class); handshakeHandler = (HandshakeHandler) new DirectFieldAccessor(handler).getPropertyValue("handshakeHandler"); assertNotNull(handshakeHandler); assertTrue(handshakeHandler instanceof TestHandshakeHandler); handshakeInterceptorList = (List<HandshakeInterceptor>) new DirectFieldAccessor(handler).getPropertyValue("interceptors"); assertNotNull(handshakeInterceptorList); assertThat( handshakeInterceptorList, Matchers.contains( Matchers.instanceOf(FooTestInterceptor.class), Matchers.instanceOf(BarTestInterceptor.class))); }
private Object getProxyBean(Object handler) { GenericWebApplicationContext wac = new GenericWebApplicationContext(); wac.registerBeanDefinition("controller", new RootBeanDefinition(handler.getClass())); DefaultAdvisorAutoProxyCreator autoProxyCreator = new DefaultAdvisorAutoProxyCreator(); autoProxyCreator.setBeanFactory(wac.getBeanFactory()); wac.getBeanFactory().addBeanPostProcessor(autoProxyCreator); wac.getBeanFactory() .registerSingleton("advsr", new DefaultPointcutAdvisor(new SimpleTraceInterceptor())); wac.refresh(); return wac.getBean("controller"); }
@Test public void sockJsSupport() { loadBeanDefinitions("websocket-config-handlers-sockjs.xml"); SimpleUrlHandlerMapping handlerMapping = appContext.getBean(SimpleUrlHandlerMapping.class); assertNotNull(handlerMapping); SockJsHttpRequestHandler testHandler = (SockJsHttpRequestHandler) handlerMapping.getUrlMap().get("/test/**"); assertNotNull(testHandler); checkDelegateHandlerType(testHandler.getWebSocketHandler(), TestWebSocketHandler.class); SockJsService testSockJsService = testHandler.getSockJsService(); SockJsHttpRequestHandler fooHandler = (SockJsHttpRequestHandler) handlerMapping.getUrlMap().get("/foo/**"); assertNotNull(fooHandler); checkDelegateHandlerType(fooHandler.getWebSocketHandler(), FooWebSocketHandler.class); SockJsService sockJsService = fooHandler.getSockJsService(); assertNotNull(sockJsService); assertEquals(testSockJsService, sockJsService); assertThat(sockJsService, Matchers.instanceOf(DefaultSockJsService.class)); DefaultSockJsService defaultSockJsService = (DefaultSockJsService) sockJsService; assertThat( defaultSockJsService.getTaskScheduler(), Matchers.instanceOf(ThreadPoolTaskScheduler.class)); assertThat( defaultSockJsService.getTransportHandlers().values(), Matchers.containsInAnyOrder( Matchers.instanceOf(XhrPollingTransportHandler.class), Matchers.instanceOf(XhrReceivingTransportHandler.class), Matchers.instanceOf(JsonpPollingTransportHandler.class), Matchers.instanceOf(JsonpReceivingTransportHandler.class), Matchers.instanceOf(XhrStreamingTransportHandler.class), Matchers.instanceOf(EventSourceTransportHandler.class), Matchers.instanceOf(HtmlFileTransportHandler.class), Matchers.instanceOf(WebSocketTransportHandler.class))); }
@Test public void webSocketHandlers() { loadBeanDefinitions("websocket-config-handlers.xml"); Map<String, HandlerMapping> handlersMap = appContext.getBeansOfType(HandlerMapping.class); assertNotNull(handlersMap); assertThat(handlersMap.values(), Matchers.hasSize(2)); for (HandlerMapping handlerMapping : handlersMap.values()) { assertTrue(handlerMapping instanceof SimpleUrlHandlerMapping); SimpleUrlHandlerMapping urlHandlerMapping = (SimpleUrlHandlerMapping) handlerMapping; if (urlHandlerMapping.getUrlMap().keySet().contains("/foo")) { assertThat(urlHandlerMapping.getUrlMap().keySet(), Matchers.contains("/foo", "/bar")); WebSocketHttpRequestHandler handler = (WebSocketHttpRequestHandler) urlHandlerMapping.getUrlMap().get("/foo"); assertNotNull(handler); checkDelegateHandlerType(handler.getWebSocketHandler(), FooWebSocketHandler.class); HandshakeHandler handshakeHandler = (HandshakeHandler) new DirectFieldAccessor(handler).getPropertyValue("handshakeHandler"); assertNotNull(handshakeHandler); assertTrue(handshakeHandler instanceof DefaultHandshakeHandler); } else { assertThat(urlHandlerMapping.getUrlMap().keySet(), Matchers.contains("/test")); WebSocketHttpRequestHandler handler = (WebSocketHttpRequestHandler) urlHandlerMapping.getUrlMap().get("/test"); assertNotNull(handler); checkDelegateHandlerType(handler.getWebSocketHandler(), TestWebSocketHandler.class); HandshakeHandler handshakeHandler = (HandshakeHandler) new DirectFieldAccessor(handler).getPropertyValue("handshakeHandler"); assertNotNull(handshakeHandler); assertTrue(handshakeHandler instanceof DefaultHandshakeHandler); } } }
@SuppressWarnings({"unchecked", "rawtypes"}) @Before public void before() throws Exception { myFhirCtx.getRestfulClientFactory().setServerValidationMode(ServerValidationModeEnum.NEVER); myFhirCtx.getRestfulClientFactory().setSocketTimeout(1200 * 1000); if (ourServer == null) { ourPort = RandomServerPortProvider.findFreePort(); ourRestServer = new RestfulServer(myFhirCtx); ourServerBase = "http://localhost:" + ourPort + "/fhir/context"; ourRestServer.setResourceProviders((List) myResourceProviders); ourRestServer .getFhirContext() .setNarrativeGenerator(new DefaultThymeleafNarrativeGenerator()); myTerminologyUploaderProvider = myAppCtx.getBean(TerminologyUploaderProviderDstu3.class); ourRestServer.setPlainProviders(mySystemProvider, myTerminologyUploaderProvider); JpaConformanceProviderDstu3 confProvider = new JpaConformanceProviderDstu3(ourRestServer, mySystemDao, myDaoConfig); confProvider.setImplementationDescription("THIS IS THE DESC"); ourRestServer.setServerConformanceProvider(confProvider); ourRestServer.setPagingProvider(myAppCtx.getBean(DatabaseBackedPagingProvider.class)); Server server = new Server(ourPort); ServletContextHandler proxyHandler = new ServletContextHandler(); proxyHandler.setContextPath("/"); ServletHolder servletHolder = new ServletHolder(); servletHolder.setServlet(ourRestServer); proxyHandler.addServlet(servletHolder, "/fhir/context/*"); ourWebApplicationContext = new GenericWebApplicationContext(); ourWebApplicationContext.setParent(myAppCtx); ourWebApplicationContext.refresh(); // ContextLoaderListener loaderListener = new ContextLoaderListener(webApplicationContext); // loaderListener.initWebApplicationContext(mock(ServletContext.class)); // proxyHandler .getServletContext() .setAttribute( WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, ourWebApplicationContext); DispatcherServlet dispatcherServlet = new DispatcherServlet(); // dispatcherServlet.setApplicationContext(webApplicationContext); dispatcherServlet.setContextClass(AnnotationConfigWebApplicationContext.class); ServletHolder subsServletHolder = new ServletHolder(); subsServletHolder.setServlet(dispatcherServlet); subsServletHolder.setInitParameter( ContextLoader.CONFIG_LOCATION_PARAM, WebsocketDstu3Config.class.getName()); proxyHandler.addServlet(subsServletHolder, "/*"); // Register a CORS filter CorsConfiguration config = new CorsConfiguration(); CorsInterceptor corsInterceptor = new CorsInterceptor(config); config.addAllowedHeader("x-fhir-starter"); config.addAllowedHeader("Origin"); config.addAllowedHeader("Accept"); config.addAllowedHeader("X-Requested-With"); config.addAllowedHeader("Content-Type"); config.addAllowedHeader("Access-Control-Request-Method"); config.addAllowedHeader("Access-Control-Request-Headers"); config.addAllowedOrigin("*"); config.addExposedHeader("Location"); config.addExposedHeader("Content-Location"); config.setAllowedMethods(Arrays.asList("GET", "POST", "PUT", "DELETE", "OPTIONS")); ourRestServer.registerInterceptor(corsInterceptor); server.setHandler(proxyHandler); server.start(); WebApplicationContext wac = WebApplicationContextUtils.getWebApplicationContext( subsServletHolder.getServlet().getServletConfig().getServletContext()); myValidationSupport = wac.getBean(JpaValidationSupportChainDstu3.class); ourClient = myFhirCtx.newRestfulGenericClient(ourServerBase); ourClient.registerInterceptor(new LoggingInterceptor(true)); PoolingHttpClientConnectionManager connectionManager = new PoolingHttpClientConnectionManager(5000, TimeUnit.MILLISECONDS); HttpClientBuilder builder = HttpClientBuilder.create(); builder.setConnectionManager(connectionManager); ourHttpClient = builder.build(); ourServer = server; } }
@Test public void testMessageConvertersWithoutDefaultRegistrations() { loadBeanDefinitions("mvc-config-message-converters-defaults-off.xml"); verifyMessageConverters(appContext.getBean(RequestMappingHandlerAdapter.class), false); verifyMessageConverters(appContext.getBean(ExceptionHandlerExceptionResolver.class), false); }
@Override public void setServletContext(ServletContext servletContext) { super.setServletContext(servletContext); prepareWebApplicationContext(servletContext); }
/** {@inheritDoc} */ public void configureWebApp() throws Exception { log.debug("Configuring Jetty webapp"); // Get context WebAppContext context = getWebAppContext(); // If app is already started... if (context.isStarted()) { log.debug("Cannot configure webapp after it is started"); return; } // Get WEB_INF directory Resource webInf = context.getWebInf(); if (webInf != null && webInf.isDirectory()) { // Get properties file with virtualHosts and context path Resource config = webInf.addPath("red5-web.properties"); if (config.exists()) { log.debug("Configuring red5-web.properties"); // Load configuration properties Properties props = new Properties(); props.load(config.getInputStream()); // Get context path and virtual hosts String contextPath = props.getProperty("webapp.contextPath"); String virtualHosts = props.getProperty("webapp.virtualHosts"); // Get hostnames String[] hostnames = virtualHosts.split(","); for (int i = 0; i < hostnames.length; i++) { hostnames[i] = hostnames[i].trim(); if (hostnames[i].equals("*")) { // A virtual host "null" must be used so requests for // any host will be served. hostnames = null; break; } } // Set virtual hosts and context path to context context.setVirtualHosts(hostnames); context.setContextPath(contextPath); LoaderBase.setRed5ApplicationContext(contextPath, new JettyApplicationContext(context)); } } else if (webInf == null) { // No WEB-INF directory found, register as default application log.info( "No WEB-INF directory found for " + context.getContextPath() + ", creating default application."); BeanFactoryLocator bfl = ContextSingletonBeanFactoryLocator.getInstance("red5.xml"); BeanFactoryReference bfr = bfl.useBeanFactory("red5.common"); // Create WebScope dynamically WebScope scope = new WebScope(); IServer server = (IServer) bfr.getFactory().getBean(IServer.ID); scope.setServer(server); scope.setGlobalScope(server.getGlobal("default")); // Get default Red5 context from context loader that is JettyLoader in this case ApplicationContext appCtx = JettyLoader.getApplicationContext(); ContextLoader loader = (ContextLoader) appCtx.getBean("context.loader"); appCtx = loader.getContext("default.context"); // Create context for the WebScope and initialize Context scopeContext = new Context(); scopeContext.setContextPath("/"); scopeContext.setClientRegistry((IClientRegistry) appCtx.getBean("global.clientRegistry")); scopeContext.setMappingStrategy((IMappingStrategy) appCtx.getBean("global.mappingStrategy")); scopeContext.setServiceInvoker((IServiceInvoker) appCtx.getBean("global.serviceInvoker")); scopeContext.setScopeResolver((IScopeResolver) appCtx.getBean("red5.scopeResolver")); // The context needs an ApplicationContext so resources can be // resolved GenericWebApplicationContext webCtx = new GenericWebApplicationContext(); webCtx.setDisplayName("Automatic generated WebAppContext"); webCtx.setParent(appCtx); webCtx.setServletContext(ContextHandler.getCurrentContext()); scopeContext.setApplicationContext(webCtx); // Store context in scope scope.setContext(scopeContext); // Use default ApplicationAdapter as handler scope.setHandler(new ApplicationAdapter()); // Make available as "/<directoryName>" and allow access from all // hosts scope.setContextPath(context.getContextPath()); scope.setVirtualHosts("*"); LoaderBase.setRed5ApplicationContext( context.getContextPath(), new JettyApplicationContext(context)); // Register WebScope in server scope.register(); } }
private void prepareContext(GenericWebApplicationContext context) { MockServletContext servletContext = new MockServletContext(); context.setServletContext(servletContext); servletContext.setAttribute( WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, context); }