springboot使用redis完整操作步骤（服务端安装、工具查看是乱码等）

一、redis服务端安装

下载Redis

进入官网找到下载地址 https://redis.io/download

右键Download按钮，选择复制链接。
进入到Xshell控制台(默认当前是root根目录)，输入wget 将上面复制的下载链接粘贴上，如下命令:（这里以5.0.7版本作为版本）

wget http://download.redis.io/releases/redis-5.0.7.tar.gz

敲入回车键执行后如下图:

等待下载完成。

解压并安装Redis

解压

下载完成后需要将压缩文件解压，输入以下命令解压到当前目录

tar -zvxf redis-5.0.7.tar.gz

解压后在根目录上输入ls 列出所有目录会发现与下载redis之前多了一个redis-5.0.7.tar.gz文件和 redis-5.0.7的目录。

移动redis目录

一般都会将redis目录放置到 /usr/local/redis目录，所以这里输入下面命令将目前在/root目录下的redis-5.0.7文件夹更改目录，同时更改文件夹名称为redis。

mv /root/redis-5.0.7 /usr/local/redis

cd 到/usr/local目录下输入ls命令可以查询到当前目录已经多了一个redis子目录，同时/root目录下已经没有redis-5.0.7文件夹

安装gcc环境

由于redis是由C语言编写的，它的运行需要C环境，因此我们需要先安装gcc。安装命令如下：

[root@localhost mnt]# yum install gcc-c++

编译

cd到/usr/local/redis目录，输入命令make执行编译命令，接下来控制台会输出各种编译过程中输出的内容。

make    //对解压后的文件进行编译

最终运行结果如下:

安装

输入以下命令

[root@localhost redis]# cd ./src   //进入到 redis/src 文件目录下

[root@localhost src]# make install    //进行redis安装

为了方便管理，将Redis文件中的conf配置文件和常用命令移动到统一文件中

(1)创建bin和etc文件夹

[root@localhost redis]# mkdir bin      //创建bin文件夹

[root@localhost redis]# mkdir etc   //创建etc文件夹

(2) 将redis目录下的 redis.conf 移动到 redis目录下的etc文件夹下

//将redis目录下的 redis.conf 移动到 redis目录下的src文件夹下
[root@localhost redis]# mv redis.conf ./etc/  

[root@localhost redis]# cd ./src/      //进入redis目录下的src文件夹下

//将mkreleasehdr.sh、redis-benchmark、redis-check-aof、redis-cli、redis-server 移动到   /usr/local/redis/bin/ 目录下
[root@localhost src]# mv mkreleasehdr.sh redis-benchmark redis-check-aof redis-cli redis-server /usr/local/redis/bin/

进入到/usr/local/redis/etc/ 目录下

//进入到/usr/local/redis/etc/ 目录下
[root@localhost src]# cd /usr/local/redis/etc/   
 
[root@localhost etc]# ls   //查看etc目录
redis.conf

编辑 redis.conf配置文件，设置后台启动redis服务

[root@localhost etc]# vi redis.conf

把文件中的daemonize属性改为yes（表明需要在后台运行）

编辑 redis.conf配置文件，开启redis远程访问服务

（1）把 redis.conf配置文件中的 bind 127.0.0.1 这一行给注释掉，这里的bind指的是只有指定的网段才能远程访问这个redis，注释掉后，就没有这个限制了。

（2）把 redis.conf配置文件中的 protected-mode 设置成no（默认是设置成yes的， 防止了远程访问，在redis3.2.3版本后）

编辑 redis.conf配置文件，修改Redis默认密码 (默认密码为空)

   （1）在配置文件中找到这一行 # requirepass foobared

   （2）删除前面的注释符号#，并把foobared修改成自己的密码  或者  另起一行 requirepass 自己的密码

设置Redis开机启动

[root@localhost etc]# vi /etc/rc.d/rc.local

添加如下代码到 /etc/rc.d/rc.local 中：

/usr/local/redis-5.0.0/bin/redis-server  /usr/local/redis-5.0.0/etc/redis.conf

切换到 /usr/local/redis/bin/ 目录下执行 redis-server 命令，使用 /usr/local/redis/etc/redis.conf配置文件来启动redis服务

//进入到/usr/local/redis/bin/ 目录下
[root@localhost etc]# cd /usr/local/redis/bin/  
 
