java.lang.Object
- com.oracle.bmc.http.internal.BaseAsyncClient
- - com.oracle.bmc.loadbalancer.LoadBalancerAsyncClient

All Implemented Interfaces:

LoadBalancerAsync, AutoCloseable
```
@Generated(value="OracleSDKGenerator",
           comments="API Version: 20170115")
public class LoadBalancerAsyncClient
extends BaseAsyncClient
implements LoadBalancerAsync
```
Async client implementation for LoadBalancer service.
There are two ways to use async client: 1. Use AsyncHandler: using AsyncHandler, if the response to the call is an InputStream, like getObject Api in object storage service, developers need to process the stream in AsyncHandler, and not anywhere else, because the stream will be closed right after the AsyncHandler is invoked.
2. Use Java Future: using Java Future, developers need to close the stream after they are done with the Java Future.
Accessing the result should be done in a mutually exclusive manner, either through the Future or the AsyncHandler, but not both. If the Future is used, the caller should pass in null as the AsyncHandler. If the AsyncHandler is used, it is still safe to use the Future to determine whether or not the request was completed via Future.isDone/isCancelled.
Please refer to https://github.com/oracle/oci-java-sdk/blob/master/bmc-examples/src/main/java/ResteasyClientWithObjectStorageExample.java

Nested Class Summary

Nested Classes
Modifier and Type Class Description

static class LoadBalancerAsyncClient.Builder
Builder class for this client.

Field Summary

Fields
Modifier and Type	Field	Description
`String`	`clientCommonLibraryVersion`	Compatible SDK version, provided by the codegen.
`Optional<String>`	`minimumClientCommonLibraryVersionFromClient`	Minimum compatible SDK version, maybe provided by the codegen.
`static Service`	`SERVICE`	Service instance for LoadBalancer.

Constructor Summary

