• Redis基础学习

    文章目录

    Redis基础

    可当数据库也可用于当缓存（cache），redis存储的方式是key-value的键值对形式

    Redis的应用场景：

    • 缓存（cache）

    • 任务队列

    • 消息队列

    • 分布式锁

    一、下载安装与使用

    1.1.下载安装

    Redis安装包分为windows版和Linux版：

    Windows版下载地址：https://github.com/microsoftarchive/redis/releases

    Linux版下载地址： https://download.redis.io/releases/

    在Linux系统安装Redis步骤：

    1.将Redis安装包上传到Linux

    2.解压安装包，命令：tar -zxvf redis-4.0.0.tar.gz -C /usr/local

    3.安装Redis的依赖环境gcc，命令：yum install gcc-c++

    4.进入/usr/local/redis-4.0.0，进行编译，命令：make

    5.进入redis的src目录，进行安装，命令：make install

    1.2.redis服务启动、连接与停止

    Linux中redis服务启动与停止

    Linux中redis服务启动，可以使用redis-server（安装redis目录里的src下），默认端口号为6379

    在这里插入图片描述

    Ctrl + C停止Redis服务

    连接redis服务（客户端连接）：redis-cli

    优化：将redis服务于后台运行

    • 修改src下的redis-conf配置文件，令daemonize yes

    • 再次启动redis显示加载配置文件： src/redis-service ./redis-conf

    关闭连接，重新连接：

    • 找到进程：ps -ef | grep reids
    • 关闭：kill -9 进程端口号

    Windows中redis服务启动与停止:

    Redis的Windows版属于绿色软件，直接解压即可使用，解压后目录结构如下：

    在这里插入图片描述

    Windows系统中启动Redis，直接双击redis-server.exe即可启动Redis服务，redis服务默认端口号为6379

    在这里插入图片描述

    Ctrl + C停止Redis服务

    1.3.设置密码和远程连接

    为了安全，当客户连接redis服务的时候，要登录，为此我们给Linux系统中设置密码认证：

    • 在redis conf配置文件中修改即可，

    requirepass foobared

    • 关闭连接，重新连接：
      • 找到进程：ps -ef | grep reids
      • 关闭：kill -9 进程端口号
    • 重新启动redis（当前在redis目录下）： src/redis-server ./redis.conf
    • 然后就可以通过客户端连接（登陆的同时完成认证）：src/redis-cli -h localhost -p 6379 -a 123456

    修改配置文件，使得可以远程连接Linux虚拟机中的redis服务

    • 进入 redis-conf，快捷方式bind，将只能由本机连接的信息注释# bind 127.0.0.1
    • 然后重新启动服务（杀掉进程 然后重启）
    • Windows系统尝试连接远程redis服务，记得关闭防火墙（或者开启特定端口号）
      • 在windows安装redis的目录下，打开终端.\redis-cli.exe -h 192.168.245.100 -p 6379 -a 123456

    在这里插入图片描述

    防火墙相关指令：

    systemctl start firewalld

systemctl status firewalld / firewall-cmd --state

firewall-cmd --zone=public --add-port=6379/tcp --permanent

