AmazonElasticLoadBalancingAsyncClient (aws-android-sdk 2.1.8 API)

java.lang.Object
- com.amazonaws.AmazonWebServiceClient
- - com.amazonaws.services.elasticloadbalancing.AmazonElasticLoadBalancingClient
  - - com.amazonaws.services.elasticloadbalancing.AmazonElasticLoadBalancingAsyncClient

All Implemented Interfaces:

AmazonElasticLoadBalancing, AmazonElasticLoadBalancingAsync
```
public class AmazonElasticLoadBalancingAsyncClient
extends AmazonElasticLoadBalancingClient
implements AmazonElasticLoadBalancingAsync
```
Asynchronous client for accessing AmazonElasticLoadBalancing. All asynchronous calls made using this client are non-blocking. Callers could either process the result and handle the exceptions in the worker thread by providing a callback handler when making the call, or use the returned Future object to check the result of the call in the calling thread. Elastic Load Balancing
Elastic Load Balancing is a cost-effective and easy to use web service to help you improve the availability and scalability of your application running on Amazon Elastic Cloud Compute (Amazon EC2). It makes it easy for you to distribute application loads between two or more EC2 instances. Elastic Load Balancing supports the growth in traffic of your application by enabling availability through redundancy.

This guide provides detailed information about Elastic Load Balancing actions, data types, and parameters that can be used for sending a query request. Query requests are HTTP or HTTPS requests that use the HTTP verb GET or POST and a query parameter named Action or Operation. Action is used throughout this documentation, although Operation is supported for backward compatibility with other AWS Query APIs.

For detailed information on constructing a query request using the actions, data types, and parameters mentioned in this guide, go to Using the Query API in the Elastic Load Balancing Developer Guide .

For detailed information about Elastic Load Balancing features and their associated actions, go to Using Elastic Load Balancing in the Elastic Load Balancing Developer Guide .

This reference guide is based on the current WSDL, which is available at:

Endpoints

The examples in this guide assume that your load balancers are created in the US East (Northern Virginia) region and use us-east-1 as the endpoint.

You can create your load balancers in other AWS regions. For information about regions and endpoints supported by Elastic Load Balancing, see Regions and Endpoints in the Amazon Web Services General Reference.

Field Summary
- Fields inherited from class com.amazonaws.services.elasticloadbalancing.AmazonElasticLoadBalancingClient
  exceptionUnmarshallers
- Fields inherited from class com.amazonaws.AmazonWebServiceClient
  client, clientConfiguration, endpoint, LOGGING_AWS_REQUEST_METRIC, requestHandler2s, timeOffset

Constructor Summary

Constructors
Constructor and Description
`AmazonElasticLoadBalancingAsyncClient()` Constructs a new asynchronous client to invoke service methods on AmazonElasticLoadBalancing.
`AmazonElasticLoadBalancingAsyncClient(AWSCredentials awsCredentials)` Constructs a new asynchronous client to invoke service methods on AmazonElasticLoadBalancing using the specified AWS account credentials.
`AmazonElasticLoadBalancingAsyncClient(AWSCredentials awsCredentials, ClientConfiguration clientConfiguration, java.util.concurrent.ExecutorService executorService)` Constructs a new asynchronous client to invoke service methods on AmazonElasticLoadBalancing using the specified AWS account credentials, executor service, and client configuration options.
`AmazonElasticLoadBalancingAsyncClient(AWSCredentials awsCredentials, java.util.concurrent.ExecutorService executorService)` Constructs a new asynchronous client to invoke service methods on AmazonElasticLoadBalancing using the specified AWS account credentials and executor service.
`AmazonElasticLoadBalancingAsyncClient(AWSCredentialsProvider awsCredentialsProvider)` Constructs a new asynchronous client to invoke service methods on AmazonElasticLoadBalancing using the specified AWS account credentials provider.
`AmazonElasticLoadBalancingAsyncClient(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration)` Constructs a new asynchronous client to invoke service methods on AmazonElasticLoadBalancing using the specified AWS account credentials provider and client configuration options.
`AmazonElasticLoadBalancingAsyncClient(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration, java.util.concurrent.ExecutorService executorService)` Constructs a new asynchronous client to invoke service methods on AmazonElasticLoadBalancing using the specified AWS account credentials provider, executor service, and client configuration options.
`AmazonElasticLoadBalancingAsyncClient(AWSCredentialsProvider awsCredentialsProvider, java.util.concurrent.ExecutorService executorService)` Constructs a new asynchronous client to invoke service methods on AmazonElasticLoadBalancing using the specified AWS account credentials provider and executor service.
`AmazonElasticLoadBalancingAsyncClient(ClientConfiguration clientConfiguration)` Constructs a new asynchronous client to invoke service methods on AmazonElasticLoadBalancing.

Method Summary

