java.lang.Object
- org.glassfish.grizzly.connectionpool.SingleEndpointPool.Builder<E>

Type Parameters:

E - endpoint address type, for example SocketAddress for TCP and UDP transports

Direct Known Subclasses:

MultiEndpointPool.EndpointPoolBuilder

Enclosing class:

SingleEndpointPool<E>
```
public static class SingleEndpointPool.Builder<E>
extends Object
```
The Builder class responsible for constructing SingleEndpointPool.

Field Summary

Fields
Modifier and Type	Field	Description
`protected long`	`asyncPollTimeoutMillis`	Async poll timeout, after which, the async connection poll operation will be failed with a timeout exception
`protected long`	`connectionTTLMillis`	the maximum amount of time, a `Connection` could stay registered with the pool Once timeout is hit - the connection will be either closed, if it's idle, or detached from the pool, if it's being used.
`protected org.glassfish.grizzly.ConnectorHandler<E>`	`connectorHandler`	`ConnectorHandler` used to establish new `Connection`s
`protected long`	`connectTimeoutMillis`	Connect timeout, after which, if a connection is not established, it is considered failed
`protected int`	`corePoolSize`	The number of `Connection`s, kept in the pool, that are immune to keep-alive mechanism
`protected org.glassfish.grizzly.utils.DelayedExecutor`	`delayedExecutor`	the `DelayedExecutor` to be used for keep-alive and reconnect mechanisms
`protected Endpoint<E>`	`endpoint`	The endpoint information
`protected E`	`endpointAddress`	Endpoint address
`protected boolean`	`failFastWhenMaxSizeReached`	if true, the "take" method will fail fast if there is no free connection in the pool and max pool size is reached.
`protected long`	`keepAliveCheckIntervalMillis`	the interval, which specifies how often the pool will perform idle `Connection`s check
`protected long`	`keepAliveTimeoutMillis`	the maximum number of milliseconds an idle `Connection` will be kept in the pool.
`protected E`	`localEndpointAddress`	Local bind address.
`protected int`	`maxPoolSize`	The max number of `Connection`s kept by this pool
`protected int`	`maxReconnectAttempts`	Maximum number of attempts that will be made to reconnect before notification of failure occurs.
`protected long`	`reconnectDelayMillis`	the delay to be used before the pool will repeat the attempt to connect to the endpoint after previous connect had failed

Constructor Summary

