Integración de Java con Redis

Integración de Java con Redis

Redis se usa principalmente para el almacenamiento en caché en el proyecto, al igual que usamos MySQL para los datos de la capa de persistencia. Hay dos implementaciones de clientes de Redis:

Una es llamar directamente a Jedis para implementarlo, similar a cómo Java usa JDBC para operar la base de datos.

La segunda es usar Spring-Data-Redis, que se llama a través del paquete de Spring.

1. Jedi

Jedis es la herramienta de desarrollo de conexiones Java recomendada oficialmente por Redis, y Jedis es la implementación de cliente de la versión Java de Redis.

Java opera el servicio Redis a través de Jedis, similar a Java opera la base de datos MySQL a través de la tecnología JDBC.

A través de las operaciones de comando de los tipos de datos comunes de Redis, Jedis se puede usar fácilmente, ya que la mayoría de los nombres de los métodos son básicamente los mismos que los comandos correspondientes . Los comandos de tipos de datos comunes de Redis pueden consultar el artículo anterior Comandos de tipos de datos comunes de Redis

El uso simple de Jedis es el siguiente:

Primero presente la dependencia maven de Jedis:

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>3.6.0</version>
</dependency>

Aquí está el código de prueba:

public class JedisTest {
    
    

    Jedis jedis;

    /**
     * 初始化Jedis实例
     */
    @Before
    public void init() {
    
    
        //指定Redis服务器的IP地址和端口号
        jedis = new Jedis("192.168.43.100", 6379);
    }

    @Test
    public void redisJedisTest() {
    
    
        //操作字符串
        //方法名与操作原生redis的命令一致
        jedis.set("dec", "hello");
        String dec = jedis.get("dec");
        System.out.println(dec);

        //操作list
        jedis.lpush("data", "v1", "v2", "v3");
        jedis.rpush("data", "v4", "v5", "v6");
        List<String> data = jedis.lrange("data", 0, -1);
        for (String s : data) {
    
    
            System.out.print(s + " ");
        }
        System.out.println();

        //操作hash
        HashMap<String, String> hashMap = new HashMap<>();
        hashMap.put("id", "1");
        hashMap.put("name", "huhai");
        hashMap.put("age", "24");
        jedis.hset("object", hashMap);
        Map<String, String> object = jedis.hgetAll("object");
        object.forEach((key, value) -> System.out.print(key + "=" + value + " "));
    }

    /**
     * 关闭Jedis连接
     */
    @After
    public void close() {
    
    
        jedis.close();
    }
}

La salida del terminal es la siguiente:

hello
v3 v2 v1 v4 v5 v6 
name=huhai age=24 id=1

También puede usar JedisPool para operar:

//声明Linux服务器IP地址
String host = "192.168.43.100";
//声明Redis端口号
int port = Protocol.DEFAULT_PORT;
//创建连接池对象
JedisPool jedisPool = new JedisPool(host, port);
//获取Jedis对象连接Redis
Jedis jedis = jedisPool.getResource();
//执行具体操作
String ping = jedis.ping();
System.out.println(ping);//pong
//关闭连接
jedisPool.close();

Dos, Spring-Data-Redis

Spring-Data-Redis es parte de la familia Spring. Accede a los servicios de Redis a través de una configuración simple y encapsula altamente los kits de desarrollo subyacentes de Redis (Jedis, JRedis, RJC). RedisTemplate proporciona varias operaciones, manejo de excepciones y secuencias de Redis. , publicación de soporte y suscríbete

Plantilla Redis

Spring encapsula el objeto RedisTemplate para realizar varias operaciones en Redis y es compatible con todas las API nativas de Redis.

org.springframework.data.redis.core.RedisTemplate<K, V>

RedisTemplate define operaciones en 5 estructuras de datos básicas

redisTemplate.opsForValue();//操作String字符串
redisTemplate.opsForList();//操作list
redisTemplate.opsForSet();//操作set
redisTemplate.opsForHash();//操作hash
redisTemplate.opsForZSet();//操作有序set

StringRedisTemplate y RedisTemplate

• La relación entre los dos es que StringRedisTemplate hereda RedisTemplate.

• Los datos de los dos no son comunes; es decir, StringRedisTemplate solo puede administrar los datos en StringRedisTemplate y RedisTemplate solo puede administrar los datos en RedisTemplate.

• Hay dos estrategias de serialización adoptadas por SDR de manera predeterminada, una es la estrategia de serialización de String y la otra es la estrategia de serialización de JDK.

