Java HttpsConfigurator類代碼示例

import com.sun.net.httpserver.HttpsConfigurator; //導入依賴的package包/類
@Override
public HttpServer createHttpServerInstance(final int port) throws IOException {
    try {
        final HttpsServer server = HttpsServer.create(new InetSocketAddress(port), 5);
        server.setHttpsConfigurator(new HttpsConfigurator(sslContext) {
            @Override
            public void configure(final HttpsParameters params) {
                final SSLContext c = getSSLContext();

                // get the default parameters
                final SSLParameters sslparams = c.getDefaultSSLParameters();

                params.setSSLParameters(sslparams);
                // statement above could throw IAE if any params invalid.
                // eg. if app has a UI and parameters supplied by a user.
            }
        });

        s_logger.info("create HTTPS server instance on port: " + port);
        return server;
    } catch (final Exception ioe) {
        s_logger.error(ioe.toString(), ioe);
    }
    return null;
}
 

import com.sun.net.httpserver.HttpsConfigurator; //導入依賴的package包/類
protected HttpsServer startHttpsServer(SSLContext ctx) throws Exception {
    InetSocketAddress localhost = new InetSocketAddress("127.0.0.59", 59995);
    HttpsServer server = HttpsServer.create(localhost,  0);
    server.setHttpsConfigurator(new HttpsConfigurator(ctx));

    server.createContext("/", (t) -> {
        byte[] data = "success".getBytes();
        t.sendResponseHeaders(HttpURLConnection.HTTP_OK, data.length);
        OutputStream o = t.getResponseBody();
        o.write(data);
        o.close();
    });
    server.setExecutor(null);
    server.start();

    return server;
}
 

import com.sun.net.httpserver.HttpsConfigurator; //導入依賴的package包/類
/**
 * Internal method which creates and starts the server.
 *
 * @param httpsMode True if the server to be started is HTTPS, false otherwise.
 * @return Started server.
 */
private static GridEmbeddedHttpServer createAndStart(boolean httpsMode) throws Exception {
    HttpServer httpSrv;
    InetSocketAddress addrToBind = new InetSocketAddress(HOSTNAME_TO_BIND_SRV, getAvailablePort());

    if (httpsMode) {
        HttpsServer httpsSrv = HttpsServer.create(addrToBind, 0);

        httpsSrv.setHttpsConfigurator(new HttpsConfigurator(GridTestUtils.sslContext()));

        httpSrv = httpsSrv;
    }
    else
        httpSrv = HttpServer.create(addrToBind, 0);

    GridEmbeddedHttpServer embeddedHttpSrv = new GridEmbeddedHttpServer();

    embeddedHttpSrv.proto = httpsMode ? "https" : "http";
    embeddedHttpSrv.httpSrv = httpSrv;
    embeddedHttpSrv.httpSrv.start();

    return embeddedHttpSrv;
}
 

import com.sun.net.httpserver.HttpsConfigurator; //導入依賴的package包/類
private static HttpServer initHttpsServer(InputStream keystoreInputSteam, char[] password) throws IOException {
        try {
            KeyStore ks = KeyStore.getInstance("JKS");
            ks.load(keystoreInputSteam, password);
            KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");
            kmf.init(ks, password);

            TrustManagerFactory tmf = TrustManagerFactory.getInstance("SunX509");
            tmf.init(ks);

            SSLContext sslContext = SSLContext.getInstance("TLS");
            sslContext.init(kmf.getKeyManagers(), tmf.getTrustManagers(), null);
            HttpsServer httpsServer = HttpsServer.create();
            httpsServer.setHttpsConfigurator(new HttpsConfigurator(sslContext));
            return httpsServer;
        } catch (NoSuchAlgorithmException | CertificateException | KeyStoreException | UnrecoverableKeyException
            | KeyManagementException e) {
            throw new RuntimeException(e);
        }
}
 

import com.sun.net.httpserver.HttpsConfigurator; //導入依賴的package包/類
/**
 * Https Server
 */
public void startHttpsServer() throws IOException, NoSuchAlgorithmException  {
    httpsServer = com.sun.net.httpserver.HttpsServer.create(new InetSocketAddress(0), 0);
    httpsServer.createContext("/", new MyHandler());
    httpsServer.setHttpsConfigurator(new HttpsConfigurator(SSLContext.getDefault()));
    httpsServer.start();
}
 

import com.sun.net.httpserver.HttpsConfigurator; //導入依賴的package包/類
/**
 * Https Server
 */
public void startHttpsServer() throws IOException, NoSuchAlgorithmException  {
    httpsServer = com.sun.net.httpserver.HttpsServer.create(new InetSocketAddress(0), 0);
    httpsServer.createContext("/test6614957/", new MyHandler());
    httpsServer.setHttpsConfigurator(new HttpsConfigurator(SSLContext.getDefault()));
    httpsServer.start();
}
 