Constructors
Modifier	Constructor	Description
`protected`	`Builder()`
`protected`	`Builder(Endpoint<E> endpoint, org.glassfish.grizzly.ConnectorHandler<E> connectorHandler, E endpointAddress, E localEndpointAddress, int corePoolSize, int maxPoolSize, org.glassfish.grizzly.utils.DelayedExecutor delayedExecutor, long connectTimeoutMillis, long reconnectDelayMillis, int maxReconnectAttempts, long asyncPollTimeoutMillis, long connectionTTLMillis, boolean failFastWhenMaxSizeReached, long keepAliveTimeoutMillis, long keepAliveCheckIntervalMillis)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`SingleEndpointPool.Builder<E>`	`asyncPollTimeout(long asyncPollTimeout, TimeUnit timeunit)`	Sets the max time consumer will wait for a `Connection` to become available.
`SingleEndpointPool<E>`	`build()`	Constructs `SingleEndpointPool`.
`protected SingleEndpointPool<E>`	`build0(Endpoint<E> e)`
`SingleEndpointPool.Builder<E>`	`connectionTTL(long connectionTTL, TimeUnit timeunit)`	Sets the max amount of time a `Connection` could be associated with the pool.
`SingleEndpointPool.Builder<E>`	`connectorHandler(org.glassfish.grizzly.ConnectorHandler<E> connectorHandler)`	Sets the `ConnectorHandler` used to establish new `Connection`s.
`SingleEndpointPool.Builder<E>`	`connectTimeout(long connectTimeout, TimeUnit timeunit)`	Sets the max time `Connection` connect operation may take.
`SingleEndpointPool.Builder<E>`	`corePoolSize(int corePoolSize)`	Sets the number of `Connection`s, kept in the pool, that are immune to keep-alive mechanism.
`SingleEndpointPool.Builder<E>`	`delayExecutor(org.glassfish.grizzly.utils.DelayedExecutor delayedExecutor)`	Sets the custom `DelayedExecutor` to be used for keep-alive and reconnect mechanisms.
`SingleEndpointPool.Builder<E>`	`endpoint(Endpoint<E> endpoint)`	Sets the endpoint information.
`SingleEndpointPool.Builder<E>`	`endpointAddress(E endpointAddress)`	Sets the endpoint address.
`SingleEndpointPool.Builder<E>`	`failFastWhenMaxSizeReached(boolean failFastWhenMaxSizeReached)`	if `true`, the "take" method will fail fast if there is no free connection in the pool and max pool size is reached.
`SingleEndpointPool.Builder<E>`	`keepAliveCheckInterval(long keepAliveCheckInterval, TimeUnit timeunit)`	Sets the interval, which specifies how often the pool will perform idle `Connection`s check.
`SingleEndpointPool.Builder<E>`	`keepAliveTimeout(long keepAliveTimeout, TimeUnit timeunit)`	Sets the maximum number of milliseconds an idle `Connection` will be kept in the pool.
`SingleEndpointPool.Builder<E>`	`localEndpointAddress(E localEndpointAddress)`	Sets the local endpoint address.
`SingleEndpointPool.Builder<E>`	`maxPoolSize(int maxPoolSize)`	Sets the max number of `Connection`s kept by this pool.
`SingleEndpointPool.Builder<E>`	`maxReconnectAttempts(int maxReconnectAttempts)`	If the reconnect mechanism is enabled, then this property will affect how many times a reconnection attempt can be made consecutively before a failure is flagged.
`SingleEndpointPool.Builder<E>`	`reconnectDelay(long reconnectDelay, TimeUnit timeunit)`	Sets the delay to be used before the pool will repeat the attempt to connect to the endpoint after previous connect operation had failed.

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

- Field Detail
  - endpoint
```
protected Endpoint<E> endpoint
```
    The endpoint information
  - connectorHandler
```
protected org.glassfish.grizzly.ConnectorHandler<E> connectorHandler
```
    ConnectorHandler used to establish new Connections
  - endpointAddress
```
protected E endpointAddress
```
    Endpoint address
  - localEndpointAddress
```
protected E localEndpointAddress
```
    Local bind address.
  - corePoolSize
```
protected int corePoolSize
```
    The number of Connections, kept in the pool, that are immune to keep-alive mechanism
  - maxPoolSize
```
protected int maxPoolSize
```
    The max number of Connections kept by this pool
  - delayedExecutor
```
protected org.glassfish.grizzly.utils.DelayedExecutor delayedExecutor
```
    the DelayedExecutor to be used for keep-alive and reconnect mechanisms
  - connectTimeoutMillis
```
protected long connectTimeoutMillis
```
    Connect timeout, after which, if a connection is not established, it is considered failed
  - reconnectDelayMillis
```
protected long reconnectDelayMillis
```
    the delay to be used before the pool will repeat the attempt to connect to the endpoint after previous connect had failed
  - maxReconnectAttempts
```
protected int maxReconnectAttempts
```
    Maximum number of attempts that will be made to reconnect before notification of failure occurs.
  - asyncPollTimeoutMillis
```
protected long asyncPollTimeoutMillis
```
    Async poll timeout, after which, the async connection poll operation will be failed with a timeout exception
  - connectionTTLMillis
```
protected long connectionTTLMillis
```
    the maximum amount of time, a Connection could stay registered with the pool Once timeout is hit - the connection will be either closed, if it's idle, or detached from the pool, if it's being used.
  - failFastWhenMaxSizeReached
```
protected boolean failFastWhenMaxSizeReached
```
    if true, the "take" method will fail fast if there is no free connection in the pool and max pool size is reached.
  - keepAliveTimeoutMillis
```
protected long keepAliveTimeoutMillis
```
    the maximum number of milliseconds an idle Connection will be kept in the pool. The idle Connections will be closed till the pool size is greater than corePoolSize
  - keepAliveCheckIntervalMillis
```
protected long keepAliveCheckIntervalMillis
```
    the interval, which specifies how often the pool will perform idle Connections check
- Constructor Detail
  - Builder
```
protected Builder()
```
  - Builder
```
protected Builder(Endpoint<E> endpoint,
                  org.glassfish.grizzly.ConnectorHandler<E> connectorHandler,
                  E endpointAddress,
                  E localEndpointAddress,
                  int corePoolSize,
                  int maxPoolSize,
                  org.glassfish.grizzly.utils.DelayedExecutor delayedExecutor,
                  long connectTimeoutMillis,
                  long reconnectDelayMillis,
                  int maxReconnectAttempts,
                  long asyncPollTimeoutMillis,
                  long connectionTTLMillis,
                  boolean failFastWhenMaxSizeReached,
                  long keepAliveTimeoutMillis,
                  long keepAliveCheckIntervalMillis)
