public static HttpServer startServer() {
    HttpServer server = new HttpServer();
    server.addListener(new NetworkListener("grizzly", "0.0.0.0", 8080));

    final TCPNIOTransportBuilder transportBuilder = TCPNIOTransportBuilder.newInstance();
    //transportBuilder.setIOStrategy(WorkerThreadIOStrategy.getInstance());
    transportBuilder.setIOStrategy(SameThreadIOStrategy.getInstance());
    server.getListener("grizzly").setTransport(transportBuilder.build());
    final ResourceConfig rc = new ResourceConfig().packages("xyz.muetsch.jersey");
    rc.register(JacksonFeature.class);
    final ServerConfiguration config = server.getServerConfiguration();
    config.addHttpHandler(RuntimeDelegate.getInstance().createEndpoint(rc, GrizzlyHttpContainer.class), "/rest/todo/");

    try {
        server.start();
    } catch (IOException e) {
        e.printStackTrace();
    }

    return server;
}
 

public static URI generateSubResourceURI(final UriInfo uriInfo, final String subResource,
                                         final boolean encodeSubResourcePathSegment) {
    logger.debug("Generating sub resource URI for sub resource: {} with encoding flag: {}", subResource, encodeSubResourcePathSegment);
    final UriBuilder uriBuilder = RuntimeDelegate.getInstance().createUriBuilder();
    uriBuilder.path(uriInfo.getAbsolutePath().toString());
    uriBuilder.path("{resourceId}");
    URI finalUri;

    if (encodeSubResourcePathSegment) {
        finalUri = uriBuilder.build(subResource);
    } else {
        finalUri = uriBuilder.buildFromEncoded(subResource);
    }
    logger.debug("Final URI: {}", finalUri);

    return finalUri;
}
 

@Bean
public org.apache.cxf.endpoint.Server jaxRsServer() {
    JAXRSServerFactoryBean factory = RuntimeDelegate.getInstance()
            .createEndpoint(jaxRsApiApplication(), JAXRSServerFactoryBean.class);
    factory.setServiceBeans(Arrays.<Object>asList(starbucksOutletService()));
    factory.setAddress("/" + factory.getAddress());
    List<Object> providers = new ArrayList<Object>();
    providers.add(jsonProvider());
    providers.add(new OrderReader());
    factory.setProviders(providers);
    //factory.setProviders( Arrays.< Object >asList( jsonProvider() ) );
    return factory.create();
}
 

@Bean
public Server jaxRsServer() {
    JAXRSServerFactoryBean factory = RuntimeDelegate.getInstance()
            .createEndpoint(jaxRsApiApplication(), JAXRSServerFactoryBean.class);
    factory.setServiceBeans(Arrays.<Object>asList(peopleRestService()));
    factory.setAddress("/" + factory.getAddress());
    factory.setProviders(Arrays.<Object>asList(jsonProvider()));
    return factory.create();
}
 

@Bean
public Server jaxRsServer() {
    JAXRSServerFactoryBean factory = RuntimeDelegate.getInstance()
            .createEndpoint(jaxRsApiApplication(), JAXRSServerFactoryBean.class);
    factory.setServiceBeans(Arrays.<Object>asList(musicRestService()));
    factory.setAddress("/" + factory.getAddress());
    factory.setProviders(Arrays.<Object>asList(jsonProvider()));
    return factory.create();
}
 

@Bean
public org.apache.cxf.endpoint.Server jaxRsServer() {
    JAXRSServerFactoryBean factory = RuntimeDelegate.getInstance()
            .createEndpoint(jaxRsApiApplication(), JAXRSServerFactoryBean.class);
    factory.setServiceBeans(Arrays.<Object>asList(customerService()));
    factory.setAddress("/" + factory.getAddress());
    factory.setProviders(Arrays.<Object>asList(jsonProvider()));
    return factory.create();
}
 

