Redis com Spring Boot

Neste post, vamos discutir o Redis , Redis é um banco de dados NoSQL baseado em valor-chave que pode ser usado para várias finalidades. É de código aberto e é um armazenamento de estrutura de dados InMemory. Porque o Redis oferece suporte a todas as estruturas de dados básicas, como lista, conjunto, mapa e conjunto classificado.

Usando o Redis, podemos desenvolver diferentes tipos de aplicativos, como aplicativos de bate-papo, aplicativos de armazenamento de sessão, painéis de jogos, etc.

Se você quiser aprender o Redis, primeiro entenda as diferentes estruturas de dados que o Redis suporta, além dos comandos que podemos usar para armazenar e obter dados do Redis.

Alguns comandos importantes

Redis oferece suporte a String, Set, Sorted Set, List e HashMap como chave — valores. Abaixo estão alguns comandos básicos para entender as diferentes estruturas de dados.

String 
SET foo bar (foo is key, bar is value)
GET foo
bar
HashMap

HMSET student name: "shubham" age: 25
HGETALL student
List
LPUSH product car
LPUSH product bike

LRANGE product 0 10
Set
SADD product car
SADD product bike

SMEMBERS product

Casos de uso do Redis

1. O Redis pode ser usado como um banco de dados NoSQL baseado em chave-valor.
2. O Redis pode ser usado como um provedor de cache.
3. O Redis pode ser usado como publicador e assinante, que é usado no processamento de eventos.
4. O Redis pode ser usado como um armazenamento de sessão.
5. O Redis pode ser usado em aplicativos de bate-papo.

Portanto, se você tiver algum interesse depois de ler isso e agora quiser praticar o Redis, configure o servidor Redis em seu sistema.

1. Instale o homebrew em seu sistema, se não estiver lá.
2. Os comandos Executar abaixo sequencialmente

brew install redis

After succesfull installation 

brew services start redis

After starting redis if you want to try above commands

redis-cli

To test whether redis server is working

PING

If yu get PONG then its connected

If you want to monitor which all commands are getting executed on redis

redis-monitor

Então, depois disso, se você quiser usar o Redis de algum outro sistema, precisará de um cliente que interaja com o servidor Redis.

Agora, nesta parte, veremos como podemos usar o Redis com inicialização por mola e usá-lo como um banco de dados NoSQL.

Configurar

A primeira etapa é criar um projeto de inicialização Spring de amostra a partir do inicializador de primavera e adicionar a dependência spring-boot-starter-data-redis .

Agora, depois de importar o projeto para seu IDE favorito, crie pacotes e classes.

A primeira aula será para configuração, temos dois drivers para Redis, um é Jedis, outro é alface (é inicializado preguiçosamente e o desempenho também é melhor.)

Além do driver, precisamos de um modelo para fazer operações no servidor Redis, da mesma forma que temos o RestTemplate para fazer operações de descanso.

package com.redisexample.redisdemo.config;

import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.repository.configuration.EnableRedisRepositories;
import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
//@EnableRedisRepositories
public class AppConfig {

    //There are two ways of creating driver, one is jedis another is lettuce,
    //lettuce is bit lazy in intialization so it creates beans  lazily
//It is using default host and port
    @Bean
    RedisConnectionFactory jedisConnectionFactory() {
        return new LettuceConnectionFactory();
    }

    @Bean
    public RedisTemplate<String, Object> redisTemplate() {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(jedisConnectionFactory());
        template.setKeySerializer(new StringRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashKeySerializer(new JdkSerializationRedisSerializer());
        template.setValueSerializer(new JdkSerializationRedisSerializer());
        template.setEnableTransactionSupport(true);
        template.afterPropertiesSet();
        return template;
    }

    //For setting host and port
//    @Bean
//    JedisConnectionFactory jedisConnectionFactory() {
//        JedisConnectionFactory jedisConFactory
//                = new JedisConnectionFactory();
//        jedisConFactory.setHostName("localhost");
//        jedisConFactory.setPort(6379);
//        return jedisConFactory;
//    }

}

Criar uma classe de Entidade

@RedisHash("student") // this is a set so we can use set command to see data via redis cli
public class Student {

    public enum Gender {
        MALE, FEMALE
    }

    private Long id;
    private String name;
    private int age;
    private String city;

    //getters and setters
}

@Repository
public interface StudnetRepo extends CrudRepository<Student, Long> {

}

package com.redisexample.redisdemo.controller;

import com.redisexample.redisdemo.model.Student;
import com.redisexample.redisdemo.repo.StudnetRepo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/student")
public class StudentController {

    @Autowired
    private StudnetRepo studnetRepo;

    @PostMapping
    public void saveStudent(@RequestBody Student student){
        studnetRepo.save(student);
    }

    @GetMapping
    public Iterable<Student> getStudent(){
        return studnetRepo.findAll();
    }
}

Portanto, este é um exemplo simples de uso do Redis como um banco de dados com um aplicativo de inicialização por mola.

No próximo post veremos como usar o Redis como provedor de cache.

Obrigado por ler!!