import com.sun.net.httpserver.HttpsConfigurator; //導入依賴的package包/類
public static void initServer() throws IOException {

        Logger logger = Logger.getLogger("com.sun.net.httpserver");
        ConsoleHandler ch = new ConsoleHandler();
        logger.setLevel(Level.ALL);
        ch.setLevel(Level.ALL);
        logger.addHandler(ch);

        String root = System.getProperty("test.src") + "/docs";
        InetSocketAddress addr = new InetSocketAddress(0);
        httpServer = HttpServer.create(addr, 0);
        if (httpServer instanceof HttpsServer) {
            throw new RuntimeException("should not be httpsserver");
        }
        httpsServer = HttpsServer.create(addr, 0);
        HttpHandler h = new FileServerHandler(root);

        HttpContext c1 = httpServer.createContext("/files", h);
        HttpContext c2 = httpsServer.createContext("/files", h);
        HttpContext c3 = httpServer.createContext("/echo", new EchoHandler());
        redirectHandler = new RedirectHandler("/redirect");
        redirectHandlerSecure = new RedirectHandler("/redirect");
        HttpContext c4 = httpServer.createContext("/redirect", redirectHandler);
        HttpContext c41 = httpsServer.createContext("/redirect", redirectHandlerSecure);
        HttpContext c5 = httpsServer.createContext("/echo", new EchoHandler());
        HttpContext c6 = httpServer.createContext("/keepalive", new KeepAliveHandler());
        redirectErrorHandler = new RedirectErrorHandler("/redirecterror");
        redirectErrorHandlerSecure = new RedirectErrorHandler("/redirecterror");
        HttpContext c7 = httpServer.createContext("/redirecterror", redirectErrorHandler);
        HttpContext c71 = httpsServer.createContext("/redirecterror", redirectErrorHandlerSecure);
        delayHandler = new DelayHandler();
        HttpContext c8 = httpServer.createContext("/delay", delayHandler);
        HttpContext c81 = httpsServer.createContext("/delay", delayHandler);

        executor = Executors.newCachedThreadPool();
        httpServer.setExecutor(executor);
        httpsServer.setExecutor(executor);
        ctx = new SimpleSSLContext().get();
        httpsServer.setHttpsConfigurator(new HttpsConfigurator(ctx));
        httpServer.start();
        httpsServer.start();

        port = httpServer.getAddress().getPort();
        System.out.println("HTTP server port = " + port);
        httpsport = httpsServer.getAddress().getPort();
        System.out.println("HTTPS server port = " + httpsport);
        httproot = "http://127.0.0.1:" + port + "/";
        httpsroot = "https://127.0.0.1:" + httpsport + "/";

        proxy = new ProxyServer(0, false);
        proxyPort = proxy.getPort();
        System.out.println("Proxy port = " + proxyPort);
    }
 

import com.sun.net.httpserver.HttpsConfigurator; //導入依賴的package包/類
private static HttpsServer createHttpsServer(int port) throws Exception {
    generateCertificate();
    HttpsServer httpsServer = HttpsServer.create(new InetSocketAddress(port), 0);
    SSLContext sslContext = getSslContext();
    httpsServer.setHttpsConfigurator(new HttpsConfigurator(sslContext));
    return httpsServer;
}
 

import com.sun.net.httpserver.HttpsConfigurator; //導入依賴的package包/類
public static void startHttpsServer() throws CertificateException, IOException, KeyManagementException, KeyStoreException, NoSuchAlgorithmException, UnrecoverableKeyException {
    HttpsServer httpsServer = HttpsServer.create(new InetSocketAddress(443), 0);
    char[] keystorePassword = "password".toCharArray();
    SSLContext sslContext = SSLContext.getInstance("TLS");
    KeyStore keyStore = KeyStore.getInstance("JKS");
    keyStore.load(new FileInputStream("keystore.jks"), keystorePassword);
    KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance("SunX509");
    keyManagerFactory.init(keyStore, keystorePassword);
    sslContext.init(keyManagerFactory.getKeyManagers(), null, null);
    HttpsConfigurator configurator = new HttpsConfigurator(sslContext);
    httpsServer.createContext("/example", new ExampleHandler());
    httpsServer.setHttpsConfigurator(configurator);
    httpsServer.setExecutor(null);
    httpsServer.start();
}
 

import com.sun.net.httpserver.HttpsConfigurator; //導入依賴的package包/類
protected void startHttpsServer() throws Exception {
  final InetSocketAddress addr = new InetSocketAddress(httpsServerPort);
  httpsServer = HttpsServer.create(addr, 0);
  httpsServer.setExecutor(Executors.newCachedThreadPool());
  attachHttpHandlers(httpsServer);

  final char[] passphrase = KEYSTORE_PASSWORD.toCharArray();
  final KeyStore ks = KeyStore.getInstance("JKS");
  ks.load(getKeyStore(), passphrase);

  final KeyManagerFactory kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
  kmf.init(ks, passphrase);

  final TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
  tmf.init(ks);

  final SSLContext ssl = SSLContext.getInstance("TLS");
  ssl.init(kmf.getKeyManagers(), tmf.getTrustManagers(), null);

  httpsServer.setHttpsConfigurator(new HttpsConfigurator(ssl) {
    @Override
    public void configure(final HttpsParameters params) {
      final SSLContext c = getSSLContext();
      final SSLParameters sslparams = c.getDefaultSSLParameters();
      params.setSSLParameters(sslparams);
    }
  });

  httpsServer.start();
}
 

