Client Building and Configuration

/**
 * Create a new Jersey client instance with default configuration
 * @return new configured Jersey client instance
 */
static JerseyClient createClient();

/**
 * Create a new Jersey client instance with custom configuration
 * @param configuration initial configuration for the client
 * @return new configured Jersey client instance
 */
static JerseyClient createClient(Configuration configuration);

import org.glassfish.jersey.client.JerseyClientBuilder;
import org.glassfish.jersey.client.ClientConfig;

// Create client with default configuration
Client client = JerseyClientBuilder.createClient();

// Create client with custom configuration
ClientConfig config = new ClientConfig();
config.property(ClientProperties.CONNECT_TIMEOUT, 5000);
config.property(ClientProperties.READ_TIMEOUT, 10000);
Client customClient = JerseyClientBuilder.createClient(config);

public class JerseyClientBuilder extends ClientBuilder {
    /**
     * Create new Jersey client builder instance
     */
    public JerseyClientBuilder();
    
    /**
     * Build the configured client instance
     * @return new configured Jersey client
     */
    public JerseyClient build();
    
    /**
     * Set SSL context for HTTPS connections
     * @param sslContext SSL context for secure connections
     * @return builder instance for method chaining
     */
    public JerseyClientBuilder sslContext(SSLContext sslContext);
    
    /**
     * Set hostname verifier for SSL connections
     * @param hostnameVerifier verifier for hostname validation
     * @return builder instance for method chaining
     */
    public JerseyClientBuilder hostnameVerifier(HostnameVerifier hostnameVerifier);
    
    /**
     * Set key store for client certificates
     * @param keyStore key store containing client certificates
     * @param password password for key store access
     * @return builder instance for method chaining
     */
    public JerseyClientBuilder keyStore(KeyStore keyStore, char[] password);
    
    /**
     * Set trust store for server certificate validation
     * @param trustStore trust store for validating server certificates
     * @return builder instance for method chaining
     */
    public JerseyClientBuilder trustStore(KeyStore trustStore);
    
    /**
     * Set connection timeout
     * @param timeout timeout value
     * @param unit time unit for timeout
     * @return builder instance for method chaining
     */
    public ClientBuilder connectTimeout(long timeout, TimeUnit unit);
    
    /**
     * Set read timeout
     * @param timeout timeout value
     * @param unit time unit for timeout
     * @return builder instance for method chaining
     */
    public ClientBuilder readTimeout(long timeout, TimeUnit unit);
    
    /**
     * Set executor service for asynchronous operations
     * @param executorService executor service for async operations
     * @return builder instance for method chaining
     */
    public ClientBuilder executorService(ExecutorService executorService);
    
    /**
     * Set scheduled executor service for background operations
     * @param scheduledExecutorService scheduled executor for background tasks
     * @return builder instance for method chaining
     */
    public ClientBuilder scheduledExecutorService(ScheduledExecutorService scheduledExecutorService);
    
    /**
     * Register provider class with the client
     * @param componentClass provider class to register
     * @return builder instance for method chaining
     */
    public JerseyClientBuilder register(Class<?> componentClass);
    
    /**
     * Register provider instance with the client
     * @param component provider instance to register
     * @return builder instance for method chaining
     */
    public JerseyClientBuilder register(Object component);
    
    /**
     * Register provider class with priority
     * @param componentClass provider class to register
     * @param priority registration priority
     * @return builder instance for method chaining
     */
    public JerseyClientBuilder register(Class<?> componentClass, int priority);
    
    /**
     * Register provider class with specific contracts
     * @param componentClass provider class to register
     * @param contracts contracts the provider implements
     * @return builder instance for method chaining
     */
    public JerseyClientBuilder register(Class<?> componentClass, Class<?>... contracts);
    
    /**
     * Set configuration property
     * @param name property name
     * @param value property value
     * @return builder instance for method chaining
     */
    public JerseyClientBuilder property(String name, Object value);
    
    /**
     * Apply configuration from another configuration instance
     * @param config configuration to apply
     * @return builder instance for method chaining
     */
    public JerseyClientBuilder withConfig(Configuration config);
}

import javax.net.ssl.SSLContext;
import javax.net.ssl.HostnameVerifier;
import java.util.concurrent.TimeUnit;

