import org.glassfish.jersey.server.ContainerFactory; //导入依赖的package包/类
private HttpServer createServer(URI uri, ResourceConfig resourceCfg) {
    final String host = uri.getHost();
    final int port = uri.getPort();
    final HttpServer server = new HttpServer();
    final NetworkListener listener = new NetworkListener("grizzly", host, port);
    listener.getTransport().setWorkerThreadPoolConfig(adjustThreadPool());
    server.addListener(listener);

    final ServerConfiguration config = server.getServerConfiguration();
    final HttpHandler handler = ContainerFactory.createContainer(HttpHandler.class, resourceCfg);

    if (handler != null)
        config.addHttpHandler(handler, uri.getPath());

    return server;
}
 

import org.glassfish.jersey.server.ContainerFactory; //导入依赖的package包/类
@Override
protected void configureHttpContainer() {
    container = ContainerFactory.createContainer(GrizzlyHttpContainer.class, getApplication().getConfig());
    ServerConfiguration serverConfiguration = httpServer.getServerConfiguration();

    serverConfiguration.setSendFileEnabled(true);
    String charset = StringUtils.defaultIfBlank((String) getApplication().getProperty("app.encoding"), "utf-8");
    serverConfiguration.setDefaultQueryEncoding(Charset.forName(charset));

    container.setRequestURIEncoding(charset);
    serverConfiguration.addHttpHandler(container);
}
 

import org.glassfish.jersey.server.ContainerFactory; //导入依赖的package包/类
@Test
public void playJersey()
{
    JdkHttpHandlerContainer container = ContainerFactory
            .createContainer(JdkHttpHandlerContainer.class, new TelletsApplication());


}
 

import org.glassfish.jersey.server.ContainerFactory; //导入依赖的package包/类
private NettyContainer getNettyContainer(Resource resource, Class... classes) throws URISyntaxException {
    ResourceConfig rc = new ResourceConfig()
            .property(NettyContainer.PROPERTY_BASE_URI, new URI("http:/localhost:0"))
            .registerResources(resource)
            .registerInstances(new NettyContainerProvider())
            .register(JacksonJsonProvider.class);
    for (Class aClass : classes) {
        rc.register(aClass);
    }

    return ContainerFactory.createContainer(NettyContainer.class, rc);
}
 

import org.glassfish.jersey.server.ContainerFactory; //导入依赖的package包/类
public static Server run(ResourceConfig application, Properties properties, int port, String originFilter,
                         String aliasName, File keystoreFile, String password, String frontendRoot, String apiPathPattern, boolean copyWebDir) {
    try {
        QueuedThreadPool threadPool = new QueuedThreadPool(
                Integer.valueOf(properties.getProperty("jetty.maxThreads")),
                Integer.valueOf(properties.getProperty("jetty.minThreads")),
                Integer.valueOf(properties.getProperty("jetty.idleTimeout")),
                new ArrayBlockingQueue<>(Integer.valueOf(properties.getProperty("jetty.maxQueueSize"))));
        Server server = new Server(threadPool);
        HttpConfiguration config = new HttpConfiguration();

        if (keystoreFile != null) {
            log.info("Jetty runner {}. SSL enabled.", application.getClass());
            SslContextFactory sslFactory = new SslContextFactory();
            sslFactory.setCertAlias(aliasName);

            String path = keystoreFile.getAbsolutePath();
            if (!keystoreFile.exists()) {
                log.error("Couldn't load keystore file: {}", path);
                return null;
            }
            sslFactory.setKeyStorePath(path);
            sslFactory.setKeyStorePassword(password);
            sslFactory.setKeyManagerPassword(password);
            sslFactory.setTrustStorePath(path);
            sslFactory.setTrustStorePassword(password);

            config.setSecureScheme("https");
            config.setSecurePort(port);
            config.addCustomizer(new SecureRequestCustomizer());

            ServerConnector https = new ServerConnector(server,
                    new SslConnectionFactory(sslFactory, "http/1.1"),
                    new HttpConnectionFactory(config));
            https.setPort(port);
            server.setConnectors(new Connector[]{https});
        } else {
            ServerConnector http = new ServerConnector(server, new HttpConnectionFactory(config));
            http.setPort(port);
            server.setConnectors(new Connector[]{http});
        }

        Handler handler = ContainerFactory.createContainer(JettyHttpContainer.class, application);
        if (originFilter != null)
            handler = new CrossDomainFilter(handler, originFilter);
        if (frontendRoot != null) {
            WebAppContext htmlHandler = new WebAppContext();
            htmlHandler.setResourceBase(frontendRoot);
            htmlHandler.setCopyWebDir(copyWebDir);
            Map<Pattern, Handler> pathToHandler = new HashMap<>();
            pathToHandler.put(Pattern.compile(apiPathPattern), handler);

            SessionManager sm = new HashSessionManager();
            SessionHandler sh = new SessionHandler(sm);
            htmlHandler.setSessionHandler(sh);

            DefaultServlet defaultServlet = new DefaultServlet();
            ServletHolder holder = new ServletHolder(defaultServlet);
            holder.setInitParameter("useFileMappedBuffer", Boolean.toString(!copyWebDir));
            holder.setInitParameter("cacheControl", "no-store,no-cache,must-revalidate,max-age=-1,public");
            htmlHandler.addServlet(holder, "/");
            
            handler = new RequestsRouter(htmlHandler, pathToHandler, frontendRoot);
        }
        server.setHandler(handler);
        server.start();

        while (!server.isStarted()) {
            Thread.sleep(50);
        }
        log.info("Jetty server started {} on port {}", application.getClass(), port);
        return server;
    } catch (Exception e) {
        log.error(String.format("Jetty start failed %s.", application.getClass()), e);
        return null;
    }
}
 

import org.glassfish.jersey.server.ContainerFactory; //导入依赖的package包/类
private HttpServer createServer(URI uri, ResourceConfig configuration) {
		GrizzlyHttpContainer handler = ContainerFactory.createContainer(GrizzlyHttpContainer.class, configuration);
		boolean secure = false;
		SSLEngineConfigurator sslEngineConfigurator = null;
		boolean start = false;

		final String host = (uri.getHost() == null) ? NetworkListener.DEFAULT_NETWORK_HOST
				: uri.getHost();
		final int port = (uri.getPort() == -1) ? 80 : uri.getPort();
		final HttpServer server = new HttpServer();
		final NetworkListener listener = new NetworkListener("grizzly", host, port);
		listener.setSecure(secure);
		if (sslEngineConfigurator != null) {
			listener.setSSLEngineConfig(sslEngineConfigurator);
		}

		// insert
//		listener.

		CompressionConfig cg = listener.getCompressionConfig();
		cg.setCompressionMode(CompressionConfig.CompressionMode.ON);
//		cg.setCompressableMimeTypes("text","application/json");
		// end insert

		server.addListener(listener);

		// Map the path to the processor.
		final ServerConfiguration config = server.getServerConfiguration();
		if (handler != null) {
			config.addHttpHandler(handler, uri.getPath());
		}

		config.setPassTraceRequest(true);

		if (start) {
			try {
				// Start the server.
				server.start();
			} catch (IOException ex) {
				throw new ProcessingException("IOException thrown when trying to start grizzly server", ex);
			}
		}

		return server;
	}