Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.infinispan.client.hotrod.configuration;
  
  
ConnectionPoolConfigurationBuilder. Specified connection pooling properties for the HotRod client

Author(s):
Tristan Tarrant
Since:
5.3
 
    private boolean lifo = true;
    private int maxActive = -1;
    private int maxTotal = -1;
    private long maxWait = -1;
    private int maxIdle = -1;
    private int minIdle = 1;
    private long timeBetweenEvictionRuns = 120000;
    private long minEvictableIdleTime = 1800000;
    private int numTestsPerEvictionRun = 3;
    private boolean testOnBorrow = false;
    private boolean testOnReturn = false;
    private boolean testWhileIdle = true;
 
       super(builder);
    }

   
Specifies what happens when asking for a connection from a server's pool, and that pool is exhausted.
 
       this. = exhaustedAction;
       return this;
    }

   
Sets the LIFO status. True means that borrowObject returns the most recently used ("last in") idle object in a pool (if there are idle instances available). False means that pools behave as FIFO queues - objects are taken from idle object pools in the order that they are returned. The default setting is true
 
    public ConnectionPoolConfigurationBuilder lifo(boolean enabled) {
       this. = enabled;
       return this;
    }

   
Controls the maximum number of connections per server that are allocated (checked out to client threads, or idle in the pool) at one time. When non-positive, there is no limit to the number of connections per server. When maxActive is reached, the connection pool for that server is said to be exhausted. The default setting for this parameter is -1, i.e. there is no limit.
 
    public ConnectionPoolConfigurationBuilder maxActive(int maxActive) {
       this. = maxActive;
       return this;
    }

   
Sets a global limit on the number persistent connections that can be in circulation within the combined set of servers. When non-positive, there is no limit to the total number of persistent connections in circulation. When maxTotal is exceeded, all connections pools are exhausted. The default setting for this parameter is -1 (no limit).
 
    public ConnectionPoolConfigurationBuilder maxTotal(int maxTotal) {
       this. = maxTotal;
       return this;
    }

   
The amount of time in milliseconds to wait for a connection to become available when the exhausted action is ExhaustedAction.WAIT, after which a java.util.NoSuchElementException will be thrown. If a negative value is supplied, the pool will block indefinitely.
 
    public ConnectionPoolConfigurationBuilder maxWait(long maxWait) {
       this. = maxWait;
       return this;
    }

   
Controls the maximum number of idle persistent connections, per server, at any time. When negative, there is no limit to the number of connections that may be idle per server. The default setting for this parameter is -1.
 
    public ConnectionPoolConfigurationBuilder maxIdle(int maxIdle) {
       this. = maxIdle;
       return this;
    }

   
Sets a target value for the minimum number of idle connections (per server) that should always be available. If this parameter is set to a positive number and timeBetweenEvictionRunsMillis > 0, each time the idle connection eviction thread runs, it will try to create enough idle instances so that there will be minIdle idle instances available for each server. The default setting for this parameter is 1.
   public ConnectionPoolConfigurationBuilder minIdle(int minIdle) {
      this. = minIdle;
      return this;
   }

   
Indicates the maximum number of connections to test during idle eviction runs. The default setting is 3.
   public ConnectionPoolConfigurationBuilder numTestsPerEvictionRun(int numTestsPerEvictionRun) {
      this. = numTestsPerEvictionRun;
      return this;
   }

   
Indicates how long the eviction thread should sleep before "runs" of examining idle connections. When non-positive, no eviction thread will be launched. The default setting for this parameter is 2 minutes.
   public ConnectionPoolConfigurationBuilder timeBetweenEvictionRuns(long timeBetweenEvictionRuns) {
      this. = timeBetweenEvictionRuns;
      return this;
   }

   
Specifies the minimum amount of time that an connection may sit idle in the pool before it is eligible for eviction due to idle time. When non-positive, no connection will be dropped from the pool due to idle time alone. This setting has no effect unless timeBetweenEvictionRunsMillis > 0. The default setting for this parameter is 1800000(30 minutes).
   public ConnectionPoolConfigurationBuilder minEvictableIdleTime(long minEvictableIdleTime) {
      this. = minEvictableIdleTime;
      return this;
   }

   
Indicates whether connections should be validated before being taken from the pool by sending an TCP packet to the server. Connections that fail to validate will be dropped from the pool. The default setting for this parameter is false.
   public ConnectionPoolConfigurationBuilder testOnBorrow(boolean testOnBorrow) {
      this. = testOnBorrow;
      return this;
   }

   
Indicates whether connections should be validated when being returned to the pool sending an TCP packet to the server. Connections that fail to validate will be dropped from the pool. The default setting for this parameter is false.
   public ConnectionPoolConfigurationBuilder testOnReturn(boolean testOnReturn) {
      this. = testOnReturn;
      return this;
   }

   
Indicates whether or not idle connections should be validated by sending an TCP packet to the server, during idle connection eviction runs. Connections that fail to validate will be dropped from the pool. This setting has no effect unless timeBetweenEvictionRunsMillis > 0. The default setting for this parameter is true.
   public ConnectionPoolConfigurationBuilder testWhileIdle(boolean testWhileIdle) {
      this. = testWhileIdle;
      return this;
   }

   
Configures the connection pool parameter according to properties
      TypedProperties typed = TypedProperties.toTypedProperties(properties);
      exhaustedAction(ExhaustedAction.values()[typed.getIntProperty("whenExhaustedAction".ordinal())]);
      lifo(typed.getBooleanProperty("lifo"));
      maxActive(typed.getIntProperty("maxActive"));
      maxTotal(typed.getIntProperty("maxTotal"));
      maxWait(typed.getLongProperty("maxWait"));
      maxIdle(typed.getIntProperty("maxIdle"));
      minIdle(typed.getIntProperty("minIdle"));
      numTestsPerEvictionRun(typed.getIntProperty("numTestsPerEvictionRun"));
      timeBetweenEvictionRuns(typed.getLongProperty("timeBetweenEvictionRunsMillis"));
      minEvictableIdleTime(typed.getLongProperty("minEvictableIdleTimeMillis"));
      testOnBorrow(typed.getBooleanProperty("testOnBorrow"));
      testOnReturn(typed.getBooleanProperty("testOnReturn"));
      testWhileIdle(typed.getBooleanProperty("testWhileIdle"));
      return this;
   }
   public void validate() {
   }
   }
       = template.exhaustedAction();
       = template.lifo();
       = template.maxActive();
       = template.maxTotal();
       = template.maxWait();
       = template.maxIdle();
       = template.minIdle();
       = template.minEvictableIdleTime();
       = template.testOnBorrow();
       = template.testOnReturn();
       = template.testWhileIdle();
      return this;
   }
New to GrepCode? Check out our FAQ X