---
title: 'Instalacion y configuracion de Redis'
---

Instalación y configuración de Redis
===

# Redis

**Redis** son las siglas de *Remote Dictionary Server*. Fue escrito en *C* por **Salvatore Sanfilippo** en 2006 y actualmente cuenta con muchos colaboradores. Hay clientes de Redis disponibles para más de 30 lenguajes de programación. El proyecto de código abierto se puede obtener desde https://github.com/antirez/redis.
Redis es un proyecto de código abierto bien establecido y ha sido utilizado en producción durante años por grandes empresas, como Twitter, GitHub, Tumblr, Pinterest, Instagram Hulu, Flickr y The New York Times.

## Repositorio

$ https://gitlab.siare.gov.py/siare-develop/gestion-entornos.git

> Proyecto que contiene las configuraciones de los servicios para los diferentes entornos.

## Requerimientos
Para la instalacion se requiren los siguientes componentes:

* docker version 20.10.14 o superior
* docker compose 1.29.2 o superior
* redis-cli 7.0.0 o superior

## Pasos de Instalación
### Copia local del repositorio
Ejecutar el siguiente comando para clonar el repositorio

$ git clone https://gitlab.siare.gov.py/siare-develop/gestion-entornos.git

El contenido del docker-compose.yml se describe a continuación:

version: '2'
services:
  redis-master:
    image: redis:7.0.0    
    restart: always
    command: redis-server 
    ports: 
      - 6379:6379

  redis-slave:
    image: redis:7.0.0
    restart: always
    command: redis-server --slaveof redis-master 6379
    ports:
      - 7001:6379
    depends_on:
      - redis-master

Acceder al directorio del repositorio `./gestion-entornos/redis/docker-compose/redis-cluster` y ejecutar el siguiente comando:

$ docker-compose up -d

> El comando inicia los contenedores y lo ejecuta en segundo plano

Para verificar la correcta ejecución de los contenedores, se debe ejecutar el siguiente comando:

$ docker-compose ps

## Gestor para Redis
### Another Redis Desktop Manager
Gestor de escritorio para redis compatible para Linux, windows y mac.

> La aplicación puede ser descargada de la siguiente dirección:

$ https://github.com/qishibo/AnotherRedisDesktopManager
$ https://github.com/qishibo/AnotherRedisDesktopManager/releases

> Vista inicial de la aplicación


---

> Vista de creación de una nueva conexión


---

> Vista de acceso al Redis


---

> Vista principal del server Redis


---

# Uso de Redis con Spring Data Redis
Spring Data Redis, proporciona las abstracciones de la plataforma Spring Data a Redis

## Dependencias Maven necesarias

<dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-redis</artifactId>
    <version>${spring.boot.version}</version>
</dependency>

<!-- Lettuce es un cliente de Redis escalable para un uso síncrono, asíncrono y reactivo -->

<dependency>
    <groupId>io.lettuce</groupId>
    <artifactId>lettuce-core</artifactId>
    <version>6.0.2.RELEASE</version>
</dependency>

## Configuración de Redis
Para definir la configuración de la conexión entre el cliente y el servidor Redis, es necesario la utilización de un cliente de Redis. Hay diversas implementaciones de clientes para Redis disponibles para el lenguaje Java. Para este ejemplo se utilizará **Lettuce** (Advanced Java Redis client)

## Configuración Java
En necesario la creación de una clase para la configuración del Redis.

### RedisConfig
Crear la clase RedisConfig dentro del proyecto java con el siguiente contenido:

import java.time.Duration;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisPassword;
import org.springframework.data.redis.connection.RedisStaticMasterReplicaConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceClientConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;

import io.lettuce.core.ReadFrom;
import io.lettuce.core.RedisURI;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;

@Configuration
@Data
@Slf4j
public class RedisConfig {

	@Value("${siare.redis.url}")
	private String redisUrl;

	@Value("${siare.redis.slave:}")
	private String redisSlave;

	@Value("${siare.redis.timeout:60}")
	private long timeout;