// Configure client with SSL and timeouts
Client client = new JerseyClientBuilder()
    .sslContext(customSslContext)
    .hostnameVerifier(customHostnameVerifier)
    .connectTimeout(5, TimeUnit.SECONDS)
    .readTimeout(30, TimeUnit.SECONDS)
    .build();

// Configure client with authentication feature
Client authClient = new JerseyClientBuilder()
    .register(HttpAuthenticationFeature.basic("username", "password"))
    .property(ClientProperties.FOLLOW_REDIRECTS, true)
    .build();

public class ClientConfig implements Configurable<ClientConfig> {
    /**
     * Create new client configuration
     */
    public ClientConfig();
    
    /**
     * Create client configuration with provider classes
     * @param providerClasses provider classes to register
     */
    public ClientConfig(Class<?>... providerClasses);
    
    /**
     * Create client configuration with provider instances
     * @param providers provider instances to register
     */
    public ClientConfig(Object... providers);
    
    /**
     * Load configuration from another configuration instance
     * @param config configuration to load from
     * @return this configuration instance
     */
    public ClientConfig loadFrom(Configuration config);
    
    /**
     * Register provider class
     * @param providerClass provider class to register
     * @return this configuration instance
     */
    public ClientConfig register(Class<?> providerClass);
    
    /**
     * Register provider instance
     * @param provider provider instance to register
     * @return this configuration instance
     */
    public ClientConfig register(Object provider);
    
    /**
     * Set configuration property
     * @param name property name
     * @param value property value
     * @return this configuration instance
     */
    public ClientConfig property(String name, Object value);
    
    /**
     * Get configuration property value
     * @param name property name
     * @return property value or null if not set
     */
    public Object getProperty(String name);
    
    /**
     * Get all configuration properties
     * @return map of all properties
     */
    public Map<String, Object> getProperties();
    
    /**
     * Set connector provider for HTTP transport
     * @param connectorProvider connector provider implementation
     * @return this configuration instance
     */
    public ClientConfig connectorProvider(ConnectorProvider connectorProvider);
    
    /**
     * Get current connector provider
     * @return connector provider or null if not set
     */
    public ConnectorProvider getConnectorProvider();
    
    /**
     * Set executor service for asynchronous operations
     * @param executorService executor service for async operations
     * @return this configuration instance
     */
    public ClientConfig executorService(ExecutorService executorService);
    
    /**
     * Get executor service for asynchronous operations
     * @return executor service or null if not set
     */
    public ExecutorService getExecutorService();
    
    /**
     * Get runtime type (always CLIENT for client configurations)
     * @return RuntimeType.CLIENT
     */
    public RuntimeType getRuntimeType();
}

public final class ClientProperties {
    // Connection and timeout properties
    public static final String FOLLOW_REDIRECTS = "jersey.config.client.followRedirects";
    public static final String READ_TIMEOUT = "jersey.config.client.readTimeout";
    public static final String CONNECT_TIMEOUT = "jersey.config.client.connectTimeout";
    
    // Chunked encoding properties
    public static final String CHUNKED_ENCODING_SIZE = "jersey.config.client.chunkedEncodingSize";
    public static final int DEFAULT_CHUNK_SIZE = 4096;
    
    // Thread pool properties
    public static final String ASYNC_THREADPOOL_SIZE = "jersey.config.client.async.threadPoolSize";
    public static final String BACKGROUND_SCHEDULER_THREADPOOL_SIZE = "jersey.config.client.backgroundSchedulerThreadPoolSize";
    
    // Content encoding properties
    public static final String USE_ENCODING = "jersey.config.client.useEncoding";
    
    // Error handling properties
    public static final String IGNORE_EXCEPTION_RESPONSE = "jersey.config.client.ignoreExceptionResponse";
    
    // Feature control properties
    public static final String FEATURE_AUTO_DISCOVERY_DISABLE = "jersey.config.disableAutoDiscovery";
    public static final String JSON_BINDING_FEATURE_DISABLE = "jersey.config.jsonBinding.disable";
    public static final String JSON_PROCESSING_FEATURE_DISABLE = "jersey.config.jsonProcessing.disable";
    public static final String MOXY_JSON_FEATURE_DISABLE = "jersey.config.client.disableMoxyJson";
    