Methods
Modifier and Type	Method and Description
`java.util.concurrent.Future<ApplySecurityGroupsToLoadBalancerResult>`	`applySecurityGroupsToLoadBalancerAsync(ApplySecurityGroupsToLoadBalancerRequest applySecurityGroupsToLoadBalancerRequest)` Associates one or more security groups with your load balancer in Amazon Virtual Private Cloud (Amazon VPC).
`java.util.concurrent.Future<ApplySecurityGroupsToLoadBalancerResult>`	`applySecurityGroupsToLoadBalancerAsync(ApplySecurityGroupsToLoadBalancerRequest applySecurityGroupsToLoadBalancerRequest, AsyncHandler<ApplySecurityGroupsToLoadBalancerRequest,ApplySecurityGroupsToLoadBalancerResult> asyncHandler)` Associates one or more security groups with your load balancer in Amazon Virtual Private Cloud (Amazon VPC).
`java.util.concurrent.Future<AttachLoadBalancerToSubnetsResult>`	`attachLoadBalancerToSubnetsAsync(AttachLoadBalancerToSubnetsRequest attachLoadBalancerToSubnetsRequest)` Adds one or more subnets to the set of configured subnets in the Amazon Virtual Private Cloud (Amazon VPC) for the load balancer.
`java.util.concurrent.Future<AttachLoadBalancerToSubnetsResult>`	`attachLoadBalancerToSubnetsAsync(AttachLoadBalancerToSubnetsRequest attachLoadBalancerToSubnetsRequest, AsyncHandler<AttachLoadBalancerToSubnetsRequest,AttachLoadBalancerToSubnetsResult> asyncHandler)` Adds one or more subnets to the set of configured subnets in the Amazon Virtual Private Cloud (Amazon VPC) for the load balancer.
`java.util.concurrent.Future<ConfigureHealthCheckResult>`	`configureHealthCheckAsync(ConfigureHealthCheckRequest configureHealthCheckRequest)` Specifies the health check settings to use for evaluating the health state of your back-end instances.
`java.util.concurrent.Future<ConfigureHealthCheckResult>`	`configureHealthCheckAsync(ConfigureHealthCheckRequest configureHealthCheckRequest, AsyncHandler<ConfigureHealthCheckRequest,ConfigureHealthCheckResult> asyncHandler)` Specifies the health check settings to use for evaluating the health state of your back-end instances.
`java.util.concurrent.Future<CreateAppCookieStickinessPolicyResult>`	`createAppCookieStickinessPolicyAsync(CreateAppCookieStickinessPolicyRequest createAppCookieStickinessPolicyRequest)` Generates a stickiness policy with sticky session lifetimes that follow that of an application-generated cookie.
`java.util.concurrent.Future<CreateAppCookieStickinessPolicyResult>`	`createAppCookieStickinessPolicyAsync(CreateAppCookieStickinessPolicyRequest createAppCookieStickinessPolicyRequest, AsyncHandler<CreateAppCookieStickinessPolicyRequest,CreateAppCookieStickinessPolicyResult> asyncHandler)` Generates a stickiness policy with sticky session lifetimes that follow that of an application-generated cookie.
`java.util.concurrent.Future<CreateLBCookieStickinessPolicyResult>`	`createLBCookieStickinessPolicyAsync(CreateLBCookieStickinessPolicyRequest createLBCookieStickinessPolicyRequest)` Generates a stickiness policy with sticky session lifetimes controlled by the lifetime of the browser (user-agent) or a specified expiration period.
`java.util.concurrent.Future<CreateLBCookieStickinessPolicyResult>`	`createLBCookieStickinessPolicyAsync(CreateLBCookieStickinessPolicyRequest createLBCookieStickinessPolicyRequest, AsyncHandler<CreateLBCookieStickinessPolicyRequest,CreateLBCookieStickinessPolicyResult> asyncHandler)` Generates a stickiness policy with sticky session lifetimes controlled by the lifetime of the browser (user-agent) or a specified expiration period.
`java.util.concurrent.Future<CreateLoadBalancerResult>`	`createLoadBalancerAsync(CreateLoadBalancerRequest createLoadBalancerRequest)` Creates a new load balancer.
`java.util.concurrent.Future<CreateLoadBalancerResult>`	`createLoadBalancerAsync(CreateLoadBalancerRequest createLoadBalancerRequest, AsyncHandler<CreateLoadBalancerRequest,CreateLoadBalancerResult> asyncHandler)` Creates a new load balancer.
`java.util.concurrent.Future<java.lang.Void>`	`createLoadBalancerListenersAsync(CreateLoadBalancerListenersRequest createLoadBalancerListenersRequest)` Creates one or more listeners on a load balancer for the specified port.
`java.util.concurrent.Future<java.lang.Void>`	`createLoadBalancerListenersAsync(CreateLoadBalancerListenersRequest createLoadBalancerListenersRequest, AsyncHandler<CreateLoadBalancerListenersRequest,java.lang.Void> asyncHandler)` Creates one or more listeners on a load balancer for the specified port.
`java.util.concurrent.Future<CreateLoadBalancerPolicyResult>`	`createLoadBalancerPolicyAsync(CreateLoadBalancerPolicyRequest createLoadBalancerPolicyRequest)` Creates a new policy that contains the necessary attributes depending on the policy type.
`java.util.concurrent.Future<CreateLoadBalancerPolicyResult>`	`createLoadBalancerPolicyAsync(CreateLoadBalancerPolicyRequest createLoadBalancerPolicyRequest, AsyncHandler<CreateLoadBalancerPolicyRequest,CreateLoadBalancerPolicyResult> asyncHandler)` Creates a new policy that contains the necessary attributes depending on the policy type.
`java.util.concurrent.Future<java.lang.Void>`	`deleteLoadBalancerAsync(DeleteLoadBalancerRequest deleteLoadBalancerRequest)` Deletes the specified load balancer.
`java.util.concurrent.Future<java.lang.Void>`	`deleteLoadBalancerAsync(DeleteLoadBalancerRequest deleteLoadBalancerRequest, AsyncHandler<DeleteLoadBalancerRequest,java.lang.Void> asyncHandler)` Deletes the specified load balancer.
`java.util.concurrent.Future<java.lang.Void>`	`deleteLoadBalancerListenersAsync(DeleteLoadBalancerListenersRequest deleteLoadBalancerListenersRequest)` Deletes listeners from the load balancer for the specified port.
`java.util.concurrent.Future<java.lang.Void>`	`deleteLoadBalancerListenersAsync(DeleteLoadBalancerListenersRequest deleteLoadBalancerListenersRequest, AsyncHandler<DeleteLoadBalancerListenersRequest,java.lang.Void> asyncHandler)` Deletes listeners from the load balancer for the specified port.
`java.util.concurrent.Future<DeleteLoadBalancerPolicyResult>`	`deleteLoadBalancerPolicyAsync(DeleteLoadBalancerPolicyRequest deleteLoadBalancerPolicyRequest)` Deletes a policy from the load balancer.
`java.util.concurrent.Future<DeleteLoadBalancerPolicyResult>`	`deleteLoadBalancerPolicyAsync(DeleteLoadBalancerPolicyRequest deleteLoadBalancerPolicyRequest, AsyncHandler<DeleteLoadBalancerPolicyRequest,DeleteLoadBalancerPolicyResult> asyncHandler)` Deletes a policy from the load balancer.
`java.util.concurrent.Future<DeregisterInstancesFromLoadBalancerResult>`	`deregisterInstancesFromLoadBalancerAsync(DeregisterInstancesFromLoadBalancerRequest deregisterInstancesFromLoadBalancerRequest)` Deregisters instances from the load balancer.
`java.util.concurrent.Future<DeregisterInstancesFromLoadBalancerResult>`	`deregisterInstancesFromLoadBalancerAsync(DeregisterInstancesFromLoadBalancerRequest deregisterInstancesFromLoadBalancerRequest, AsyncHandler<DeregisterInstancesFromLoadBalancerRequest,DeregisterInstancesFromLoadBalancerResult> asyncHandler)` Deregisters instances from the load balancer.
`java.util.concurrent.Future<DescribeInstanceHealthResult>`	`describeInstanceHealthAsync(DescribeInstanceHealthRequest describeInstanceHealthRequest)` Returns the current state of the specified instances registered with the specified load balancer.
`java.util.concurrent.Future<DescribeInstanceHealthResult>`	`describeInstanceHealthAsync(DescribeInstanceHealthRequest describeInstanceHealthRequest, AsyncHandler<DescribeInstanceHealthRequest,DescribeInstanceHealthResult> asyncHandler)` Returns the current state of the specified instances registered with the specified load balancer.
`java.util.concurrent.Future<DescribeLoadBalancerAttributesResult>`	`describeLoadBalancerAttributesAsync(DescribeLoadBalancerAttributesRequest describeLoadBalancerAttributesRequest)` Returns detailed information about all of the attributes associated with the specified load balancer.
`java.util.concurrent.Future<DescribeLoadBalancerAttributesResult>`	`describeLoadBalancerAttributesAsync(DescribeLoadBalancerAttributesRequest describeLoadBalancerAttributesRequest, AsyncHandler<DescribeLoadBalancerAttributesRequest,DescribeLoadBalancerAttributesResult> asyncHandler)` Returns detailed information about all of the attributes associated with the specified load balancer.
`java.util.concurrent.Future<DescribeLoadBalancerPoliciesResult>`	`describeLoadBalancerPoliciesAsync(DescribeLoadBalancerPoliciesRequest describeLoadBalancerPoliciesRequest)` Returns detailed descriptions of the policies.
`java.util.concurrent.Future<DescribeLoadBalancerPoliciesResult>`	`describeLoadBalancerPoliciesAsync(DescribeLoadBalancerPoliciesRequest describeLoadBalancerPoliciesRequest, AsyncHandler<DescribeLoadBalancerPoliciesRequest,DescribeLoadBalancerPoliciesResult> asyncHandler)` Returns detailed descriptions of the policies.
`java.util.concurrent.Future<DescribeLoadBalancerPolicyTypesResult>`	`describeLoadBalancerPolicyTypesAsync(DescribeLoadBalancerPolicyTypesRequest describeLoadBalancerPolicyTypesRequest)` Returns meta-information on the specified load balancer policies defined by the Elastic Load Balancing service.
`java.util.concurrent.Future<DescribeLoadBalancerPolicyTypesResult>`	`describeLoadBalancerPolicyTypesAsync(DescribeLoadBalancerPolicyTypesRequest describeLoadBalancerPolicyTypesRequest, AsyncHandler<DescribeLoadBalancerPolicyTypesRequest,DescribeLoadBalancerPolicyTypesResult> asyncHandler)` Returns meta-information on the specified load balancer policies defined by the Elastic Load Balancing service.
`java.util.concurrent.Future<DescribeLoadBalancersResult>`	`describeLoadBalancersAsync(DescribeLoadBalancersRequest describeLoadBalancersRequest)` Returns detailed configuration information for all the load balancers created for the account.
`java.util.concurrent.Future<DescribeLoadBalancersResult>`	`describeLoadBalancersAsync(DescribeLoadBalancersRequest describeLoadBalancersRequest, AsyncHandler<DescribeLoadBalancersRequest,DescribeLoadBalancersResult> asyncHandler)` Returns detailed configuration information for all the load balancers created for the account.
`java.util.concurrent.Future<DetachLoadBalancerFromSubnetsResult>`	`detachLoadBalancerFromSubnetsAsync(DetachLoadBalancerFromSubnetsRequest detachLoadBalancerFromSubnetsRequest)` Removes subnets from the set of configured subnets in the Amazon Virtual Private Cloud (Amazon VPC) for the load balancer.
`java.util.concurrent.Future<DetachLoadBalancerFromSubnetsResult>`	`detachLoadBalancerFromSubnetsAsync(DetachLoadBalancerFromSubnetsRequest detachLoadBalancerFromSubnetsRequest, AsyncHandler<DetachLoadBalancerFromSubnetsRequest,DetachLoadBalancerFromSubnetsResult> asyncHandler)` Removes subnets from the set of configured subnets in the Amazon Virtual Private Cloud (Amazon VPC) for the load balancer.
`java.util.concurrent.Future<DisableAvailabilityZonesForLoadBalancerResult>`	`disableAvailabilityZonesForLoadBalancerAsync(DisableAvailabilityZonesForLoadBalancerRequest disableAvailabilityZonesForLoadBalancerRequest)` Removes the specified EC2 Availability Zones from the set of configured Availability Zones for the load balancer.
`java.util.concurrent.Future<DisableAvailabilityZonesForLoadBalancerResult>`	`disableAvailabilityZonesForLoadBalancerAsync(DisableAvailabilityZonesForLoadBalancerRequest disableAvailabilityZonesForLoadBalancerRequest, AsyncHandler<DisableAvailabilityZonesForLoadBalancerRequest,DisableAvailabilityZonesForLoadBalancerResult> asyncHandler)` Removes the specified EC2 Availability Zones from the set of configured Availability Zones for the load balancer.
`java.util.concurrent.Future<EnableAvailabilityZonesForLoadBalancerResult>`	`enableAvailabilityZonesForLoadBalancerAsync(EnableAvailabilityZonesForLoadBalancerRequest enableAvailabilityZonesForLoadBalancerRequest)` Adds one or more EC2 Availability Zones to the load balancer.
`java.util.concurrent.Future<EnableAvailabilityZonesForLoadBalancerResult>`	`enableAvailabilityZonesForLoadBalancerAsync(EnableAvailabilityZonesForLoadBalancerRequest enableAvailabilityZonesForLoadBalancerRequest, AsyncHandler<EnableAvailabilityZonesForLoadBalancerRequest,EnableAvailabilityZonesForLoadBalancerResult> asyncHandler)` Adds one or more EC2 Availability Zones to the load balancer.
`java.util.concurrent.ExecutorService`	`getExecutorService()` Returns the executor service used by this async client to execute requests.
`java.util.concurrent.Future<ModifyLoadBalancerAttributesResult>`	`modifyLoadBalancerAttributesAsync(ModifyLoadBalancerAttributesRequest modifyLoadBalancerAttributesRequest)` Modifies the attributes of a specified load balancer.
`java.util.concurrent.Future<ModifyLoadBalancerAttributesResult>`	`modifyLoadBalancerAttributesAsync(ModifyLoadBalancerAttributesRequest modifyLoadBalancerAttributesRequest, AsyncHandler<ModifyLoadBalancerAttributesRequest,ModifyLoadBalancerAttributesResult> asyncHandler)` Modifies the attributes of a specified load balancer.
`java.util.concurrent.Future<RegisterInstancesWithLoadBalancerResult>`	`registerInstancesWithLoadBalancerAsync(RegisterInstancesWithLoadBalancerRequest registerInstancesWithLoadBalancerRequest)` Adds new instances to the load balancer.
`java.util.concurrent.Future<RegisterInstancesWithLoadBalancerResult>`	`registerInstancesWithLoadBalancerAsync(RegisterInstancesWithLoadBalancerRequest registerInstancesWithLoadBalancerRequest, AsyncHandler<RegisterInstancesWithLoadBalancerRequest,RegisterInstancesWithLoadBalancerResult> asyncHandler)` Adds new instances to the load balancer.
`java.util.concurrent.Future<java.lang.Void>`	`setLoadBalancerListenerSSLCertificateAsync(SetLoadBalancerListenerSSLCertificateRequest setLoadBalancerListenerSSLCertificateRequest)` Sets the certificate that terminates the specified listener's SSL connections.
`java.util.concurrent.Future<java.lang.Void>`	`setLoadBalancerListenerSSLCertificateAsync(SetLoadBalancerListenerSSLCertificateRequest setLoadBalancerListenerSSLCertificateRequest, AsyncHandler<SetLoadBalancerListenerSSLCertificateRequest,java.lang.Void> asyncHandler)` Sets the certificate that terminates the specified listener's SSL connections.
`java.util.concurrent.Future<SetLoadBalancerPoliciesForBackendServerResult>`	`setLoadBalancerPoliciesForBackendServerAsync(SetLoadBalancerPoliciesForBackendServerRequest setLoadBalancerPoliciesForBackendServerRequest)` Replaces the current set of policies associated with a port on which the back-end server is listening with a new set of policies.
`java.util.concurrent.Future<SetLoadBalancerPoliciesForBackendServerResult>`	`setLoadBalancerPoliciesForBackendServerAsync(SetLoadBalancerPoliciesForBackendServerRequest setLoadBalancerPoliciesForBackendServerRequest, AsyncHandler<SetLoadBalancerPoliciesForBackendServerRequest,SetLoadBalancerPoliciesForBackendServerResult> asyncHandler)` Replaces the current set of policies associated with a port on which the back-end server is listening with a new set of policies.
`java.util.concurrent.Future<SetLoadBalancerPoliciesOfListenerResult>`	`setLoadBalancerPoliciesOfListenerAsync(SetLoadBalancerPoliciesOfListenerRequest setLoadBalancerPoliciesOfListenerRequest)` Associates, updates, or disables a policy with a listener on the load balancer.
`java.util.concurrent.Future<SetLoadBalancerPoliciesOfListenerResult>`	`setLoadBalancerPoliciesOfListenerAsync(SetLoadBalancerPoliciesOfListenerRequest setLoadBalancerPoliciesOfListenerRequest, AsyncHandler<SetLoadBalancerPoliciesOfListenerRequest,SetLoadBalancerPoliciesOfListenerResult> asyncHandler)` Associates, updates, or disables a policy with a listener on the load balancer.
`void`	`shutdown()` Shuts down the client, releasing all managed resources.

Methods inherited from class com.amazonaws.services.elasticloadbalancing.AmazonElasticLoadBalancingClient
applySecurityGroupsToLoadBalancer, attachLoadBalancerToSubnets, configureHealthCheck, createAppCookieStickinessPolicy, createLBCookieStickinessPolicy, createLoadBalancer, createLoadBalancerListeners, createLoadBalancerPolicy, deleteLoadBalancer, deleteLoadBalancerListeners, deleteLoadBalancerPolicy, deregisterInstancesFromLoadBalancer, describeInstanceHealth, describeLoadBalancerAttributes, describeLoadBalancerPolicies, describeLoadBalancerPolicies, describeLoadBalancerPolicyTypes, describeLoadBalancerPolicyTypes, describeLoadBalancers, describeLoadBalancers, detachLoadBalancerFromSubnets, disableAvailabilityZonesForLoadBalancer, enableAvailabilityZonesForLoadBalancer, getCachedResponseMetadata, modifyLoadBalancerAttributes, registerInstancesWithLoadBalancer, setLoadBalancerListenerSSLCertificate, setLoadBalancerPoliciesForBackendServer, setLoadBalancerPoliciesOfListener

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

Methods inherited from interface com.amazonaws.services.elasticloadbalancing.AmazonElasticLoadBalancing
applySecurityGroupsToLoadBalancer, attachLoadBalancerToSubnets, configureHealthCheck, createAppCookieStickinessPolicy, createLBCookieStickinessPolicy, createLoadBalancer, createLoadBalancerListeners, createLoadBalancerPolicy, deleteLoadBalancer, deleteLoadBalancerListeners, deleteLoadBalancerPolicy, deregisterInstancesFromLoadBalancer, describeInstanceHealth, describeLoadBalancerAttributes, describeLoadBalancerPolicies, describeLoadBalancerPolicies, describeLoadBalancerPolicyTypes, describeLoadBalancerPolicyTypes, describeLoadBalancers, describeLoadBalancers, detachLoadBalancerFromSubnets, disableAvailabilityZonesForLoadBalancer, enableAvailabilityZonesForLoadBalancer, getCachedResponseMetadata, modifyLoadBalancerAttributes, registerInstancesWithLoadBalancer, setEndpoint, setLoadBalancerListenerSSLCertificate, setLoadBalancerPoliciesForBackendServer, setLoadBalancerPoliciesOfListener, setRegion

- Constructor Detail
  - AmazonElasticLoadBalancingAsyncClient
```
public AmazonElasticLoadBalancingAsyncClient()
```
    Constructs a new asynchronous client to invoke service methods on AmazonElasticLoadBalancing. A credentials provider chain will be used that searches for credentials in this order:
    - Environment Variables - AWS_ACCESS_KEY_ID and AWS_SECRET_KEY
    - Java System Properties - aws.accessKeyId and aws.secretKey
    - Instance profile credentials delivered through the Amazon EC2 metadata service
    All service calls made using this new client object are blocking, and will not return until the service call completes.
    See Also:
    DefaultAWSCredentialsProviderChain
  - AmazonElasticLoadBalancingAsyncClient
```
public AmazonElasticLoadBalancingAsyncClient(ClientConfiguration clientConfiguration)
```
    Constructs a new asynchronous client to invoke service methods on AmazonElasticLoadBalancing. A credentials provider chain will be used that searches for credentials in this order:
    - Environment Variables - AWS_ACCESS_KEY_ID and AWS_SECRET_KEY
    - Java System Properties - aws.accessKeyId and aws.secretKey
    - Instance profile credentials delivered through the Amazon EC2 metadata service
    All service calls made using this new client object are blocking, and will not return until the service call completes.
    Parameters:
    clientConfiguration - The client configuration options controlling how this client connects to AmazonElasticLoadBalancing (ex: proxy settings, retry counts, etc.).
    See Also:
    DefaultAWSCredentialsProviderChain
  - AmazonElasticLoadBalancingAsyncClient