Constructors
Constructor	Description
`LoadBalancerAsyncClient(AbstractAuthenticationDetailsProvider authenticationDetailsProvider, ClientConfiguration configuration, ClientConfigurator clientConfigurator, RequestSignerFactory defaultRequestSignerFactory)`	Deprecated. Use the `builder` instead.
`LoadBalancerAsyncClient(AbstractAuthenticationDetailsProvider authenticationDetailsProvider, ClientConfiguration configuration, ClientConfigurator clientConfigurator, RequestSignerFactory defaultRequestSignerFactory, List<ClientConfigurator> additionalClientConfigurators)`	Deprecated. Use the `builder` instead.
`LoadBalancerAsyncClient(AbstractAuthenticationDetailsProvider authenticationDetailsProvider, ClientConfiguration configuration, ClientConfigurator clientConfigurator, RequestSignerFactory defaultRequestSignerFactory, List<ClientConfigurator> additionalClientConfigurators, String endpoint)`	Deprecated. Use the `builder` instead.
`LoadBalancerAsyncClient(AbstractAuthenticationDetailsProvider authenticationDetailsProvider, ClientConfiguration configuration, ClientConfigurator clientConfigurator, RequestSignerFactory defaultRequestSignerFactory, Map<SigningStrategy,RequestSignerFactory> signingStrategyRequestSignerFactories, List<ClientConfigurator> additionalClientConfigurators, String endpoint)`	Deprecated. Use the `builder` instead.
`LoadBalancerAsyncClient(BasicAuthenticationDetailsProvider authenticationDetailsProvider)`	Deprecated. Use the `builder` instead.
`LoadBalancerAsyncClient(BasicAuthenticationDetailsProvider authenticationDetailsProvider, ClientConfiguration configuration)`	Deprecated. Use the `builder` instead.
`LoadBalancerAsyncClient(BasicAuthenticationDetailsProvider authenticationDetailsProvider, ClientConfiguration configuration, ClientConfigurator clientConfigurator)`	Deprecated. Use the `builder` instead.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`static LoadBalancerAsyncClient.Builder`	`builder()`	Create a builder for this client.
`Future<ChangeLoadBalancerCompartmentResponse>`	`changeLoadBalancerCompartment(ChangeLoadBalancerCompartmentRequest request, AsyncHandler<ChangeLoadBalancerCompartmentRequest,ChangeLoadBalancerCompartmentResponse> handler)`	Moves a load balancer into a different compartment within the same tenancy.
`protected <REQ extends BmcRequest<?>,RESP extends BmcResponse,RESP_BUILDER extends BmcResponse.Builder<RESP>> ClientCall<REQ,RESP,RESP_BUILDER>`	`clientCall(REQ request, Supplier<RESP_BUILDER> responseBuilder)`
`void`	`close()`
`Future<CreateBackendResponse>`	`createBackend(CreateBackendRequest request, AsyncHandler<CreateBackendRequest,CreateBackendResponse> handler)`	Adds a backend server to a backend set.
`Future<CreateBackendSetResponse>`	`createBackendSet(CreateBackendSetRequest request, AsyncHandler<CreateBackendSetRequest,CreateBackendSetResponse> handler)`	Adds a backend set to a load balancer.
`Future<CreateCertificateResponse>`	`createCertificate(CreateCertificateRequest request, AsyncHandler<CreateCertificateRequest,CreateCertificateResponse> handler)`	Creates an asynchronous request to add an SSL certificate bundle.
`Future<CreateHostnameResponse>`	`createHostname(CreateHostnameRequest request, AsyncHandler<CreateHostnameRequest,CreateHostnameResponse> handler)`	Adds a hostname resource to the specified load balancer.
`Future<CreateListenerResponse>`	`createListener(CreateListenerRequest request, AsyncHandler<CreateListenerRequest,CreateListenerResponse> handler)`	Adds a listener to a load balancer.
`Future<CreateLoadBalancerResponse>`	`createLoadBalancer(CreateLoadBalancerRequest request, AsyncHandler<CreateLoadBalancerRequest,CreateLoadBalancerResponse> handler)`	Creates a new load balancer in the specified compartment.
`Future<CreatePathRouteSetResponse>`	`createPathRouteSet(CreatePathRouteSetRequest request, AsyncHandler<CreatePathRouteSetRequest,CreatePathRouteSetResponse> handler)`	Adds a path route set to a load balancer.
`Future<CreateRoutingPolicyResponse>`	`createRoutingPolicy(CreateRoutingPolicyRequest request, AsyncHandler<CreateRoutingPolicyRequest,CreateRoutingPolicyResponse> handler)`	Adds a routing policy to a load balancer.
`Future<CreateRuleSetResponse>`	`createRuleSet(CreateRuleSetRequest request, AsyncHandler<CreateRuleSetRequest,CreateRuleSetResponse> handler)`	Creates a new rule set associated with the specified load balancer.
`Future<CreateSSLCipherSuiteResponse>`	`createSSLCipherSuite(CreateSSLCipherSuiteRequest request, AsyncHandler<CreateSSLCipherSuiteRequest,CreateSSLCipherSuiteResponse> handler)`	Creates a custom SSL cipher suite.
`Future<DeleteBackendResponse>`	`deleteBackend(DeleteBackendRequest request, AsyncHandler<DeleteBackendRequest,DeleteBackendResponse> handler)`	Removes a backend server from a given load balancer and backend set.
`Future<DeleteBackendSetResponse>`	`deleteBackendSet(DeleteBackendSetRequest request, AsyncHandler<DeleteBackendSetRequest,DeleteBackendSetResponse> handler)`	Deletes the specified backend set.
`Future<DeleteCertificateResponse>`	`deleteCertificate(DeleteCertificateRequest request, AsyncHandler<DeleteCertificateRequest,DeleteCertificateResponse> handler)`	Deletes an SSL certificate bundle from a load balancer.
`Future<DeleteHostnameResponse>`	`deleteHostname(DeleteHostnameRequest request, AsyncHandler<DeleteHostnameRequest,DeleteHostnameResponse> handler)`	Deletes a hostname resource from the specified load balancer.
`Future<DeleteListenerResponse>`	`deleteListener(DeleteListenerRequest request, AsyncHandler<DeleteListenerRequest,DeleteListenerResponse> handler)`	Deletes a listener from a load balancer.
`Future<DeleteLoadBalancerResponse>`	`deleteLoadBalancer(DeleteLoadBalancerRequest request, AsyncHandler<DeleteLoadBalancerRequest,DeleteLoadBalancerResponse> handler)`	Stops a load balancer and removes it from service.
`Future<DeletePathRouteSetResponse>`	`deletePathRouteSet(DeletePathRouteSetRequest request, AsyncHandler<DeletePathRouteSetRequest,DeletePathRouteSetResponse> handler)`	Deletes a path route set from the specified load balancer.
`Future<DeleteRoutingPolicyResponse>`	`deleteRoutingPolicy(DeleteRoutingPolicyRequest request, AsyncHandler<DeleteRoutingPolicyRequest,DeleteRoutingPolicyResponse> handler)`	Deletes a routing policy from the specified load balancer.
`Future<DeleteRuleSetResponse>`	`deleteRuleSet(DeleteRuleSetRequest request, AsyncHandler<DeleteRuleSetRequest,DeleteRuleSetResponse> handler)`	Deletes a rule set from the specified load balancer.
`Future<DeleteSSLCipherSuiteResponse>`	`deleteSSLCipherSuite(DeleteSSLCipherSuiteRequest request, AsyncHandler<DeleteSSLCipherSuiteRequest,DeleteSSLCipherSuiteResponse> handler)`	Deletes an SSL cipher suite from a load balancer.
`Future<GetBackendResponse>`	`getBackend(GetBackendRequest request, AsyncHandler<GetBackendRequest,GetBackendResponse> handler)`	Gets the specified backend server’s configuration information.
`Future<GetBackendHealthResponse>`	`getBackendHealth(GetBackendHealthRequest request, AsyncHandler<GetBackendHealthRequest,GetBackendHealthResponse> handler)`	Gets the current health status of the specified backend server.
`Future<GetBackendSetResponse>`	`getBackendSet(GetBackendSetRequest request, AsyncHandler<GetBackendSetRequest,GetBackendSetResponse> handler)`	Gets the specified backend set’s configuration information.
`Future<GetBackendSetHealthResponse>`	`getBackendSetHealth(GetBackendSetHealthRequest request, AsyncHandler<GetBackendSetHealthRequest,GetBackendSetHealthResponse> handler)`	Gets the health status for the specified backend set.
`String`	`getClientCommonLibraryVersion()`
`protected ClientConfigurator`	`getDefaultConfigurator()`
`String`	`getEndpoint()`
`Future<GetHealthCheckerResponse>`	`getHealthChecker(GetHealthCheckerRequest request, AsyncHandler<GetHealthCheckerRequest,GetHealthCheckerResponse> handler)`	Gets the health check policy information for a given load balancer and backend set.
`Future<GetHostnameResponse>`	`getHostname(GetHostnameRequest request, AsyncHandler<GetHostnameRequest,GetHostnameResponse> handler)`	Gets the specified hostname resource’s configuration information.
`Future<GetLoadBalancerResponse>`	`getLoadBalancer(GetLoadBalancerRequest request, AsyncHandler<GetLoadBalancerRequest,GetLoadBalancerResponse> handler)`	Gets the specified load balancer’s configuration information.
`Future<GetLoadBalancerHealthResponse>`	`getLoadBalancerHealth(GetLoadBalancerHealthRequest request, AsyncHandler<GetLoadBalancerHealthRequest,GetLoadBalancerHealthResponse> handler)`	Gets the health status for the specified load balancer.
`Optional<String>`	`getMinimumClientCommonLibraryVersionFromClient()`
`Future<GetPathRouteSetResponse>`	`getPathRouteSet(GetPathRouteSetRequest request, AsyncHandler<GetPathRouteSetRequest,GetPathRouteSetResponse> handler)`	Gets the specified path route set’s configuration information.
`Future<GetRoutingPolicyResponse>`	`getRoutingPolicy(GetRoutingPolicyRequest request, AsyncHandler<GetRoutingPolicyRequest,GetRoutingPolicyResponse> handler)`	Gets the specified routing policy.
`Future<GetRuleSetResponse>`	`getRuleSet(GetRuleSetRequest request, AsyncHandler<GetRuleSetRequest,GetRuleSetResponse> handler)`	Gets the specified set of rules.
`Future<GetSSLCipherSuiteResponse>`	`getSSLCipherSuite(GetSSLCipherSuiteRequest request, AsyncHandler<GetSSLCipherSuiteRequest,GetSSLCipherSuiteResponse> handler)`	Gets the specified SSL cipher suite’s configuration information.
`Future<GetWorkRequestResponse>`	`getWorkRequest(GetWorkRequestRequest request, AsyncHandler<GetWorkRequestRequest,GetWorkRequestResponse> handler)`	Gets the details of a work request.
`Future<ListBackendsResponse>`	`listBackends(ListBackendsRequest request, AsyncHandler<ListBackendsRequest,ListBackendsResponse> handler)`	Lists the backend servers for a given load balancer and backend set.
`Future<ListBackendSetsResponse>`	`listBackendSets(ListBackendSetsRequest request, AsyncHandler<ListBackendSetsRequest,ListBackendSetsResponse> handler)`	Lists all backend sets associated with a given load balancer.
`Future<ListCertificatesResponse>`	`listCertificates(ListCertificatesRequest request, AsyncHandler<ListCertificatesRequest,ListCertificatesResponse> handler)`	Lists all SSL certificates bundles associated with a given load balancer.
`Future<ListHostnamesResponse>`	`listHostnames(ListHostnamesRequest request, AsyncHandler<ListHostnamesRequest,ListHostnamesResponse> handler)`	Lists all hostname resources associated with the specified load balancer.
`Future<ListListenerRulesResponse>`	`listListenerRules(ListListenerRulesRequest request, AsyncHandler<ListListenerRulesRequest,ListListenerRulesResponse> handler)`	Lists all of the rules from all of the rule sets associated with the specified listener.
`Future<ListLoadBalancerHealthsResponse>`	`listLoadBalancerHealths(ListLoadBalancerHealthsRequest request, AsyncHandler<ListLoadBalancerHealthsRequest,ListLoadBalancerHealthsResponse> handler)`	Lists the summary health statuses for all load balancers in the specified compartment.
`Future<ListLoadBalancersResponse>`	`listLoadBalancers(ListLoadBalancersRequest request, AsyncHandler<ListLoadBalancersRequest,ListLoadBalancersResponse> handler)`	Lists all load balancers in the specified compartment.
`Future<ListPathRouteSetsResponse>`	`listPathRouteSets(ListPathRouteSetsRequest request, AsyncHandler<ListPathRouteSetsRequest,ListPathRouteSetsResponse> handler)`	Lists all path route sets associated with the specified load balancer.
`Future<ListPoliciesResponse>`	`listPolicies(ListPoliciesRequest request, AsyncHandler<ListPoliciesRequest,ListPoliciesResponse> handler)`	Lists the available load balancer policies.
`Future<ListProtocolsResponse>`	`listProtocols(ListProtocolsRequest request, AsyncHandler<ListProtocolsRequest,ListProtocolsResponse> handler)`	Lists all supported traffic protocols.
`Future<ListRoutingPoliciesResponse>`	`listRoutingPolicies(ListRoutingPoliciesRequest request, AsyncHandler<ListRoutingPoliciesRequest,ListRoutingPoliciesResponse> handler)`	Lists all routing policies associated with the specified load balancer.
`Future<ListRuleSetsResponse>`	`listRuleSets(ListRuleSetsRequest request, AsyncHandler<ListRuleSetsRequest,ListRuleSetsResponse> handler)`	Lists all rule sets associated with the specified load balancer.
`Future<ListShapesResponse>`	`listShapes(ListShapesRequest request, AsyncHandler<ListShapesRequest,ListShapesResponse> handler)`	Lists the valid load balancer shapes.
`Future<ListSSLCipherSuitesResponse>`	`listSSLCipherSuites(ListSSLCipherSuitesRequest request, AsyncHandler<ListSSLCipherSuitesRequest,ListSSLCipherSuitesResponse> handler)`	Lists all SSL cipher suites associated with the specified load balancer.
`Future<ListWorkRequestsResponse>`	`listWorkRequests(ListWorkRequestsRequest request, AsyncHandler<ListWorkRequestsRequest,ListWorkRequestsResponse> handler)`	Lists the work requests for a given load balancer.
`void`	`populateServiceParametersInEndpoint(String endpoint, Map<String,Object> requiredParametersMap)`	Populate the parameters in the endpoint with its corresponding value and update the base endpoint.
`void`	`refreshClient()`	Rebuild the backing `HttpClient`.
`void`	`setEndpoint(String endpoint)`
`void`	`setRegion(Region region)`	Sets the region to call (ex, Region.US_PHOENIX_1).
`void`	`setRegion(String regionId)`	Sets the region to call (ex, ‘us-phoenix-1’).
`Future<UpdateBackendResponse>`	`updateBackend(UpdateBackendRequest request, AsyncHandler<UpdateBackendRequest,UpdateBackendResponse> handler)`	Updates the configuration of a backend server within the specified backend set.
`Future<UpdateBackendSetResponse>`	`updateBackendSet(UpdateBackendSetRequest request, AsyncHandler<UpdateBackendSetRequest,UpdateBackendSetResponse> handler)`	Updates a backend set.
`void`	`updateBaseEndpoint(String endpoint)`	This method should be used for parameterized endpoint templates only.
`Future<UpdateHealthCheckerResponse>`	`updateHealthChecker(UpdateHealthCheckerRequest request, AsyncHandler<UpdateHealthCheckerRequest,UpdateHealthCheckerResponse> handler)`	Updates the health check policy for a given load balancer and backend set.
`Future<UpdateHostnameResponse>`	`updateHostname(UpdateHostnameRequest request, AsyncHandler<UpdateHostnameRequest,UpdateHostnameResponse> handler)`	Overwrites an existing hostname resource on the specified load balancer.
`Future<UpdateListenerResponse>`	`updateListener(UpdateListenerRequest request, AsyncHandler<UpdateListenerRequest,UpdateListenerResponse> handler)`	Updates a listener for a given load balancer.
`Future<UpdateLoadBalancerResponse>`	`updateLoadBalancer(UpdateLoadBalancerRequest request, AsyncHandler<UpdateLoadBalancerRequest,UpdateLoadBalancerResponse> handler)`	Updates a load balancer’s configuration.
`Future<UpdateLoadBalancerShapeResponse>`	`updateLoadBalancerShape(UpdateLoadBalancerShapeRequest request, AsyncHandler<UpdateLoadBalancerShapeRequest,UpdateLoadBalancerShapeResponse> handler)`	Update the shape of a load balancer.
`Future<UpdateNetworkSecurityGroupsResponse>`	`updateNetworkSecurityGroups(UpdateNetworkSecurityGroupsRequest request, AsyncHandler<UpdateNetworkSecurityGroupsRequest,UpdateNetworkSecurityGroupsResponse> handler)`	Updates the network security groups associated with the specified load balancer.
`Future<UpdatePathRouteSetResponse>`	`updatePathRouteSet(UpdatePathRouteSetRequest request, AsyncHandler<UpdatePathRouteSetRequest,UpdatePathRouteSetResponse> handler)`	Overwrites an existing path route set on the specified load balancer.
`Future<UpdateRoutingPolicyResponse>`	`updateRoutingPolicy(UpdateRoutingPolicyRequest request, AsyncHandler<UpdateRoutingPolicyRequest,UpdateRoutingPolicyResponse> handler)`	Overwrites an existing routing policy on the specified load balancer.
`Future<UpdateRuleSetResponse>`	`updateRuleSet(UpdateRuleSetRequest request, AsyncHandler<UpdateRuleSetRequest,UpdateRuleSetResponse> handler)`	Overwrites an existing set of rules on the specified load balancer.
`Future<UpdateSSLCipherSuiteResponse>`	`updateSSLCipherSuite(UpdateSSLCipherSuiteRequest request, AsyncHandler<UpdateSSLCipherSuiteRequest,UpdateSSLCipherSuiteResponse> handler)`	Updates an existing SSL cipher suite for the specified load balancer.
`void`	`useRealmSpecificEndpointTemplate(boolean useOfRealmSpecificEndpointTemplateEnabled)`	This method should be used to enable or disable the use of realm-specific endpoint template.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface java.lang.AutoCloseable
close