    // HTTP properties
    public static final String SUPPRESS_HTTP_COMPLIANCE_VALIDATION = "jersey.config.client.suppressHttpComplianceValidation";
    public static final String EXPECT_100_CONTINUE = "jersey.config.client.httpUrlConnector.expect100Continue";
    public static final String EXPECT_100_CONTINUE_THRESHOLD_SIZE = "jersey.config.client.httpUrlConnector.expect100ContinueThreshold";
    public static final Long DEFAULT_EXPECT_100_CONTINUE_THRESHOLD_SIZE = 1024L;
    
    // Proxy properties
    public static final String PROXY_URI = "jersey.config.client.proxy.uri";
    public static final String PROXY_USERNAME = "jersey.config.client.proxy.username";
    public static final String PROXY_PASSWORD = "jersey.config.client.proxy.password";
    
    // Request processing properties
    public static final String REQUEST_ENTITY_PROCESSING = "jersey.config.client.request.entity.processing";
    public static final String OUTBOUND_CONTENT_LENGTH_BUFFER = "jersey.config.client.outbound.contentLength.buffer";
    
    // Query parameter style
    public static final String QUERY_PARAM_STYLE = "jersey.config.client.uri.query.param.style";
    
    // SSL properties
    public static final String SNI_HOST_NAME = "jersey.config.client.tls.sni.hostname";
    public static final String SSL_CONTEXT_SUPPLIER = "jersey.config.client.tls.sslContext.supplier";
    
    /**
     * Get typed property value with default
     * @param properties property map
     * @param key property key
     * @param defaultValue default value if property not found
     * @return property value or default
     */
    public static <T> T getValue(Map<String, ?> properties, String key, T defaultValue);
    
    /**
     * Get typed property value with type conversion
     * @param properties property map
     * @param key property key
     * @param defaultValue default value if property not found
     * @param type target type for conversion
     * @return converted property value or default
     */
    public static <T> T getValue(Map<String, ?> properties, String key, T defaultValue, Class<T> type);
}

import org.glassfish.jersey.client.ClientProperties;

// Configure client with properties
ClientConfig config = new ClientConfig();
config.property(ClientProperties.CONNECT_TIMEOUT, 5000);
config.property(ClientProperties.READ_TIMEOUT, 30000);
config.property(ClientProperties.FOLLOW_REDIRECTS, true);
config.property(ClientProperties.CHUNKED_ENCODING_SIZE, 8192);

// Set proxy configuration
config.property(ClientProperties.PROXY_URI, "http://proxy.company.com:8080");
config.property(ClientProperties.PROXY_USERNAME, "proxyuser");
config.property(ClientProperties.PROXY_PASSWORD, "proxypass");

// Control request entity processing
config.property(ClientProperties.REQUEST_ENTITY_PROCESSING, RequestEntityProcessing.CHUNKED);

Client client = JerseyClientBuilder.createClient(config);

public class SslContextClientBuilder {
    /**
     * Create new SSL context builder
     */
    public SslContextClientBuilder();
    
    /**
     * Set custom SSL context
     * @param sslContext SSL context to use
     * @return this builder instance
     */
    public SslContextClientBuilder sslContext(SSLContext sslContext);
    
    /**
     * Set key store for client certificates
     * @param keyStore key store containing client certificates
     * @param password password for key store access
     * @return this builder instance
     */
    public SslContextClientBuilder keyStore(KeyStore keyStore, char[] password);
    
    /**
     * Set trust store for server certificate validation
     * @param trustStore trust store for validating server certificates
     * @return this builder instance
     */
    public SslContextClientBuilder trustStore(KeyStore trustStore);
    
    /**
     * Build SSL context from configuration
     * @return configured SSL context
     */
    public SSLContext get();
}

import javax.net.ssl.SSLContext;
import java.security.KeyStore;

// Build SSL context with custom trust store
KeyStore trustStore = loadTrustStore();
SslContextClientBuilder sslBuilder = new SslContextClientBuilder()
    .trustStore(trustStore);

SSLContext sslContext = sslBuilder.get();

// Use with client builder
Client client = new JerseyClientBuilder()
    .sslContext(sslContext)
    .build();