```
public AmazonElasticLoadBalancingAsyncClient(AWSCredentials awsCredentials)
```
    Constructs a new asynchronous client to invoke service methods on AmazonElasticLoadBalancing using the specified AWS account credentials. Default client settings will be used, and a fixed size thread pool will be created for executing the asynchronous tasks.
    All calls made using this new client object are non-blocking, and will immediately return a Java Future object that the caller can later check to see if the service call has actually completed.
    
    Parameters:
    awsCredentials - The AWS credentials (access key ID and secret key) to use when authenticating with AWS services.
  - AmazonElasticLoadBalancingAsyncClient
```
public AmazonElasticLoadBalancingAsyncClient(AWSCredentials awsCredentials,
                                     java.util.concurrent.ExecutorService executorService)
```
    Constructs a new asynchronous client to invoke service methods on AmazonElasticLoadBalancing using the specified AWS account credentials and executor service. Default client settings will be used.
    All calls made using this new client object are non-blocking, and will immediately return a Java Future object that the caller can later check to see if the service call has actually completed.
    
    Parameters:
    awsCredentials - The AWS credentials (access key ID and secret key) to use when authenticating with AWS services.
    executorService - The executor service by which all asynchronous requests will be executed.
  - AmazonElasticLoadBalancingAsyncClient
```
public AmazonElasticLoadBalancingAsyncClient(AWSCredentials awsCredentials,
                                     ClientConfiguration clientConfiguration,
                                     java.util.concurrent.ExecutorService executorService)
```
    Constructs a new asynchronous client to invoke service methods on AmazonElasticLoadBalancing using the specified AWS account credentials, executor service, and client configuration options.
    All calls made using this new client object are non-blocking, and will immediately return a Java Future object that the caller can later check to see if the service call has actually completed.
    
    Parameters:
    awsCredentials - The AWS credentials (access key ID and secret key) to use when authenticating with AWS services.
    clientConfiguration - Client configuration options (ex: max retry limit, proxy settings, etc).
    executorService - The executor service by which all asynchronous requests will be executed.
  - AmazonElasticLoadBalancingAsyncClient
```
public AmazonElasticLoadBalancingAsyncClient(AWSCredentialsProvider awsCredentialsProvider)
```
    Constructs a new asynchronous client to invoke service methods on AmazonElasticLoadBalancing using the specified AWS account credentials provider. Default client settings will be used, and a fixed size thread pool will be created for executing the asynchronous tasks.
    All calls made using this new client object are non-blocking, and will immediately return a Java Future object that the caller can later check to see if the service call has actually completed.
    
    Parameters:
    awsCredentialsProvider - The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
  - AmazonElasticLoadBalancingAsyncClient
```
public AmazonElasticLoadBalancingAsyncClient(AWSCredentialsProvider awsCredentialsProvider,
                                     java.util.concurrent.ExecutorService executorService)
```
    Constructs a new asynchronous client to invoke service methods on AmazonElasticLoadBalancing using the specified AWS account credentials provider and executor service. Default client settings will be used.
    All calls made using this new client object are non-blocking, and will immediately return a Java Future object that the caller can later check to see if the service call has actually completed.
    
    Parameters:
    awsCredentialsProvider - The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
    executorService - The executor service by which all asynchronous requests will be executed.
  - AmazonElasticLoadBalancingAsyncClient
```
public AmazonElasticLoadBalancingAsyncClient(AWSCredentialsProvider awsCredentialsProvider,
                                     ClientConfiguration clientConfiguration)
```
    Constructs a new asynchronous client to invoke service methods on AmazonElasticLoadBalancing using the specified AWS account credentials provider and client configuration options.
    All calls made using this new client object are non-blocking, and will immediately return a Java Future object that the caller can later check to see if the service call has actually completed.
    
    Parameters:
    awsCredentialsProvider - The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
    clientConfiguration - Client configuration options (ex: max retry limit, proxy settings, etc).
  - AmazonElasticLoadBalancingAsyncClient
```
public AmazonElasticLoadBalancingAsyncClient(AWSCredentialsProvider awsCredentialsProvider,
                                     ClientConfiguration clientConfiguration,
                                     java.util.concurrent.ExecutorService executorService)
```
    Constructs a new asynchronous client to invoke service methods on AmazonElasticLoadBalancing using the specified AWS account credentials provider, executor service, and client configuration options.
    All calls made using this new client object are non-blocking, and will immediately return a Java Future object that the caller can later check to see if the service call has actually completed.
    
    Parameters:
    awsCredentialsProvider - The AWS credentials provider which will provide credentials to authenticate requests with AWS services.
    clientConfiguration - Client configuration options (ex: max retry limit, proxy settings, etc).
    executorService - The executor service by which all asynchronous requests will be executed.
- Method Detail
  - getExecutorService
```
public java.util.concurrent.ExecutorService getExecutorService()
```
    Returns the executor service used by this async client to execute requests.
    
    Returns:
    The executor service used by this async client to execute requests.
  - shutdown
```
public void shutdown()
```
    Shuts down the client, releasing all managed resources. This includes forcibly terminating all pending asynchronous service calls. Clients who wish to give pending asynchronous service calls time to complete should call getExecutorService().shutdown() followed by getExecutorService().awaitTermination() prior to calling this method.
    
    Specified by:
    
    shutdown in interface AmazonElasticLoadBalancing
    
    Overrides:
    
    shutdown in class AmazonWebServiceClient
  - describeLoadBalancerPolicyTypesAsync
```
public java.util.concurrent.Future<DescribeLoadBalancerPolicyTypesResult> describeLoadBalancerPolicyTypesAsync(DescribeLoadBalancerPolicyTypesRequest describeLoadBalancerPolicyTypesRequest)
                                                                                                        throws AmazonServiceException,
                                                                                                               AmazonClientException
```
    Returns meta-information on the specified load balancer policies defined by the Elastic Load Balancing service. The policy types that are returned from this action can be used in a CreateLoadBalancerPolicy action to instantiate specific policy configurations that will be applied to a load balancer.
    
    Specified by:
    
    describeLoadBalancerPolicyTypesAsync in interface AmazonElasticLoadBalancingAsync
    
    Parameters:
    describeLoadBalancerPolicyTypesRequest - Container for the necessary parameters to execute the DescribeLoadBalancerPolicyTypes operation on AmazonElasticLoadBalancing.
    
    Returns:
    A Java Future object containing the response from the DescribeLoadBalancerPolicyTypes service method, as returned by AmazonElasticLoadBalancing.
    
    Throws:
    
    AmazonClientException - If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
    
    AmazonServiceException - If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
  - describeLoadBalancerPolicyTypesAsync
```
public java.util.concurrent.Future<DescribeLoadBalancerPolicyTypesResult> describeLoadBalancerPolicyTypesAsync(DescribeLoadBalancerPolicyTypesRequest describeLoadBalancerPolicyTypesRequest,
                                                                                                      AsyncHandler<DescribeLoadBalancerPolicyTypesRequest,DescribeLoadBalancerPolicyTypesResult> asyncHandler)
                                                                                                        throws AmazonServiceException,
                                                                                                               AmazonClientException
```
    Returns meta-information on the specified load balancer policies defined by the Elastic Load Balancing service. The policy types that are returned from this action can be used in a CreateLoadBalancerPolicy action to instantiate specific policy configurations that will be applied to a load balancer.
    
    Specified by:
    
    describeLoadBalancerPolicyTypesAsync in interface AmazonElasticLoadBalancingAsync
    
    Parameters:
    describeLoadBalancerPolicyTypesRequest - Container for the necessary parameters to execute the DescribeLoadBalancerPolicyTypes operation on AmazonElasticLoadBalancing.
    asyncHandler - Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
    
    Returns:
    A Java Future object containing the response from the DescribeLoadBalancerPolicyTypes service method, as returned by AmazonElasticLoadBalancing.
    
    Throws:
    
    AmazonClientException - If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
    
    AmazonServiceException - If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
  - configureHealthCheckAsync
```
public java.util.concurrent.Future<ConfigureHealthCheckResult> configureHealthCheckAsync(ConfigureHealthCheckRequest configureHealthCheckRequest)
                                                                                  throws AmazonServiceException,
                                                                                         AmazonClientException
```
    Specifies the health check settings to use for evaluating the health state of your back-end instances.
    
    For more information, see Health Check in the Elastic Load Balancing Developer Guide .
    
    Specified by:
    
    configureHealthCheckAsync in interface AmazonElasticLoadBalancingAsync
    
    Parameters:
    configureHealthCheckRequest - Container for the necessary parameters to execute the ConfigureHealthCheck operation on AmazonElasticLoadBalancing.
    
    Returns:
    A Java Future object containing the response from the ConfigureHealthCheck service method, as returned by AmazonElasticLoadBalancing.
    
    Throws:
    
    AmazonClientException - If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
    
    AmazonServiceException - If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
  - configureHealthCheckAsync
```
public java.util.concurrent.Future<ConfigureHealthCheckResult> configureHealthCheckAsync(ConfigureHealthCheckRequest configureHealthCheckRequest,
                                                                                AsyncHandler<ConfigureHealthCheckRequest,ConfigureHealthCheckResult> asyncHandler)
                                                                                  throws AmazonServiceException,
                                                                                         AmazonClientException
```
    Specifies the health check settings to use for evaluating the health state of your back-end instances.
    
    For more information, see Health Check in the Elastic Load Balancing Developer Guide .
    
    Specified by:
    
    configureHealthCheckAsync in interface AmazonElasticLoadBalancingAsync
    
    Parameters:
    configureHealthCheckRequest - Container for the necessary parameters to execute the ConfigureHealthCheck operation on AmazonElasticLoadBalancing.
    asyncHandler - Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
    
    Returns:
    A Java Future object containing the response from the ConfigureHealthCheck service method, as returned by AmazonElasticLoadBalancing.
    
    Throws:
    
    AmazonClientException - If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
    
    AmazonServiceException - If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
  - detachLoadBalancerFromSubnetsAsync
```
public java.util.concurrent.Future<DetachLoadBalancerFromSubnetsResult> detachLoadBalancerFromSubnetsAsync(DetachLoadBalancerFromSubnetsRequest detachLoadBalancerFromSubnetsRequest)
                                                                                                    throws AmazonServiceException,
                                                                                                           AmazonClientException
```
    Removes subnets from the set of configured subnets in the Amazon Virtual Private Cloud (Amazon VPC) for the load balancer.
    
    After a subnet is removed all of the EC2 instances registered with the load balancer that are in the removed subnet will go into the OutOfService state. When a subnet is removed, the load balancer will balance the traffic among the remaining routable subnets for the load balancer.
    
    Specified by:
    
    detachLoadBalancerFromSubnetsAsync in interface AmazonElasticLoadBalancingAsync
    
    Parameters:
    detachLoadBalancerFromSubnetsRequest - Container for the necessary parameters to execute the DetachLoadBalancerFromSubnets operation on AmazonElasticLoadBalancing.
    
    Returns:
    A Java Future object containing the response from the DetachLoadBalancerFromSubnets service method, as returned by AmazonElasticLoadBalancing.
    
    Throws:
    
    AmazonClientException - If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
    
    AmazonServiceException - If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
  - detachLoadBalancerFromSubnetsAsync
```
public java.util.concurrent.Future<DetachLoadBalancerFromSubnetsResult> detachLoadBalancerFromSubnetsAsync(DetachLoadBalancerFromSubnetsRequest detachLoadBalancerFromSubnetsRequest,
                                                                                                  AsyncHandler<DetachLoadBalancerFromSubnetsRequest,DetachLoadBalancerFromSubnetsResult> asyncHandler)
                                                                                                    throws AmazonServiceException,
                                                                                                           AmazonClientException
```
    Removes subnets from the set of configured subnets in the Amazon Virtual Private Cloud (Amazon VPC) for the load balancer.
    
    After a subnet is removed all of the EC2 instances registered with the load balancer that are in the removed subnet will go into the OutOfService state. When a subnet is removed, the load balancer will balance the traffic among the remaining routable subnets for the load balancer.
    
    Specified by:
    
    detachLoadBalancerFromSubnetsAsync in interface AmazonElasticLoadBalancingAsync
    
    Parameters:
    detachLoadBalancerFromSubnetsRequest - Container for the necessary parameters to execute the DetachLoadBalancerFromSubnets operation on AmazonElasticLoadBalancing.
    asyncHandler - Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
    
    Returns:
    A Java Future object containing the response from the DetachLoadBalancerFromSubnets service method, as returned by AmazonElasticLoadBalancing.
    
    Throws:
    
    AmazonClientException - If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
    
    AmazonServiceException - If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
  - modifyLoadBalancerAttributesAsync