Methods inherited from interface com.oracle.bmc.loadbalancer.LoadBalancerAsync
getEndpoint, refreshClient, setEndpoint, useRealmSpecificEndpointTemplate

- Field Detail
  - SERVICE
```
public static final Service SERVICE
```
    Service instance for LoadBalancer.
  - clientCommonLibraryVersion
```
public final String clientCommonLibraryVersion
```
    Compatible SDK version, provided by the codegen.
  - minimumClientCommonLibraryVersionFromClient
```
public final Optional<String> minimumClientCommonLibraryVersionFromClient
```
    Minimum compatible SDK version, maybe provided by the codegen.
- Constructor Detail
  - LoadBalancerAsyncClient
```
@Deprecated
public LoadBalancerAsyncClient(BasicAuthenticationDetailsProvider authenticationDetailsProvider)
```
    Deprecated.
    Use the builder instead.
    
    Create a new client instance.
    
    Parameters:
    
    authenticationDetailsProvider - The authentication details (see LoadBalancerAsyncClient.Builder.build(com.oracle.bmc.auth.AbstractAuthenticationDetailsProvider))
  - LoadBalancerAsyncClient
```
@Deprecated
public LoadBalancerAsyncClient(BasicAuthenticationDetailsProvider authenticationDetailsProvider,
                               ClientConfiguration configuration)
```
    Deprecated.
    Use the builder instead.
    
    Create a new client instance.
    
    Parameters:
    
    authenticationDetailsProvider - The authentication details (see LoadBalancerAsyncClient.Builder.build(com.oracle.bmc.auth.AbstractAuthenticationDetailsProvider))
    
    configuration - ClientBuilderBase.configuration
  - LoadBalancerAsyncClient
