/** * Add new servlet according to {@link Application} subclass with {@link ApplicationPath} annotation or existing * {@code servlet-mapping}. */ private static void addServletWithApplication(final ServletContext context, final Class<? extends Application> clazz, final Set<Class<?>> defaultClasses) throws ServletException { final ApplicationPath ap = clazz.getAnnotation(ApplicationPath.class); if (ap != null) { // App is annotated with ApplicationPath final ResourceConfig resourceConfig = ResourceConfig.forApplicationClass(clazz, defaultClasses) .addProperties(Utils.getContextParams(context)); final ServletContainer s = new ServletContainer(resourceConfig); final ServletRegistration.Dynamic dsr = context.addServlet(clazz.getName(), s); dsr.setAsyncSupported(true); dsr.setLoadOnStartup(1); final String mapping = createMappingPath(ap); if (!mappingExists(context, mapping)) { dsr.addMapping(mapping); LOGGER.log(Level.CONFIG, LocalizationMessages.JERSEY_APP_REGISTERED_MAPPING(clazz.getName(), mapping)); } else { LOGGER.log(Level.WARNING, LocalizationMessages.JERSEY_APP_MAPPING_CONFLICT(clazz.getName(), mapping)); } } }
@Override public void init() throws ServletException { super.init(); getServletContext().setAttribute(ALLUXIO_JOB_MASTER_SERVLET_RESOURCE_KEY, jobMaster); } };
/** * Dispatches client requests to the protected * {@code service} method. There's no need to * override this method. * * @param req the {@link HttpServletRequest} object that * contains the request the client made of * the servlet * @param res the {@link HttpServletResponse} object that * contains the response the servlet returns * to the client * @throws IOException if an input or output error occurs * while the servlet is handling the * HTTP request * @throws ServletException if the HTTP request cannot * be handled * @see javax.servlet.Servlet#service */ @Override public void service(final ServletRequest req, final ServletResponse res) throws ServletException, IOException { final HttpServletRequest request; final HttpServletResponse response; if (!(req instanceof HttpServletRequest && res instanceof HttpServletResponse)) { throw new ServletException("non-HTTP request or response"); } request = (HttpServletRequest) req; response = (HttpServletResponse) res; service(request, response); }
@Override public void init(final FilterConfig filterConfig) throws ServletException { this.filterConfig = filterConfig; init(new WebFilterConfig(filterConfig)); final String regex = (String) getConfiguration().getProperty(ServletProperties.FILTER_STATIC_CONTENT_REGEX); if (regex != null && !regex.isEmpty()) { try { final FilterUrlMappingsProvider filterUrlMappingsProvider = getFilterUrlMappingsProvider(); if (filterUrlMappingsProvider != null) { filterUrlMappings = filterUrlMappingsProvider.getFilterUrlMappings(filterConfig);
absoluteUriBuilder = UriBuilder.fromUri(requestUrl.toString()); } catch (final IllegalArgumentException iae) { setResponseForInvalidUri(response, iae); return; .build(); } catch (final UriBuilderException | IllegalArgumentException ex) { setResponseForInvalidUri(response, ex); return; service(baseUri, requestUri, request, response);
new ResourceConfig() .packages("org.apache.storm.daemon.ui.resources") .registerInstances(new AbstractBinder() { @Override protected void configure() { .register(DefaultExceptionMapper.class); ServletHolder jerseyServlet = new ServletHolder(new ServletContainer(resourceConfig)); jerseyServlet.setInitOrder(0); context.addServlet(jerseyServlet, STORM_API_URL_PREFIX + "*");
ServletContainer container = new ServletContainer( ResourceConfig.forApplication(app)); Bundle appBundle = componentContext.getBundleContext().getBundle(); httpService.registerServlet(applicationAlias, container, getInitParams(), null); servletContext = container.getServletContext(); servletContext.setAttribute(BundleContext.class.getName(), componentContext.getBundleContext()); layoutConfiguration.setRootUrl(applicationAlias); servletContext.setAttribute(CORS_ORIGIN, corsOrigins); servletContext.setAttribute(CORS_ACCESS_CONTROL_EXPOSE_HEADERS, exposedHeaders);
private static ServletContainer createJerseyServlet() throws IOException { ResourceConfig resourceConfig = new ResourceConfig(); resourceConfig.register(JacksonFeature.class); resourceConfig.register(new ApiResource()); return new ServletContainer(resourceConfig); } }
private void reload() throws Fabric3Exception { try { // register contribution resources ResourceConfig resourceConfig = new ResourceConfig(); resourceConfig.registerInstances(new Fabric3ApplicationEventListener()); resourceConfig.register(JacksonFeature.class); resourceConfig.register(MultiPartFeature.class); // configure filters Collection<Object> globalProviders = providerRegistry.getGlobalProvider(); globalProviders.forEach(resourceConfig::register); resourceConfig.register(provider); resources.forEach(resourceConfig::registerResources); servlet = new ServletContainer(resourceConfig); servlet.init(servletConfig); } catch (Throwable t) { throw new Fabric3Exception(t); } }
/** * Add a Jersey resource package. * @param packageName The Java package name containing the Jersey resource. * @param pathSpec The path spec for the servlet */ public void addJerseyResourcePackage(final String packageName, final String pathSpec) { LOG.info("addJerseyResourcePackage: packageName=" + packageName + ", pathSpec=" + pathSpec); ResourceConfig application = new ResourceConfig().packages(packageName); final ServletHolder sh = new ServletHolder(new ServletContainer(application)); webAppContext.addServlet(sh, pathSpec); }
private void initApi(Config config, ServletContextHandler servletHandler) { servletHandler.addServlet(new ServletHolder(new AsyncSocketServlet()), "/api/socket"); if (config.hasKey("media.path")) { ServletHolder servletHolder = new ServletHolder(DefaultServlet.class); servletHolder.setInitParameter("resourceBase", config.getString("media.path")); servletHolder.setInitParameter("dirAllowed", config.getString("media.dirAllowed", "false")); servletHolder.setInitParameter("pathInfoOnly", "true"); servletHandler.addServlet(servletHolder, "/api/media/*"); servletHandler.addFilter(MediaFilter.class, "/api/media/*", EnumSet.allOf(DispatcherType.class)); } ResourceConfig resourceConfig = new ResourceConfig(); resourceConfig.registerClasses(JacksonFeature.class, ObjectMapperProvider.class, ResourceErrorHandler.class); resourceConfig.registerClasses(SecurityRequestFilter.class, CorsResponseFilter.class); resourceConfig.packages(ServerResource.class.getPackage().getName()); servletHandler.addServlet(new ServletHolder(new ServletContainer(resourceConfig)), "/api/*"); }
public class JerseyServletContainerInitializer implements ServletContainerInitializer { @Override public void onStartup(Set<Class<?>> classes, ServletContext servletContext) throws ServletException { //Register spring configurations AnnotationConfigWebApplicationContext springContext = new AnnotationConfigWebApplicationContext(); springContext.register(SpringConfig.class, JPAConfig.class); servletContext.addListener(new RequestContextListener()); servletContext.addListener(new ContextLoaderListener(springContext)); springContext.setServletContext(servletContext); //Register Jersey servlet ServletRegistration.Dynamic servletRegistration = servletContext.addServlet("JerseyServlet", new ServletContainer()); servletRegistration.addMapping("/api/*"); servletRegistration.setLoadOnStartup(1); servletRegistration.setInitParameter("javax.ws.rs.Application", JerseyResourceConfig.class.getName()); } }
@SuppressWarnings("unchecked") public void start() { Set<Object> controllers = new HashSet<>(); controllers.add(new DataTypesController(actions.get(GetDataTypes.class))); controllers.add(new TransferServicesController(actions.get(GetTransferServices.class))); controllers.add( new TransferController( actions.get(CreateTransferJob.class), actions.get(GenerateServiceAuthData.class), actions.get(ReserveWorker.class), actions.get(GetReservedWorker.class), actions.get(StartTransferJob.class), actions.get(GetTransferJob.class))); // Create a Jersey JAX-RS Application (resourceConfig), add the actions, and register it with // the Jetty transport. ResourceConfig resourceConfig = new ResourceConfig(); // resourceConfig.register(JacksonFeature.class) resourceConfig.registerInstances(controllers); ServletContainer servletContainer = new ServletContainer(resourceConfig); jettyTransport.registerServlet("/api/*", servletContainer); } }
private void reload() throws RsContainerException { try { // register contribution resources ResourceConfig resourceConfig = new ResourceConfig(); for (Resource resource : resources) { resourceConfig.registerResources(resource); } servlet = new ServletContainer(resourceConfig); servlet.init(servletConfig); } catch (ServletException e) { throw new RsContainerException(e); } catch (Throwable t) { RsContainerException e = new RsContainerException(t); throw e; } }
private void rawRegisterServlets() throws ServletException, NamespaceException, InterruptedException { logger.info("JERSEY BUNDLE: REGISTERING SERVLETS"); logger.info("JERSEY BUNDLE: HTTP SERVICE = " + httpService.toString()); // TODO - temporary workaround // This is a workaround related to issue JERSEY-2093; grizzly (1.9.5) needs to have the correct context // classloader set ClassLoader myClassLoader = getClass().getClassLoader(); ClassLoader originalContextClassLoader = Thread.currentThread().getContextClassLoader(); try { Thread.currentThread().setContextClassLoader(myClassLoader); httpService.registerServlet("/jersey-http-service", new ServletContainer(), getJerseyServletParams(), null); } finally { Thread.currentThread().setContextClassLoader(originalContextClassLoader); } // END of workaround - after grizzly updated to the recent version, only the inner call from try block will remain: // httpService.registerServlet("/jersey-http-service", new ServletContainer(), getJerseyServletParams(), null); sendAdminEvent(); logger.info("JERSEY BUNDLE: SERVLETS REGISTERED"); }
public static void init(ServletContext servletContext, WebApplicationContext rootContext) { WebAppInitUtils.defaultSetup(servletContext, rootContext); { ServletRegistration.Dynamic servlet = servletContext.addServlet("sparqlServiceServlet", new ServletContainer()); //servlet.setInitParameter("contextConfigLocation", "workaround-for-JERSEY-2038"); servlet.setInitParameter(ServerProperties.PROVIDER_CLASSNAMES, org.aksw.jena_sparql_api.web.servlets.ServletSparqlServiceImpl.class.getCanonicalName()); // servlet.setInitParameter(ServletProperties.FILTER_FORWARD_ON_404, "true"); // servlet.setInitParameter(ServletProperties.FILTER_STATIC_CONTENT_REGEX, ".*(html|css|js)"); servlet.addMapping("/sparql/*"); servlet.setAsyncSupported(true); servlet.setLoadOnStartup(1); } { AnnotationConfigWebApplicationContext dispatcherContext = new AnnotationConfigWebApplicationContext(); dispatcherContext.register(WebMvcConfigSnorql.class); ServletRegistration.Dynamic servlet = servletContext.addServlet("dispatcherServlet", new DispatcherServlet(dispatcherContext)); servlet.addMapping("/*"); servlet.setAsyncSupported(true); servlet.setLoadOnStartup(1); } } }
@Override public void init(WebConfig webConfig) throws ServletException { super.init(webConfig); ResourceConfig config = new ResourceConfig(); Reflections reflection = new Reflections("info.magnolia.rest"); final Set<Class<?>> providers = reflection.getTypesAnnotatedWith(Provider.class); config.registerClasses(providers); log.info("Registered scanned Provider classes: {}", providers.stream().map(c -> c.getName()).collect(Collectors.joining(", "))); // Register all currently registered endpoints for (DefinitionProvider<EndpointDefinition> provider : endpointRegistry.getAllProviders()) { try { registerEndpoint(provider, config); } catch (Exception e) { log.error("Failed to register endpoint [{}]", provider.getMetadata().getReferenceId(), e); } } reload(config); // Listen for changes to the registry to observe endpoints being added or removed registerHandler = systemEventBus.addHandler(EndpointDefinitionRegistryEvent.class, this); }
ServletContainer s = new ServletContainer(); // Add the Servlet to the context ... // Deploy context to the server ... s.getServletContext().setAttribute("myRc", new MyRc()); httpServer.start();
@Override public void init() throws ServletException { init(new WebServletConfig(this)); }
@Override public ServletContext getServletContext() { return servlet.getServletContext(); } }