Java GrizzlyHttpServerFactory类代码示例

import org.glassfish.jersey.grizzly2.httpserver.GrizzlyHttpServerFactory; //导入依赖的package包/类
/**
 * Starts Grizzly HTTP server exposing JAX-RS resources defined in this application.
 * @return Grizzly HTTP server.
 * @param serverURI
 */
public static HttpServer startServer(URI serverURI) throws IOException {
    // create a resource config that scans for JAX-RS resources and providers
    // in org.esa.pfa.ws package
    final ResourceConfig resourceConfig = new ResourceConfig()
            .packages("org.esa.pfa.ws")
            .property("jersey.config.server.tracing.type ", "ALL");

    // create and start a new instance of grizzly http server
    // exposing the Jersey application at BASE_URI
    HttpServer httpServer = GrizzlyHttpServerFactory.createHttpServer(serverURI, resourceConfig, false);
    ServerConfiguration serverConfiguration = httpServer.getServerConfiguration();

    final AccessLogBuilder builder = new AccessLogBuilder("access.log");
    builder.instrument(serverConfiguration);

    httpServer.start();
    return httpServer;
}
 

import org.glassfish.jersey.grizzly2.httpserver.GrizzlyHttpServerFactory; //导入依赖的package包/类
private HttpServer createHttpsServer() {
    SSLContextConfigurator sslContextConfig = new SSLContextConfigurator();

    // set up security context
    sslContextConfig.setKeyStoreFile(this.serverKeystore); // contains server cert and key
    sslContextConfig.setKeyStorePass(this.serverKeystorePwd);

    // Create context and have exceptions raised if anything wrong with keystore or password
    SSLContext sslContext = sslContextConfig.createSSLContext(true);
            
    // Create server but do not start it
    HttpServer server = GrizzlyHttpServerFactory.createHttpServer(URI.create(this.baseUri),false);

    
    //LOGGER.debug("About to loop through listeners");
    //for (NetworkListener listener : server.getListeners()) {
    //	LOGGER.debug("About to setSecure on listener name: " + listener.getName());
    //}
    
    // grizzly is the default listener name
    server.getListener("grizzly").setSecure(true);
    // One way authentication
    server.getListener("grizzly").setSSLEngineConfig(new SSLEngineConfigurator(sslContext).setClientMode(false).setNeedClientAuth(false));
    return server;
}
 

import org.glassfish.jersey.grizzly2.httpserver.GrizzlyHttpServerFactory; //导入依赖的package包/类
public static HttpServer httpBuilder (String connectionUrl, String profileName) {
    try {
        URL url = new URL(connectionUrl);

        System.setProperty("spring.profiles.active", profileName);
        AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(SpringAnnotationConfig.class);

        ResourceConfig resourceConfig = new ResourceConfig();
        resourceConfig.register(RequestContextFilter.class);
        resourceConfig.property("contextConfig", annotationConfigApplicationContext);
        resourceConfig.register(RestSupport.class);

        URI baseUri = URI.create(url.getProtocol() + "://" + url.getAuthority());
        return  GrizzlyHttpServerFactory.createHttpServer(baseUri, resourceConfig, false);
    } catch (Exception e) {
        Assert.fail("Could'n parse configfile." + e.getMessage());
    }
    return null;
}
 

import org.glassfish.jersey.grizzly2.httpserver.GrizzlyHttpServerFactory; //导入依赖的package包/类
public void startServer() throws TelegramApiException {
    SSLContextConfigurator sslContext = new SSLContextConfigurator();

    // set up security context
    sslContext.setKeyStoreFile(KEYSTORE_SERVER_FILE); // contains server keypair
    sslContext.setKeyStorePass(KEYSTORE_SERVER_PWD);

    ResourceConfig rc = new ResourceConfig();
    rc.register(restApi);
    rc.register(JacksonFeature.class);
    rc.property(JSONConfiguration.FEATURE_POJO_MAPPING, true);
    final HttpServer grizzlyServer = GrizzlyHttpServerFactory.createHttpServer(
            getBaseURI(),
            rc,
            true,
            new SSLEngineConfigurator(sslContext).setClientMode(false).setNeedClientAuth(false));
    try {
        grizzlyServer.start();
    } catch (IOException e) {
        throw new TelegramApiException("Error starting webhook server", e);
    }
}
 

import org.glassfish.jersey.grizzly2.httpserver.GrizzlyHttpServerFactory; //导入依赖的package包/类
void start() {
    try {
        Config config = core.getConfig();
        String urlStr = config.getString("networking.rest-url");
        ResourceConfig rc = new ResourceConfig();
        rc.register(LoggingFilter.class);
        rc.register(JacksonFeature.class);
        rc.register(CatchAllExceptionMapper.class);
        rc.register(SerializationExceptionMapper.class);
        rc.register(AdminResourceImpl.class);
        rc.register(new KBResourceImpl(core));
        rc.register(new QueryResourceImpl(core));
        httpServer = GrizzlyHttpServerFactory.createHttpServer(URI.create(urlStr), rc, true);
        logger.info(marker, "Stargraph listening on {}", urlStr);
    } catch (Exception e) {
        throw new StarGraphException(e);
    }
}
 