```
public java.util.concurrent.Future<ModifyLoadBalancerAttributesResult> modifyLoadBalancerAttributesAsync(ModifyLoadBalancerAttributesRequest modifyLoadBalancerAttributesRequest)
                                                                                                  throws AmazonServiceException,
                                                                                                         AmazonClientException
```
    Modifies the attributes of a specified load balancer.
    
    You can modify the load balancer attributes, such as AccessLogs , ConnectionDraining , and CrossZoneLoadBalancing by either enabling or disabling them.
    
    For information on cross-zone load balancing, see Request Routing and for information on connection draining, see Connection Draining in the Concepts section of the Elastic Load Balancer Developer Guide . For information on access logs, see Access Logs .
    
    Specified by:
    
    modifyLoadBalancerAttributesAsync in interface AmazonElasticLoadBalancingAsync
    
    Parameters:
    modifyLoadBalancerAttributesRequest - Container for the necessary parameters to execute the ModifyLoadBalancerAttributes operation on AmazonElasticLoadBalancing.
    
    Returns:
    A Java Future object containing the response from the ModifyLoadBalancerAttributes service method, as returned by AmazonElasticLoadBalancing.
    
    Throws:
    
    AmazonClientException - If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
    
    AmazonServiceException - If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
  - modifyLoadBalancerAttributesAsync
```
public java.util.concurrent.Future<ModifyLoadBalancerAttributesResult> modifyLoadBalancerAttributesAsync(ModifyLoadBalancerAttributesRequest modifyLoadBalancerAttributesRequest,
                                                                                                AsyncHandler<ModifyLoadBalancerAttributesRequest,ModifyLoadBalancerAttributesResult> asyncHandler)
                                                                                                  throws AmazonServiceException,
                                                                                                         AmazonClientException
```
    Modifies the attributes of a specified load balancer.
    
    You can modify the load balancer attributes, such as AccessLogs , ConnectionDraining , and CrossZoneLoadBalancing by either enabling or disabling them.
    
    For information on cross-zone load balancing, see Request Routing and for information on connection draining, see Connection Draining in the Concepts section of the Elastic Load Balancer Developer Guide . For information on access logs, see Access Logs .
    
    Specified by:
    
    modifyLoadBalancerAttributesAsync in interface AmazonElasticLoadBalancingAsync
    
    Parameters:
    modifyLoadBalancerAttributesRequest - Container for the necessary parameters to execute the ModifyLoadBalancerAttributes operation on AmazonElasticLoadBalancing.
    asyncHandler - Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
    
    Returns:
    A Java Future object containing the response from the ModifyLoadBalancerAttributes service method, as returned by AmazonElasticLoadBalancing.
    
    Throws:
    
    AmazonClientException - If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
    
    AmazonServiceException - If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
  - createLoadBalancerListenersAsync
```
public java.util.concurrent.Future<java.lang.Void> createLoadBalancerListenersAsync(CreateLoadBalancerListenersRequest createLoadBalancerListenersRequest)
                                                                             throws AmazonServiceException,
                                                                                    AmazonClientException
```
    Creates one or more listeners on a load balancer for the specified port. If a listener with the given port does not already exist, it will be created; otherwise, the properties of the new listener must match the properties of the existing listener.
    
    For more information, see Add a Listener to Your Load Balancer in the Elastic Load Balancing Developer Guide .
    
    Specified by:
    
    createLoadBalancerListenersAsync in interface AmazonElasticLoadBalancingAsync
    
    Parameters:
    createLoadBalancerListenersRequest - Container for the necessary parameters to execute the CreateLoadBalancerListeners operation on AmazonElasticLoadBalancing.
    
    Returns:
    A Java Future object containing the response from the CreateLoadBalancerListeners service method, as returned by AmazonElasticLoadBalancing.
    
    Throws:
    
    AmazonClientException - If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
    
    AmazonServiceException - If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
  - createLoadBalancerListenersAsync
```
public java.util.concurrent.Future<java.lang.Void> createLoadBalancerListenersAsync(CreateLoadBalancerListenersRequest createLoadBalancerListenersRequest,
                                                                           AsyncHandler<CreateLoadBalancerListenersRequest,java.lang.Void> asyncHandler)
                                                                             throws AmazonServiceException,
                                                                                    AmazonClientException
```
    Creates one or more listeners on a load balancer for the specified port. If a listener with the given port does not already exist, it will be created; otherwise, the properties of the new listener must match the properties of the existing listener.
    
    For more information, see Add a Listener to Your Load Balancer in the Elastic Load Balancing Developer Guide .
    
    Specified by:
    
    createLoadBalancerListenersAsync in interface AmazonElasticLoadBalancingAsync
    
    Parameters:
    createLoadBalancerListenersRequest - Container for the necessary parameters to execute the CreateLoadBalancerListeners operation on AmazonElasticLoadBalancing.
    asyncHandler - Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
    
    Returns:
    A Java Future object containing the response from the CreateLoadBalancerListeners service method, as returned by AmazonElasticLoadBalancing.
    
    Throws:
    
    AmazonClientException - If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
    
    AmazonServiceException - If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
  - deleteLoadBalancerListenersAsync
```
public java.util.concurrent.Future<java.lang.Void> deleteLoadBalancerListenersAsync(DeleteLoadBalancerListenersRequest deleteLoadBalancerListenersRequest)
                                                                             throws AmazonServiceException,
                                                                                    AmazonClientException
```
    Deletes listeners from the load balancer for the specified port.
    
    Specified by:
    
    deleteLoadBalancerListenersAsync in interface AmazonElasticLoadBalancingAsync
    
    Parameters:
    deleteLoadBalancerListenersRequest - Container for the necessary parameters to execute the DeleteLoadBalancerListeners operation on AmazonElasticLoadBalancing.
    
    Returns:
    A Java Future object containing the response from the DeleteLoadBalancerListeners service method, as returned by AmazonElasticLoadBalancing.
    
    Throws:
    
    AmazonClientException - If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
    
    AmazonServiceException - If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
  - deleteLoadBalancerListenersAsync
```
public java.util.concurrent.Future<java.lang.Void> deleteLoadBalancerListenersAsync(DeleteLoadBalancerListenersRequest deleteLoadBalancerListenersRequest,
                                                                           AsyncHandler<DeleteLoadBalancerListenersRequest,java.lang.Void> asyncHandler)
                                                                             throws AmazonServiceException,
                                                                                    AmazonClientException
```
    Deletes listeners from the load balancer for the specified port.
    
    Specified by:
    
    deleteLoadBalancerListenersAsync in interface AmazonElasticLoadBalancingAsync
    
    Parameters:
    deleteLoadBalancerListenersRequest - Container for the necessary parameters to execute the DeleteLoadBalancerListeners operation on AmazonElasticLoadBalancing.
    asyncHandler - Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
    
    Returns:
    A Java Future object containing the response from the DeleteLoadBalancerListeners service method, as returned by AmazonElasticLoadBalancing.
    
    Throws:
    
    AmazonClientException - If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
    
    AmazonServiceException - If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
  - createAppCookieStickinessPolicyAsync
```
public java.util.concurrent.Future<CreateAppCookieStickinessPolicyResult> createAppCookieStickinessPolicyAsync(CreateAppCookieStickinessPolicyRequest createAppCookieStickinessPolicyRequest)
                                                                                                        throws AmazonServiceException,
                                                                                                               AmazonClientException
```
    Generates a stickiness policy with sticky session lifetimes that follow that of an application-generated cookie. This policy can be associated only with HTTP/HTTPS listeners.
    
    This policy is similar to the policy created by CreateLBCookieStickinessPolicy, except that the lifetime of the special Elastic Load Balancing cookie follows the lifetime of the application-generated cookie specified in the policy configuration. The load balancer only inserts a new stickiness cookie when the application response includes a new application cookie.
    
    If the application cookie is explicitly removed or expires, the session stops being sticky until a new application cookie is issued.
    
    NOTE: An application client must receive and send two cookies: the application-generated cookie and the special Elastic Load Balancing cookie named AWSELB. This is the default behavior for many common web browsers.
    
    For more information, see Enabling Application-Controlled Session Stickiness in the Elastic Load Balancing Developer Guide .
    
    Specified by:
    
    createAppCookieStickinessPolicyAsync in interface AmazonElasticLoadBalancingAsync
    
    Parameters:
    createAppCookieStickinessPolicyRequest - Container for the necessary parameters to execute the CreateAppCookieStickinessPolicy operation on AmazonElasticLoadBalancing.
    
    Returns:
    A Java Future object containing the response from the CreateAppCookieStickinessPolicy service method, as returned by AmazonElasticLoadBalancing.
    
    Throws:
    
    AmazonClientException - If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
    
    AmazonServiceException - If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
  - createAppCookieStickinessPolicyAsync
```
public java.util.concurrent.Future<CreateAppCookieStickinessPolicyResult> createAppCookieStickinessPolicyAsync(CreateAppCookieStickinessPolicyRequest createAppCookieStickinessPolicyRequest,
                                                                                                      AsyncHandler<CreateAppCookieStickinessPolicyRequest,CreateAppCookieStickinessPolicyResult> asyncHandler)
                                                                                                        throws AmazonServiceException,
                                                                                                               AmazonClientException
```
    Generates a stickiness policy with sticky session lifetimes that follow that of an application-generated cookie. This policy can be associated only with HTTP/HTTPS listeners.
    
    This policy is similar to the policy created by CreateLBCookieStickinessPolicy, except that the lifetime of the special Elastic Load Balancing cookie follows the lifetime of the application-generated cookie specified in the policy configuration. The load balancer only inserts a new stickiness cookie when the application response includes a new application cookie.
    
    If the application cookie is explicitly removed or expires, the session stops being sticky until a new application cookie is issued.
    
    NOTE: An application client must receive and send two cookies: the application-generated cookie and the special Elastic Load Balancing cookie named AWSELB. This is the default behavior for many common web browsers.
    
    For more information, see Enabling Application-Controlled Session Stickiness in the Elastic Load Balancing Developer Guide .
    
    Specified by:
    
    createAppCookieStickinessPolicyAsync in interface AmazonElasticLoadBalancingAsync
    
    Parameters:
    createAppCookieStickinessPolicyRequest - Container for the necessary parameters to execute the CreateAppCookieStickinessPolicy operation on AmazonElasticLoadBalancing.
    asyncHandler - Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
    
    Returns:
    A Java Future object containing the response from the CreateAppCookieStickinessPolicy service method, as returned by AmazonElasticLoadBalancing.
    
    Throws:
    
    AmazonClientException - If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
    
    AmazonServiceException - If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
  - applySecurityGroupsToLoadBalancerAsync
```
public java.util.concurrent.Future<ApplySecurityGroupsToLoadBalancerResult> applySecurityGroupsToLoadBalancerAsync(ApplySecurityGroupsToLoadBalancerRequest applySecurityGroupsToLoadBalancerRequest)
                                                                                                            throws AmazonServiceException,
                                                                                                                   AmazonClientException
```
    Associates one or more security groups with your load balancer in Amazon Virtual Private Cloud (Amazon VPC). The provided security group IDs will override any currently applied security groups.
    
    For more information, see Manage Security Groups in Amazon VPC in the Elastic Load Balancing Developer Guide .
    
    Specified by:
    
    applySecurityGroupsToLoadBalancerAsync in interface AmazonElasticLoadBalancingAsync
    
    Parameters:
    applySecurityGroupsToLoadBalancerRequest - Container for the necessary parameters to execute the ApplySecurityGroupsToLoadBalancer operation on AmazonElasticLoadBalancing.
    
    Returns:
    A Java Future object containing the response from the ApplySecurityGroupsToLoadBalancer service method, as returned by AmazonElasticLoadBalancing.
    
    Throws:
    
    AmazonClientException - If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
    
    AmazonServiceException - If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
  - applySecurityGroupsToLoadBalancerAsync
```
public java.util.concurrent.Future<ApplySecurityGroupsToLoadBalancerResult> applySecurityGroupsToLoadBalancerAsync(ApplySecurityGroupsToLoadBalancerRequest applySecurityGroupsToLoadBalancerRequest,
                                                                                                          AsyncHandler<ApplySecurityGroupsToLoadBalancerRequest,ApplySecurityGroupsToLoadBalancerResult> asyncHandler)
                                                                                                            throws AmazonServiceException,
                                                                                                                   AmazonClientException
```
    Associates one or more security groups with your load balancer in Amazon Virtual Private Cloud (Amazon VPC). The provided security group IDs will override any currently applied security groups.
    
    For more information, see Manage Security Groups in Amazon VPC in the Elastic Load Balancing Developer Guide .
    
    Specified by:
    
    applySecurityGroupsToLoadBalancerAsync in interface AmazonElasticLoadBalancingAsync
    
    Parameters:
    applySecurityGroupsToLoadBalancerRequest - Container for the necessary parameters to execute the ApplySecurityGroupsToLoadBalancer operation on AmazonElasticLoadBalancing.
    asyncHandler - Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
    
    Returns:
    A Java Future object containing the response from the ApplySecurityGroupsToLoadBalancer service method, as returned by AmazonElasticLoadBalancing.
    
    Throws:
    
    AmazonClientException - If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
    
    AmazonServiceException - If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
  - describeLoadBalancerPoliciesAsync