public static void main(String[] args) throws Exception {
    RuntimeDelegate.setInstance(new org.glassfish.jersey.internal.RuntimeDelegateImpl());
    final SpringApplication application = new SpringApplication(DSSSpringApplication.class);
    application.addListeners(new ApplicationListener<ApplicationPreparedEvent>(){
        public void onApplicationEvent(ApplicationPreparedEvent applicationPreparedEvent) {
            logger.info("add config from config server...");
            if(applicationContext == null) {
                applicationContext = applicationPreparedEvent.getApplicationContext();
                try {
                    setApplicationContext(applicationContext);
                } catch (Exception e) {
                    logger.error(e);
                }
            }
            addRemoteConfig();
            logger.info("initialize DataWorkCloud spring application...");
            initDWCApplication();
        }
    });
    application.addListeners(new ApplicationListener<RefreshScopeRefreshedEvent>() {
        public void onApplicationEvent(RefreshScopeRefreshedEvent applicationEvent) {
            logger.info("refresh config from config server...");
            updateRemoteConfig();
        }
    });
    String listeners = ServerConfiguration.BDP_SERVER_SPRING_APPLICATION_LISTENERS().getValue();
    if(StringUtils.isNotBlank(listeners)) {
        for (String listener : listeners.split(",")) {
            application.addListeners((ApplicationListener<?>) Class.forName(listener).newInstance());
        }
    }
    applicationContext = application.run(args);
    setApplicationContext(applicationContext);
}
 

@BeforeEach
void setUp() {
    tested = new ExceptionsHandler();
    RuntimeDelegate.setInstance(runtimeDelegate);
    when(runtimeDelegate.createResponseBuilder()).thenReturn(builder);
    when(builder.status(any(Response.StatusType.class))).thenReturn(builder);
    when(builder.header(anyString(), any())).thenReturn(builder);
    when(builder.entity(any())).thenReturn(builder);
    when(builder.build()).thenReturn(response);
}
 

@SuppressWarnings({ "rawtypes", "unchecked" })
public static void transformHeaders(VertxHttpResponse vertxResponse, HttpServerResponse response,
        ResteasyProviderFactory factory) {
    for (Map.Entry<String, List<Object>> entry : vertxResponse.getOutputHeaders().entrySet()) {
        String key = entry.getKey();
        for (Object value : entry.getValue()) {
            RuntimeDelegate.HeaderDelegate delegate = factory.getHeaderDelegate(value.getClass());
            if (delegate != null) {
                response.headers().add(key, delegate.toString(value));
            } else {
                response.headers().add(key, value.toString());
            }
        }
    }
}
 

@Bean
 public org.apache.cxf.endpoint.Server jaxRsServer() {
     JAXRSServerFactoryBean factory = RuntimeDelegate.getInstance().createEndpoint( jaxRsApiApplication(), JAXRSServerFactoryBean.class );
     factory.setServiceBeans( Arrays.< Object >asList(starbucksOutletService()) );
     factory.setAddress( "/" + factory.getAddress() );
List<Object> providers = new ArrayList<Object>();
     providers.add(jsonProvider());
     providers.add(new OrderReader());
     factory.setProviders(providers);
     //factory.setProviders( Arrays.< Object >asList( jsonProvider() ) );
     return factory.create();
 }
 

@Bean
public Server jaxRsServer() {
    JAXRSServerFactoryBean factory = RuntimeDelegate.getInstance().createEndpoint( jaxRsApiApplication(), JAXRSServerFactoryBean.class );
    factory.setServiceBeans( Arrays.< Object >asList( peopleRestService() ) );
    factory.setAddress( "/" + factory.getAddress() );
    factory.setProviders( Arrays.< Object >asList( jsonProvider() ) );
    return factory.create();
}
 

@Bean
public Server jaxRsServer() {
    JAXRSServerFactoryBean factory = RuntimeDelegate.getInstance().createEndpoint( jaxRsApiApplication(), JAXRSServerFactoryBean.class );
    factory.setServiceBeans( Arrays.< Object >asList(musicRestService()) );
    factory.setAddress( "/" + factory.getAddress() );
    factory.setProviders( Arrays.< Object >asList( jsonProvider() ) );
    return factory.create();
}
 