firewall-cmd --reload

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    二、redis数据类型

    在这里插入图片描述

    redis中通过命令操作数据！

    更多命令可以参考Redis中文网：https://www.redis.net.cn

    2.1.字符串 string 操作命令

    在这里插入图片描述

    2.2.哈希 hash 操作命令

    该指令常用于存储对象！

    在这里插入图片描述

    2.3.列表 list 操作命令

    常用于做任务队列！

    在这里插入图片描述

    BRPOP当删除列表的最后一个元素后，会堵塞timeout秒

    在这里插入图片描述

    2.4.集合 set 操作命令

    在这里插入图片描述

    2.5.有序集合 sorted set 操作命令

    在这里插入图片描述

    2.6.通用命令

    以下指令是针对key的，也就说适用于所有类型！

    在这里插入图片描述

    三、在 Java 中操作 Redis

    3.1.介绍

    Redis 的 Java 客户端很多，官方推荐的有三种：

    • Jedis
    • Lettuce
    • Redisson

    Spring 对 Redis 客户端进行了整合，提供了 Spring Data Redis，在Spring Boot项目中还提供了对应的Starter，即spring-boot-starter-data-redis

    3.2.Jedis（不常用略过）

    3.3.Data Redis（常用）

    Spring Data Redis中提供了一个高度封装的类：RedisTemplate，针对jedis客户端中大量api进行了归类封装,将同一类型操作封装为operation接口，具体分类如下：

    • ValueOperations：简单K-V操作
    • SetOperations：set类型数据操作
    • ZSetOperations：zset类型数据操作
    • HashOperations：针对map类型的数据操作
    • ListOperations：针对list类型的数据操作

    实现步骤：

    1、引入maven坐标

    在Spring Boot 项目中，可以使用Spring Data Redis（boot项目自带）来简化Redis操作，maven坐标：

            <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-data-redisartifactId>
        dependency>

    • 1
    • 2
    • 3
    • 4

    2、配置yml配置文件，一定要保证基本信息是正确的！

    spring:
  application:
    name: redis-demo
  #Redis相关配置
  redis:
    host: 192.168.245.100 #安装redis的服务器ip
    port: 6379 #redis进程端口号
    password: 123456
    database: 0 #操作的是0号数据库
    jedis:
      #Redis连接池配置
      pool:
        max-active: 8 #最大连接数
        max-wait: 1ms #连接池最大阻塞等待时间
        max-idle: 4 #连接池中的最大空闲连接
        min-idle: 0 #连接池中的最小空闲连接

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    3、编写测试类测试

    package com.itheima.test;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.connection.DataType;
import org.springframework.data.redis.core.*;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;

@SpringBootTest
@RunWith(SpringRunner.class)
public class SpringDataRedisTest {

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 操作String类型数据
     */
    @Test
    public void testString(){
        redisTemplate.opsForValue().set("city123","beijing");

        String value = (String) redisTemplate.opsForValue().get("city123");
        System.out.println(value);

        redisTemplate.opsForValue().set("key1","value1",10l, TimeUnit.SECONDS);

        Boolean aBoolean = redisTemplate.opsForValue().setIfAbsent("city1234", "nanjing");
        System.out.println(aBoolean);
    }

    /**
     * 操作Hash类型数据
     */
    @Test
    public void testHash(){
        HashOperations hashOperations = redisTemplate.opsForHash();

        //存值
        hashOperations.put("002","name","xiaoming");
        hashOperations.put("002","age","20");
        hashOperations.put("002","address","bj");

        //取值
        String age = (String) hashOperations.get("002", "age");
        System.out.println(age);

        //获得hash结构中的所有字段
        Set keys = hashOperations.keys("002");
        for (Object key : keys) {
            System.out.println(key);
        }

        //获得hash结构中的所有值
        List values = hashOperations.values("002");
        for (Object value : values) {
            System.out.println(value);
        }
    }

    /**
     * 操作List类型的数据
     */
    @Test
    public void testList(){
        ListOperations listOperations = redisTemplate.opsForList();

        //存值
        listOperations.leftPush("mylist","a");
        listOperations.leftPushAll("mylist","b","c","d");

        //取值
        List<String> mylist = listOperations.range("mylist", 0, -1);
        for (String value : mylist) {
            System.out.println(value);
        }

        //获得列表长度 llen
        Long size = listOperations.size("mylist");
        int lSize = size.intValue();
        for (int i = 0; i < lSize; i++) {
            //出队列
            String element = (String) listOperations.rightPop("mylist");
            System.out.println(element);
        }
    }

