org.redisson.config.BaseConfig Maven / Gradle / Ivy
Show all versions of redisson-all Show documentation
/**
* Copyright (c) 2013-2021 Nikita Koksharov
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.redisson.config;
import org.redisson.api.NameMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.net.URL;
/**
*
* @author Nikita Koksharov
*
* @param config type
*/
public class BaseConfig> {
private static final Logger log = LoggerFactory.getLogger("config");
/**
* If pooled connection not used for a timeout time
* and current connections amount bigger than minimum idle connections pool size,
* then it will closed and removed from pool.
* Value in milliseconds.
*
*/
private int idleConnectionTimeout = 10000;
/**
* Timeout during connecting to any Redis server.
* Value in milliseconds.
*
*/
private int connectTimeout = 10000;
/**
* Redis server response timeout. Starts to countdown when Redis command was succesfully sent.
* Value in milliseconds.
*
*/
private int timeout = 3000;
private int retryAttempts = 3;
private int retryInterval = 1500;
/**
* Password for Redis authentication. Should be null if not needed
*/
private String password;
private String username;
/**
* Subscriptions per Redis connection limit
*/
private int subscriptionsPerConnection = 5;
/**
* Name of client connection
*/
private String clientName;
private boolean sslEnableEndpointIdentification = true;
private SslProvider sslProvider = SslProvider.JDK;
private URL sslTruststore;
private String sslTruststorePassword;
private URL sslKeystore;
private String sslKeystorePassword;
private String[] sslProtocols;
private int pingConnectionInterval = 30000;
private boolean keepAlive;
private boolean tcpNoDelay = true;
private NameMapper nameMapper = NameMapper.direct();
BaseConfig() {
}
BaseConfig(T config) {
setPassword(config.getPassword());
setUsername(config.getUsername());
setSubscriptionsPerConnection(config.getSubscriptionsPerConnection());
setRetryAttempts(config.getRetryAttempts());
setRetryInterval(config.getRetryInterval());
setTimeout(config.getTimeout());
setClientName(config.getClientName());
setConnectTimeout(config.getConnectTimeout());
setIdleConnectionTimeout(config.getIdleConnectionTimeout());
setSslEnableEndpointIdentification(config.isSslEnableEndpointIdentification());
setSslProvider(config.getSslProvider());
setSslTruststore(config.getSslTruststore());
setSslTruststorePassword(config.getSslTruststorePassword());
setSslKeystore(config.getSslKeystore());
setSslKeystorePassword(config.getSslKeystorePassword());
setSslProtocols(config.getSslProtocols());
setPingConnectionInterval(config.getPingConnectionInterval());
setKeepAlive(config.isKeepAlive());
setTcpNoDelay(config.isTcpNoDelay());
setNameMapper(config.getNameMapper());
}
/**
* Subscriptions per Redis connection limit
*
* Default is 5
*
* @param subscriptionsPerConnection amount
* @return config
*/
public T setSubscriptionsPerConnection(int subscriptionsPerConnection) {
this.subscriptionsPerConnection = subscriptionsPerConnection;
return (T) this;
}
public int getSubscriptionsPerConnection() {
return subscriptionsPerConnection;
}
/**
* Password for Redis authentication. Should be null if not needed.
*
* Default is null
*
* @param password for connection
* @return config
*/
public T setPassword(String password) {
this.password = password;
return (T) this;
}
public String getPassword() {
return password;
}
/**
* Username for Redis authentication. Should be null if not needed
*
* Default is null
*
* Requires Redis 6.0+
*
* @param username for connection
* @return config
*/
public T setUsername(String username) {
this.username = username;
return (T) this;
}
public String getUsername() {
return username;
}
/**
* Error will be thrown if Redis command can't be sent to Redis server after retryAttempts.
* But if it sent successfully then timeout will be started.
*
* Default is 3 attempts
*
* @see #timeout
* @param retryAttempts - retry attempts
* @return config
*/
public T setRetryAttempts(int retryAttempts) {
this.retryAttempts = retryAttempts;
return (T) this;
}
public int getRetryAttempts() {
return retryAttempts;
}
/**
* Defines time interval for another one attempt send Redis command
* if it hasn't been sent already.
*
* Default is 1500 milliseconds
*
* @param retryInterval - time in milliseconds
* @return config
*/
public T setRetryInterval(int retryInterval) {
this.retryInterval = retryInterval;
return (T) this;
}
public int getRetryInterval() {
return retryInterval;
}
/**
* Redis server response timeout. Starts to countdown when Redis command has been successfully sent.
*
* Default is 3000 milliseconds
*
* @param timeout in milliseconds
* @return config
*/
public T setTimeout(int timeout) {
this.timeout = timeout;
return (T) this;
}
public int getTimeout() {
return timeout;
}
/**
* Setup connection name during connection init
* via CLIENT SETNAME command
*
* Default is null
*
* @param clientName - name of client
* @return config
*/
public T setClientName(String clientName) {
this.clientName = clientName;
return (T) this;
}
public String getClientName() {
return clientName;
}
/**
* Timeout during connecting to any Redis server.
*
* Default is 10000 milliseconds.
*
* @param connectTimeout - timeout in milliseconds
* @return config
*/
public T setConnectTimeout(int connectTimeout) {
this.connectTimeout = connectTimeout;
return (T) this;
}
public int getConnectTimeout() {
return connectTimeout;
}
/**
* If pooled connection not used for a timeout time
* and current connections amount bigger than minimum idle connections pool size,
* then it will closed and removed from pool.
*
* Default is 10000 milliseconds.
*
* @param idleConnectionTimeout - timeout in milliseconds
* @return config
*/
public T setIdleConnectionTimeout(int idleConnectionTimeout) {
this.idleConnectionTimeout = idleConnectionTimeout;
return (T) this;
}
public int getIdleConnectionTimeout() {
return idleConnectionTimeout;
}
public boolean isSslEnableEndpointIdentification() {
return sslEnableEndpointIdentification;
}
/**
* Enables SSL endpoint identification.
*
* Default is true
*
* @param sslEnableEndpointIdentification - boolean value
* @return config
*/
public T setSslEnableEndpointIdentification(boolean sslEnableEndpointIdentification) {
this.sslEnableEndpointIdentification = sslEnableEndpointIdentification;
return (T) this;
}
public SslProvider getSslProvider() {
return sslProvider;
}
/**
* Defines SSL provider used to handle SSL connections.
*
* Default is JDK
*
* @param sslProvider - ssl provider
* @return config
*/
public T setSslProvider(SslProvider sslProvider) {
this.sslProvider = sslProvider;
return (T) this;
}
public URL getSslTruststore() {
return sslTruststore;
}
/**
* Defines path to SSL truststore
*
* Default is null
*
* @param sslTruststore - path
* @return config
*/
public T setSslTruststore(URL sslTruststore) {
this.sslTruststore = sslTruststore;
return (T) this;
}
public String getSslTruststorePassword() {
return sslTruststorePassword;
}
/**
* Defines password for SSL truststore.
* SSL truststore is read on each new connection creation and can be dynamically reloaded.
*
* Default is null
*
* @param sslTruststorePassword - password
* @return config
*/
public T setSslTruststorePassword(String sslTruststorePassword) {
this.sslTruststorePassword = sslTruststorePassword;
return (T) this;
}
public URL getSslKeystore() {
return sslKeystore;
}
/**
* Defines path to SSL keystore.
* SSL keystore is read on each new connection creation and can be dynamically reloaded.
*
* Default is null
*
* @param sslKeystore - path to keystore
* @return config
*/
public T setSslKeystore(URL sslKeystore) {
this.sslKeystore = sslKeystore;
return (T) this;
}
public String getSslKeystorePassword() {
return sslKeystorePassword;
}
/**
* Defines password for SSL keystore
*
* Default is null
*
* @param sslKeystorePassword - password
* @return config
*/
public T setSslKeystorePassword(String sslKeystorePassword) {
this.sslKeystorePassword = sslKeystorePassword;
return (T) this;
}
public String[] getSslProtocols() {
return sslProtocols;
}
/**
* Defines SSL protocols.
* Example values: TLSv1.3, TLSv1.2, TLSv1.1, TLSv1
*
* Default is null
*
* @param sslProtocols - protocols
* @return config
*/
public T setSslProtocols(String[] sslProtocols) {
this.sslProtocols = sslProtocols;
return (T) this;
}
public int getPingConnectionInterval() {
return pingConnectionInterval;
}
/**
* Defines PING command sending interval per connection to Redis.
* 0 means disable.
*
* Default is 30000
*
* @param pingConnectionInterval - time in milliseconds
* @return config
*/
public T setPingConnectionInterval(int pingConnectionInterval) {
this.pingConnectionInterval = pingConnectionInterval;
return (T) this;
}
public boolean isKeepAlive() {
return keepAlive;
}
/**
* Enables TCP keepAlive for connection
*
* Default is false
*
* @param keepAlive - boolean value
* @return config
*/
public T setKeepAlive(boolean keepAlive) {
this.keepAlive = keepAlive;
return (T) this;
}
public boolean isTcpNoDelay() {
return tcpNoDelay;
}
/**
* Enables TCP noDelay for connection
*
* Default is true
*
* @param tcpNoDelay - boolean value
* @return config
*/
public T setTcpNoDelay(boolean tcpNoDelay) {
this.tcpNoDelay = tcpNoDelay;
return (T) this;
}
public NameMapper getNameMapper() {
return nameMapper;
}
/**
* Defines Name mapper which maps Redisson object name.
* Applied to all Redisson objects.
*
* @param nameMapper - name mapper object
* @return config
*/
public T setNameMapper(NameMapper nameMapper) {
this.nameMapper = nameMapper;
return (T) this;
}
}