分布式文件存储与数据缓存 Redis高可用分布式实践（上）（四）

2023-08-12 97

版权

本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。

本文涉及的产品

云原生内存数据库 Tair，内存型 2GB

云数据库 Redis 版，标准版 2GB

简介： 分布式文件存储与数据缓存 Redis高可用分布式实践（上）（四）

四、Redis可视化工具：Redis Destktop Manager（带时间）

4.1 下载Redis Desktop Manager

官网RESP.app (formerly Redis Desktop Manager) - GUI for Redis ® available on Windows, macOS, iPad and Linux.

或者使用文章配套的安装包。

4.2 连接Redis服务

关闭防火墙

systemctl stop firewalld.service

在redis配置文件中关闭保护模式

protected-mode no

开启远程访问

redis默认只允许本地访问，要使redis可以远程访问可以修改redis.conf。

注释掉bind 127.0.0.1 可以使所有的ip访问redi

重启redis服务

#查看redis端口
lsof -i:6379
#杀死redis进程
kill -9 PID
#重启reids服务
[root@localhost src]# ./redis-server ../redis.conf

- 出现16个库代表连接成功

五、Java整合Redis

5.1 Jedis操作

什么是Jedis

Jedis是Redis官方推荐的Java连接开发工具。

创建maven工程引入maven依赖

<dependency>
   <groupId>redis.clients</groupId>
   <artifactId>jedis</artifactId>
   <version>3.6.0</version>
</dependency>
<dependency>
   <groupId>junit</groupId>
   <artifactId>junit</artifactId>
   <version>4.12</version>
   <scope>test</scope>
</dependency>

Jedis连接到redis并操作redis

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import redis.clients.jedis.Jedis;
import java.util.List;
import java.util.Set;
public class TestJedis {
    Jedis jedis;
    //1.创建连接实例
    @Before
    public void init(){
        /*
         * 第一个参数：redis服务的ip
         * 第二个参数：redis服务的端口
         */
        jedis = new Jedis("192.168.66.100",6379);
    }
    //2.Jedis-API:String
    @Test
    public void stringTest(){
        //设置一个键值对
        jedis.set("k1","v1");
        //通过key获取value
        String k1 = jedis.get("k1");
        System.out.println(k1);
        //对某一个key自增
        Long ires = jedis.incr("k2");
    }
    //2.Jedis-API:Keys
    @Test
    public void keysTest(){
        //返回所有的key
        Set<String> keys = jedis.keys("*");
        //返回该key剩余过期时间
        Long time = jedis.ttl("k1");
    }
    //3.Jedis-API:List
    @Test
    public void listTest(){
        //向list中添加数据
        jedis.lpush("list1","v1","v2","v3");
        //返回list全部数据
        List<String> list = jedis.lrange("list1",0,-1 );
    }
    //4.Jedis-API:Set
    @Test
    public void setTest(){
        //向set中添加数据
        jedis.sadd("set1" ,"v1","v2","v2","v3");
        //查看该集合中有多少个元素
        jedis.smembers("set1");
    }
    //4.Jedis-API:Hash
    @Test
    public void hashTest(){
        //设置一个hash
        jedis.hset("user","age","25");
        //获取该key的所有value
        jedis.hvals("user");
    }
    //4.Jedis-API:Zset
    @Test
    public void zsetTest(){
        //向zset中添加一条数据
        jedis.zadd("zset1",100,"java");
       //获取所有的值
        jedis.zrange("zset1",0,-1);
    }
    //5.Jedis-API:Bitmaps
    @Test
    public void bitmapsTest(){
        //将b1偏移量为0的位设置为1
        jedis.setbit("b1",0, "1");
        //获取b1偏移量为0的位
        jedis.getbit("b1",0);
    }
    //6.Jedis-API:Geospatia
    @Test
    public void geospatiaTest(){
        //添加一条地理信息数据
        jedis.geoadd("chinacity",130,110,"beijing");
    }
    //7.Jedis-API:Hyperloglog
    @Test
    public void hyperloglogTest(){
        //将所有元素参数添加到 Hyperloglog 数据结构中。
        jedis.pfadd("book","c++","java","php");
    }
    @After
    public void close(){
        //1.关闭连接实例
        jedis.close();
    }
}

注意：

其实jedis中的方法基本同redis命令一致。

5.2 Spring-Data-Reids

简介

Spring-Data-Redis是spring大家族的一部分，通过简单的配置访问Redis服务，对Reids底层开发包(Jedis, JRedis, and RJC)进行了高度封装，RedisTemplate提供了Redis各种操作、异常处理及序列化，支持发布订阅。

RedisTemplate介绍

Spring封装了RedisTemplate对象来进行对Redis的各种操作，它支持所有的Redis原生的api。

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

注意：

K：模板中的Redis key的类型，模板中的Redis key的类型（通常为String）如：RedisTemplate<String, Object>。

V：模板中的Redis value的类型

RedisTemplate中定义了对5种数据结构操作

redisTemplate.opsForValue();//操作字符串

redisTemplate.opsForHash();//操作hash