```
public java.util.concurrent.Future<DescribeLoadBalancerPoliciesResult> describeLoadBalancerPoliciesAsync(DescribeLoadBalancerPoliciesRequest describeLoadBalancerPoliciesRequest)
                                                                                                  throws AmazonServiceException,
                                                                                                         AmazonClientException
```
    Returns detailed descriptions of the policies. If you specify a load balancer name, the action returns the descriptions of all the policies created for the load balancer. If you specify a policy name associated with your load balancer, the action returns the description of that policy. If you don't specify a load balancer name, the action returns descriptions of the specified sample policies, or descriptions of all the sample policies. The names of the sample policies have the ELBSample- prefix.
    
    Specified by:
    
    describeLoadBalancerPoliciesAsync in interface AmazonElasticLoadBalancingAsync
    
    Parameters:
    describeLoadBalancerPoliciesRequest - Container for the necessary parameters to execute the DescribeLoadBalancerPolicies operation on AmazonElasticLoadBalancing.
    
    Returns:
    A Java Future object containing the response from the DescribeLoadBalancerPolicies service method, as returned by AmazonElasticLoadBalancing.
    
    Throws:
    
    AmazonClientException - If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
    
    AmazonServiceException - If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
  - describeLoadBalancerPoliciesAsync
```
public java.util.concurrent.Future<DescribeLoadBalancerPoliciesResult> describeLoadBalancerPoliciesAsync(DescribeLoadBalancerPoliciesRequest describeLoadBalancerPoliciesRequest,
                                                                                                AsyncHandler<DescribeLoadBalancerPoliciesRequest,DescribeLoadBalancerPoliciesResult> asyncHandler)
                                                                                                  throws AmazonServiceException,
                                                                                                         AmazonClientException
```
    Returns detailed descriptions of the policies. If you specify a load balancer name, the action returns the descriptions of all the policies created for the load balancer. If you specify a policy name associated with your load balancer, the action returns the description of that policy. If you don't specify a load balancer name, the action returns descriptions of the specified sample policies, or descriptions of all the sample policies. The names of the sample policies have the ELBSample- prefix.
    
    Specified by:
    
    describeLoadBalancerPoliciesAsync in interface AmazonElasticLoadBalancingAsync
    
    Parameters:
    describeLoadBalancerPoliciesRequest - Container for the necessary parameters to execute the DescribeLoadBalancerPolicies operation on AmazonElasticLoadBalancing.
    asyncHandler - Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
    
    Returns:
    A Java Future object containing the response from the DescribeLoadBalancerPolicies service method, as returned by AmazonElasticLoadBalancing.
    
    Throws:
    
    AmazonClientException - If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
    
    AmazonServiceException - If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
  - setLoadBalancerPoliciesOfListenerAsync
```
public java.util.concurrent.Future<SetLoadBalancerPoliciesOfListenerResult> setLoadBalancerPoliciesOfListenerAsync(SetLoadBalancerPoliciesOfListenerRequest setLoadBalancerPoliciesOfListenerRequest)
                                                                                                            throws AmazonServiceException,
                                                                                                                   AmazonClientException
```
    Associates, updates, or disables a policy with a listener on the load balancer. You can associate multiple policies with a listener.
    
    Specified by:
    
    setLoadBalancerPoliciesOfListenerAsync in interface AmazonElasticLoadBalancingAsync
    
    Parameters:
    setLoadBalancerPoliciesOfListenerRequest - Container for the necessary parameters to execute the SetLoadBalancerPoliciesOfListener operation on AmazonElasticLoadBalancing.
    
    Returns:
    A Java Future object containing the response from the SetLoadBalancerPoliciesOfListener service method, as returned by AmazonElasticLoadBalancing.
    
    Throws:
    
    AmazonClientException - If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
    
    AmazonServiceException - If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
  - setLoadBalancerPoliciesOfListenerAsync
```
public java.util.concurrent.Future<SetLoadBalancerPoliciesOfListenerResult> setLoadBalancerPoliciesOfListenerAsync(SetLoadBalancerPoliciesOfListenerRequest setLoadBalancerPoliciesOfListenerRequest,
                                                                                                          AsyncHandler<SetLoadBalancerPoliciesOfListenerRequest,SetLoadBalancerPoliciesOfListenerResult> asyncHandler)
                                                                                                            throws AmazonServiceException,
                                                                                                                   AmazonClientException
```
    Associates, updates, or disables a policy with a listener on the load balancer. You can associate multiple policies with a listener.
    
    Specified by:
    
    setLoadBalancerPoliciesOfListenerAsync in interface AmazonElasticLoadBalancingAsync
    
    Parameters:
    setLoadBalancerPoliciesOfListenerRequest - Container for the necessary parameters to execute the SetLoadBalancerPoliciesOfListener operation on AmazonElasticLoadBalancing.
    asyncHandler - Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
    
    Returns:
    A Java Future object containing the response from the SetLoadBalancerPoliciesOfListener service method, as returned by AmazonElasticLoadBalancing.
    
    Throws:
    
    AmazonClientException - If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
    
    AmazonServiceException - If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
  - disableAvailabilityZonesForLoadBalancerAsync
```
public java.util.concurrent.Future<DisableAvailabilityZonesForLoadBalancerResult> disableAvailabilityZonesForLoadBalancerAsync(DisableAvailabilityZonesForLoadBalancerRequest disableAvailabilityZonesForLoadBalancerRequest)
                                                                                                                        throws AmazonServiceException,
                                                                                                                               AmazonClientException
```
    Removes the specified EC2 Availability Zones from the set of configured Availability Zones for the load balancer.
    
    There must be at least one Availability Zone registered with a load balancer at all times. Once an Availability Zone is removed, all the instances registered with the load balancer that are in the removed Availability Zone go into the OutOfService state. Upon Availability Zone removal, the load balancer attempts to equally balance the traffic among its remaining usable Availability Zones. Trying to remove an Availability Zone that was not associated with the load balancer does nothing.
    
    For more information, see Disable an Availability Zone from a Load-Balanced Application in the Elastic Load Balancing Developer Guide .
    
    Specified by:
    
    disableAvailabilityZonesForLoadBalancerAsync in interface AmazonElasticLoadBalancingAsync
    
    Parameters:
    disableAvailabilityZonesForLoadBalancerRequest - Container for the necessary parameters to execute the DisableAvailabilityZonesForLoadBalancer operation on AmazonElasticLoadBalancing.
    
    Returns:
    A Java Future object containing the response from the DisableAvailabilityZonesForLoadBalancer service method, as returned by AmazonElasticLoadBalancing.
    
    Throws:
    
    AmazonClientException - If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
    
    AmazonServiceException - If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
  - disableAvailabilityZonesForLoadBalancerAsync
```
public java.util.concurrent.Future<DisableAvailabilityZonesForLoadBalancerResult> disableAvailabilityZonesForLoadBalancerAsync(DisableAvailabilityZonesForLoadBalancerRequest disableAvailabilityZonesForLoadBalancerRequest,
                                                                                                                      AsyncHandler<DisableAvailabilityZonesForLoadBalancerRequest,DisableAvailabilityZonesForLoadBalancerResult> asyncHandler)
                                                                                                                        throws AmazonServiceException,
                                                                                                                               AmazonClientException
```
    Removes the specified EC2 Availability Zones from the set of configured Availability Zones for the load balancer.
    
    There must be at least one Availability Zone registered with a load balancer at all times. Once an Availability Zone is removed, all the instances registered with the load balancer that are in the removed Availability Zone go into the OutOfService state. Upon Availability Zone removal, the load balancer attempts to equally balance the traffic among its remaining usable Availability Zones. Trying to remove an Availability Zone that was not associated with the load balancer does nothing.
    
    For more information, see Disable an Availability Zone from a Load-Balanced Application in the Elastic Load Balancing Developer Guide .
    
    Specified by:
    
    disableAvailabilityZonesForLoadBalancerAsync in interface AmazonElasticLoadBalancingAsync
    
    Parameters:
    disableAvailabilityZonesForLoadBalancerRequest - Container for the necessary parameters to execute the DisableAvailabilityZonesForLoadBalancer operation on AmazonElasticLoadBalancing.
    asyncHandler - Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
    
    Returns:
    A Java Future object containing the response from the DisableAvailabilityZonesForLoadBalancer service method, as returned by AmazonElasticLoadBalancing.
    
    Throws:
    
    AmazonClientException - If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
    
    AmazonServiceException - If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
  - describeInstanceHealthAsync
```
public java.util.concurrent.Future<DescribeInstanceHealthResult> describeInstanceHealthAsync(DescribeInstanceHealthRequest describeInstanceHealthRequest)
                                                                                      throws AmazonServiceException,
                                                                                             AmazonClientException
```
    Returns the current state of the specified instances registered with the specified load balancer. If no instances are specified, the state of all the instances registered with the load balancer is returned.
    
    NOTE: You must provide the same account credentials as those that were used to create the load balancer.
    
    Specified by:
    
    describeInstanceHealthAsync in interface AmazonElasticLoadBalancingAsync
    
    Parameters:
    describeInstanceHealthRequest - Container for the necessary parameters to execute the DescribeInstanceHealth operation on AmazonElasticLoadBalancing.
    
    Returns:
    A Java Future object containing the response from the DescribeInstanceHealth service method, as returned by AmazonElasticLoadBalancing.
    
    Throws:
    
    AmazonClientException - If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
    
    AmazonServiceException - If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
  - describeInstanceHealthAsync
```
public java.util.concurrent.Future<DescribeInstanceHealthResult> describeInstanceHealthAsync(DescribeInstanceHealthRequest describeInstanceHealthRequest,
                                                                                    AsyncHandler<DescribeInstanceHealthRequest,DescribeInstanceHealthResult> asyncHandler)
                                                                                      throws AmazonServiceException,
                                                                                             AmazonClientException
```
    Returns the current state of the specified instances registered with the specified load balancer. If no instances are specified, the state of all the instances registered with the load balancer is returned.
    
    NOTE: You must provide the same account credentials as those that were used to create the load balancer.
    
    Specified by:
    
    describeInstanceHealthAsync in interface AmazonElasticLoadBalancingAsync
    
    Parameters:
    describeInstanceHealthRequest - Container for the necessary parameters to execute the DescribeInstanceHealth operation on AmazonElasticLoadBalancing.
    asyncHandler - Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
    
    Returns:
    A Java Future object containing the response from the DescribeInstanceHealth service method, as returned by AmazonElasticLoadBalancing.
    
    Throws:
    
    AmazonClientException - If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
    
    AmazonServiceException - If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
  - deleteLoadBalancerPolicyAsync
```
public java.util.concurrent.Future<DeleteLoadBalancerPolicyResult> deleteLoadBalancerPolicyAsync(DeleteLoadBalancerPolicyRequest deleteLoadBalancerPolicyRequest)
                                                                                          throws AmazonServiceException,
                                                                                                 AmazonClientException
```
    Deletes a policy from the load balancer. The specified policy must not be enabled for any listeners.
    
    Specified by:
    
    deleteLoadBalancerPolicyAsync in interface AmazonElasticLoadBalancingAsync
    
    Parameters:
    deleteLoadBalancerPolicyRequest - Container for the necessary parameters to execute the DeleteLoadBalancerPolicy operation on AmazonElasticLoadBalancing.
    
    Returns:
    A Java Future object containing the response from the DeleteLoadBalancerPolicy service method, as returned by AmazonElasticLoadBalancing.
    
    Throws:
    
    AmazonClientException - If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
    
    AmazonServiceException - If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
  - deleteLoadBalancerPolicyAsync
```
public java.util.concurrent.Future<DeleteLoadBalancerPolicyResult> deleteLoadBalancerPolicyAsync(DeleteLoadBalancerPolicyRequest deleteLoadBalancerPolicyRequest,
                                                                                        AsyncHandler<DeleteLoadBalancerPolicyRequest,DeleteLoadBalancerPolicyResult> asyncHandler)
                                                                                          throws AmazonServiceException,
                                                                                                 AmazonClientException
```
    Deletes a policy from the load balancer. The specified policy must not be enabled for any listeners.
    
    Specified by:
    
    deleteLoadBalancerPolicyAsync in interface AmazonElasticLoadBalancingAsync
    
    Parameters:
    deleteLoadBalancerPolicyRequest - Container for the necessary parameters to execute the DeleteLoadBalancerPolicy operation on AmazonElasticLoadBalancing.
    asyncHandler - Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
    
    Returns:
    A Java Future object containing the response from the DeleteLoadBalancerPolicy service method, as returned by AmazonElasticLoadBalancing.
    
    Throws:
    
    AmazonClientException - If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
    
    AmazonServiceException - If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
  - createLoadBalancerPolicyAsync