import org.glassfish.jersey.grizzly2.httpserver.GrizzlyHttpServerFactory; //导入依赖的package包/类
public void startServer() throws TelegramApiRequestException {
    ResourceConfig rc = new ResourceConfig();
    rc.register(restApi);
    rc.register(JacksonFeature.class);

    final HttpServer grizzlyServer;
    if (keystoreServerFile != null && keystoreServerPwd != null) {
        SSLContextConfigurator sslContext = new SSLContextConfigurator();

        // set up security context
        sslContext.setKeyStoreFile(keystoreServerFile); // contains server keypair
        sslContext.setKeyStorePass(keystoreServerPwd);

        grizzlyServer = GrizzlyHttpServerFactory.createHttpServer(getBaseURI(), rc, true,
                new SSLEngineConfigurator(sslContext).setClientMode(false).setNeedClientAuth(false));
    } else {
        grizzlyServer = GrizzlyHttpServerFactory.createHttpServer(getBaseURI(), rc);
    }

    try {
        grizzlyServer.start();
    } catch (IOException e) {
        throw new TelegramApiRequestException("Error starting webhook server", e);
    }
}
 

import org.glassfish.jersey.grizzly2.httpserver.GrizzlyHttpServerFactory; //导入依赖的package包/类
protected void startServer() {
        WifiManager wifiMgr = (WifiManager) getApplicationContext()
                .getSystemService(Service.WIFI_SERVICE);
        if (wifiMgr.isWifiEnabled()) {
            // Deprecated. Does not support ipv6. *shrug* :)
            String ipAddress = Formatter.formatIpAddress(wifiMgr.getConnectionInfo()
                    .getIpAddress());

            URI baseUri = UriBuilder.fromUri("http://" + ipAddress)
                    .port(49152)
                    .build();
            ResourceConfig config = new ResourceConfig(SseFeature.class)
                    .register(JacksonFeature.class);
            config.registerInstances(new SecureFilter(this));
            config.registerInstances(new DeskDroidResource(this));
//            server = JettyHttpContainerFactory.createServer(baseUri, config);
            server = GrizzlyHttpServerFactory.createHttpServer(baseUri, config);
        }
    }
 

import org.glassfish.jersey.grizzly2.httpserver.GrizzlyHttpServerFactory; //导入依赖的package包/类
@Override
public void start() {
    System.out.println("Starting GrizzlyTestContainer...");
    try {
        this.server = GrizzlyHttpServerFactory.createHttpServer(uri, rc);

        // Initialize and register Jersey Servlet
        WebappContext context = new WebappContext("WebappContext", "");
        ServletRegistration registration = context.addServlet("ServletContainer", ServletContainer.class);
        registration.setInitParameter("javax.ws.rs.Application", rc.getClass().getName());
        // Add an init parameter - this could be loaded from a parameter in the constructor
        registration.setInitParameter("myparam", "myvalue");

        registration.addMapping("/*");
        context.deploy(server);
    } catch (ProcessingException e) {
        throw new TestContainerException(e);
    }
}
 

import org.glassfish.jersey.grizzly2.httpserver.GrizzlyHttpServerFactory; //导入依赖的package包/类
@EventHandler
public void init(FMLInitializationEvent event) throws Exception
{
    if(event.getSide().isServer())
        modpack = new Modpack(logger, solderConfig, gson);
    if(event.getSide().isServer() && solderConfig.isEnabled()) {

        logger.info("Loading mod MinecraftSolder");
        ResourceConfig config = new ResourceConfig()
                .packages("it.admiral0")
                .register(new AbstractBinder() {
                    @Override
                    protected void configure() {
                        bind(solderConfig);
                        bind(Loader.instance());
                        bind(modpack);
                        bind(gson);
                    }
                });
        HttpServer server = GrizzlyHttpServerFactory.createHttpServer(solderConfig.getBaseUri(), config);
        server.getServerConfiguration().addHttpHandler(
                new StaticHttpHandler(modpack.getSolderCache().toAbsolutePath().toString()), "/download"
        );
        server.start();
        logger.info("Server running on " + solderConfig.getBaseUri().toString());
    }else{
        logger.info("Mod is disabled.");
    }
}
 

import org.glassfish.jersey.grizzly2.httpserver.GrizzlyHttpServerFactory; //导入依赖的package包/类
@Before
public void setup() throws Exception {
  // create ResourceConfig from Resource class
  ResourceConfig rc = new ResourceConfig();
  MultiCube cube = new MultiCubeTest(null);
  rc.registerInstances(new CubeResource(cube));
  rc.register(JsonIteratorConverter.class);

  // create the Grizzly server instance
  httpServer = GrizzlyHttpServerFactory.createHttpServer(baseUri, rc);
  // start the server
  httpServer.start();

  // configure client with the base URI path
  Client client = ClientBuilder.newClient();
  client.register(JsonIteratorConverter.class);
  webTarget = client.target(baseUri);
}
 

