Linux部署Redis + Java客户端 快速入门

一、快速入门

1、安装Redis

​ 在CentOS系统上安装Redis

第一步：安装依赖 Redis是基于C语言编写的，先安装Redis所需要的gcc依赖。

yum install -y gcc tcl

第二步：安装Redis 通过远程仓库直接下载安装redis

yum install redis

第三步：配置 设置Redis开机自启

systemctl enable redis

第四步：启动Redis

systemctl start redis

第五步：检查测试 检查Redis是否启动成功

systemctl status redis

最后：进入redis

redis-cli

2、修改配置文件

快速安装之后，本地就可以进入redis使用了，但还有一些不足，比如密码设置、外界访问等，需要修改配置文件以实现。

​ 修改redis配置文件：

vim /etc/redis.conf

​ 一般来说yum命令下载安装的应用都在/etc目录下，如果不在，可以检索一下：

sudo find / -name "redis.conf"

就可以显示配置文件路径。

进入后，

1、修改

将原有的bind 127.0.0.1注释掉，加上bind 0.0.0.0，这样外界就也可以访问了。

2、修改

将原有的daemonize no修改为daemonize yes，打开redis的守护进程，可以后台运行。

3、修改

将原有的# requirepass的注解取消，后面写上自己的密码。

在文件中可以按/进行检索单词。

4、重启redis

systemctl restart redis

即可。这样一来，其他设备就可以通过ip+密码方式连接到redis了

3、测试

通过redis-cli命令连接的redis是未认证的，需要输入密码才可进行操作，可以在redis内部通过AUTH 123456(密码)进行认证，亦可在进入时使用redis-cli -a 123456(密码)直接认证。

二、Redis的Java客户端

Spring Data Redis

​ 官方文档： https://spring.io/projects/spring-data-redis

• 提供了对不同Redis客户端的整合（Lettuce和Jedis）
• 提供RedisTemplate统一API操作Reedis
• 支持Redis哨兵和Redis集群
• 支持基于Lettuce的响应式编程
• 支持基于JDK、JSON、字符串、Spring对象的数据序列化及反序列化

2.1快速开始：

1、引入依赖

<!--        redis-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
<!--        连接池-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

2、配置yaml

server:
  port: 8000
spring:
  redis:
    host: localhost # 服务器地址
    port: 6379
    password: 123456
    database: 1
    lettuce:
      pool:
        max-active: 8
        max-idle: 8
        min-idle: 0
        max-wait: 100ms

​ 这里必须选择Lettuce而不能是jedis，因为导的包中默认是Luttuce，如果想用Jedis需要重新导别的包，产看maven依赖可以发现：

3、测试

​ 直接在测试类中编写代码

@Autowired
    private RedisTemplate redisTemplate;

    @Test
    void contextLoads() {
        // 写入一条 String 数据
        redisTemplate.opsForValue().set("name","张三");
        // 根据key拿到value
        System.out.println(redisTemplate.opsForValue().get("name"));
    }

2.2 序列化与反序列化

2.2.1 存在的问题

​ 经过第一步快速开始后，就可以使用redis了，但是这中间还有点问题，我们进入到redis库中查看（我用的库1）：

这是因为RedisTemplate对传入的数据进行的序列化处理。

浏览源码发现：

该类下定义了几个序列化器

他们的初始化如下：

即默认为jdk序列化器。

因此最终存进库中的数据是经过序列化的，将其取出时，又进行了反序列化。

存在的问题：

• 可读性差
• 内存占用大

因此，我们需要重写序列化器。

2.2.2 解决

​ 编写redis配置类

@Configuration
public class RedisConfig {
    @Bean
    //                                                   redis连接工厂
    public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        // 创建RedisTemplate对象
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        // 设置连接
        template.setConnectionFactory(redisConnectionFactory);
        // 创建JSON序列化工具
        // 该序列化器可以用于序列化对象值
        GenericJackson2JsonRedisSerializer jsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
        // 键以String格式存储 值以JSON格式存储
        //        设置key的序列化器
        template.setKeySerializer(RedisSerializer.string());
        template.setHashKeySerializer(RedisSerializer.string());
        //       设置value的序列化器
        template.setValueSerializer(jsonRedisSerializer);
        template.setHashValueSerializer(jsonRedisSerializer);
        return template;
    }
}

这里因为牵扯到后面的序列化，需要有序列化包的依赖：

<!--        序列化-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>2.0.26</version>
        </dependency>

配置好之后就可以测试了

测试代码：

@Test
    void contextLoads() {
        // 写入一条 String 数据
        redisTemplate.opsForValue().set("name","张三");
        // 根据key拿到value
        System.out.println(redisTemplate.opsForValue().get("name"));
        // 写入一条对象数据
        redisTemplate.opsForValue().set("user",new User("张三", "123456"));
        // 根据key拿到对象
        System.out.println(redisTemplate.opsForValue().get("user"));
    }

结果：

2.2.3 新的问题

当使用JSON序列化器存储对象时，发现存储的对象JSON内容上有一个类属性

"@class": "org.example.domain.User".该属性是非常占用内存的，因此，在实际开发中不存储该值，而是只存储String类型的key和value

因此，当存储对象时，需要手动完成序列化。

2.2.4 解决

对于String类型的序列化，我们可以直接使用StringRedisTemplate类，该类直接封装了String的序列化器。即不用手动配置。

​ 直接编写测试代码：

@Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Test
    public void test(){
        stringRedisTemplate.opsForValue().set("nameString","李四");
        String name = stringRedisTemplate.opsForValue().get("nameString");
    }

​ 结果：

但是对于对象的存储，需要手动实现序列化和反序列化。

// spring MVC提供的JSON序列化工具
    private static final ObjectMapper mapper = new ObjectMapper();

    @Test
    public void test() throws JsonProcessingException {
        // String格式 的存储
        stringRedisTemplate.opsForValue().set("nameString","李四");
        String name = stringRedisTemplate.opsForValue().get("nameString");

        // 对象储存
        User user = new User("wdblzs1978","123456");
        // 对象序列化
        String json = mapper.writeValueAsString(user);
        // 写入数据
        stringRedisTemplate.opsForValue().set("user",json);
        // 读出数据
        String userJson = stringRedisTemplate.opsForValue().get("user");
        // 反序列化
        //                 json  和对应的 类
        User user1 = mapper.readValue(userJson, User.class);
        System.out.println(user1);
    }

库内容：

总结：

​ 虽然这样写有些麻烦，但可以将其封装成工具类使用。