Come connettersi a Redis usando Jedis
Come connettersi a Redis usando Jedis in un’applicazione Spring Boot? Scopriamolo insieme con il tutorial di Luigi Fùgaro, detto Foo!
Lo so, l’argomento può sembrare di una banalità disarmante. Eppure, c’è ancora molta confusione su come connettersi correttamente a Redis, soprattutto quando entrano in gioco aspetti come l’alta affidabilità, la scalabilità e il passaggio dalla versione open-source a quella commerciale, la cosiddetta Enterprise.
Chiedo venia a chi ha già le idee chiare, ma sentivo che questo articolo fosse necessario.
Entriamo nel vivo della questione. In questo primo capitolo affronterò il tema utilizzando Jedis, una libreria di basso livello, e mostrerò come integrarla in un’applicazione Spring Boot attraverso del codice di esempio. Esistono anche altre opzioni, come Lettuce e Spring Data Redis, che tratterò nei prossimi capitoli.
Avvertenza
Questo articolo non è una guida completa su Redis, Jedis, Spring Boot o Java. Il suo obiettivo è mostrare, attraverso esempi pratici, come connettersi a Redis utilizzando Jedis all’interno di un’applicazione Spring Boot.
E ricordate sempre: se funziona sul tuo computer, non è detto che funzionerà anche in produzione. 🔥
Introduzione
A seconda di come viene distribuito, Redis può essere eseguito in diverse configurazioni: come istanza singola, come istanza singola con repliche di sola lettura, oppure come cluster composto da più nodi e relative repliche.
Nel caso di Redis Software o Redis Cloud, in genere ci si connette a un endpoint specifico che rappresenta il proprio database Redis — indipendentemente dal fatto che si tratti di una singola istanza, di più istanze o di istanze con repliche.
Prerequisiti
- Git
- Java 17 o superiore
- Maven 3 o superiore
- Docker 4 o superiore
- Redis Server (per le modalità istanza singola, sentinel e cluster)
- Redis Software e Redis Cloud (per la modalità enterprise)
Istanza Singola
La forma più semplice di Redis è un singolo processo redis-server che esegue un’istanza di Redis.
Per connettere la tua applicazione, è sufficiente conoscere l’host e la porta su cui è in esecuzione il server Redis e, se l’autenticazione è abilitata, fornire anche le credenziali richieste.
# Redis Configuration
redis.host=localhost
redis.port=6379
redis.username=
redis.password=your-password
Ecco una semplice classe di configurazione Spring (@Configuration) che inizializza un bean Jedis utilizzando host, porta e, se necessari, le credenziali di accesso:
@Configuration
public class JedisConfiguration {
@Value("${redis.host}")
protected String host;
@Value("${redis.port}")
protected int port;
@Value("${redis.username}")
protected String username;
@Value("${redis.password}")
protected String password;
@Bean
public Jedis jedis() {
Jedis jedis = new Jedis(host, port);
if (!ObjectUtils.isEmpty(username) && ObjectUtils.isEmpty(password)) {
jedis.auth(username);
}
if (!ObjectUtils.isEmpty(password)) {
jedis.auth(password);
}
return jedis;
}
}
Una volta che il bean Jedis è stato inizializzato, può essere iniettato negli altri componenti della tua applicazione Spring per inviare comandi a Redis.
Ad esempio:
@Service
public class JedisService {
private final Jedis jedis;
public JedisService(Jedis jedis) {
this.jedis = jedis;
}
public String set(TextData textData) {
return jedis.set(textData.key(), textData.value());
}
public TextData get(String key) {
return new TextData(key, jedis.get(key));
}
}
Connection Pool
L’utilizzo di un pool di connessioni migliora le performance e consente una gestione più efficiente delle connessioni Redis:
Maggiore performance grazie al riutilizzo delle connessioni.
Gestione sicura delle risorse tramite try-with-resources.
Ecco come puoi aggiornare la configurazione per usare JedisPool invece di una singola istanza Jedis:
# Redis Configuration
redis.host=localhost
redis.port=6379
redis.username=
redis.password=your-password
# Redis Pool Configuration
redis.pool.max-total=8
redis.pool.max-idle=8
redis.pool.min-idle=0
redis.pool.connection-timeout=2000
redis.pool.max-wait=3000
redis.pool.test-on-borrow=true
redis.pool.test-on-return=true
redis.pool.test-while-idle=true
Ecco come puoi aggiornare la configurazione Spring per usare JedisPool invece di una singola istanza Jedis:
@Configuration
public class JedisPoolConfiguration {
@Value("${redis.host}")
protected String host;
@Value("${redis.port}")
protected int port;
@Value("${redis.username}")
protected String username;
@Value("${redis.password}")
protected String password;
@Value("${redis.pool.max-total}")
protected int maxTotal;
@Value("${redis.pool.max-idle}")
protected int maxIdle;
@Value("${redis.pool.min-idle}")
protected int minIdle;
@Value("${redis.pool.connection-timeout}")
protected int connectionTimeout;
@Value("${redis.pool.max-wait}")
protected int maxWait;
@Value("${redis.pool.test-on-borrow}")
protected boolean testOnBorrow;
@Value("${redis.pool.test-on-return}")
protected boolean testOnReturn;
@Value("${redis.pool.test-while-idle}")
protected boolean testWhileIdle;
@Value("${redis.pool.time-between-eviction-runs}")
protected long timeBetweenEvictionRuns;
@Value("${redis.pool.min-evictable-idle-time}")
protected long minEvictableIdleTime;
@Value("${redis.pool.num-tests-per-eviction-run}")
protected int numTestsPerEvictionRun;
@Value("${redis.pool.block-when-exhausted}")
protected boolean blockWhenExhausted;
@Value("${redis.pool.lifo}")
protected boolean lifo;
@Value("${redis.pool.fairness}")
protected boolean fairness;
@Value("${redis.pool.jmx-enabled}")
protected boolean jmxEnabled;
@Bean
public JedisPool jedisPool() {
if (!ObjectUtils.isEmpty(username) && !ObjectUtils.isEmpty(password)) {
return new JedisPool(getPoolConfig(), host, port, connectionTimeout, username, password);
} else if (!ObjectUtils.isEmpty(password)) {
return new JedisPool(getPoolConfig(), host, port, connectionTimeout, password);
} else {
return new JedisPool(getPoolConfig(), host, port, connectionTimeout);
}
}
protected JedisPoolConfig getPoolConfig() {
JedisPoolConfig poolConfig = new JedisPoolConfig();
// Pool size configuration
poolConfig.setMaxTotal(maxTotal);
poolConfig.setMaxIdle(maxIdle);
poolConfig.setMinIdle(minIdle);
// Connection test configuration
poolConfig.setTestOnBorrow(testOnBorrow);
poolConfig.setTestOnReturn(testOnReturn);
poolConfig.setTestWhileIdle(testWhileIdle);
poolConfig.setTimeBetweenEvictionRuns(Duration.ofMillis(timeBetweenEvictionRuns));
poolConfig.setMinEvictableIdleDuration(Duration.ofMillis(minEvictableIdleTime));
poolConfig.setNumTestsPerEvictionRun(numTestsPerEvictionRun);
// Pool behavior configuration
poolConfig.setBlockWhenExhausted(blockWhenExhausted);
poolConfig.setMaxWait(Duration.ofMillis(maxWait));
poolConfig.setLifo(lifo);
poolConfig.setFairness(fairness);
poolConfig.setJmxEnabled(jmxEnabled);
return poolConfig;
}
}
Una volta inizializzato il bean JedisPool, può essere iniettato negli altri componenti della tua applicazione Spring per inviare comandi a Redis.
Utilizzando try-with-resources, garantisci una gestione sicura ed efficiente delle connessioni Redis.
Ad esempio:
@Service
public class JedisPoolService {
private final JedisPool pool;
public JedisPoolService(JedisPool pool) {
this.pool = pool;
}
public String set(TextData textData) {
try (Jedis jedis = pool.getResource()) {
return jedis.set(textData.key(), textData.value());
}
}
public TextData get(String key) {
try (Jedis jedis = pool.getResource()) {
return new TextData(key, jedis.get(key));
}
}
}
Redis Sentinel
Redis Sentinel fornisce alta disponibilità per Redis monitorando le istanze, rilevando eventuali guasti e gestendo il failover quando un server primario va offline.
Garantisce che la tua applicazione possa continuare a funzionare con il minimo impatto, eleggendo una replica come nuovo primario e reindirizzando le connessioni di conseguenza.
Per funzionare correttamente, Redis Sentinel richiede una configurazione aggiuntiva. È necessario definire come il nodo primario e le sue repliche comunicano tra loro, oltre a specificare le condizioni in cui deve avvenire il failover automatico.
I parametri di configurazione più comuni includono:
- Il nome del gruppo del master monitorato
- L’indirizzo e la porta del nodo primario
- Il numero di istanze Sentinel che devono concordare prima di avviare il failover
- Timeout e soglie utilizzate per rilevare eventuali guasti
Queste impostazioni consentono a Sentinel di monitorare le istanze Redis ed eleggere una replica a primario quando necessario.
port 26379
sentinel resolve-hostnames yes
sentinel announce-hostnames yes
dir /tmp
sentinel monitor mymaster 172.32.0.10 6379 2
sentinel auth-pass mymaster luigi
sentinel down-after-milliseconds mymaster 5000
sentinel failover-timeout mymaster 10000
sentinel parallel-syncs mymaster 1
Ecco come puoi aggiornare la configurazione per utilizzare Redis Sentinel insieme a JedisPool:
# Redis Sentinel Configuration
redis.sentinel.master=mymaster
redis.sentinel.nodes=localhost:26379,localhost:26380,localhost:26381
redis.password=your-password
Ecco come puoi aggiornare la configurazione Spring per utilizzare JedisSentinelPool al posto di JedisPool:
@Configuration
public class JedisSentinelConfiguration {
@Value("${redis.username}")
protected String username;
@Value("${redis.password}")
protected String password;
@Value("${redis.pool.max-total}")
protected int maxTotal;
@Value("${redis.pool.max-idle}")
protected int maxIdle;
@Value("${redis.pool.min-idle}")
protected int minIdle;
@Value("${redis.pool.connection-timeout}")
protected int connectionTimeout;
@Value("${redis.pool.max-wait}")
protected int maxWait;
@Value("${redis.pool.test-on-borrow}")
protected boolean testOnBorrow;
@Value("${redis.pool.test-on-return}")
protected boolean testOnReturn;
@Value("${redis.pool.test-while-idle}")
protected boolean testWhileIdle;
@Value("${redis.pool.time-between-eviction-runs}")
protected long timeBetweenEvictionRuns;
@Value("${redis.pool.min-evictable-idle-time}")
protected long minEvictableIdleTime;
@Value("${redis.pool.num-tests-per-eviction-run}")
protected int numTestsPerEvictionRun;
@Value("${redis.pool.block-when-exhausted}")
protected boolean blockWhenExhausted;
@Value("${redis.pool.lifo}")
protected boolean lifo;
@Value("${redis.pool.fairness}")
protected boolean fairness;
@Value("${redis.pool.jmx-enabled}")
protected boolean jmxEnabled;
@Value("${redis.sentinel.master}")
private String masterName;
@Value("${redis.sentinel.nodes}")
private String sentinelNodes;
@Bean
public JedisSentinelPool jedisSentinelPool() {
Set<String> sentinels = new HashSet<>();
for (String node : sentinelNodes.split(",")) {
sentinels.add(node.trim());
}
if (!ObjectUtils.isEmpty(password)) {
return new JedisSentinelPool(masterName, sentinels, getPoolConfig(), connectionTimeout, password);
} else {
return new JedisSentinelPool(masterName, sentinels, getPoolConfig(), connectionTimeout);
}
}
protected JedisPoolConfig getPoolConfig() {
JedisPoolConfig poolConfig = new JedisPoolConfig();
// Pool size configuration
poolConfig.setMaxTotal(maxTotal);
poolConfig.setMaxIdle(maxIdle);
poolConfig.setMinIdle(minIdle);
// Connection test configuration
poolConfig.setTestOnBorrow(testOnBorrow);
poolConfig.setTestOnReturn(testOnReturn);
poolConfig.setTestWhileIdle(testWhileIdle);
poolConfig.setTimeBetweenEvictionRuns(Duration.ofMillis(timeBetweenEvictionRuns));
poolConfig.setMinEvictableIdleDuration(Duration.ofMillis(minEvictableIdleTime));
poolConfig.setNumTestsPerEvictionRun(numTestsPerEvictionRun);
// Pool behavior configuration
poolConfig.setBlockWhenExhausted(blockWhenExhausted);
poolConfig.setMaxWait(Duration.ofMillis(maxWait));
poolConfig.setLifo(lifo);
poolConfig.setFairness(fairness);
poolConfig.setJmxEnabled(jmxEnabled);
return poolConfig;
}
}
Una volta inizializzato il bean JedisSentinelPool, può essere iniettato negli altri componenti della tua applicazione Spring per inviare comandi a Redis.
Utilizzando try-with-resources, garantisci una gestione sicura ed efficiente delle connessioni Redis.
Ad esempio:
@Service
public class JedisSentinelService {
private final JedisSentinelPool pool;
public JedisSentinelPoolService(JedisSentinelPool pool) {
this.pool = pool;
}
public String set(TextData textData) {
try (Jedis jedis = pool.getResource()) {
return jedis.set(textData.key(), textData.value());
}
}
public TextData get(String key) {
try (Jedis jedis = pool.getResource()) {
return new TextData(key, jedis.get(key));
}
}
}
Redis Cluster
Redis Cluster offre scalabilità orizzontale suddividendo i dati (sharding) su più nodi. Questo consente a Redis di gestire quantità maggiori di dati e un traffico più elevato rispetto a una singola istanza.
Il cluster include anche replica e failover: se un nodo fallisce, una replica può subentrare. I client che supportano Redis Cluster conoscono la topologia del cluster e sono in grado di indirizzare le richieste al nodo corretto in base alla chiave.
Ecco come puoi aggiornare la configurazione per utilizzare Redis Cluster insieme a JedisPool:
# Redis Cluster Configuration
redis.cluster.nodes=localhost:6379,localhost:6380,localhost:6381
redis.cluster.connection-timeout=2000
redis.cluster.socket-timeout=2000
redis.cluster.max-attempts=3
redis.cluster.max-total-retries-duration=2000
redis.password=your-password
Ecco come puoi aggiornare la configurazione Spring per utilizzare JedisCluster al posto di JedisSentinelPool:
@Configuration
public class JedisClusterConfiguration {
private final Logger logger = LoggerFactory.getLogger(getClass());
@Value("${redis.username}")
protected String username;
@Value("${redis.password}")
protected String password;
@Value("${redis.pool.max-total}")
protected int maxTotal;
@Value("${redis.pool.max-idle}")
protected int maxIdle;
@Value("${redis.pool.min-idle}")
protected int minIdle;
@Value("${redis.pool.max-wait}")
protected int maxWait;
@Value("${redis.pool.test-on-borrow}")
protected boolean testOnBorrow;
@Value("${redis.pool.test-on-return}")
protected boolean testOnReturn;
@Value("${redis.pool.test-while-idle}")
protected boolean testWhileIdle;
@Value("${redis.cluster.nodes}")
protected String clusterNodes;
@Value("${redis.cluster.connection-timeout}")
protected int connectionTimeout;
@Value("${redis.cluster.socket-timeout}")
protected int socketTimeout;
@Value("${redis.cluster.max-attempts}")
protected int maxAttempts;
@Value("${redis.cluster.max-total-retries-duration}")
protected int maxTotalRetriesDuration;
@Bean
public GenericObjectPoolConfig<Connection> getJedisClusterConfig() {
GenericObjectPoolConfig<Connection> poolConfig = new GenericObjectPoolConfig<>();
poolConfig.setMaxTotal(maxTotal);
poolConfig.setMaxIdle(maxIdle);
poolConfig.setMinIdle(minIdle);
poolConfig.setTestOnBorrow(testOnBorrow);
poolConfig.setTestOnReturn(testOnReturn);
poolConfig.setTestWhileIdle(testWhileIdle);
return poolConfig;
}
@Bean
public DefaultJedisClientConfig getDefaultJedisClientConfig() {
DefaultJedisClientConfig.Builder clientConfigBuilder = DefaultJedisClientConfig
.builder()
.connectionTimeoutMillis(connectionTimeout)
.socketTimeoutMillis(socketTimeout);
if (!ObjectUtils.isEmpty(username) && ObjectUtils.isEmpty(password)) {
clientConfigBuilder.user(username);
}
if (!ObjectUtils.isEmpty(password)) {
clientConfigBuilder.password(password);
}
if (!ObjectUtils.isEmpty(password)) {
clientConfigBuilder.password(password);
}
return clientConfigBuilder.build();
}
@Bean
public Set<HostAndPort> getJedisClusterNodes() {
Set<HostAndPort> nodes = new HashSet<>();
for (String node : clusterNodes.split(",")) {
try {
nodes.add(new HostAndPort(node.split(":")[0], Integer.parseInt(node.split(":")[1])));
} catch (NumberFormatException numberFormatException) {
logger.error("Can't parse node {}: {}", node, numberFormatException.getMessage());
}
}
return nodes;
}
@Bean
public JedisCluster getJedisCluster(Set<HostAndPort> jedisClusterNodes, DefaultJedisClientConfig jedisClientConfig, GenericObjectPoolConfig<Connection> jedisClusterConfig) {
return new JedisCluster(jedisClusterNodes, jedisClientConfig, maxAttempts, Duration.ofMillis(maxTotalRetriesDuration), jedisClusterConfig);
}
}
Una volta inizializzato il bean JedisCluster, può essere iniettato negli altri componenti della tua applicazione Spring per inviare comandi a Redis.
Ad esempio:
@Service
public class JedisClusterService {
private final JedisCluster jedis;
public JedisClusterService(JedisCluster jedis) {
this.jedis = jedis;
}
public String set(TextData textData) {
return jedis.set(textData.key(), textData.value());
}
public TextData get(String key) {
return new TextData(key, jedis.get(key));
}
}
Redis Software e Redis Cloud
Redis è disponibile anche in una versione commerciale offerta da Redis Inc., suddivisa in due principali edizioni:
- Redis Software – per ambienti on-premises
- Redis Cloud – un servizio completamente gestito per ambienti cloud
Queste versioni commerciali si differenziano da Redis Open Source sotto vari aspetti, in particolare per quanto riguarda la sicurezza dei dati, l’affidabilità, la scalabilità, la sicurezza e le modalità di deployment.
Ad esempio, a differenza di Redis Sentinel, Redis Software gestisce l’alta disponibilità creando automaticamente una replica dell’istanza primaria. Questa replica non è accessibile dai client, ma viene mantenuta sincronizzata e pronta a subentrare immediatamente in caso di anomalie del nodo primario. Quando ciò accade, la replica viene promossa all’istante — senza bisogno di elezioni — e viene creata una nuova replica al suo posto. Questo processo è continuo e garantisce che ci sia sempre una replica standby disponibile.
Tutto ciò avviene in modo trasparente. La tua applicazione deve semplicemente connettersi a un endpoint stabile e consistente (un FQDN e una porta), indipendentemente da cosa accade dietro le quinte.
Inoltre, a differenza di Redis Cluster, Redis Software gestisce la scalabilità in modo dinamico. Puoi iniziare con un database Redis a singolo shard e scalarlo fino a 2, 10 o anche 20 shard, in base al volume dei dati e al throughput delle richieste. Durante la scalata (??? mamma mia che brutto termine che mi è venuto in mente… Serena mi aiuti???), Redis Software ridistribuisce automaticamente tutte le chiavi sui nuovi shard, assicurando una distribuzione uniforme di dati e carico — cosa che Redis Cluster non fa in modo nativo.
Tutto questo rende la scalabilità con Redis Software/Cloud più fluida ed efficiente dal punto di vista operativo, senza necessità di migrazioni manuali delle chiavi o di logica complessa lato client.
E questo è solo un assaggio per paragonare ciò che abbiamo visto finora — la connessione a Redis tramite approcci comuni come Redis Sentinel e Redis Cluster. C’è ancora molto da esplorare sia in Redis Software che in Redis Cloud, inclusi strumenti avanzati per le prestazioni, l’automazione e l’alta disponibilità.
Ma ora torniamo a ciò che davvero conta: il codice.
Ecco come puoi aggiornare la configurazione per connetterti a un endpoint Redis Software/Cloud:
# Redis Software and Redis Cloud Configuration
redis.host=redis
redis.port=6379
redis.username=
redis.password=luigi
# Redis Pool Configuration
redis.pool.max-total=8
redis.pool.max-idle=8
redis.pool.min-idle=0
redis.pool.connection-timeout=2000
redis.pool.max-wait=3000
redis.pool.test-on-borrow=true
redis.pool.test-on-return=true
redis.pool.test-while-idle=true
redis.pool.time-between-eviction-runs=30000
redis.pool.min-evictable-idle-time=1800000
redis.pool.num-tests-per-eviction-run=3
redis.pool.block-when-exhausted=true
redis.pool.lifo=true
redis.pool.fairness=false
redis.pool.jmx-enabled=true
Sì, si tratta della stessa configurazione utilizzata per connettersi a una singola istanza Redis con JedisPool.
Questo perché, con Redis Software/Cloud, è sufficiente connettersi a un unico endpoint, senza doversi preoccupare della topologia sottostante di Redis.
Ecco come puoi aggiornare la configurazione Spring per connetterti a un endpoint Redis Software o Redis Cloud:
@Configuration
public class JedisEnterpriseConfiguration {
@Value("${redis.host}")
protected String host;
@Value("${redis.port}")
protected int port;
@Value("${redis.username}")
protected String username;
@Value("${redis.password}")
protected String password;
@Value("${redis.pool.max-total}")
protected int maxTotal;
@Value("${redis.pool.max-idle}")
protected int maxIdle;
@Value("${redis.pool.min-idle}")
protected int minIdle;
@Value("${redis.pool.connection-timeout}")
protected int connectionTimeout;
@Value("${redis.pool.max-wait}")
protected int maxWait;
@Value("${redis.pool.test-on-borrow}")
protected boolean testOnBorrow;
@Value("${redis.pool.test-on-return}")
protected boolean testOnReturn;
@Value("${redis.pool.test-while-idle}")
protected boolean testWhileIdle;
@Value("${redis.pool.time-between-eviction-runs}")
protected long timeBetweenEvictionRuns;
@Value("${redis.pool.min-evictable-idle-time}")
protected long minEvictableIdleTime;
@Value("${redis.pool.num-tests-per-eviction-run}")
protected int numTestsPerEvictionRun;
@Value("${redis.pool.block-when-exhausted}")
protected boolean blockWhenExhausted;
@Value("${redis.pool.lifo}")
protected boolean lifo;
@Value("${redis.pool.fairness}")
protected boolean fairness;
@Value("${redis.pool.jmx-enabled}")
protected boolean jmxEnabled;
@Bean
public JedisPool jedisPool() {
if (!ObjectUtils.isEmpty(username) && !ObjectUtils.isEmpty(password)) {
return new JedisPool(getPoolConfig(), host, port, connectionTimeout, username, password);
} else if (!ObjectUtils.isEmpty(password)) {
return new JedisPool(getPoolConfig(), host, port, connectionTimeout, password);
} else {
return new JedisPool(getPoolConfig(), host, port, connectionTimeout);
}
}
protected JedisPoolConfig getPoolConfig() {
JedisPoolConfig poolConfig = new JedisPoolConfig();
// Pool size configuration
poolConfig.setMaxTotal(maxTotal);
poolConfig.setMaxIdle(maxIdle);
poolConfig.setMinIdle(minIdle);
// Connection test configuration
poolConfig.setTestOnBorrow(testOnBorrow);
poolConfig.setTestOnReturn(testOnReturn);
poolConfig.setTestWhileIdle(testWhileIdle);
poolConfig.setTimeBetweenEvictionRuns(Duration.ofMillis(timeBetweenEvictionRuns));
poolConfig.setMinEvictableIdleDuration(Duration.ofMillis(minEvictableIdleTime));
poolConfig.setNumTestsPerEvictionRun(numTestsPerEvictionRun);
// Pool behavior configuration
poolConfig.setBlockWhenExhausted(blockWhenExhausted);
poolConfig.setMaxWait(Duration.ofMillis(maxWait));
poolConfig.setLifo(lifo);
poolConfig.setFairness(fairness);
poolConfig.setJmxEnabled(jmxEnabled);
return poolConfig;
}
}
Ancora una volta, si tratta della stessa configurazione utilizzata per connettersi a una singola istanza Redis con JedisPool.
Una volta inizializzato il bean JedisPool, può essere iniettato negli altri componenti della tua applicazione Spring per inviare comandi a Redis.
Ad esempio:
@Service
public class JedisEnterpriseService {
private final JedisPool pool;
public JedisEnterpriseService(JedisPool pool) {
this.pool = pool;
}
public String set(TextData textData) {
try (Jedis jedis = pool.getResource()) {
return jedis.set(textData.key(), textData.value());
}
}
public TextData get(String key) {
try (Jedis jedis = pool.getResource()) {
return new TextData(key, jedis.get(key));
}
}
}
Conclusioni
Ecco alcune best practice consigliate da seguire quando ci si connette a Redis:
Usa sempre l’autenticazione
Utilizza il connection pooling negli ambienti di produzione
Configura time-out e politiche di retry adeguate
Usa SSL quando ti connetti a Redis Software
Monitora le metriche del pool di connessioni
Gestisci gli errori di connessione in modo robusto
Scegli il metodo di connessione più adatto alle tue esigenze:
- Istanza singola: per sviluppo e test
- Pool di connessioni: per la produzione
- Sentinel: per alta disponibilità
- Cluster: per scalabilità orizzontale
- Sentinel e Cluster: NON USARLI INSIEME
- Redis Software e Redis Cloud: per funzionalità avanzate come Control Plane, Web Console, Scalabilità, Alta Disponibilità, Automazione, Sicurezza, Multi-tenant, distribuzione geografica (Active-Active), SLA del 99,999% e molto altro!
Repository
Tutto ciò che abbiamo visto finora è disponibile nel seguente repository GitHub, dove puoi esplorare in dettaglio esempi di codice, file di configurazione e pattern d’uso:
E adesso?
Avrebbe senso offrire esempi analoghi anche per Lettuce e Spring Data Redis — ma per il momento, concediamoci una pausa estiva. 😎
Post correlati
- Go Structs: Ottimizzazione della Memoria
- Hugo Dark Mode: come implementare il tema scuro su siti statici
- Heap vs stack vs Metaspace: come funziona la JVM
- Comprendere i Validators con Angular: una semplice guida alla validazione dei form
- Integrazione di GitHub CodeQL e Checkov per la Sicurezza Completa: Un Approccio Pratico con GitHub Actions