• StringRedisTemplate adopta la estrategia de serialización de String de forma predeterminada, y la clave y el valor guardados se serializan y guardan con esta estrategia.

• RedisTemplate adopta la estrategia de serialización de JDK de forma predeterminada, y la clave y el valor guardados se serializan y guardan con esta estrategia.

La demostración usando Spring-Data-Redis es la siguiente:

1. Primero introduce las dependencias:

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    <!-- redis -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
        <exclusions>
            <exclusion>
                <groupId>io.lettuce</groupId>
                <artifactId>lettuce-core</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
    </dependency>
    <!-- lombok依赖 -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>

2. Agregue un archivo de configuración y realice alguna configuración de Redis

spring:
  redis:
    #redis服务器连接地址
    host: 192.168.43.100
    #端口号
    port: 6379
    #连接超时时间（毫秒）
    timeout: 10000
    #使用的redis库
    database: 0
    jedis:
      pool:
        #连接池最大连接数
        max-active: 10
        #连接池中的最大空闲连接
        max-idle: 10
        #连接池中的最小空闲连接
        min-idle: 2
        #连接池最大阻塞等待时间（使用负值表示没有限制）
        max-wait: 10000

3. Agregue la clase de configuración de Redis y defina el mecanismo de serialización

/**
 * Description: Redis 基础配置类
 */
public class BaseRedisConfig {
    
    
    
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory, RedisSerializer<Object> redisSerializer) {
    
    
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(redisSerializer);
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(redisSerializer);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

    @Bean
    public RedisSerializer<Object> redisSerializer() {
    
    
        //创建JSON序列化器
        Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        //必须设置，否则无法将JSON转化为对象，会转化成Map类型
        objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL);
        serializer.setObjectMapper(objectMapper);
        return serializer;
    }

    @Bean
    public IRedisService redisService(RedisTemplate<String, Object> redisTemplate) {
    
    
        return new RedisServiceImpl(redisTemplate);
    }
}

/**
 * Description: Redis配置类
 */
@Configuration
public class RedisConfig extends BaseRedisConfig{
    
    
}

4. Cree la interfaz IRedisService y la clase de implementación RedisServiceImpl

Solo escribí algunos métodos básicos de uso, si es necesario, puede continuar agregando, inyectarlo en otras clases y usarlo ~

/**
 * Description: Redis操作Service
 */
public interface IRedisService {
    
    

    /**
     * 保存属性
     *
     * @param key   key
     * @param value value
     * @param time  超时时间（秒）
     */
    void set(String key, Object value, long time);

    /**
     * 保存属性,无过期时间
     *
     * @param key   key
     * @param value value
     */
    void set(String key, Object value);

    /**
     * 获取属性
     *
     * @param key key
     * @return value
     */
    Object get(String key);

    /**
     * 设置过期时间
     *
     * @param key  key
     * @param time 超时时间（秒）
     * @return 是否设置成功
     */
    Boolean expire(String key, long time);

    /**
     * 删除key
     * @param key  key
     * @return 是否设置成功
     */
    Boolean delete(String key);

}

/**
 * Description: Redis操作实现类
 */
@RequiredArgsConstructor
@Service
public class RedisServiceImpl implements IRedisService {
    
    

    private final RedisTemplate<String, Object> redisTemplate;

    @Override
    public void set(String key, Object value, long time) {
    
    
        redisTemplate.opsForValue().set(key, value, time);
    }

    @Override
    public void set(String key, Object value) {
    
    
        redisTemplate.opsForValue().set(key, value);
    }

    @Override
    public Object get(String key) {
    
    
        return redisTemplate.opsForValue().get(key);
    }

    @Override
    public Boolean expire(String key, long time) {
    
    
        return redisTemplate.expire(key, time, TimeUnit.SECONDS);
    }

    @Override
    public Boolean delete(String key) {
    
    
        return redisTemplate.delete(key);
    }
}

5. Realice la prueba Junit

@SpringBootTest
class SpringDataRedisDemoApplicationTests {
    
    

    @Resource
    private IRedisService redisService;

    @Test
    void contextLoads() {
    
    
        redisService.set("name", "xiaobai");
        System.out.println(redisService.get("name"));//xiaobai
    }
}

Solo se muestran algunas operaciones comunes de las cadenas de Redis. Si hay otras operaciones, puede agregar el método correspondiente en IRedisService y luego implementarlo en RedisServiceImpl y llamarlo donde sea necesario.