```
@Deprecated
public LoadBalancerAsyncClient(BasicAuthenticationDetailsProvider authenticationDetailsProvider,
                               ClientConfiguration configuration,
                               ClientConfigurator clientConfigurator)
```
    Deprecated.
    Use the builder instead.
    
    Create a new client instance.
    
    Parameters:
    
    authenticationDetailsProvider - The authentication details (see LoadBalancerAsyncClient.Builder.build(com.oracle.bmc.auth.AbstractAuthenticationDetailsProvider))
    
    configuration - ClientBuilderBase.configuration
    
    clientConfigurator - ClientBuilderBase.clientConfigurator(com.oracle.bmc.http.ClientConfigurator)
  - LoadBalancerAsyncClient
```
@Deprecated
public LoadBalancerAsyncClient(AbstractAuthenticationDetailsProvider authenticationDetailsProvider,
                               ClientConfiguration configuration,
                               ClientConfigurator clientConfigurator,
                               RequestSignerFactory defaultRequestSignerFactory)
```
    Deprecated.
    Use the builder instead.
    
    Create a new client instance.
    
    Parameters:
    
    authenticationDetailsProvider - The authentication details (see LoadBalancerAsyncClient.Builder.build(com.oracle.bmc.auth.AbstractAuthenticationDetailsProvider))
    
    configuration - ClientBuilderBase.configuration
    
    clientConfigurator - ClientBuilderBase.clientConfigurator(com.oracle.bmc.http.ClientConfigurator)
    
    defaultRequestSignerFactory - ClientBuilderBase.requestSignerFactory
  - LoadBalancerAsyncClient
```
@Deprecated
public LoadBalancerAsyncClient(AbstractAuthenticationDetailsProvider authenticationDetailsProvider,
                               ClientConfiguration configuration,
                               ClientConfigurator clientConfigurator,
                               RequestSignerFactory defaultRequestSignerFactory,
                               List<ClientConfigurator> additionalClientConfigurators)
```
    Deprecated.
    Use the builder instead.
    
    Create a new client instance.
    
    Parameters:
    
    authenticationDetailsProvider - The authentication details (see LoadBalancerAsyncClient.Builder.build(com.oracle.bmc.auth.AbstractAuthenticationDetailsProvider))
    
    configuration - ClientBuilderBase.configuration
    
    clientConfigurator - ClientBuilderBase.clientConfigurator(com.oracle.bmc.http.ClientConfigurator)
    
    defaultRequestSignerFactory - ClientBuilderBase.requestSignerFactory
    
    additionalClientConfigurators - ClientBuilderBase.additionalClientConfigurators
  - LoadBalancerAsyncClient
```
@Deprecated
public LoadBalancerAsyncClient(AbstractAuthenticationDetailsProvider authenticationDetailsProvider,
                               ClientConfiguration configuration,
                               ClientConfigurator clientConfigurator,
                               RequestSignerFactory defaultRequestSignerFactory,
                               List<ClientConfigurator> additionalClientConfigurators,
                               String endpoint)
```
    Deprecated.
    Use the builder instead.
    
    Create a new client instance.
    
    Parameters:
    
    authenticationDetailsProvider - The authentication details (see LoadBalancerAsyncClient.Builder.build(com.oracle.bmc.auth.AbstractAuthenticationDetailsProvider))
    
    configuration - ClientBuilderBase.configuration
    
    clientConfigurator - ClientBuilderBase.clientConfigurator(com.oracle.bmc.http.ClientConfigurator)
    
    defaultRequestSignerFactory - ClientBuilderBase.requestSignerFactory
    
    additionalClientConfigurators - ClientBuilderBase.additionalClientConfigurators
    
    endpoint - ClientBuilderBase.endpoint(java.lang.String)
  - LoadBalancerAsyncClient
```
@Deprecated
public LoadBalancerAsyncClient(AbstractAuthenticationDetailsProvider authenticationDetailsProvider,
                               ClientConfiguration configuration,
                               ClientConfigurator clientConfigurator,
                               RequestSignerFactory defaultRequestSignerFactory,
                               Map<SigningStrategy,RequestSignerFactory> signingStrategyRequestSignerFactories,
                               List<ClientConfigurator> additionalClientConfigurators,
                               String endpoint)
```
    Deprecated.
    Use the builder instead.
    
    Create a new client instance.
    
    Parameters:
    
    authenticationDetailsProvider - The authentication details (see LoadBalancerAsyncClient.Builder.build(com.oracle.bmc.auth.AbstractAuthenticationDetailsProvider))
    
    configuration - ClientBuilderBase.configuration
    
    clientConfigurator - ClientBuilderBase.clientConfigurator(com.oracle.bmc.http.ClientConfigurator)
    
    defaultRequestSignerFactory - ClientBuilderBase.requestSignerFactory
    
    additionalClientConfigurators - ClientBuilderBase.additionalClientConfigurators
    
    endpoint - ClientBuilderBase.endpoint(java.lang.String)
    
    signingStrategyRequestSignerFactories - ClientBuilderBase.signingStrategyRequestSignerFactories
- Method Detail
  - builder
```
public static LoadBalancerAsyncClient.Builder builder()
```
    Create a builder for this client.
    
    Returns:
    
    builder
  - setRegion
```
public void setRegion(Region region)
```
    Description copied from interface: LoadBalancerAsync
    
    Sets the region to call (ex, Region.US_PHOENIX_1).
    Note, this will call setEndpoint after resolving the endpoint. If the service is not available in this region, however, an IllegalArgumentException will be raised.
    
    Specified by:
    
    setRegion in interface LoadBalancerAsync
    
    Parameters:
    
    region - The region of the service.
  - setRegion
