javax.ws.rs.client.ClientBuilder#readTimeout ( )源码实例Demo

/**
 * Creates a new client, which may or may not be SSL enabled or a unix socket enabled depending on the
 * configuration.
 *
 * @param config
 * @return
 * @see Client
 */
public Client buildFrom(final ServerConfig config) {

    final ClientBuilder clientBuilder = ClientBuilder.newBuilder();

    final long pollInterval = new IntervalPropertyHelper(config.getProperties()).partyInfoInterval();
    final long timeout = Math.round(Math.ceil(pollInterval * 0.75));
    clientBuilder.connectTimeout(timeout, TimeUnit.MILLISECONDS);
    clientBuilder.readTimeout(timeout, TimeUnit.MILLISECONDS);

    if (config.isUnixSocket()) {
        Configuration clientConfig = createUnixServerSocketConfig();
        URI unixfile = config.getServerUri();
        return ClientBuilder.newClient(clientConfig).property("unixfile", unixfile);

    } else if (config.isSsl()) {
        final SSLContext sslContext =
                sslContextFactory.from(config.getServerUri().toString(), config.getSslConfig());
        return clientBuilder.sslContext(sslContext).build();
    } else {
        return clientBuilder.build();
    }
}
 

private ClientBuilder createClient(final ExecutorService executor, final Optional<String> keystoreLocation,
        final Optional<String> keystoreType, final String keystorePassword, final Optional<String> truststoreType,
        final List<String> serverHostnames) {
    final ClientBuilder builder = ClientBuilder.newBuilder();
    builder.connectTimeout(connectTimeout, MILLISECONDS);
    builder.readTimeout(readTimeout, MILLISECONDS);
    builder.executorService(executor);
    if (acceptAnyCertificate) {
        builder.hostnameVerifier((host, session) -> true);
        builder.sslContext(createUnsafeSSLContext());
    } else if (keystoreLocation.isPresent()) {
        builder.hostnameVerifier((host, session) -> serverHostnames.contains(host));
        builder.sslContext(createSSLContext(keystoreLocation, keystoreType, keystorePassword, truststoreType));
    }
    providers.map(it -> Stream.of(it.split(",")).map(String::trim).filter(v -> !v.isEmpty()).map(fqn -> {
        try {
            return Thread.currentThread().getContextClassLoader().loadClass(fqn).getConstructor().newInstance();
        } catch (final Exception e) {
            log.warn("Can't add provider " + fqn + ": " + e.getMessage(), e);
            return null;
        }
    }).filter(Objects::nonNull)).ifPresent(it -> it.forEach(builder::register));
    return ClientTracingRegistrar.configure(builder);
}
 

private Client createClient(final Routes.Route route) {
    final ClientBuilder clientBuilder = ClientBuilder.newBuilder();
    clientBuilder.executorService(route.executor);
    clientBuilder.readTimeout(route.clientConfiguration.timeouts.read, MILLISECONDS);
    clientBuilder.connectTimeout(route.clientConfiguration.timeouts.connect, MILLISECONDS);
    // clientBuilder.scheduledExecutorService(); // not used by cxf for instance so no need to overkill the conf

    if (route.clientConfiguration.sslConfiguration.acceptAnyCertificate) {
        clientBuilder.hostnameVerifier((host, session) -> true);
        clientBuilder.sslContext(createUnsafeSSLContext());
    } else if (route.clientConfiguration.sslConfiguration.keystoreLocation != null) {
        if (route.clientConfiguration.sslConfiguration.verifiedHostnames != null) {
            clientBuilder.hostnameVerifier((host, session) -> route.clientConfiguration.sslConfiguration.verifiedHostnames.contains(host));
        }
        clientBuilder.sslContext(createSSLContext(
                route.clientConfiguration.sslConfiguration.keystoreLocation,
                route.clientConfiguration.sslConfiguration.keystoreType,
                route.clientConfiguration.sslConfiguration.keystorePassword,
                route.clientConfiguration.sslConfiguration.truststoreType));
    }

    return clientBuilder.build();
}
 

protected Client createClient() {
    ClientBuilder clientBuilder;

    try {
        clientBuilder = _clientBuilderTracker.waitForService(5000);

        clientBuilder.connectTimeout(3000, TimeUnit.SECONDS);
        clientBuilder.readTimeout(3000, TimeUnit.SECONDS);

        return clientBuilder.build();
    }
    catch (InterruptedException ie) {
        throw new RuntimeException(ie);
    }
}