redisTemplate.opsForList();//操作list

redisTemplate.opsForSet();//操作set

redisTemplate.opsForZSet();//操作有序set

StringRedisTemplate与RedisTemplate

两者的关系是StringRedisTemplate继承RedisTemplate。
两者的数据是不共通的；也就是说StringRedisTemplate只能管理StringRedisTemplate里面的数据，RedisTemplate只能管理RedisTemplate中的数据。
SDR默认采用的序列化策略有两种，一种是String的序列化策略，一种是JDK的序列化策略。
StringRedisTemplate默认采用的是String的序列化策略，保存的key和value都是采用此策略序列化保存的。
RedisTemplate默认采用的是JDK的序列化策略，保存的key和value都是采用此策略序列化保存的。

创建springboot项目并添加依赖

<dependencies>
     <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-data-redis-reactive</artifactId>
     </dependency>
     <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-web</artifactId>
     </dependency>
     <dependency>
       <groupId>org.projectlombok</groupId>
       <artifactId>lombok</artifactId>
       <optional>true</optional>
     </dependency>
     <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-test</artifactId>
       <scope>test</scope>
     </dependency>
     <dependency>
       <groupId>io.projectreactor</groupId>
       <artifactId>reactor-test</artifactId>
       <scope>test</scope>
     </dependency>
   </dependencies>

在application.properties中配置

#Redis服务器连接地址
spring.redis.host=192.168.56.31
#Redis服务器连接端口
spring.redis.port=6379
#连接池最大连接数（使用负值表示没有限制）
spring.redis.pool.max-active=8
#连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.pool.max-wait=-1
#连接池中的最大空闲连接
spring.redis.pool.max-idle=8
#连接池中的最小空闲连接
spring.redis.pool.min-idle=0
#连接超时时间（毫秒）
spring.redis.timeout=30000

自定义序列化

RedisTemplate默认采用的是JDK的序列化策略，保存的key和value都是采用此策略序列化保存的。该配置是将其序列化的方式改为json序列化。

package com.zj.redis.conf;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
/**
 * 自定义序列化方式
 */
@Configuration
public class RedisConfig {
   @Bean
   public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory redisConnectionFactory){
     RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
     redisTemplate.setKeySerializer(new StringRedisSerializer());
     redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
     redisTemplate.setHashKeySerializer(new StringRedisSerializer());
     redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
     redisTemplate.setConnectionFactory(redisConnectionFactory);
     return redisTemplate;
   }
}

没有配置自定义序列化之前：

配置自定义序列化之后：注意此时是json类型

package com.zj.redis;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
import javax.annotation.Resource;
import java.util.Set;
@SpringBootTest
class RedisApplicationTests {
    @Resource
    private RedisTemplate redisTemplate;
    /*
    * 使用RedisTemplate实例操作redis
    * */
    //操作字符串
    @Test
    void contextLoads() {
        //添加数据(key是name,value是zhangsan)
        redisTemplate.opsForValue().set("name", "zhangsan");
        //获取数据
        System.out.println(redisTemplate.opsForValue().get("name"));
    }
    //操作list
    @Test
    void contextLoads2(){
        //添加数据
        redisTemplate.opsForList().rightPush("age",23);
        redisTemplate.opsForList().rightPush("age",24);
        redisTemplate.opsForList().rightPush("age",25);
        //获取最右边的数据
        System.out.println(redisTemplate.opsForList().rightPop("age"));
    }
    //操作Hash
    @Test
    void contextLoads3(){
        //添加
        redisTemplate.opsForHash().put("user","name","张三");
        redisTemplate.opsForHash().put("user","age",12);
        redisTemplate.opsForHash().put("user","address","临沂市");
        //获取
        System.out.println(redisTemplate.opsForHash().get("user", "name"));
    }
    //操作set
    @Test
    void contextLoads4(){
        //添加
        redisTemplate.opsForSet().add("verse","两岸猿声啼不住，轻舟已过万重山。","莫愁前路无知己，天下谁人不识君。",
                                                   "大鹏一日同风起，扶摇直上九万里。");
        //获取
        Set verse = redisTemplate.opsForSet().members("verse");
        System.out.println(verse);
        //获取元素长度
        System.out.println(redisTemplate.opsForSet().size("verse"));
    }
    //操作ZSet
    @Test
    void contextLoads5(){
        //添加元素
        redisTemplate.opsForZSet().add("programmer","Dennis MacAlistair Ritchie",100);
        redisTemplate.opsForZSet().add("programmer","Linus Benedict Torvalds",99);
        redisTemplate.opsForZSet().add("programmer","Bjarne Stroustrup ",98);
        redisTemplate.opsForZSet().add("programmer","Brain Wlison Kernighan",97);
        //获取元素
        Set programmer = redisTemplate.opsForZSet().range("programmer", 0, -1);
        System.out.println(programmer);
        //通过分数获取元素
        Set programmer1 = redisTemplate.opsForZSet().rangeByScore("programmer", 90, 100);
        System.out.println(programmer1);
    }
}