import org.glassfish.jersey.grizzly2.httpserver.GrizzlyHttpServerFactory; //导入依赖的package包/类
@Before
public void setup() throws Exception {
  //create ResourceConfig from Resource class
  ResourceConfig rc = new ResourceConfig();
  cube = new MultiCubeImpl(null);
  rc.registerInstances(new CubeResource(cube));
  rc.register(JsonIteratorConverter.class);

  //create the Grizzly server instance
  httpServer = GrizzlyHttpServerFactory.createHttpServer(baseUri, rc);
  //start the server
  httpServer.start();

  //configure client with the base URI path
  Client client = ClientBuilder.newClient();
  client.register(JsonIteratorConverter.class);
  webTarget = client.target(baseUri);
}
 

import org.glassfish.jersey.grizzly2.httpserver.GrizzlyHttpServerFactory; //导入依赖的package包/类
public static void start(int port) throws IOException {
	String baseUrl = "http://localhost:"+port+"/";
	System.out.println("Starting Weather App local testing server: " + baseUrl);
	System.out.println("Not for production use");

	final ResourceConfig resourceConfig = new ResourceConfig();
	resourceConfig.register(RestWeatherCollectorEndpoint.class);
	resourceConfig.register(RestWeatherQueryEndpoint.class);
	resourceConfig.register(GenericExceptionMapper.class);
	resourceConfig.register(new MyApplicationBinder());
	server = GrizzlyHttpServerFactory.createHttpServer(URI.create(baseUrl), resourceConfig, false);

	HttpServerProbe probe = new HttpServerProbe.Adapter() {
		@Override
		public void onRequestReceiveEvent(HttpServerFilter filter, @SuppressWarnings("rawtypes") Connection connection, Request request) {
			System.out.println(request.getRequestURI());
		}
	};

	server.getServerConfiguration().getMonitoringConfig().getWebServerConfig().addProbes(probe);
	System.out.println(format("Weather Server started.\n url=%s\n", baseUrl));
	server.start();
}
 

import org.glassfish.jersey.grizzly2.httpserver.GrizzlyHttpServerFactory; //导入依赖的package包/类
private void startManagementHttpServer() throws Exception {
    final String httpManagementServerUrl = _properties.getProperty("managementurl", HTTP_MANAGEMENTSERVER_URL);
    final ResourceConfig config = new ResourceConfig().register(RaqetService.class).register(new RaqetBinder(_raqetControll));
    final CLStaticHttpHandler staticHttpHandler = new CLStaticHttpHandler(this.getClass().getClassLoader(), "/static/");


    _httpManagementServer = GrizzlyHttpServerFactory.createHttpServer(URI.create(httpManagementServerUrl), config);
    _httpManagementServer.getServerConfiguration().addHttpHandler(staticHttpHandler, "/gui/");
    /* Redirect users to the GUI */
    _httpManagementServer.getServerConfiguration().addHttpHandler(new HttpHandler() {
        @Override
        public void service(final Request request, final Response response) throws Exception {
            response.sendRedirect("/gui/");
        }
    }, "/index.html");
    _httpManagementServer.start();
}
 

import org.glassfish.jersey.grizzly2.httpserver.GrizzlyHttpServerFactory; //导入依赖的package包/类
public SwiftProxy(Properties properties, BlobStoreLocator locator, URI endpoint) {
    this.endpoint = requireNonNull(endpoint);

    rc = new BounceResourceConfig(properties, locator);
    if (logger.isDebugEnabled()) {
        rc.register(new LoggingFilter(java.util.logging.Logger.getGlobal(), false));
    }
    server = GrizzlyHttpServerFactory.createHttpServer(endpoint, rc, false);
    server.getListeners().forEach(listener -> {
        listener.registerAddOn(new ContentLengthAddOn());
    });

    // allow HTTP DELETE to have payload for multi-object delete
    server.getServerConfiguration().setAllowPayloadForUndefinedHttpMethods(true);

    RuntimeDelegate.setInstance(new RuntimeDelegateImpl(RuntimeDelegate.getInstance()));
}
 

import org.glassfish.jersey.grizzly2.httpserver.GrizzlyHttpServerFactory; //导入依赖的package包/类
/**
 * Starts the HTTP server exposing the resources defined in the RestRules class.
 * It takes a reference to an object that implements the RestListener interface,
 * which will be notified every time the REST API receives a request of some type.
 *
 * @param wsUri The base URL of the HTTP REST API
 * @param rl The RestListener object that will be notified when a user sends
 *           an HTTP request to the API
 * @see RestRules
 * @see RestListener
 */

public static void startServer(String wsUri, RestListener rl) {
    // Create a resource config that scans for JAX-RS resources and providers
    ResourceConfig rc = new ResourceConfig()
            .register(RestRules.class)
            .register(JacksonFeature.class);

    // Set the listener for the petitions
    listener = rl;

    // Create a new instance of grizzly http server
    // exposing the Jersey application at BASE_URI
    server = GrizzlyHttpServerFactory.createHttpServer(URI.create(wsUri), rc);

    // start the server
    try {
        server.start();
    } catch (IOException e) {
        log.error(e.getMessage());
    }

    log.info("HTTP server started");
}