[root@localhost bin]# ls        //查看bin目录
mkreleasehdr.sh  redis-benchmark  redis-check-aof  redis-cli  redis-server
 
[root@localhost bin]# ./redis-server /usr/local/redis/etc/redis.conf   //启动Redis服务

打开RedisDesktopManager，测试服务是否开启 以及 是否可以远程访问Redis

Redis的整个安装过程到此结束。

查看Redis是否正在运行

1、采取查看进程方式

ps -aux | grep redis

结果如下图：

2、采取端口监听查看方式

netstat -lanp | grep 6379

结果如下图：

redis-cli

redis-cli是连接本地redis服务的一个命令，通过该命令后可以既然怒redis的脚本控制台。如下图

输入exit可以退出redis脚本控制台

关闭运行中的Redis服务

输入redis-cli 进入控制台后输入命令shutdown即可关闭运行中的Redis服务了。如下图:

远程连接不上问题

如下图，已经开放了Redis服务的ip不为127.0.0.1,理论上远程客户端应该可以连接了，而且云服务器的端口号也在安全组里开放了。

二、springboot整合redis服务

添加pom依赖

       <!--redis-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!--序列化配置-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>${fastjson.version}</version>
</dependency>

增加配置数据

spring:
  redis:
    port: 6379
    #这里配置服务器ip
    host: 127.0.0.1
    #Redis数据库索引（默认为0）
    database: 0
    password: 123456
    #连接池配置
    jedis:
      pool:
        #连接池最大连接数（使用负值表示没有限制）
        max-active: 8
        #连接池最大阻塞等待时间（使用负值表示没有限制）
        max-wait: -1ms
        #连接池中的最大空闲连接
        max-idle: 8
        #连接池中的最小空闲连接
        min-idle: 0
    #超时时间
    timeout: 5000ms

创建一个util服务

package com.XXX.util.redis;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;

/**
 * redis 服务
 *
 * @desc: 封装的redis服务，包含string、list、hash等数据的插入、获取删除等操作
 * @author: ys.mao
 * @time: 2021/6/22 20:07
 */
@Component
public class RedisUtils {

