Spring Boot + Redis

Spring Boot + Redis

Como o título do post sugere vamos ver um exemplo simples e didático de como podemos usar o Redis com o Spring Boot.

O projeto deste post está no seguinte repositório:

https://github.com/apedrina/blog/tree/master/alisson/spring-redis

Redis

Redis é uma ferramenta open-source que armazena estruturas de dados in-memory, ideal para ser utilizado como database, message broker e cache.

Nosso exemplo aborda o uso do Redis para cache juntamente com o Spring Boot, veja a dependência para inicializar o Redis neste  trecho do arquivo build.gradle:

compile "org.springframework.boot:spring-boot-starter-data-redis:${springBootVersion}"

Para mais informações sobre o Redis e para fazer o download do mesmo acesse:

https://redis.io/

Após instalar o redis precisamos inicializar o mesmo, para tanto execute o comando abaixo:

redis-server

Quando instalamos o Redis temos também acesso a um cliente, para inicializar o mesmo execute o comando abaixo:

redis-cli

Aplicação

Vamos analizar algumas partes do nosso projeto de exemplo. Primeiro vamos a observar a classe RedisConfiguration, nela temos configurados os Beans: RedisTemplate, GenericJackson2JsonRedisSerializer e CacheManager. Desses vamos destacar o CacheManager no qual podemos ver o nome especializado do Bean e o TTL (Time to Live). O ttl determina o tempo de duração das chaves armazenadas no Redis.

Vamos destacar também algumas configurações do redis no arquivo application.yml

spring:
  application:
    name: spring-redis
  cache:
    type: redis
  redis:
    host: localhost
    port: 6379
    timeout: 100
    pool:
      max-active: 1000
      max-wait: 100

Temos também a classe que representa nosso endpoint REST. O mais interessante deste didático método é a anotação @Cacheable que declara o nome do cache controller, declarado na classe RedisConfiguration, e a definição da key a ser armazenada no Redis.

@Cacheable(cacheNames = "helloCache", key = "#id")
@GetMapping("/hello/{id}")
@ResponseBody
public Hello getHello(@PathVariable("id") long id) {
  return new Hello(id, "Hello!!");
}

Como vemos a key será o id, key = “#id”.

Testando

Primeiro vamos inicializar o Redis. Digite na linha de comando:

redis-server

Depois vamos inicializar a aplicação. Estando na raiz do projeto digite o comando:

./gradlew bootRun

Agora vamos inicializar o cliente do Redis para podermos monitora-lo. Digite o comando:

redis-cli

De dentro do redis-cli digite:

monitor

Agora estamos monitorando o Redis, qualquer acesso e outros comandos requisitados ao redis-server será visível no redis-cli no modo monitor.

Para acessar o nosso didático endpoint digite no browser:

http://localhost:8081/spring-redis/hello/3

Sendo o 3 na url acima referente ao parametro id. O Redis sempre armazena uma chave que está atrelada a um valor, chave-valor. Nosso Redis está configurando para armazenar objetos tendo como chave o valor id. Assim sendo ao invocar a url mostrada acima podemos observar no redis-cli algo como a exibida abaixo:

1531247220.342027 [0 127.0.0.1:55147] "EXISTS" "helloCache:3"
1531247220.381844 [0 127.0.0.1:55147] "EXISTS" "helloCache~lock"
1531247220.401511 [0 127.0.0.1:55147] "MULTI"
1531247220.401534 [0 127.0.0.1:55147] "SET" "helloCache:3" "[\"com.alissonpedrina.model.Hello\",{\"id\":3,\"content\":\"Hello!!\"}]"
1531247220.401561 [0 127.0.0.1:55147] "EXPIRE" "helloCache:3" "30"
1531247220.401572 [0 127.0.0.1:55147] "EXEC"

Primeiro é checado se a chave, no caso 3, existe senão existe ela é criada e um objeto do tipo Hello é armazenado. Esse objeto é o retorno do método chamado no endpoint:  getHello(@PathVariable(“id”) long id).

Nosso ttl está configurado com o valor de 30 segundos, veja no arquivo application.yml. Assim sendo se nós invocarmos a mesma url novamente. O resultado é algo parecido com o exibido abaixo:

1531247422.222708 [0 127.0.0.1:55194] "EXISTS" "helloCache:3"
1531247422.225244 [0 127.0.0.1:55194] "EXISTS" "helloCache~lock"
1531247422.225441 [0 127.0.0.1:55194] "GET" "helloCache:3"

Ou seja em realidade foi retornado o objeto encontrado no cache. Num exemplo da vida real, para fazer sentido usar um cache, o método teria que fazer acesso a algum recurso externo e relativamente oneroso como um banco de dados.

Passado 30 segundos se tentarmos acessar o endpoint o resultado no Redis tem que ser algo parecido com o exibido abaixo:

1531247562.414904 [0 127.0.0.1:55236] "EXISTS" "helloCache:3"
1531247562.415338 [0 127.0.0.1:55236] "EXISTS" "helloCache~lock"
1531247562.415497 [0 127.0.0.1:55236] "MULTI"
1531247562.415511 [0 127.0.0.1:55236] "SET" "helloCache:3" "[\"com.alissonpedrina.model.Hello\",{\"id\":3,\"content\":\"Hello!!\"}]"
1531247562.415524 [0 127.0.0.1:55236] "EXPIRE" "helloCache:3" "30"
1531247562.415530 [0 127.0.0.1:55236] "EXEC"

Como podemos ver acima a chave para o id com valor 3 não existe mais, porque o ttl já a expirou, e assim ele cria uma nova chave para o valor. Claro que no mundo real o ttl provavelmente seria maior.

Conclusão

O uso de cache com SpringBoot é algo muito útil e simples, como todos os recursos do Spring Boot. Neste exemplo exibido neste post você pode ter um projeto base para utilizar o Redis. Melhore o exemplo, teste, adicione novos recursos e configurações como quiser para melhorar seu entendimento do uso destas duas poderosas, porém simples,  ferramentas. Até a próxima.

One thought on “Spring Boot + Redis

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s