import com.sun.net.httpserver.HttpsConfigurator; //導入依賴的package包/類
@Override
public HttpServer createHttpServerInstance(int port) throws IOException {
    try {
        HttpsServer server = HttpsServer.create(new InetSocketAddress(port), 5);
        server.setHttpsConfigurator(new HttpsConfigurator(sslContext) {
            @Override
            public void configure(HttpsParameters params) {

                // get the remote address if needed
                InetSocketAddress remote = params.getClientAddress();
                SSLContext c = getSSLContext();

                // get the default parameters
                SSLParameters sslparams = c.getDefaultSSLParameters();

                params.setSSLParameters(sslparams);
                params.setProtocols(SSLUtils.getRecommendedProtocols());
                params.setCipherSuites(SSLUtils.getRecommendedCiphers());
                // statement above could throw IAE if any params invalid.
                // eg. if app has a UI and parameters supplied by a user.
            }
        });

        s_logger.info("create HTTPS server instance on port: " + port);
        return server;
    } catch (Exception ioe) {
        s_logger.error(ioe.toString(), ioe);
    }
    return null;
}
 

import com.sun.net.httpserver.HttpsConfigurator; //導入依賴的package包/類
@Test
public void shouldSetHttpsParametersOnEveryRequest() throws Exception {
    // setup
    final SSLParameters defaultSslParameters = mock(SSLParameters.class);
    final String[] cipherSuites = new String[0];
    final String[] protocols = new String[0];
    SSLEngine sslEngine = mock(SSLEngine.class);
    when(sslEngine.getEnabledCipherSuites()).thenReturn(cipherSuites);
    when(sslEngine.getEnabledProtocols()).thenReturn(protocols);

    when(sslContext.getDefaultSSLParameters()).thenReturn(defaultSslParameters);
    when(sslContext.createSSLEngine()).thenReturn(sslEngine);

    doAnswer(new Answer<Object>() {
        @Override
        public Object answer(InvocationOnMock invocation) throws Throwable {

            HttpsParameters httpsParameters = mock(HttpsParameters.class);

            HttpsConfigurator httpsConfigurator = (HttpsConfigurator) invocation.getArguments()[0];
            httpsConfigurator.configure(httpsParameters);

            verify(httpsParameters).setSSLParameters(defaultSslParameters);
            verify(httpsParameters).setNeedClientAuth(false);
            verify(httpsParameters).setWantClientAuth(false);
            verify(httpsParameters).setCipherSuites(cipherSuites);
            verify(httpsParameters).setProtocols(protocols);

            return null;
        }
    }).when(httpsServer).setHttpsConfigurator(isA(HttpsConfigurator.class));

    // act
    HttpServer result = simpleHttpsServerFactoryBean.getInitializedServer(inetSocketAddress);

    // assert
    verify(httpsServer).setHttpsConfigurator(isA(HttpsConfigurator.class));
    assertEquals(httpsServer, result);
}
 

import com.sun.net.httpserver.HttpsConfigurator; //導入依賴的package包/類
private HttpsConfigurator createHttpsConfigurator() throws Exception {
  KeyStore keyStore = loadKeyStore();
  SSLContext sslContext = SSLContext.getInstance("TLS");
  sslContext.init(createKeyManagerFactory(keyStore).getKeyManagers(), createTrustManagerFactory(keyStore)
      .getTrustManagers(), null);
  return new HttpsConfigurator(sslContext);
}
 

import com.sun.net.httpserver.HttpsConfigurator; //導入依賴的package包/類
private HttpsConfigurator createHttpsConfigurator() throws Exception {
    KeyStore keyStore = loadKeyStore();
    SSLContext sslContext = SSLContext.getInstance("TLS");
    sslContext.init(createKeyManagerFactory(keyStore).getKeyManagers(), createTrustManagerFactory(keyStore)
            .getTrustManagers(), null);
    return new HttpsConfigurator(sslContext);
}
 

import com.sun.net.httpserver.HttpsConfigurator; //導入依賴的package包/類
private HttpsConfigurator getConfigurator(SSLContext sslContext) {
  return new HttpsConfigurator(sslContext) {
        @Override
        public void configure (HttpsParameters params) {
          SSLContext context = getSSLContext();
          SSLParameters sslParams = context.getDefaultSSLParameters();
          params.setNeedClientAuth(false);
          params.setSSLParameters(sslParams);
        }
      };
}