```
- Method Detail
  - connectorHandler
```
public SingleEndpointPool.Builder<E> connectorHandler(org.glassfish.grizzly.ConnectorHandler<E> connectorHandler)
```
    Sets the ConnectorHandler used to establish new Connections.
    
    Parameters:
    
    connectorHandler - ConnectorHandler
    
    Returns:
    
    this SingleEndpointPool.Builder
  - endpointAddress
```
public SingleEndpointPool.Builder<E> endpointAddress(E endpointAddress)
```
    Sets the endpoint address.
    
    Parameters:
    
    endpointAddress -
    
    Returns:
    
    this SingleEndpointPool.Builder
  - localEndpointAddress
```
public SingleEndpointPool.Builder<E> localEndpointAddress(E localEndpointAddress)
```
    Sets the local endpoint address.
    
    Parameters:
    
    localEndpointAddress -
    
    Returns:
    
    this SingleEndpointPool.Builder
  - endpoint
```
public SingleEndpointPool.Builder<E> endpoint(Endpoint<E> endpoint)
```
    Sets the endpoint information. If set, this setting precedes the connectorHandler(org.glassfish.grizzly.ConnectorHandler), endpointAddress(java.lang.Object) and localEndpointAddress(java.lang.Object) values, if they were or will be set.
    
    Parameters:
    
    endpoint - Endpoint
    
    Returns:
    
    this SingleEndpointPool.Builder
  - corePoolSize
```
public SingleEndpointPool.Builder<E> corePoolSize(int corePoolSize)
```
    Sets the number of Connections, kept in the pool, that are immune to keep-alive mechanism. Default value is 0.
    
    Parameters:
    
    corePoolSize -
    
    Returns:
    
    this SingleEndpointPool.Builder
  - maxPoolSize
```
public SingleEndpointPool.Builder<E> maxPoolSize(int maxPoolSize)
```
    Sets the max number of Connections kept by this pool. Default value is 4.
    
    Parameters:
    
    maxPoolSize -
    
    Returns:
    
    this SingleEndpointPool.Builder
  - delayExecutor
```
public SingleEndpointPool.Builder<E> delayExecutor(org.glassfish.grizzly.utils.DelayedExecutor delayedExecutor)
```
    Sets the custom DelayedExecutor to be used for keep-alive and reconnect mechanisms. If none is set - the SingleEndpointPool will create its own DelayedExecutor.
    
    Parameters:
    
    delayedExecutor -
    
    Returns:
    
    this SingleEndpointPool.Builder
  - connectTimeout
```
public SingleEndpointPool.Builder<E> connectTimeout(long connectTimeout,
                                                    TimeUnit timeunit)
```
    Sets the max time Connection connect operation may take. If timeout expires - the connect operation is considered failed. If connectTimeout < 0 - the connect timeout mechanism will be disabled. By default the connect timeout mechanism is disabled.
    
    Parameters:
    
    connectTimeout - the max time Connection connect operation may take. If timeout expires - the connect operation is considered failed. The negative value disables the connect timeout mechanism.
    
    timeunit - a TimeUnit determining how to interpret the timeout parameter
    
    Returns:
    
    this SingleEndpointPool.Builder
  - reconnectDelay
```
public SingleEndpointPool.Builder<E> reconnectDelay(long reconnectDelay,
                                                    TimeUnit timeunit)
```
    Sets the delay to be used before the pool will repeat the attempt to connect to the endpoint after previous connect operation had failed. If reconnectDelay < 0 - the reconnect mechanism will be disabled. By default the reconnect mechanism is disabled.
    
    Parameters:
    
    reconnectDelay - the delay to be used before the pool will repeat the attempt to connect to the endpoint after previous connect operation had failed. The negative value disables the reconnect mechanism.
    
    timeunit - a TimeUnit determining how to interpret the timeout parameter
    
    Returns:
    
    this SingleEndpointPool.Builder
  - maxReconnectAttempts
```
public SingleEndpointPool.Builder<E> maxReconnectAttempts(int maxReconnectAttempts)
```
    If the reconnect mechanism is enabled, then this property will affect how many times a reconnection attempt can be made consecutively before a failure is flagged.
    
    Parameters:
    
    maxReconnectAttempts - the maximum number of reconnect attempts. If the reconnect mechanism isn't enabled, this property is ignored.
    
    Returns:
    
    this SingleEndpointPool.Builder
  - asyncPollTimeout
```
public SingleEndpointPool.Builder<E> asyncPollTimeout(long asyncPollTimeout,
                                                      TimeUnit timeunit)