@Bean
public org.apache.cxf.endpoint.Server jaxRsServer() {
    JAXRSServerFactoryBean factory = RuntimeDelegate.getInstance().createEndpoint( jaxRsApiApplication(), JAXRSServerFactoryBean.class );
    factory.setServiceBeans( Arrays.< Object >asList(customerService()) );
    factory.setAddress( "/" + factory.getAddress() );
    factory.setProviders( Arrays.< Object >asList( jsonProvider() ) );
    return factory.create();
}
 

public <T> T createEndpoint(Application app, Class<T> endpointType) {
    JAXRSServerFactoryBean bean =
        RuntimeDelegate.getInstance().createEndpoint(
            app, JAXRSServerFactoryBean.class);

    if (JAXRSServerFactoryBean.class.isAssignableFrom(endpointType)) {
        return endpointType.cast(bean);
    }
    bean.setApplication(app);
    bean.setStart(false);
    Server server = bean.create();
    return endpointType.cast(server);
}
 

@Override
public void stop(BundleContext context) throws Exception {
    if (_log.isDebugEnabled()) {
        _log.debug("Stopping whiteboard factory");
    }

    _defaultOSGiResult.close();

    if (_log.isDebugEnabled()) {
        _log.debug("Stopped whiteboard factory");
    }

    RuntimeDelegate.setInstance(null);
}
 

@BeforeMethod
public void prepare() throws ServletException {
  RuntimeDelegate.setInstance(new RuntimeDelegateImpl());
  when(filterConfig.getServletContext()).thenReturn(servletContext);
  setFieldValue(filter, "apiEndpoint", "http://localhost:8080/api");
  setFieldValue(filter, "loginPageUrl", "/site/login");
  setFieldValue(filter, "cookiesDisabledErrorPageUrl", "/site/cookiesDisabledErrorPageUrl");
  setFieldValue(filter, "allowAnonymous", false);
  //        setFieldValue(filter, "attemptToGetNewTokenIfNotExist", false);
  //        setFieldValue(filter, "attemptToGetNewTokenIfInvalid", false);
  //
  EnvironmentContext.reset();
}
 

@Override
public void init(final ServletConfig config) throws ServletException {
  super.init(config);

  // TODO: Figure out what version of RESTEasy is used and log it

  // Initialize container
  componentContainer.init(config);
  log.info("JAX-RS RuntimeDelegate: {}", RuntimeDelegate.getInstance());

  // Watch for components
  beanLocator.watch(Key.get(Component.class), new ComponentMediator(), componentContainer);

  log.info("Initialized");
}
 

public static void start(int port) throws IOException {
    // Create an HTTP server listening at port 8282
    URI uri = UriBuilder.fromUri("http://localhost/").port(port).build();
    server = HttpServer.create(new InetSocketAddress(uri.getPort()), 0);
    HttpHandler handler = RuntimeDelegate.getInstance().createEndpoint(new ApplicationConfig(), HttpHandler.class);
    server.createContext(uri.getPath(), handler);
    discoveryMsg = discoveryMsg.replaceAll("PORT", "" + uri.getPort());
    server.start();
}
 

public static void start(int port) throws IOException {
  // Create an HTTP server listening at port
  URI uri = UriBuilder.fromUri("http://localhost/").port(port).build();
  server = HttpServer.create(new InetSocketAddress(uri.getPort()), 0);
  HttpHandler handler = RuntimeDelegate.getInstance().createEndpoint(new ApplicationConfig(), HttpHandler.class);
  server.createContext(uri.getPath(), handler);
  server.start();
}
 