```
public java.util.concurrent.Future<CreateLoadBalancerPolicyResult> createLoadBalancerPolicyAsync(CreateLoadBalancerPolicyRequest createLoadBalancerPolicyRequest)
                                                                                          throws AmazonServiceException,
                                                                                                 AmazonClientException
```
    Creates a new policy that contains the necessary attributes depending on the policy type. Policies are settings that are saved for your load balancer and that can be applied to the front-end listener, or the back-end application server, depending on your policy type.
    
    Specified by:
    
    createLoadBalancerPolicyAsync in interface AmazonElasticLoadBalancingAsync
    
    Parameters:
    createLoadBalancerPolicyRequest - Container for the necessary parameters to execute the CreateLoadBalancerPolicy operation on AmazonElasticLoadBalancing.
    
    Returns:
    A Java Future object containing the response from the CreateLoadBalancerPolicy service method, as returned by AmazonElasticLoadBalancing.
    
    Throws:
    
    AmazonClientException - If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
    
    AmazonServiceException - If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
  - createLoadBalancerPolicyAsync
```
public java.util.concurrent.Future<CreateLoadBalancerPolicyResult> createLoadBalancerPolicyAsync(CreateLoadBalancerPolicyRequest createLoadBalancerPolicyRequest,
                                                                                        AsyncHandler<CreateLoadBalancerPolicyRequest,CreateLoadBalancerPolicyResult> asyncHandler)
                                                                                          throws AmazonServiceException,
                                                                                                 AmazonClientException
```
    Creates a new policy that contains the necessary attributes depending on the policy type. Policies are settings that are saved for your load balancer and that can be applied to the front-end listener, or the back-end application server, depending on your policy type.
    
    Specified by:
    
    createLoadBalancerPolicyAsync in interface AmazonElasticLoadBalancingAsync
    
    Parameters:
    createLoadBalancerPolicyRequest - Container for the necessary parameters to execute the CreateLoadBalancerPolicy operation on AmazonElasticLoadBalancing.
    asyncHandler - Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
    
    Returns:
    A Java Future object containing the response from the CreateLoadBalancerPolicy service method, as returned by AmazonElasticLoadBalancing.
    
    Throws:
    
    AmazonClientException - If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
    
    AmazonServiceException - If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
  - enableAvailabilityZonesForLoadBalancerAsync
```
public java.util.concurrent.Future<EnableAvailabilityZonesForLoadBalancerResult> enableAvailabilityZonesForLoadBalancerAsync(EnableAvailabilityZonesForLoadBalancerRequest enableAvailabilityZonesForLoadBalancerRequest)
                                                                                                                      throws AmazonServiceException,
                                                                                                                             AmazonClientException
```
    Adds one or more EC2 Availability Zones to the load balancer.
    
    The load balancer evenly distributes requests across all its registered Availability Zones that contain instances.
    
    NOTE: The new EC2 Availability Zones to be added must be in the same EC2 Region as the Availability Zones for which the load balancer was created.
    
    For more information, see Expand a Load Balanced Application to an Additional Availability Zone in the Elastic Load Balancing Developer Guide .
    
    Specified by:
    
    enableAvailabilityZonesForLoadBalancerAsync in interface AmazonElasticLoadBalancingAsync
    
    Parameters:
    enableAvailabilityZonesForLoadBalancerRequest - Container for the necessary parameters to execute the EnableAvailabilityZonesForLoadBalancer operation on AmazonElasticLoadBalancing.
    
    Returns:
    A Java Future object containing the response from the EnableAvailabilityZonesForLoadBalancer service method, as returned by AmazonElasticLoadBalancing.
    
    Throws:
    
    AmazonClientException - If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
    
    AmazonServiceException - If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
  - enableAvailabilityZonesForLoadBalancerAsync
```
public java.util.concurrent.Future<EnableAvailabilityZonesForLoadBalancerResult> enableAvailabilityZonesForLoadBalancerAsync(EnableAvailabilityZonesForLoadBalancerRequest enableAvailabilityZonesForLoadBalancerRequest,
                                                                                                                    AsyncHandler<EnableAvailabilityZonesForLoadBalancerRequest,EnableAvailabilityZonesForLoadBalancerResult> asyncHandler)
                                                                                                                      throws AmazonServiceException,
                                                                                                                             AmazonClientException
```
    Adds one or more EC2 Availability Zones to the load balancer.
    
    The load balancer evenly distributes requests across all its registered Availability Zones that contain instances.
    
    NOTE: The new EC2 Availability Zones to be added must be in the same EC2 Region as the Availability Zones for which the load balancer was created.
    
    For more information, see Expand a Load Balanced Application to an Additional Availability Zone in the Elastic Load Balancing Developer Guide .
    
    Specified by:
    
    enableAvailabilityZonesForLoadBalancerAsync in interface AmazonElasticLoadBalancingAsync
    
    Parameters:
    enableAvailabilityZonesForLoadBalancerRequest - Container for the necessary parameters to execute the EnableAvailabilityZonesForLoadBalancer operation on AmazonElasticLoadBalancing.
    asyncHandler - Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
    
    Returns:
    A Java Future object containing the response from the EnableAvailabilityZonesForLoadBalancer service method, as returned by AmazonElasticLoadBalancing.
    
    Throws:
    
    AmazonClientException - If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
    
    AmazonServiceException - If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
  - deleteLoadBalancerAsync
```
public java.util.concurrent.Future<java.lang.Void> deleteLoadBalancerAsync(DeleteLoadBalancerRequest deleteLoadBalancerRequest)
                                                                    throws AmazonServiceException,
                                                                           AmazonClientException
```
    Deletes the specified load balancer.
    
    If attempting to recreate the load balancer, you must reconfigure all the settings. The DNS name associated with a deleted load balancer will no longer be usable. Once deleted, the name and associated DNS record of the load balancer no longer exist and traffic sent to any of its IP addresses will no longer be delivered to back-end instances.
    
    To successfully call this API, you must provide the same account credentials as were used to create the load balancer.
    
    NOTE: By design, if the load balancer does not exist or has already been deleted, a call to DeleteLoadBalancer action still succeeds.
    
    Specified by:
    
    deleteLoadBalancerAsync in interface AmazonElasticLoadBalancingAsync
    
    Parameters:
    deleteLoadBalancerRequest - Container for the necessary parameters to execute the DeleteLoadBalancer operation on AmazonElasticLoadBalancing.
    
    Returns:
    A Java Future object containing the response from the DeleteLoadBalancer service method, as returned by AmazonElasticLoadBalancing.
    
    Throws:
    
    AmazonClientException - If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
    
    AmazonServiceException - If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
  - deleteLoadBalancerAsync
```
public java.util.concurrent.Future<java.lang.Void> deleteLoadBalancerAsync(DeleteLoadBalancerRequest deleteLoadBalancerRequest,
                                                                  AsyncHandler<DeleteLoadBalancerRequest,java.lang.Void> asyncHandler)
                                                                    throws AmazonServiceException,
                                                                           AmazonClientException
```
    Deletes the specified load balancer.
    
    If attempting to recreate the load balancer, you must reconfigure all the settings. The DNS name associated with a deleted load balancer will no longer be usable. Once deleted, the name and associated DNS record of the load balancer no longer exist and traffic sent to any of its IP addresses will no longer be delivered to back-end instances.
    
    To successfully call this API, you must provide the same account credentials as were used to create the load balancer.
    
    NOTE: By design, if the load balancer does not exist or has already been deleted, a call to DeleteLoadBalancer action still succeeds.
    
    Specified by:
    
    deleteLoadBalancerAsync in interface AmazonElasticLoadBalancingAsync
    
    Parameters:
    deleteLoadBalancerRequest - Container for the necessary parameters to execute the DeleteLoadBalancer operation on AmazonElasticLoadBalancing.
    asyncHandler - Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
    
    Returns:
    A Java Future object containing the response from the DeleteLoadBalancer service method, as returned by AmazonElasticLoadBalancing.
    
    Throws:
    
    AmazonClientException - If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
    
    AmazonServiceException - If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
  - createLoadBalancerAsync
```
public java.util.concurrent.Future<CreateLoadBalancerResult> createLoadBalancerAsync(CreateLoadBalancerRequest createLoadBalancerRequest)
                                                                              throws AmazonServiceException,
                                                                                     AmazonClientException
```
    Creates a new load balancer.
    
    After the call has completed successfully, a new load balancer is created with a unique Domain Name Service (DNS) name. The DNS name includes the name of the AWS region in which the load balance was created. For example, if your load balancer was created in the United States, the DNS name might end with either of the following:
    - us-east-1.elb.amazonaws.com (for the Northern Virginia Region)
    - us-west-1.elb.amazonaws.com (for the Northern California Region)
    For information about the AWS regions supported by Elastic Load Balancing, see Regions and Endpoints .
    
    You can create up to 20 load balancers per region per account.
    
    Elastic Load Balancing supports load balancing your Amazon EC2 instances launched within any one of the following platforms:
    - EC2-Classic
      For information on creating and managing your load balancers in EC2-Classic, see Deploy Elastic Load Balancing in Amazon EC2-Classic .
    - EC2-VPC
      For information on creating and managing your load balancers in EC2-VPC, see Deploy Elastic Load Balancing in Amazon VPC .
    Specified by:
    
    createLoadBalancerAsync in interface AmazonElasticLoadBalancingAsync
    
    Parameters:
    createLoadBalancerRequest - Container for the necessary parameters to execute the CreateLoadBalancer operation on AmazonElasticLoadBalancing.
    
    Returns:
    A Java Future object containing the response from the CreateLoadBalancer service method, as returned by AmazonElasticLoadBalancing.
    
    Throws:
    
    AmazonClientException - If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
    
    AmazonServiceException - If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
  - createLoadBalancerAsync
```
public java.util.concurrent.Future<CreateLoadBalancerResult> createLoadBalancerAsync(CreateLoadBalancerRequest createLoadBalancerRequest,
                                                                            AsyncHandler<CreateLoadBalancerRequest,CreateLoadBalancerResult> asyncHandler)
                                                                              throws AmazonServiceException,
                                                                                     AmazonClientException
```
    Creates a new load balancer.
    
    After the call has completed successfully, a new load balancer is created with a unique Domain Name Service (DNS) name. The DNS name includes the name of the AWS region in which the load balance was created. For example, if your load balancer was created in the United States, the DNS name might end with either of the following:
    - us-east-1.elb.amazonaws.com (for the Northern Virginia Region)
    - us-west-1.elb.amazonaws.com (for the Northern California Region)
    For information about the AWS regions supported by Elastic Load Balancing, see Regions and Endpoints .
    
    You can create up to 20 load balancers per region per account.
    
    Elastic Load Balancing supports load balancing your Amazon EC2 instances launched within any one of the following platforms:
    - EC2-Classic
      For information on creating and managing your load balancers in EC2-Classic, see Deploy Elastic Load Balancing in Amazon EC2-Classic .
    - EC2-VPC
      For information on creating and managing your load balancers in EC2-VPC, see Deploy Elastic Load Balancing in Amazon VPC .
    Specified by:
    
    createLoadBalancerAsync in interface AmazonElasticLoadBalancingAsync
    
    Parameters:
    createLoadBalancerRequest - Container for the necessary parameters to execute the CreateLoadBalancer operation on AmazonElasticLoadBalancing.
    asyncHandler - Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
    
    Returns:
    A Java Future object containing the response from the CreateLoadBalancer service method, as returned by AmazonElasticLoadBalancing.
    
    Throws:
    
    AmazonClientException - If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
    
    AmazonServiceException - If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
  - setLoadBalancerPoliciesForBackendServerAsync
```
public java.util.concurrent.Future<SetLoadBalancerPoliciesForBackendServerResult> setLoadBalancerPoliciesForBackendServerAsync(SetLoadBalancerPoliciesForBackendServerRequest setLoadBalancerPoliciesForBackendServerRequest)
                                                                                                                        throws AmazonServiceException,
                                                                                                                               AmazonClientException
```
    Replaces the current set of policies associated with a port on which the back-end server is listening with a new set of policies. After the policies have been created using CreateLoadBalancerPolicy, they can be applied here as a list. At this time, only the back-end server authentication policy type can be applied to the back-end ports; this policy type is composed of multiple public key policies.
    
    NOTE: The SetLoadBalancerPoliciesForBackendServer replaces the current set of policies associated with the specified instance port. Every time you use this action to enable the policies, use the PolicyNames parameter to list all the policies you want to enable.
    
    You can use DescribeLoadBalancers or DescribeLoadBalancerPolicies action to verify that the policy has been associated with the back-end server.
    
    Specified by:
    
    setLoadBalancerPoliciesForBackendServerAsync in interface AmazonElasticLoadBalancingAsync
    
    Parameters:
    setLoadBalancerPoliciesForBackendServerRequest - Container for the necessary parameters to execute the SetLoadBalancerPoliciesForBackendServer operation on AmazonElasticLoadBalancing.
    
    Returns:
    A Java Future object containing the response from the SetLoadBalancerPoliciesForBackendServer service method, as returned by AmazonElasticLoadBalancing.
    
    Throws:
    
    AmazonClientException - If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
    
    AmazonServiceException - If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
  - setLoadBalancerPoliciesForBackendServerAsync