    /**
     * 操作Set类型的数据
     */
    @Test
    public void testSet(){
        SetOperations setOperations = redisTemplate.opsForSet();

        //存值
        setOperations.add("myset","a","b","c","a");

        //取值
        Set<String> myset = setOperations.members("myset");
        for (String o : myset) {
            System.out.println(o);
        }

        //删除成员
        setOperations.remove("myset","a","b");

        //取值
        myset = setOperations.members("myset");
        for (String o : myset) {
            System.out.println(o);
        }

    }

    /**
     * 操作ZSet类型的数据
     */
    @Test
    public void testZset(){
        ZSetOperations zSetOperations = redisTemplate.opsForZSet();

        //存值
        zSetOperations.add("myZset","a",10.0);
        zSetOperations.add("myZset","b",11.0);
        zSetOperations.add("myZset","c",12.0);
        zSetOperations.add("myZset","a",13.0);

        //取值
        Set<String> myZset = zSetOperations.range("myZset", 0, -1);
        for (String s : myZset) {
            System.out.println(s);
        }

        //修改分数
        zSetOperations.incrementScore("myZset","b",20.0);

        //取值
        myZset = zSetOperations.range("myZset", 0, -1);
        for (String s : myZset) {
            System.out.println(s);
        }

        //删除成员
        zSetOperations.remove("myZset","a","b");

        //取值
        myZset = zSetOperations.range("myZset", 0, -1);
        for (String s : myZset) {
            System.out.println(s);
        }
    }

    /**
     * 通用操作，针对不同的数据类型都可以操作
     */
    @Test
    public void testCommon(){
        //获取Redis中所有的key
        Set<String> keys = redisTemplate.keys("*");
        for (String key : keys) {
            System.out.println(key);
        }

        //判断某个key是否存在
        Boolean itcast = redisTemplate.hasKey("itcast");
        System.out.println(itcast);

        //删除指定key
        redisTemplate.delete("myZset");

        //获取指定key对应的value的数据类型
        DataType dataType = redisTemplate.type("myset");
        System.out.println(dataType.name());

    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151
    • 152
    • 153
    • 154
    • 155
    • 156
    • 157
    • 158
    • 159
    • 160
    • 161
    • 162
    • 163
    • 164
    • 165
    • 166
    • 167
    • 168
    • 169
    • 170
    • 171
    • 172
    • 173
    • 174
    • 175
    • 176
    • 177
    • 178
    • 179
    • 180
    • 181
    • 182
    • 183

    发现key乱码：

    在这里插入图片描述

    • 原因集成的RedisTemplate带有默认的Key序列化器
    • 解决方案：编写配置类，修改掉默认序列化器，用我们自己的即可

    方式一：编写配置类，自定义序列化器

    import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
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.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * redis配置
 *
 * @author MinghanSui
 */
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {
    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);

        ObjectMapper mapper = new ObjectMapper();
        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);

        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer(mapper);

        // key采用StringRedisSerializer 序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // value采用GenericJackson2JsonRedisSerializer 序列化方式
        template.setValueSerializer(genericJackson2JsonRedisSerializer);

        // Hash key采用StringRedisSerializer 序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // Hash value采用GenericJackson2JsonRedisSerializer 序列化方式
        template.setHashValueSerializer(genericJackson2JsonRedisSerializer);

        template.afterPropertiesSet();
        return template;
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48

    方式二：编写配置类，自定义序列化器

    RedisTemplate改为使用StringRedisTemplate即可

  • 相关阅读:
    TCP的可靠传输
    OpenCV 人脸检测（易上手版）
    动态规划 八月八日
    低代码助力生产管理：健康安全环境管理系统
    浙江文投旗下良渚文创与艾叶文化达成战略合作，让版本文化“活”起来
    Android Studio(项目收获)
    传输层 TCP 拥塞控制（2）：拥塞避免
    Spring MVC（一）— DispatcherServlet
    java继承与多态——多态
    【Shell篇＜Ⅴ＞】——三剑客之awk
  • 原文地址：https://blog.csdn.net/qq_54773252/article/details/126686973