@Override
public void start(BundleContext context) throws Exception {
	// Ensure that the service loader uses the right class
	// See: http://www.mail-archive.com/[email protected]/msg07539.html
	ClassLoader oldcl = Thread.currentThread().getContextClassLoader();
	ClassLoader newcl = RuntimeDelegate.class.getClassLoader();
	
	Thread.currentThread().setContextClassLoader(newcl);
	try {
		RuntimeDelegate.setInstance(new RuntimeDelegateImpl());
	} finally {
		Thread.currentThread().setContextClassLoader(oldcl);
	}
	super.start(context);
}
 

@Override
public void start(BundleContext context) throws Exception {
	// Ensure that the service loader uses the right class
	// See: http://www.mail-archive.com/[email protected]/msg07539.html
	ClassLoader oldcl = Thread.currentThread().getContextClassLoader();
	ClassLoader newcl = RuntimeDelegate.class.getClassLoader();
	
	Thread.currentThread().setContextClassLoader(newcl);
	try {
		RuntimeDelegate.setInstance(new RuntimeDelegateImpl());
	} finally {
		Thread.currentThread().setContextClassLoader(oldcl);
	}
	super.start(context);
}
 

public static URI encode(final URI uri) {
    final List<PathSegment> pathSegments = UriComponent.decodePath(uri, false);
    final UriBuilder uriBuilder = RuntimeDelegate.getInstance().createUriBuilder();
    // Build base URL
    uriBuilder.scheme(uri.getScheme()).host(uri.getHost()).port(uri.getPort());
    // Iterate over path segments and encode it if necessary
    for (final PathSegment ps : pathSegments) {
        uriBuilder.path(UriComponent.encode(ps.toString(), UriComponent.Type.PATH_SEGMENT));
    }
    logger.debug("URL before encoding: {}", uri.toString());
    URI result = uriBuilder.build();
    logger.debug("URL after encoding:  {}", result.toString());
    return result;
}
 

@Bean @DependsOn("cxf")
Server jaxRsServer() {
    final JAXRSServerFactoryBean factory = RuntimeDelegate
        .getInstance()
        .createEndpoint(new StatsApplication(), JAXRSServerFactoryBean.class);
    factory.setServiceBean(statsRestService);
    factory.setProvider(new JacksonJsonProvider());
    return factory.create();
}
 

@Override
protected void run() {
    final JAXRSServerFactoryBean sf = RuntimeDelegate
        .getInstance()
        .createEndpoint(new BookStoreApplication(), JAXRSServerFactoryBean.class);
    sf.setResourceClasses(BookStoreOpenApi.class);
    sf.setResourceClasses(BookStoreStylesheetsOpenApi.class);
    sf.setResourceProvider(BookStoreOpenApi.class,
        new SingletonResourceProvider(new BookStoreOpenApi()));
    sf.setProvider(new JacksonJsonProvider());
    final OpenApiFeature feature = createOpenApiFeature();
    sf.setFeatures(Arrays.asList(feature));
    sf.setAddress("http://localhost:" + port + "/api");
    sf.create();
}
 

public static RuntimeDelegate getOtherRuntimeDelegate() {
    try {
        RuntimeDelegate rd = RuntimeDelegate.getInstance();
        return rd instanceof RuntimeDelegateImpl ? null : rd;
    } catch (Throwable t) {
        return null;
    }
}
 

public static void convertHeaderValuesToString(Map<String, List<Object>> headers, boolean delegateOnly) {
    if (headers == null) {
        return;
    }
    RuntimeDelegate rd = getOtherRuntimeDelegate();
    if (rd == null && delegateOnly) {
        return;
    }
    for (Map.Entry<String, List<Object>> entry : headers.entrySet()) {
        List<Object> values = entry.getValue();
        for (int i = 0; i < values.size(); i++) {
            Object value = values.get(i);

            if (value != null && !(value instanceof String)) {

                HeaderDelegate<Object> hd = getHeaderDelegate(rd, value);

                if (hd != null) {
                    value = hd.toString(value);
                } else if (!delegateOnly) {
                    value = value.toString();
                }

                try {
                    values.set(i, value);
                } catch (UnsupportedOperationException ex) {
                    // this may happen if an unmodifiable List was set via Map put
                    List<Object> newList = new ArrayList<>(values);
                    newList.set(i, value);
                    // Won't help if the map is unmodifiable in which case it is a bug anyway
                    headers.put(entry.getKey(), newList);
                }

            }

        }
    }

}
 