	@Bean
	public LettuceConnectionFactory redisConnectionFactory() {
	// RedisURI. Contiene la configuración de contexión para Redis/Sentinel. 
	// La configuración puede contener datos de la base de datos, 
	// el nombre del usuario, contraseña y tiempos de espera dentro del RedisURI.
        // Ejemplos :
        // RedisURI.create("redis://localhost/");
        // new RedisURI("localhost", 6379, Duration.ofSeconds(60));
        
		RedisURI uri = RedisURI.create(redisUrl);
		LettuceClientConfiguration clientConfig = 
            LettuceClientConfiguration
            .builder()
            .readFrom(ReadFrom.UPSTREAM)
			.commandTimeout(Duration.ofSeconds(timeout))
            .build();

		RedisStaticMasterReplicaConfiguration smc = 
            new RedisStaticMasterReplicaConfiguration(
            uri.getHost(),
            uri.getPort());
		smc.setPassword(
            RedisPassword.of(uri.getPassword()));

		if (redisSlave != null && !redisSlave.isEmpty()) {
			for (String r : redisSlave.split(";")) {
				String[] node = r.split(":");
				smc.addNode(node[0], Integer.parseInt(node[1]));
			}
		}

		return new LettuceConnectionFactory(smc, clientConfig);
	}


	@Bean
    public RedisTemplate<String, Object> redisTemplate() {
        
	// Clase utilitaria que facilita el acceso a datos de Redis
        // Realiza la serialización/deserialización automática entre los 
        // objetos dados y los datos binarios subyacentes en el Almacén de 
        // Redis. 
        // Por defecto, utiliza la serialización de Java para sus objetos 
        // a través de JdkSerializationRedisSerializer
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory());

        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = 
            new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper mapper = 
            new ObjectMapper();
        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        mapper.activateDefaultTyping(
            mapper.getPolymorphicTypeValidator(), 
            ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(mapper);

        JdkSerializationRedisSerializer serializer = 
            new JdkSerializationRedisSerializer();
        template.setDefaultSerializer(serializer);
        StringRedisSerializer stringSerializer = new StringRedisSerializer();
        template.setKeySerializer(stringSerializer);
        template.setHashKeySerializer(stringSerializer);
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.setValueSerializer(jackson2JsonRedisSerializer);
        
        return template;
    }
}

> La clase tiene la responsabilidad de crear los objetos necesarios para la conexión con el servidor Redis.
* @Configuration : Anotación que indica al spring que la clase será utilizada como fuente de definición de Bean para el contexto de la aplicación
* @Data : Anotación de la librería *lombok*, que permite generación de setter y getter de todos los atributos de la clase en forma automática
* @Value("${my.app.myProp}") : Anotación que permite cargar datos desde el archivo application.properties del proyecto
* @Bean : Anotación que nos permite generar Objetos en forma personalizada dentro del contexto de la aplicación.

### Uso del Redis
Para la utilización del Redis se ha generado los siguientes archivos :

### SiareCache
Anotación que permite identificar donde será requerido el acceso al servidor de Redis

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface SiareCache {

       //Tiempo de expiración del dato en el Redis
	int ttl() default 300;
}

* @Target : Indica donde será aplicado la anotación, en este caso será utilizado a nivel de método unicamente (ElementType.Method).
* @Retention : Indica si la anotación estará disponible para el JVM en tiempo de ejecución.

### SiareCacheAspect
Clase de Aspecto que intercepta las invocaciones de métodos de servicio, todas las clases de Aspecto debe llevar la anotación **@Aspect**

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.math.BigInteger;
import java.time.Duration;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.hibernate.cache.CacheException;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import py.gov.siare.siarecommon.util.FNV;

@Aspect
@Component
@Slf4j
@AllArgsConstructor
public class SiareCacheAspect {