```
public java.util.concurrent.Future<SetLoadBalancerPoliciesForBackendServerResult> setLoadBalancerPoliciesForBackendServerAsync(SetLoadBalancerPoliciesForBackendServerRequest setLoadBalancerPoliciesForBackendServerRequest,
                                                                                                                      AsyncHandler<SetLoadBalancerPoliciesForBackendServerRequest,SetLoadBalancerPoliciesForBackendServerResult> asyncHandler)
                                                                                                                        throws AmazonServiceException,
                                                                                                                               AmazonClientException
```
    Replaces the current set of policies associated with a port on which the back-end server is listening with a new set of policies. After the policies have been created using CreateLoadBalancerPolicy, they can be applied here as a list. At this time, only the back-end server authentication policy type can be applied to the back-end ports; this policy type is composed of multiple public key policies.
    
    NOTE: The SetLoadBalancerPoliciesForBackendServer replaces the current set of policies associated with the specified instance port. Every time you use this action to enable the policies, use the PolicyNames parameter to list all the policies you want to enable.
    
    You can use DescribeLoadBalancers or DescribeLoadBalancerPolicies action to verify that the policy has been associated with the back-end server.
    
    Specified by:
    
    setLoadBalancerPoliciesForBackendServerAsync in interface AmazonElasticLoadBalancingAsync
    
    Parameters:
    setLoadBalancerPoliciesForBackendServerRequest - Container for the necessary parameters to execute the SetLoadBalancerPoliciesForBackendServer operation on AmazonElasticLoadBalancing.
    asyncHandler - Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
    
    Returns:
    A Java Future object containing the response from the SetLoadBalancerPoliciesForBackendServer service method, as returned by AmazonElasticLoadBalancing.
    
    Throws:
    
    AmazonClientException - If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
    
    AmazonServiceException - If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
  - deregisterInstancesFromLoadBalancerAsync
```
public java.util.concurrent.Future<DeregisterInstancesFromLoadBalancerResult> deregisterInstancesFromLoadBalancerAsync(DeregisterInstancesFromLoadBalancerRequest deregisterInstancesFromLoadBalancerRequest)
                                                                                                                throws AmazonServiceException,
                                                                                                                       AmazonClientException
```
    Deregisters instances from the load balancer. Once the instance is deregistered, it will stop receiving traffic from the load balancer.
    
    In order to successfully call this API, the same account credentials as those used to create the load balancer must be provided.
    
    For more information, see De-register and Register Amazon EC2 Instances in the Elastic Load Balancing Developer Guide .
    
    You can use DescribeLoadBalancers to verify if the instance is deregistered from the load balancer.
    
    Specified by:
    
    deregisterInstancesFromLoadBalancerAsync in interface AmazonElasticLoadBalancingAsync
    
    Parameters:
    deregisterInstancesFromLoadBalancerRequest - Container for the necessary parameters to execute the DeregisterInstancesFromLoadBalancer operation on AmazonElasticLoadBalancing.
    
    Returns:
    A Java Future object containing the response from the DeregisterInstancesFromLoadBalancer service method, as returned by AmazonElasticLoadBalancing.
    
    Throws:
    
    AmazonClientException - If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
    
    AmazonServiceException - If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
  - deregisterInstancesFromLoadBalancerAsync
```
public java.util.concurrent.Future<DeregisterInstancesFromLoadBalancerResult> deregisterInstancesFromLoadBalancerAsync(DeregisterInstancesFromLoadBalancerRequest deregisterInstancesFromLoadBalancerRequest,
                                                                                                              AsyncHandler<DeregisterInstancesFromLoadBalancerRequest,DeregisterInstancesFromLoadBalancerResult> asyncHandler)
                                                                                                                throws AmazonServiceException,
                                                                                                                       AmazonClientException
```
    Deregisters instances from the load balancer. Once the instance is deregistered, it will stop receiving traffic from the load balancer.
    
    In order to successfully call this API, the same account credentials as those used to create the load balancer must be provided.
    
    For more information, see De-register and Register Amazon EC2 Instances in the Elastic Load Balancing Developer Guide .
    
    You can use DescribeLoadBalancers to verify if the instance is deregistered from the load balancer.
    
    Specified by:
    
    deregisterInstancesFromLoadBalancerAsync in interface AmazonElasticLoadBalancingAsync
    
    Parameters:
    deregisterInstancesFromLoadBalancerRequest - Container for the necessary parameters to execute the DeregisterInstancesFromLoadBalancer operation on AmazonElasticLoadBalancing.
    asyncHandler - Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
    
    Returns:
    A Java Future object containing the response from the DeregisterInstancesFromLoadBalancer service method, as returned by AmazonElasticLoadBalancing.
    
    Throws:
    
    AmazonClientException - If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
    
    AmazonServiceException - If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
  - setLoadBalancerListenerSSLCertificateAsync
```
public java.util.concurrent.Future<java.lang.Void> setLoadBalancerListenerSSLCertificateAsync(SetLoadBalancerListenerSSLCertificateRequest setLoadBalancerListenerSSLCertificateRequest)
                                                                                       throws AmazonServiceException,
                                                                                              AmazonClientException
```
    Sets the certificate that terminates the specified listener's SSL connections. The specified certificate replaces any prior certificate that was used on the same load balancer and port.
    
    For more information on updating your SSL certificate, see Updating an SSL Certificate for a Load Balancer in the Elastic Load Balancing Developer Guide .
    
    Specified by:
    
    setLoadBalancerListenerSSLCertificateAsync in interface AmazonElasticLoadBalancingAsync
    
    Parameters:
    setLoadBalancerListenerSSLCertificateRequest - Container for the necessary parameters to execute the SetLoadBalancerListenerSSLCertificate operation on AmazonElasticLoadBalancing.
    
    Returns:
    A Java Future object containing the response from the SetLoadBalancerListenerSSLCertificate service method, as returned by AmazonElasticLoadBalancing.
    
    Throws:
    
    AmazonClientException - If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
    
    AmazonServiceException - If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
  - setLoadBalancerListenerSSLCertificateAsync
```
public java.util.concurrent.Future<java.lang.Void> setLoadBalancerListenerSSLCertificateAsync(SetLoadBalancerListenerSSLCertificateRequest setLoadBalancerListenerSSLCertificateRequest,
                                                                                     AsyncHandler<SetLoadBalancerListenerSSLCertificateRequest,java.lang.Void> asyncHandler)
                                                                                       throws AmazonServiceException,
                                                                                              AmazonClientException
```
    Sets the certificate that terminates the specified listener's SSL connections. The specified certificate replaces any prior certificate that was used on the same load balancer and port.
    
    For more information on updating your SSL certificate, see Updating an SSL Certificate for a Load Balancer in the Elastic Load Balancing Developer Guide .
    
    Specified by:
    
    setLoadBalancerListenerSSLCertificateAsync in interface AmazonElasticLoadBalancingAsync
    
    Parameters:
    setLoadBalancerListenerSSLCertificateRequest - Container for the necessary parameters to execute the SetLoadBalancerListenerSSLCertificate operation on AmazonElasticLoadBalancing.
    asyncHandler - Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
    
    Returns:
    A Java Future object containing the response from the SetLoadBalancerListenerSSLCertificate service method, as returned by AmazonElasticLoadBalancing.
    
    Throws:
    
    AmazonClientException - If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
    
    AmazonServiceException - If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
  - describeLoadBalancerAttributesAsync
```
public java.util.concurrent.Future<DescribeLoadBalancerAttributesResult> describeLoadBalancerAttributesAsync(DescribeLoadBalancerAttributesRequest describeLoadBalancerAttributesRequest)
                                                                                                      throws AmazonServiceException,
                                                                                                             AmazonClientException
```
    Returns detailed information about all of the attributes associated with the specified load balancer.
    
    Specified by:
    
    describeLoadBalancerAttributesAsync in interface AmazonElasticLoadBalancingAsync
    
    Parameters:
    describeLoadBalancerAttributesRequest - Container for the necessary parameters to execute the DescribeLoadBalancerAttributes operation on AmazonElasticLoadBalancing.
    
    Returns:
    A Java Future object containing the response from the DescribeLoadBalancerAttributes service method, as returned by AmazonElasticLoadBalancing.
    
    Throws:
    
    AmazonClientException - If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
    
    AmazonServiceException - If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
  - describeLoadBalancerAttributesAsync
```
public java.util.concurrent.Future<DescribeLoadBalancerAttributesResult> describeLoadBalancerAttributesAsync(DescribeLoadBalancerAttributesRequest describeLoadBalancerAttributesRequest,
                                                                                                    AsyncHandler<DescribeLoadBalancerAttributesRequest,DescribeLoadBalancerAttributesResult> asyncHandler)
                                                                                                      throws AmazonServiceException,
                                                                                                             AmazonClientException
```
    Returns detailed information about all of the attributes associated with the specified load balancer.
    
    Specified by:
    
    describeLoadBalancerAttributesAsync in interface AmazonElasticLoadBalancingAsync
    
    Parameters:
    describeLoadBalancerAttributesRequest - Container for the necessary parameters to execute the DescribeLoadBalancerAttributes operation on AmazonElasticLoadBalancing.
    asyncHandler - Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
    
    Returns:
    A Java Future object containing the response from the DescribeLoadBalancerAttributes service method, as returned by AmazonElasticLoadBalancing.
    
    Throws:
    
    AmazonClientException - If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
    
    AmazonServiceException - If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
  - createLBCookieStickinessPolicyAsync
```
public java.util.concurrent.Future<CreateLBCookieStickinessPolicyResult> createLBCookieStickinessPolicyAsync(CreateLBCookieStickinessPolicyRequest createLBCookieStickinessPolicyRequest)
                                                                                                      throws AmazonServiceException,
                                                                                                             AmazonClientException
```
    Generates a stickiness policy with sticky session lifetimes controlled by the lifetime of the browser (user-agent) or a specified expiration period. This policy can be associated only with HTTP/HTTPS listeners.
    
    When a load balancer implements this policy, the load balancer uses a special cookie to track the backend server instance for each request. When the load balancer receives a request, it first checks to see if this cookie is present in the request. If so, the load balancer sends the request to the application server specified in the cookie. If not, the load balancer sends the request to a server that is chosen based on the existing load balancing algorithm.
    
    A cookie is inserted into the response for binding subsequent requests from the same user to that server. The validity of the cookie is based on the cookie expiration time, which is specified in the policy configuration.
    
    For more information, see Enabling Duration-Based Session Stickiness in the Elastic Load Balancing Developer Guide .
    
    Specified by:
    
    createLBCookieStickinessPolicyAsync in interface AmazonElasticLoadBalancingAsync
    
    Parameters:
    createLBCookieStickinessPolicyRequest - Container for the necessary parameters to execute the CreateLBCookieStickinessPolicy operation on AmazonElasticLoadBalancing.
    
    Returns:
    A Java Future object containing the response from the CreateLBCookieStickinessPolicy service method, as returned by AmazonElasticLoadBalancing.
    
    Throws:
    
    AmazonClientException - If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
    
    AmazonServiceException - If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
  - createLBCookieStickinessPolicyAsync
```
public java.util.concurrent.Future<CreateLBCookieStickinessPolicyResult> createLBCookieStickinessPolicyAsync(CreateLBCookieStickinessPolicyRequest createLBCookieStickinessPolicyRequest,
                                                                                                    AsyncHandler<CreateLBCookieStickinessPolicyRequest,CreateLBCookieStickinessPolicyResult> asyncHandler)
                                                                                                      throws AmazonServiceException,
                                                                                                             AmazonClientException
```
    Generates a stickiness policy with sticky session lifetimes controlled by the lifetime of the browser (user-agent) or a specified expiration period. This policy can be associated only with HTTP/HTTPS listeners.
    
    When a load balancer implements this policy, the load balancer uses a special cookie to track the backend server instance for each request. When the load balancer receives a request, it first checks to see if this cookie is present in the request. If so, the load balancer sends the request to the application server specified in the cookie. If not, the load balancer sends the request to a server that is chosen based on the existing load balancing algorithm.
    
    A cookie is inserted into the response for binding subsequent requests from the same user to that server. The validity of the cookie is based on the cookie expiration time, which is specified in the policy configuration.
    
    For more information, see Enabling Duration-Based Session Stickiness in the Elastic Load Balancing Developer Guide .
    
    Specified by:
    
    createLBCookieStickinessPolicyAsync in interface AmazonElasticLoadBalancingAsync
    
    Parameters:
    createLBCookieStickinessPolicyRequest - Container for the necessary parameters to execute the CreateLBCookieStickinessPolicy operation on AmazonElasticLoadBalancing.
    asyncHandler - Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
    
    Returns:
    A Java Future object containing the response from the CreateLBCookieStickinessPolicy service method, as returned by AmazonElasticLoadBalancing.
    
    Throws:
    
    AmazonClientException - If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
    
    AmazonServiceException - If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
  - attachLoadBalancerToSubnetsAsync