```
    Sets the max time consumer will wait for a Connection to become available. When timeout expires the consumer will be notified about the failure (TimeoutException) via CompletionHandler or Future. If asyncPollTimeout < 0 - timeout will not be set. By default the timeout is not set and consumer may wait forever for a Connection.
    
    Parameters:
    
    asyncPollTimeout - the maximum time, the async poll operation could wait for a connection to become available
    
    timeunit - a TimeUnit determining how to interpret the timeout parameter
    
    Returns:
    
    this SingleEndpointPool.Builder
  - connectionTTL
```
public SingleEndpointPool.Builder<E> connectionTTL(long connectionTTL,
                                                   TimeUnit timeunit)
```
    Sets the max amount of time a Connection could be associated with the pool. Once timeout expired the Connection will be either closed, if it's idle, or detached from the pool, if it's being used. If connectionTTL < 0 - the Connection time to live will not be set and the Connection can be associated with a pool forever, if no other limit is hit (like keep-alive). By default the connectionTTL is not set.
    
    Parameters:
    
    connectionTTL - the max amount of time a Connection could be associated with the pool
    
    timeunit - a TimeUnit determining how to interpret the connectionTTL parameter
    
    Returns:
    
    this SingleEndpointPool.Builder
  - failFastWhenMaxSizeReached
```
public SingleEndpointPool.Builder<E> failFastWhenMaxSizeReached(boolean failFastWhenMaxSizeReached)
```
    if true, the "take" method will fail fast if there is no free connection in the pool and max pool size is reached. Otherwise the pool will queue up the take request and wait for a Connection to become available
    
    Parameters:
    
    failFastWhenMaxSizeReached -
    
    Returns:
    
    this SingleEndpointPool.Builder
  - keepAliveTimeout
```
public SingleEndpointPool.Builder<E> keepAliveTimeout(long keepAliveTimeout,
                                                      TimeUnit timeunit)
```
    Sets the maximum number of milliseconds an idle Connection will be kept in the pool. The idle Connections will be closed till the pool size is greater than corePoolSize. If keepAliveTimeout < 0 - the keep-alive mechanism will be disabled. By default the keep-alive timeout is set to 30 seconds.
    
    Parameters:
    
    keepAliveTimeout - the maximum number of milliseconds an idle Connection will be kept in the pool. The negative value disables the keep-alive mechanism.
    
    timeunit - a TimeUnit determining how to interpret the timeout parameter
    
    Returns:
    
    this SingleEndpointPool.Builder
  - keepAliveCheckInterval
```
public SingleEndpointPool.Builder<E> keepAliveCheckInterval(long keepAliveCheckInterval,
                                                            TimeUnit timeunit)
```
    Sets the interval, which specifies how often the pool will perform idle Connections check.
    
    Parameters:
    
    keepAliveCheckInterval - the interval, which specifies how often the pool will perform idle Connections check
    
    timeunit - a TimeUnit determining how to interpret the timeout parameter
    
    Returns:
    
    this SingleEndpointPool.Builder
  - build
```
public SingleEndpointPool<E> build()
```
    Constructs SingleEndpointPool.
    
    Returns:
    
    SingleEndpointPool
  - build0
```
protected SingleEndpointPool<E> build0(Endpoint<E> e)
```

Class SingleEndpointPool.Builder<E>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

endpoint

connectorHandler

endpointAddress

localEndpointAddress

corePoolSize

maxPoolSize

delayedExecutor

connectTimeoutMillis

reconnectDelayMillis

maxReconnectAttempts

asyncPollTimeoutMillis

connectionTTLMillis

failFastWhenMaxSizeReached

keepAliveTimeoutMillis

keepAliveCheckIntervalMillis

Constructor Detail

Builder

Builder

Method Detail

connectorHandler

endpointAddress

localEndpointAddress

endpoint

corePoolSize

maxPoolSize

delayExecutor

connectTimeout

reconnectDelay

maxReconnectAttempts

asyncPollTimeout

connectionTTL

failFastWhenMaxSizeReached

keepAliveTimeout

keepAliveCheckInterval

build

build0