	private RedisTemplate<String, Object> cache;
	
// Hemos anotado nuestro método con @Around
// Este es el bloque del advice, y significa que estamos añadiendo 
// código extra tanto antes 
// como después de la ejecución del método. 
// La anotación @Around recibe un parámetro de punto de corte (pointcut), 
// lo que indica que este código será aplicado a los métodos 
// que tenga la anotación *SiareCache*
	@Around("@annotation(siareCache)")
	public Object cache(ProceedingJoinPoint pjp, final SiareCache siareCache) 
        throws Throwable {

		try {

			byte[] byteArray;
			log.debug(" Preparando los datos para realizar cache {}", pjp);
			log.debug("argumentos {}", pjp.getArgs());
			ByteArrayOutputStream baos = new ByteArrayOutputStream();
			ObjectOutputStream oos;

			try {
				oos = new ObjectOutputStream(baos);
				oos.writeObject(pjp.getArgs());
			} catch (IOException e) {
				log.error("{}", e.getMessage());
				log.debug("no se puede guardar en el cache, 
                    no trae valor el argumento, 
                    por lo tanto se pasa la responsabilidad el servicio");
				return pjp.proceed();
			}

			byteArray = baos.toByteArray();
            //Algoritmo de Fowler Noll Vo 
            // Función de hash
			FNV fnv = new FNV();
			BigInteger identificators = fnv.fnv1_64(byteArray);
            // Generación de key
			String target = generateName(
                pjp.getTarget().getClass(), 
                identificators
            );

			Boolean hasKey = cache.hasKey(target);
			Object objetoCache = null;
			log.debug("Target [{}]", target);
            
            // Se verifica la existencia del key en el cache de Redis
            // en caso de exitir toma el objeto almacenado en el cache sino 
            // realiza la consulta a la base de datos relacional

			if (hasKey.equals(false)) {
				objetoCache = pjp.proceed();
				cache.opsForValue()
                    .set(target, 
                         objetoCache, Duration.ofSeconds(siareCache.ttl()
                                                        )
                        );
				
			} else {
				objetoCache = cache.opsForValue().get(target);
			}


			return objetoCache;
		} catch (Throwable e) {
			throw new CacheException(e.getMessage());
		}

	}

	/**
	 * Genera el nombre del cache, basado en el siguiente algoritmo: * SimpleName
	 * del modelo * Id del objeto (debe heredar de la clase base model.
	 *
	 * @param clazz Classe para obtener el valor "SimpleName"
	 * @param id    Id del objeto
	 * @return devuelve el valor del cache con el formado foo:id
	 */
	private String generateName(Class<?> clazz, BigInteger id) {
		
		StringBuilder stb = new StringBuilder();
		stb.append(clazz.getSimpleName());
		stb.append(":");
		stb.append(id.toString());
		return stb.toString();
	}

	private String generateName(Class<?> clazz, String id) {
		
		StringBuilder stb = new StringBuilder();
		stb.append(clazz.getSimpleName());
		stb.append(":");
		stb.append(id);
		return stb.toString();
	}

}

* @Component : Anotación que indica al spring que la clase será un Bean gestionado dentro del contexto de la aplicación
* @Slf4j : Anotación de la librería *lombok*, que permite generar logs
* @AllArgsConstructor : Anotación de la librería *lombok*, que permite generar un constructor con todos los atributos de la clase.

### FNV
Clase que implementa el algoritmo hash FNV (Fowler Noll Vo)

import java.math.BigInteger;

public class FNV {
    private static final BigInteger INIT32  = new BigInteger("811c9dc5",         16);
    private static final BigInteger INIT64  = new BigInteger("cbf29ce484222325", 16);
    private static final BigInteger PRIME32 = new BigInteger("01000193",         16);
    private static final BigInteger PRIME64 = new BigInteger("100000001b3",      16);
    private static final BigInteger MOD32   = new BigInteger("2").pow(32);
    private static final BigInteger MOD64   = new BigInteger("2").pow(64);

    public BigInteger fnv1_32(byte[] data) {
        BigInteger hash = INIT32;

        for (byte b : data) {
            hash = hash.multiply(PRIME32).mod(MOD32);
            hash = hash.xor(BigInteger.valueOf((int) b & 0xff));
        }

        return hash;
    }

    public BigInteger fnv1_64(byte[] data) {
        BigInteger hash = INIT64;

        for (byte b : data) {
            hash = hash.multiply(PRIME64).mod(MOD64);
            hash = hash.xor(BigInteger.valueOf((int) b & 0xff));
        }

        return hash;
    }

    public BigInteger fnv1a_32(byte[] data) {
        BigInteger hash = INIT32;

        for (byte b : data) {
            hash = hash.xor(BigInteger.valueOf((int) b & 0xff));
            hash = hash.multiply(PRIME32).mod(MOD32);
        }

        return hash;
    }

    public BigInteger fnv1a_64(byte[] data) {
        BigInteger hash = INIT64;

        for (byte b : data) {
            hash = hash.xor(BigInteger.valueOf((int) b & 0xff));
            hash = hash.multiply(PRIME64).mod(MOD64);
        }

        return hash;
    }
}

### Ejemplo de utilización

En las implementaciones de los servicios agregamos la anotacion **@SiareCache**

    @SiareCache
	@Override
	public ResponseDto<List<MetodosDto>> obtenerRegistrosPaginadoOrdenado(
        String filtros, 
        int page, 
        int cantidad, 
        String orderBy,
        String orderDir) {
		return super.obtenerRegistrosPaginadoOrdenado(
            filtros, 
            page, 
            cantidad, 
            orderBy, 
            orderDir);
	}

# Referencias
[1] Redis. Introduction to Redis. Recuperado el 27 de mayo del 2022, de https://redis.io/docs/about/