```
public java.util.concurrent.Future<AttachLoadBalancerToSubnetsResult> attachLoadBalancerToSubnetsAsync(AttachLoadBalancerToSubnetsRequest attachLoadBalancerToSubnetsRequest)
                                                                                                throws AmazonServiceException,
                                                                                                       AmazonClientException
```
    Adds one or more subnets to the set of configured subnets in the Amazon Virtual Private Cloud (Amazon VPC) for the load balancer.
    
    The load balancers evenly distribute requests across all of the registered subnets. For more information, see Deploy Elastic Load Balancing in Amazon VPC in the Elastic Load Balancing Developer Guide .
    
    Specified by:
    
    attachLoadBalancerToSubnetsAsync in interface AmazonElasticLoadBalancingAsync
    
    Parameters:
    attachLoadBalancerToSubnetsRequest - Container for the necessary parameters to execute the AttachLoadBalancerToSubnets operation on AmazonElasticLoadBalancing.
    
    Returns:
    A Java Future object containing the response from the AttachLoadBalancerToSubnets service method, as returned by AmazonElasticLoadBalancing.
    
    Throws:
    
    AmazonClientException - If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
    
    AmazonServiceException - If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
  - attachLoadBalancerToSubnetsAsync
```
public java.util.concurrent.Future<AttachLoadBalancerToSubnetsResult> attachLoadBalancerToSubnetsAsync(AttachLoadBalancerToSubnetsRequest attachLoadBalancerToSubnetsRequest,
                                                                                              AsyncHandler<AttachLoadBalancerToSubnetsRequest,AttachLoadBalancerToSubnetsResult> asyncHandler)
                                                                                                throws AmazonServiceException,
                                                                                                       AmazonClientException
```
    Adds one or more subnets to the set of configured subnets in the Amazon Virtual Private Cloud (Amazon VPC) for the load balancer.
    
    The load balancers evenly distribute requests across all of the registered subnets. For more information, see Deploy Elastic Load Balancing in Amazon VPC in the Elastic Load Balancing Developer Guide .
    
    Specified by:
    
    attachLoadBalancerToSubnetsAsync in interface AmazonElasticLoadBalancingAsync
    
    Parameters:
    attachLoadBalancerToSubnetsRequest - Container for the necessary parameters to execute the AttachLoadBalancerToSubnets operation on AmazonElasticLoadBalancing.
    asyncHandler - Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
    
    Returns:
    A Java Future object containing the response from the AttachLoadBalancerToSubnets service method, as returned by AmazonElasticLoadBalancing.
    
    Throws:
    
    AmazonClientException - If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
    
    AmazonServiceException - If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
  - registerInstancesWithLoadBalancerAsync
```
public java.util.concurrent.Future<RegisterInstancesWithLoadBalancerResult> registerInstancesWithLoadBalancerAsync(RegisterInstancesWithLoadBalancerRequest registerInstancesWithLoadBalancerRequest)
                                                                                                            throws AmazonServiceException,
                                                                                                                   AmazonClientException
```
    Adds new instances to the load balancer.
    
    Once the instance is registered, it starts receiving traffic and requests from the load balancer. Any instance that is not in any of the Availability Zones registered for the load balancer will be moved to the OutOfService state. It will move to the InService state when the Availability Zone is added to the load balancer.
    
    When an instance registered with a load balancer is stopped and then restarted, the IP addresses associated with the instance changes. Elastic Load Balancing cannot recognize the new IP address, which prevents it from routing traffic to the instances. We recommend that you de-register your Amazon EC2 instances from your load balancer after you stop your instance, and then register the load balancer with your instance after you've restarted. To de-register your instances from load balancer, use DeregisterInstancesFromLoadBalancer action.
    
    For more information, see De-register and Register Amazon EC2 Instances in the Elastic Load Balancing Developer Guide .
    
    NOTE: In order for this call to be successful, you must provide the same account credentials as those that were used to create the load balancer.
    
    NOTE: Completion of this API does not guarantee that operation has completed. Rather, it means that the request has been registered and the changes will happen shortly.
    
    You can use DescribeLoadBalancers or DescribeInstanceHealth action to check the state of the newly registered instances.
    
    Specified by:
    
    registerInstancesWithLoadBalancerAsync in interface AmazonElasticLoadBalancingAsync
    
    Parameters:
    registerInstancesWithLoadBalancerRequest - Container for the necessary parameters to execute the RegisterInstancesWithLoadBalancer operation on AmazonElasticLoadBalancing.
    
    Returns:
    A Java Future object containing the response from the RegisterInstancesWithLoadBalancer service method, as returned by AmazonElasticLoadBalancing.
    
    Throws:
    
    AmazonClientException - If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
    
    AmazonServiceException - If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
  - registerInstancesWithLoadBalancerAsync
```
public java.util.concurrent.Future<RegisterInstancesWithLoadBalancerResult> registerInstancesWithLoadBalancerAsync(RegisterInstancesWithLoadBalancerRequest registerInstancesWithLoadBalancerRequest,
                                                                                                          AsyncHandler<RegisterInstancesWithLoadBalancerRequest,RegisterInstancesWithLoadBalancerResult> asyncHandler)
                                                                                                            throws AmazonServiceException,
                                                                                                                   AmazonClientException
```
    Adds new instances to the load balancer.
    
    Once the instance is registered, it starts receiving traffic and requests from the load balancer. Any instance that is not in any of the Availability Zones registered for the load balancer will be moved to the OutOfService state. It will move to the InService state when the Availability Zone is added to the load balancer.
    
    When an instance registered with a load balancer is stopped and then restarted, the IP addresses associated with the instance changes. Elastic Load Balancing cannot recognize the new IP address, which prevents it from routing traffic to the instances. We recommend that you de-register your Amazon EC2 instances from your load balancer after you stop your instance, and then register the load balancer with your instance after you've restarted. To de-register your instances from load balancer, use DeregisterInstancesFromLoadBalancer action.
    
    For more information, see De-register and Register Amazon EC2 Instances in the Elastic Load Balancing Developer Guide .
    
    NOTE: In order for this call to be successful, you must provide the same account credentials as those that were used to create the load balancer.
    
    NOTE: Completion of this API does not guarantee that operation has completed. Rather, it means that the request has been registered and the changes will happen shortly.
    
    You can use DescribeLoadBalancers or DescribeInstanceHealth action to check the state of the newly registered instances.
    
    Specified by:
    
    registerInstancesWithLoadBalancerAsync in interface AmazonElasticLoadBalancingAsync
    
    Parameters:
    registerInstancesWithLoadBalancerRequest - Container for the necessary parameters to execute the RegisterInstancesWithLoadBalancer operation on AmazonElasticLoadBalancing.
    asyncHandler - Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
    
    Returns:
    A Java Future object containing the response from the RegisterInstancesWithLoadBalancer service method, as returned by AmazonElasticLoadBalancing.
    
    Throws:
    
    AmazonClientException - If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
    
    AmazonServiceException - If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
  - describeLoadBalancersAsync
```
public java.util.concurrent.Future<DescribeLoadBalancersResult> describeLoadBalancersAsync(DescribeLoadBalancersRequest describeLoadBalancersRequest)
                                                                                    throws AmazonServiceException,
                                                                                           AmazonClientException
```
    Returns detailed configuration information for all the load balancers created for the account. If you specify load balancer names, the action returns configuration information of the specified load balancers.
    
    NOTE: In order to retrieve this information, you must provide the same account credentials that was used to create the load balancer.
    
    Specified by:
    
    describeLoadBalancersAsync in interface AmazonElasticLoadBalancingAsync
    
    Parameters:
    describeLoadBalancersRequest - Container for the necessary parameters to execute the DescribeLoadBalancers operation on AmazonElasticLoadBalancing.
    
    Returns:
    A Java Future object containing the response from the DescribeLoadBalancers service method, as returned by AmazonElasticLoadBalancing.
    
    Throws:
    
    AmazonClientException - If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
    
    AmazonServiceException - If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.
  - describeLoadBalancersAsync
```
public java.util.concurrent.Future<DescribeLoadBalancersResult> describeLoadBalancersAsync(DescribeLoadBalancersRequest describeLoadBalancersRequest,
                                                                                  AsyncHandler<DescribeLoadBalancersRequest,DescribeLoadBalancersResult> asyncHandler)
                                                                                    throws AmazonServiceException,
                                                                                           AmazonClientException
```
    Returns detailed configuration information for all the load balancers created for the account. If you specify load balancer names, the action returns configuration information of the specified load balancers.
    
    NOTE: In order to retrieve this information, you must provide the same account credentials that was used to create the load balancer.
    
    Specified by:
    
    describeLoadBalancersAsync in interface AmazonElasticLoadBalancingAsync
    
    Parameters:
    describeLoadBalancersRequest - Container for the necessary parameters to execute the DescribeLoadBalancers operation on AmazonElasticLoadBalancing.
    asyncHandler - Asynchronous callback handler for events in the life-cycle of the request. Users could provide the implementation of the four callback methods in this interface to process the operation result or handle the exception.
    
    Returns:
    A Java Future object containing the response from the DescribeLoadBalancers service method, as returned by AmazonElasticLoadBalancing.
    
    Throws:
    
    AmazonClientException - If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available.
    
    AmazonServiceException - If an error response is returned by AmazonElasticLoadBalancing indicating either a problem with the data in the request, or a server side issue.

Class AmazonElasticLoadBalancingAsyncClient

Field Summary

Fields inherited from class com.amazonaws.services.elasticloadbalancing.AmazonElasticLoadBalancingClient

Fields inherited from class com.amazonaws.AmazonWebServiceClient

Constructor Summary

Method Summary

Methods inherited from class com.amazonaws.services.elasticloadbalancing.AmazonElasticLoadBalancingClient

Methods inherited from class com.amazonaws.AmazonWebServiceClient

Methods inherited from class java.lang.Object

Methods inherited from interface com.amazonaws.services.elasticloadbalancing.AmazonElasticLoadBalancing

Constructor Detail

AmazonElasticLoadBalancingAsyncClient

AmazonElasticLoadBalancingAsyncClient

AmazonElasticLoadBalancingAsyncClient

AmazonElasticLoadBalancingAsyncClient

AmazonElasticLoadBalancingAsyncClient

AmazonElasticLoadBalancingAsyncClient

AmazonElasticLoadBalancingAsyncClient

AmazonElasticLoadBalancingAsyncClient

AmazonElasticLoadBalancingAsyncClient

Method Detail

getExecutorService

shutdown

describeLoadBalancerPolicyTypesAsync

describeLoadBalancerPolicyTypesAsync

configureHealthCheckAsync

configureHealthCheckAsync

detachLoadBalancerFromSubnetsAsync

detachLoadBalancerFromSubnetsAsync

modifyLoadBalancerAttributesAsync

modifyLoadBalancerAttributesAsync

createLoadBalancerListenersAsync

createLoadBalancerListenersAsync

deleteLoadBalancerListenersAsync

deleteLoadBalancerListenersAsync

createAppCookieStickinessPolicyAsync

createAppCookieStickinessPolicyAsync

applySecurityGroupsToLoadBalancerAsync

applySecurityGroupsToLoadBalancerAsync

describeLoadBalancerPoliciesAsync

describeLoadBalancerPoliciesAsync

setLoadBalancerPoliciesOfListenerAsync

setLoadBalancerPoliciesOfListenerAsync

disableAvailabilityZonesForLoadBalancerAsync

disableAvailabilityZonesForLoadBalancerAsync

describeInstanceHealthAsync

describeInstanceHealthAsync

deleteLoadBalancerPolicyAsync

deleteLoadBalancerPolicyAsync

createLoadBalancerPolicyAsync

createLoadBalancerPolicyAsync

enableAvailabilityZonesForLoadBalancerAsync

enableAvailabilityZonesForLoadBalancerAsync

deleteLoadBalancerAsync

deleteLoadBalancerAsync

createLoadBalancerAsync

createLoadBalancerAsync

setLoadBalancerPoliciesForBackendServerAsync

setLoadBalancerPoliciesForBackendServerAsync

deregisterInstancesFromLoadBalancerAsync

deregisterInstancesFromLoadBalancerAsync

setLoadBalancerListenerSSLCertificateAsync

setLoadBalancerListenerSSLCertificateAsync

describeLoadBalancerAttributesAsync

describeLoadBalancerAttributesAsync

createLBCookieStickinessPolicyAsync

createLBCookieStickinessPolicyAsync

attachLoadBalancerToSubnetsAsync

attachLoadBalancerToSubnetsAsync

registerInstancesWithLoadBalancerAsync

registerInstancesWithLoadBalancerAsync

describeLoadBalancersAsync

describeLoadBalancersAsync