```
public void setRegion(String regionId)
```
    Description copied from interface: LoadBalancerAsync
    
    Sets the region to call (ex, ‘us-phoenix-1’).
    Note, this will first try to map the region ID to a known Region and call setRegion.
    If no known Region could be determined, it will create an endpoint based on the default endpoint format (Region.formatDefaultRegionEndpoint(Service, String) and then call setEndpoint.
    
    Specified by:
    
    setRegion in interface LoadBalancerAsync
    
    Parameters:
    
    regionId - The public region ID.
  - changeLoadBalancerCompartment
```
public Future<ChangeLoadBalancerCompartmentResponse> changeLoadBalancerCompartment(ChangeLoadBalancerCompartmentRequest request,
                                                                                   AsyncHandler<ChangeLoadBalancerCompartmentRequest,ChangeLoadBalancerCompartmentResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Moves a load balancer into a different compartment within the same tenancy.
    For information about moving resources between compartments, see Moving Resources to a Different Compartment.
    
    Specified by:
    
    changeLoadBalancerCompartment in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - createBackend
```
public Future<CreateBackendResponse> createBackend(CreateBackendRequest request,
                                                   AsyncHandler<CreateBackendRequest,CreateBackendResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Adds a backend server to a backend set.
    
    Specified by:
    
    createBackend in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - createBackendSet
```
public Future<CreateBackendSetResponse> createBackendSet(CreateBackendSetRequest request,
                                                         AsyncHandler<CreateBackendSetRequest,CreateBackendSetResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Adds a backend set to a load balancer.
    
    Specified by:
    
    createBackendSet in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - createCertificate
```
public Future<CreateCertificateResponse> createCertificate(CreateCertificateRequest request,
                                                           AsyncHandler<CreateCertificateRequest,CreateCertificateResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Creates an asynchronous request to add an SSL certificate bundle.
    
    Specified by:
    
    createCertificate in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - createHostname
```
public Future<CreateHostnameResponse> createHostname(CreateHostnameRequest request,
                                                     AsyncHandler<CreateHostnameRequest,CreateHostnameResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Adds a hostname resource to the specified load balancer.
    For more information, see Managing Request Routing.
    
    Specified by:
    
    createHostname in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - createListener
```
public Future<CreateListenerResponse> createListener(CreateListenerRequest request,
                                                     AsyncHandler<CreateListenerRequest,CreateListenerResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Adds a listener to a load balancer.
    
    Specified by:
    
    createListener in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - createLoadBalancer
```
public Future<CreateLoadBalancerResponse> createLoadBalancer(CreateLoadBalancerRequest request,
                                                             AsyncHandler<CreateLoadBalancerRequest,CreateLoadBalancerResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Creates a new load balancer in the specified compartment.
    For general information about load balancers, see Overview of the Load Balancing Service.
    
    For the purposes of access control, you must provide the OCID of the compartment where you want the load balancer to reside. Notice that the load balancer doesn't have to be in the same compartment as the VCN or backend set. If you're not sure which compartment to use, put the load balancer in the same compartment as the VCN. For information about access control and compartments, see [Overview of the IAM Service](https://docs.oracle.com/iaas/Content/Identity/Concepts/overview.htm).
    You must specify a display name for the load balancer. It does not have to be unique, and you can change it.
    For information about Availability Domains, see [Regions and Availability Domains](https://docs.oracle.com/iaas/Content/General/Concepts/regions.htm). To get a list of Availability Domains, use the `ListAvailabilityDomains` operation in the Identity and Access Management Service API.
    All Oracle Cloud Infrastructure resources, including load balancers, get an Oracle-assigned, unique ID called an Oracle Cloud Identifier (OCID). When you create a resource, you can find its OCID in the response. You can also retrieve a resource's OCID by using a List API operation on that resource type, or by viewing the resource in the Console. Fore more information, see [Resource Identifiers](https://docs.oracle.com/iaas/Content/General/Concepts/identifiers.htm).
    After you send your request, the new object's state will temporarily be PROVISIONING. Before using the object, first make sure its state has changed to RUNNING.
    When you create a load balancer, the system assigns an IP address. To get the IP address, use the getLoadBalancer operation.
    
    Specified by:
    
    createLoadBalancer in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - createPathRouteSet
```
public Future<CreatePathRouteSetResponse> createPathRouteSet(CreatePathRouteSetRequest request,
                                                             AsyncHandler<CreatePathRouteSetRequest,CreatePathRouteSetResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Adds a path route set to a load balancer.
    For more information, see Managing Request Routing.
    
    Specified by:
    
    createPathRouteSet in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - createRoutingPolicy
```
public Future<CreateRoutingPolicyResponse> createRoutingPolicy(CreateRoutingPolicyRequest request,
                                                               AsyncHandler<CreateRoutingPolicyRequest,CreateRoutingPolicyResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Adds a routing policy to a load balancer.
    For more information, see Managing Request Routing.
    
    Specified by:
    
    createRoutingPolicy in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - createRuleSet
```
public Future<CreateRuleSetResponse> createRuleSet(CreateRuleSetRequest request,
                                                   AsyncHandler<CreateRuleSetRequest,CreateRuleSetResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Creates a new rule set associated with the specified load balancer.
    For more information, see Managing Rule Sets.
    
    Specified by:
    
    createRuleSet in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - createSSLCipherSuite
```
public Future<CreateSSLCipherSuiteResponse> createSSLCipherSuite(CreateSSLCipherSuiteRequest request,
                                                                 AsyncHandler<CreateSSLCipherSuiteRequest,CreateSSLCipherSuiteResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Creates a custom SSL cipher suite.
    
    Specified by:
    
    createSSLCipherSuite in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - deleteBackend
```
public Future<DeleteBackendResponse> deleteBackend(DeleteBackendRequest request,
                                                   AsyncHandler<DeleteBackendRequest,DeleteBackendResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Removes a backend server from a given load balancer and backend set.
    
    Specified by:
    
    deleteBackend in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - deleteBackendSet
```
public Future<DeleteBackendSetResponse> deleteBackendSet(DeleteBackendSetRequest request,
                                                         AsyncHandler<DeleteBackendSetRequest,DeleteBackendSetResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Deletes the specified backend set.
    Note that deleting a backend set removes its backend servers from the load balancer.
    
    Before you can delete a backend set, you must remove it from any active listeners.
    
    Specified by:
    
    deleteBackendSet in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - deleteCertificate
```
public Future<DeleteCertificateResponse> deleteCertificate(DeleteCertificateRequest request,
                                                           AsyncHandler<DeleteCertificateRequest,DeleteCertificateResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Deletes an SSL certificate bundle from a load balancer.
    
    Specified by:
    
    deleteCertificate in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - deleteHostname
```
public Future<DeleteHostnameResponse> deleteHostname(DeleteHostnameRequest request,
                                                     AsyncHandler<DeleteHostnameRequest,DeleteHostnameResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Deletes a hostname resource from the specified load balancer.
    
    Specified by:
    
    deleteHostname in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - deleteListener
```
public Future<DeleteListenerResponse> deleteListener(DeleteListenerRequest request,
                                                     AsyncHandler<DeleteListenerRequest,DeleteListenerResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Deletes a listener from a load balancer.
    
    Specified by:
    
    deleteListener in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - deleteLoadBalancer
```
public Future<DeleteLoadBalancerResponse> deleteLoadBalancer(DeleteLoadBalancerRequest request,
                                                             AsyncHandler<DeleteLoadBalancerRequest,DeleteLoadBalancerResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Stops a load balancer and removes it from service.
    
    Specified by:
    
    deleteLoadBalancer in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - deletePathRouteSet
```
public Future<DeletePathRouteSetResponse> deletePathRouteSet(DeletePathRouteSetRequest request,
                                                             AsyncHandler<DeletePathRouteSetRequest,DeletePathRouteSetResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Deletes a path route set from the specified load balancer.
    To delete a path route rule from a path route set, use the updatePathRouteSet operation.
    
    Specified by:
    
    deletePathRouteSet in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - deleteRoutingPolicy
```
public Future<DeleteRoutingPolicyResponse> deleteRoutingPolicy(DeleteRoutingPolicyRequest request,
                                                               AsyncHandler<DeleteRoutingPolicyRequest,DeleteRoutingPolicyResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Deletes a routing policy from the specified load balancer.
    To delete a routing rule from a routing policy, use the updateRoutingPolicy operation.
    
    Specified by:
    
    deleteRoutingPolicy in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - deleteRuleSet
```
public Future<DeleteRuleSetResponse> deleteRuleSet(DeleteRuleSetRequest request,
                                                   AsyncHandler<DeleteRuleSetRequest,DeleteRuleSetResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Deletes a rule set from the specified load balancer.
    To delete a rule from a rule set, use the updateRuleSet operation.
    
    Specified by:
    
    deleteRuleSet in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - deleteSSLCipherSuite
```
public Future<DeleteSSLCipherSuiteResponse> deleteSSLCipherSuite(DeleteSSLCipherSuiteRequest request,
                                                                 AsyncHandler<DeleteSSLCipherSuiteRequest,DeleteSSLCipherSuiteResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Deletes an SSL cipher suite from a load balancer.
    
    Specified by:
    
    deleteSSLCipherSuite in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - getBackend
```
public Future<GetBackendResponse> getBackend(GetBackendRequest request,
                                             AsyncHandler<GetBackendRequest,GetBackendResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Gets the specified backend server’s configuration information.
    
    Specified by:
    
    getBackend in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - getBackendHealth
```
public Future<GetBackendHealthResponse> getBackendHealth(GetBackendHealthRequest request,
                                                         AsyncHandler<GetBackendHealthRequest,GetBackendHealthResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Gets the current health status of the specified backend server.
    
    Specified by:
    
    getBackendHealth in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - getBackendSet
```
public Future<GetBackendSetResponse> getBackendSet(GetBackendSetRequest request,
                                                   AsyncHandler<GetBackendSetRequest,GetBackendSetResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Gets the specified backend set’s configuration information.
    
    Specified by:
    
    getBackendSet in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - getBackendSetHealth
```
public Future<GetBackendSetHealthResponse> getBackendSetHealth(GetBackendSetHealthRequest request,
                                                               AsyncHandler<GetBackendSetHealthRequest,GetBackendSetHealthResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Gets the health status for the specified backend set.
    
    Specified by:
    
    getBackendSetHealth in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - getHealthChecker
```
public Future<GetHealthCheckerResponse> getHealthChecker(GetHealthCheckerRequest request,
                                                         AsyncHandler<GetHealthCheckerRequest,GetHealthCheckerResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Gets the health check policy information for a given load balancer and backend set.
    
    Specified by:
    
    getHealthChecker in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - getHostname
```
public Future<GetHostnameResponse> getHostname(GetHostnameRequest request,
                                               AsyncHandler<GetHostnameRequest,GetHostnameResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Gets the specified hostname resource’s configuration information.
    
    Specified by:
    
    getHostname in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - getLoadBalancer
```
public Future<GetLoadBalancerResponse> getLoadBalancer(GetLoadBalancerRequest request,
                                                       AsyncHandler<GetLoadBalancerRequest,GetLoadBalancerResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Gets the specified load balancer’s configuration information.
    
    Specified by:
    
    getLoadBalancer in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - getLoadBalancerHealth
```
public Future<GetLoadBalancerHealthResponse> getLoadBalancerHealth(GetLoadBalancerHealthRequest request,
                                                                   AsyncHandler<GetLoadBalancerHealthRequest,GetLoadBalancerHealthResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Gets the health status for the specified load balancer.
    
    Specified by:
    
    getLoadBalancerHealth in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - getPathRouteSet
```
public Future<GetPathRouteSetResponse> getPathRouteSet(GetPathRouteSetRequest request,
                                                       AsyncHandler<GetPathRouteSetRequest,GetPathRouteSetResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Gets the specified path route set’s configuration information.
    
    Specified by:
    
    getPathRouteSet in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - getRoutingPolicy
```
public Future<GetRoutingPolicyResponse> getRoutingPolicy(GetRoutingPolicyRequest request,
                                                         AsyncHandler<GetRoutingPolicyRequest,GetRoutingPolicyResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Gets the specified routing policy.
    
    Specified by:
    
    getRoutingPolicy in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - getRuleSet
```
public Future<GetRuleSetResponse> getRuleSet(GetRuleSetRequest request,
                                             AsyncHandler<GetRuleSetRequest,GetRuleSetResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Gets the specified set of rules.
    
    Specified by:
    
    getRuleSet in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - getSSLCipherSuite
```
public Future<GetSSLCipherSuiteResponse> getSSLCipherSuite(GetSSLCipherSuiteRequest request,
                                                           AsyncHandler<GetSSLCipherSuiteRequest,GetSSLCipherSuiteResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Gets the specified SSL cipher suite’s configuration information.
    
    Specified by:
    
    getSSLCipherSuite in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - getWorkRequest
```
public Future<GetWorkRequestResponse> getWorkRequest(GetWorkRequestRequest request,
                                                     AsyncHandler<GetWorkRequestRequest,GetWorkRequestResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Gets the details of a work request.
    
    Specified by:
    
    getWorkRequest in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - listBackendSets
```
public Future<ListBackendSetsResponse> listBackendSets(ListBackendSetsRequest request,
                                                       AsyncHandler<ListBackendSetsRequest,ListBackendSetsResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Lists all backend sets associated with a given load balancer.
    
    Specified by:
    
    listBackendSets in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - listBackends
```
public Future<ListBackendsResponse> listBackends(ListBackendsRequest request,
                                                 AsyncHandler<ListBackendsRequest,ListBackendsResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Lists the backend servers for a given load balancer and backend set.
    
    Specified by:
    
    listBackends in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - listCertificates
```
public Future<ListCertificatesResponse> listCertificates(ListCertificatesRequest request,
                                                         AsyncHandler<ListCertificatesRequest,ListCertificatesResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Lists all SSL certificates bundles associated with a given load balancer.
    
    Specified by:
    
    listCertificates in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - listHostnames
```
public Future<ListHostnamesResponse> listHostnames(ListHostnamesRequest request,
                                                   AsyncHandler<ListHostnamesRequest,ListHostnamesResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Lists all hostname resources associated with the specified load balancer.
    
    Specified by:
    
    listHostnames in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - listListenerRules
```
public Future<ListListenerRulesResponse> listListenerRules(ListListenerRulesRequest request,
                                                           AsyncHandler<ListListenerRulesRequest,ListListenerRulesResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Lists all of the rules from all of the rule sets associated with the specified listener.
    The response organizes the rules in the following order:
    
    Access control rules * Allow method rules * Request header rules * Response header rules
    
    Specified by:
    
    listListenerRules in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - listLoadBalancerHealths
```
public Future<ListLoadBalancerHealthsResponse> listLoadBalancerHealths(ListLoadBalancerHealthsRequest request,
                                                                       AsyncHandler<ListLoadBalancerHealthsRequest,ListLoadBalancerHealthsResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Lists the summary health statuses for all load balancers in the specified compartment.
    
    Specified by:
    
    listLoadBalancerHealths in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - listLoadBalancers
```
public Future<ListLoadBalancersResponse> listLoadBalancers(ListLoadBalancersRequest request,
                                                           AsyncHandler<ListLoadBalancersRequest,ListLoadBalancersResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Lists all load balancers in the specified compartment.
    
    Specified by:
    
    listLoadBalancers in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - listPathRouteSets
```
public Future<ListPathRouteSetsResponse> listPathRouteSets(ListPathRouteSetsRequest request,
                                                           AsyncHandler<ListPathRouteSetsRequest,ListPathRouteSetsResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Lists all path route sets associated with the specified load balancer.
    
    Specified by:
    
    listPathRouteSets in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - listPolicies
```
public Future<ListPoliciesResponse> listPolicies(ListPoliciesRequest request,
                                                 AsyncHandler<ListPoliciesRequest,ListPoliciesResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Lists the available load balancer policies.
    
    Specified by:
    
    listPolicies in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - listProtocols
```
public Future<ListProtocolsResponse> listProtocols(ListProtocolsRequest request,
                                                   AsyncHandler<ListProtocolsRequest,ListProtocolsResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Lists all supported traffic protocols.
    
    Specified by:
    
    listProtocols in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - listRoutingPolicies
```
public Future<ListRoutingPoliciesResponse> listRoutingPolicies(ListRoutingPoliciesRequest request,
                                                               AsyncHandler<ListRoutingPoliciesRequest,ListRoutingPoliciesResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Lists all routing policies associated with the specified load balancer.
    
    Specified by:
    
    listRoutingPolicies in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - listRuleSets
```
public Future<ListRuleSetsResponse> listRuleSets(ListRuleSetsRequest request,
                                                 AsyncHandler<ListRuleSetsRequest,ListRuleSetsResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Lists all rule sets associated with the specified load balancer.
    
    Specified by:
    
    listRuleSets in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - listSSLCipherSuites
```
public Future<ListSSLCipherSuitesResponse> listSSLCipherSuites(ListSSLCipherSuitesRequest request,
                                                               AsyncHandler<ListSSLCipherSuitesRequest,ListSSLCipherSuitesResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Lists all SSL cipher suites associated with the specified load balancer.
    
    Specified by:
    
    listSSLCipherSuites in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - listShapes
```
public Future<ListShapesResponse> listShapes(ListShapesRequest request,
                                             AsyncHandler<ListShapesRequest,ListShapesResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Lists the valid load balancer shapes.
    
    Specified by:
    
    listShapes in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - listWorkRequests
```
public Future<ListWorkRequestsResponse> listWorkRequests(ListWorkRequestsRequest request,
                                                         AsyncHandler<ListWorkRequestsRequest,ListWorkRequestsResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Lists the work requests for a given load balancer.
    
    Specified by:
    
    listWorkRequests in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - updateBackend
```
public Future<UpdateBackendResponse> updateBackend(UpdateBackendRequest request,
                                                   AsyncHandler<UpdateBackendRequest,UpdateBackendResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Updates the configuration of a backend server within the specified backend set.
    
    Specified by:
    
    updateBackend in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - updateBackendSet
```
public Future<UpdateBackendSetResponse> updateBackendSet(UpdateBackendSetRequest request,
                                                         AsyncHandler<UpdateBackendSetRequest,UpdateBackendSetResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Updates a backend set.
    
    Specified by:
    
    updateBackendSet in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - updateHealthChecker
```
public Future<UpdateHealthCheckerResponse> updateHealthChecker(UpdateHealthCheckerRequest request,
                                                               AsyncHandler<UpdateHealthCheckerRequest,UpdateHealthCheckerResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Updates the health check policy for a given load balancer and backend set.
    
    Specified by:
    
    updateHealthChecker in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - updateHostname
```
public Future<UpdateHostnameResponse> updateHostname(UpdateHostnameRequest request,
                                                     AsyncHandler<UpdateHostnameRequest,UpdateHostnameResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Overwrites an existing hostname resource on the specified load balancer.
    Use this operation to change a virtual hostname.
    
    Specified by:
    
    updateHostname in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - updateListener
```
public Future<UpdateListenerResponse> updateListener(UpdateListenerRequest request,
                                                     AsyncHandler<UpdateListenerRequest,UpdateListenerResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Updates a listener for a given load balancer.
    
    Specified by:
    
    updateListener in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - updateLoadBalancer
```
public Future<UpdateLoadBalancerResponse> updateLoadBalancer(UpdateLoadBalancerRequest request,
                                                             AsyncHandler<UpdateLoadBalancerRequest,UpdateLoadBalancerResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Updates a load balancer’s configuration.
    
    Specified by:
    
    updateLoadBalancer in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - updateLoadBalancerShape
```
public Future<UpdateLoadBalancerShapeResponse> updateLoadBalancerShape(UpdateLoadBalancerShapeRequest request,
                                                                       AsyncHandler<UpdateLoadBalancerShapeRequest,UpdateLoadBalancerShapeResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Update the shape of a load balancer.
    The new shape can be larger or smaller compared to existing shape of the LB. The service will try to perform this operation in the least disruptive way to existing connections, but there is a possibility that they might be lost during the LB resizing process. The new shape becomes effective as soon as the related work request completes successfully, i.e. when reshaping to a larger shape, the LB will start accepting larger bandwidth and when reshaping to a smaller one, the LB will be accepting smaller bandwidth.
    
    Specified by:
    
    updateLoadBalancerShape in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - updateNetworkSecurityGroups
```
public Future<UpdateNetworkSecurityGroupsResponse> updateNetworkSecurityGroups(UpdateNetworkSecurityGroupsRequest request,
                                                                               AsyncHandler<UpdateNetworkSecurityGroupsRequest,UpdateNetworkSecurityGroupsResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Updates the network security groups associated with the specified load balancer.
    
    Specified by:
    
    updateNetworkSecurityGroups in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - updatePathRouteSet
```
public Future<UpdatePathRouteSetResponse> updatePathRouteSet(UpdatePathRouteSetRequest request,
                                                             AsyncHandler<UpdatePathRouteSetRequest,UpdatePathRouteSetResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Overwrites an existing path route set on the specified load balancer.
    Use this operation to add, delete, or alter path route rules in a path route set.
    
    To add a new path route rule to a path route set, the `pathRoutes` in the updatePathRouteSetDetails object must include both the new path route rule to add and the existing path route rules to retain.
    
    Specified by:
    
    updatePathRouteSet in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - updateRoutingPolicy
```
public Future<UpdateRoutingPolicyResponse> updateRoutingPolicy(UpdateRoutingPolicyRequest request,
                                                               AsyncHandler<UpdateRoutingPolicyRequest,UpdateRoutingPolicyResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Overwrites an existing routing policy on the specified load balancer.
    Use this operation to add, delete, or alter routing policy rules in a routing policy.
    
    To add a new routing rule to a routing policy, the body must include both the new routing rule to add and the existing rules to retain.
    
    Specified by:
    
    updateRoutingPolicy in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - updateRuleSet
```
public Future<UpdateRuleSetResponse> updateRuleSet(UpdateRuleSetRequest request,
                                                   AsyncHandler<UpdateRuleSetRequest,UpdateRuleSetResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Overwrites an existing set of rules on the specified load balancer.
    Use this operation to add or alter the rules in a rule set.
    
    To add a new rule to a set, the body must include both the new rule to add and the existing rules to retain.
    
    Specified by:
    
    updateRuleSet in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - updateSSLCipherSuite
```
public Future<UpdateSSLCipherSuiteResponse> updateSSLCipherSuite(UpdateSSLCipherSuiteRequest request,
                                                                 AsyncHandler<UpdateSSLCipherSuiteRequest,UpdateSSLCipherSuiteResponse> handler)
```
    Description copied from interface: LoadBalancerAsync
    
    Updates an existing SSL cipher suite for the specified load balancer.
    
    Specified by:
    
    updateSSLCipherSuite in interface LoadBalancerAsync
    
    Parameters:
    
    request - The request object containing the details to send
    
    handler - The request handler to invoke upon completion, may be null.
    
    Returns:
    
    A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
  - getDefaultConfigurator
```
protected ClientConfigurator getDefaultConfigurator()
```
  - useRealmSpecificEndpointTemplate
```
public void useRealmSpecificEndpointTemplate(boolean useOfRealmSpecificEndpointTemplateEnabled)
```
    This method should be used to enable or disable the use of realm-specific endpoint template.
    The default value is null. To enable the use of endpoint template defined for the realm in use, set the flag to true To disable the use of endpoint template defined for the realm in use, set the flag to false
    
    Parameters:
    
    useOfRealmSpecificEndpointTemplateEnabled - This flag can be set to true or false to enable or disable the use of realm-specific endpoint template respectively
  - populateServiceParametersInEndpoint
```
public final void populateServiceParametersInEndpoint(String endpoint,
                                                      Map<String,Object> requiredParametersMap)
```
    Populate the parameters in the endpoint with its corresponding value and update the base endpoint.
    The value will be populated iff the parameter in endpoint is a required request path parameter or a required request query parameter. If not, the parameter in the endpoint will be ignored and left blank.
    
    Parameters:
    
    endpoint - The endpoint template in use
    
    requiredParametersMap - Map of parameter name as key and value set in request path or query parameter as value
  - updateBaseEndpoint
```
public final void updateBaseEndpoint(String endpoint)
```
    This method should be used for parameterized endpoint templates only.
    This does not include {region} and {secondLevelDomain} parameters.
    
    Parameters:
    
    endpoint - The updated endpoint to use
  - setEndpoint
```
public final void setEndpoint(String endpoint)
```
  - getEndpoint
```
public final String getEndpoint()
```
  - refreshClient
```
public final void refreshClient()
```
    Rebuild the backing HttpClient.
    This will call ClientConfigurators again, and can be used to e.g. refresh the SSL certificate.
  - close
```
public final void close()
```
    Specified by:
    
    close in interface AutoCloseable
  - getClientCommonLibraryVersion
```
public String getClientCommonLibraryVersion()
```
  - getMinimumClientCommonLibraryVersionFromClient
```
public Optional<String> getMinimumClientCommonLibraryVersionFromClient()
```
  - clientCall
```
protected <REQ extends BmcRequest<?>,RESP extends BmcResponse,RESP_BUILDER extends BmcResponse.Builder<RESP>> ClientCall<REQ,RESP,RESP_BUILDER> clientCall(REQ request,
                                                                                                                                                                                   Supplier<RESP_BUILDER> responseBuilder)
```

Class LoadBalancerAsyncClient

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.lang.AutoCloseable

Methods inherited from interface com.oracle.bmc.loadbalancer.LoadBalancerAsync

Field Detail

SERVICE

clientCommonLibraryVersion

minimumClientCommonLibraryVersionFromClient

Constructor Detail

LoadBalancerAsyncClient

LoadBalancerAsyncClient

LoadBalancerAsyncClient

LoadBalancerAsyncClient

LoadBalancerAsyncClient

LoadBalancerAsyncClient

LoadBalancerAsyncClient

Method Detail

builder

setRegion

setRegion

changeLoadBalancerCompartment

createBackend

createBackendSet

createCertificate

createHostname

createListener

createLoadBalancer

createPathRouteSet

createRoutingPolicy

createRuleSet

createSSLCipherSuite

deleteBackend

deleteBackendSet

deleteCertificate

deleteHostname

deleteListener

deleteLoadBalancer

deletePathRouteSet

deleteRoutingPolicy

deleteRuleSet

deleteSSLCipherSuite

getBackend

getBackendHealth

getBackendSet

getBackendSetHealth

getHealthChecker

getHostname

getLoadBalancer

getLoadBalancerHealth

getPathRouteSet

getRoutingPolicy

getRuleSet

getSSLCipherSuite

getWorkRequest

listBackendSets

listBackends

listCertificates

listHostnames

listListenerRules

listLoadBalancerHealths

listLoadBalancers

listPathRouteSets

listPolicies

listProtocols

listRoutingPolicies

listRuleSets

listSSLCipherSuites

listShapes

listWorkRequests

updateBackend

updateBackendSet

updateHealthChecker

updateHostname

updateListener

updateLoadBalancer

updateLoadBalancerShape