    private RedisUtils() {
    }

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 设置有效时间
     *
     * @param key     Redis键
     * @param timeout 超时时间
     * @return true=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long timeout) {

        return expire(key, timeout, TimeUnit.SECONDS);
    }

    /**
     * 设置有效时间
     *
     * @param key     Redis键
     * @param timeout 超时时间
     * @param unit    时间单位
     * @return true=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long timeout, final TimeUnit unit) {

        Boolean flag = redisTemplate.expire(key, timeout, unit);
        return flag != null && flag;
    }

    /**
     * 删除单个key
     *
     * @param key 键
     * @return true=删除成功；false=删除失败
     */
    public boolean del(final String key) {

        Boolean flag = redisTemplate.delete(key);
        return flag != null && flag;
    }

    /**
     * 删除多个key
     *
     * @param keys 键集合
     * @return 成功删除的个数
     */
    public long del(final Collection<String> keys) {

        Long flag = redisTemplate.delete(keys);
        return flag == null ? 0 : flag;
    }

    /**
     * 存入普通对象
     *
     * @param key   Redis键
     * @param value 值
     */
    public void set(final String key, final Object value) {

        //普通对象 不加失效时间的话  默认有效时间1分钟
        redisTemplate.opsForValue().set(key, value, 1, TimeUnit.MINUTES);
    }


    /**
     * 存入普通对象
     *
     * @param key     键
     * @param value   值
     * @param timeout 有效期，单位秒
     */
    public void set(final String key, final Object value, final long timeout) {

        redisTemplate.opsForValue().set(key, value, timeout, TimeUnit.SECONDS);
    }

    /**
     * 获取普通对象
     *
     * @param key 键
     * @return 对象
     */
    public Object get(final String key) {

        return redisTemplate.opsForValue().get(key);
    }


    /**
     * 往Hash中存入数据
     *
     * @param key   Redis键
     * @param hKey  Hash键
     * @param value 值
     */
    public void hPut(final String key, final String hKey, final Object value) {

        redisTemplate.opsForHash().put(key, hKey, value);
    }

    /**
     * 往Hash中存入多个数据
     *
     * @param key    Redis键
     * @param values Hash键值对
     */
    public void hPutAll(final String key, final Map<String, Object> values) {

        redisTemplate.opsForHash().putAll(key, values);
    }

    /**
     * 获取Hash中的数据
     *
     * @param key  Redis键
     * @param hKey Hash键
     * @return Hash中的对象
     */
    public Object hGet(final String key, final String hKey) {

        return redisTemplate.opsForHash().get(key, hKey);
    }

    /**
     * 获取多个Hash中的数据
     *
     * @param key   Redis键
     * @param hKeys Hash键集合
     * @return Hash对象集合
     */
    public List<Object> hMultiGet(final String key, final Collection<Object> hKeys) {

        return redisTemplate.opsForHash().multiGet(key, hKeys);
    }


    /**
     * 往Set中存入数据
     *
     * @param key    Redis键
     * @param values 值
     * @return 存入的个数
     */
    public long sSet(final String key, final Object... values) {
        Long count = redisTemplate.opsForSet().add(key, values);
        return count == null ? 0 : count;
    }

    /**
     * 删除Set中的数据
     *
     * @param key    Redis键
     * @param values 值
     * @return 移除的个数
     */
    public long sDel(final String key, final Object... values) {
        Long count = redisTemplate.opsForSet().remove(key, values);
        return count == null ? 0 : count;
    }


    /**
     * 往List中存入数据
     *
     * @param key   Redis键
     * @param value 数据
     * @return 存入的个数
     */
    public long lPush(final String key, final Object value) {
        Long count = redisTemplate.opsForList().rightPush(key, value);
        return count == null ? 0 : count;
    }

    /**
     * 往List中存入多个数据
     *
     * @param key    Redis键
     * @param values 多个数据
     * @return 存入的个数
     */
    public long lPushAll(final String key, final Collection<Object> values) {
        Long count = redisTemplate.opsForList().rightPushAll(key, values);
        return count == null ? 0 : count;
    }

    /**
     * 往List中存入多个数据
     *
     * @param key    Redis键
     * @param values 多个数据
     * @return 存入的个数
     */
    public long lPushAll(final String key, final Object... values) {
        Long count = redisTemplate.opsForList().rightPushAll(key, values);
        return count == null ? 0 : count;
    }

    /**
     * 从List中获取begin到end之间的元素
     *
     * @param key   Redis键
     * @param start 开始位置
     * @param end   结束位置（start=0，end=-1表示获取全部元素）
     * @return List对象
     */
    public List<Object> lGet(final String key, final int start, final int end) {
        return redisTemplate.opsForList().range(key, start, end);
    }


}

增加配置类 解决rdm打开全是二进制问题

package com.XXX.config;

import com.alibaba.fastjson.parser.ParserConfig;
import com.alibaba.fastjson.support.spring.FastJsonRedisSerializer;
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.StringRedisSerializer;


/**
 * redis 序列化可视问题
 *
 * @desc: 重写Redis序列化方式，使用Json方式:
 * 当我们的数据存储到Redis的时候，我们的键（key）和值（value）都是通过Spring提供的Serializer序列化到数据库的。
 * RedisTemplate默认使用的是JdkSerializationRedisSerializer，StringRedisTemplate默认使用的是StringRedisSerializer。
 * Spring Data JPA为我们提供了下面的Serializer：
 * GenericToStringSerializer、Jackson2JsonRedisSerializer、JacksonJsonRedisSerializer、
 * JdkSerializationRedisSerializer、OxmSerializer、StringRedisSerializer。
 * 在此我们将自己配置RedisTemplate并定义Serializer。
 * @author: ys.mao
 * @time: 2021/6/22 20:11
 */
@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);

        FastJsonRedisSerializer<Object> fastJsonRedisSerializer = new FastJsonRedisSerializer<>(Object.class);
        // 全局开启AutoType，不建议使用
         ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
        // 建议使用这种方式，小范围指定白名单
//        ParserConfig.getGlobalInstance().addAccept("com.fable.");

        // 设置值（value）的序列化采用FastJsonRedisSerializer
        redisTemplate.setValueSerializer(fastJsonRedisSerializer);
        redisTemplate.setHashValueSerializer(fastJsonRedisSerializer);
        // 设置键（key）的序列化采用StringRedisSerializer
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());

        redisTemplate.afterPropertiesSet();
        return redisTemplate;


    }
}