public static final void assertNotStringBeanRuntimeDelegate(RuntimeDelegate delegate) {
    if (delegate instanceof StringBeanRuntimeDelegate) {
        StringBeanRuntimeDelegate sbrd = (StringBeanRuntimeDelegate) delegate;
        if (sbrd.getOriginal() != null) {
            RuntimeDelegate.setInstance(sbrd.getOriginal());
            throw new RuntimeException(
                "RuntimeDelegate.getInstance() is StringBeanRuntimeDelegate");
        }
    }
}
 

private void doSetHeader(RuntimeDelegate rd, String name, Object value) {
    HeaderDelegate<Object> hd = HttpUtils.getHeaderDelegate(rd, value);
    if (hd != null) {
        value = hd.toString(value);
    }
    
    // If value is null then all current headers of the same name should be removed
    if (value == null) {
        webClient.replaceHeader(name, value);
    } else {
        webClient.header(name, value);
    }
}
 

@Override
public void contextInitialized(ServletContextEvent sce) {
    super.contextInitialized(sce);
    ServletContext servletContext = sce.getServletContext();
    ResourceBinderImpl resources = new ResourceBinderImpl();
    ApplicationProviderBinder providers = new ApplicationProviderBinder();
    Injector injector = getInjector(servletContext);
    DependencySupplier dependencySupplier = new GuiceDependencySupplier(injector);
    EverrestConfiguration config = injector.getInstance(EverrestConfiguration.class);
    EverrestServletContextInitializer everrestInitializer = new EverrestServletContextInitializer(servletContext);
    Application application = everrestInitializer.getApplication();
    EverrestApplication everrest = new EverrestApplication();
    if (config.isAsynchronousSupported()) {
        everrest.addResource(config.getAsynchronousServicePath(), AsynchronousJobService.class);
        everrest.addSingleton(new AsynchronousJobPool(config));
        everrest.addSingleton(new AsynchronousProcessListWriter());
    }
    if (config.isCheckSecurity()) {
        everrest.addSingleton(new SecurityConstraint());
    }
    everrest.addApplication(application);

    processBindings(injector, everrest);
    RequestDispatcher requestDispatcher = new RequestDispatcher(resources);
    RequestHandlerImpl requestHandler = new RequestHandlerImpl(requestDispatcher, providers);
    EverrestProcessor processor = new EverrestProcessor(config, dependencySupplier, requestHandler, everrest);
    processor.start();

    servletContext.setAttribute(EverrestConfiguration.class.getName(), config);
    servletContext.setAttribute(Application.class.getName(), everrest);
    servletContext.setAttribute(DependencySupplier.class.getName(), dependencySupplier);
    servletContext.setAttribute(ResourceBinder.class.getName(), resources);
    servletContext.setAttribute(ApplicationProviderBinder.class.getName(), providers);
    servletContext.setAttribute(EverrestProcessor.class.getName(), processor);
    // use specific RuntimeDelegate instance which is able to work with guice rest service proxies.
    // (need for interceptors functionality)
    RuntimeDelegate.setInstance(new GuiceRuntimeDelegateImpl());
}
 

@Override
public Locale getLanguage() {
    Object value = getMetadata().getFirst(CONTENT_LANGUAGE);
    if (value == null) {
        return null;
    }
    if (value instanceof Locale) {
        return (Locale)value;
    }
    return RuntimeDelegate.getInstance().createHeaderDelegate(Locale.class)
                          .fromString(value instanceof String ? (String)value : getHeaderAsString(value));
}