redis 入门教程 redis入门指南 pdf

文章目录

• 一、初识Redis

• 1. 认识NoSQL
• 2. 认识Redis
• 3. 安装Redis （Linux）
• 4. Redis客户端

• 二、Redis 常见命令

• 1. Redis 的数据结构
• 2. 通用命令
• 3. String 类型
• 4. Hash 类型
• 5. List 类型
• 5. Set 类型
• 6. SortedSet 类型
• 7. key的命名

• 三、Redis的Java客户端

• 1. Jedis 客户端
• 2. Jedis 连接池
• 3. Spring Data Redis 简介
• 4. Spring Data Redis 快速入门
• 5. 改变RedisTemplate序列化方式

• 四、参考资料

一、初识Redis

Redis 是键值数据库，NoSQL

1. 认识NoSQL

2. 认识Redis

3. 安装Redis （Linux）

1. 官网下载安装包
   https://redis.io/download/
2. 首先安装Redis的gcc 依赖
   yum install -y gcc tcl
3. 上传安装包、解压
   将redis安装包上传到 Linux usr/local/src/ 目录下。
   进入src目录cd usr/local/src 解压 tar -zxvf redis-7.0.5.tar.gz
4. 进入redis解压目录
   cd redis-7.0.5
5. 运行编译、安装命令
   make && make install
7. 安装成功 默认在 usr/local/bin路径下



9. 修改配置文件
   先拷贝一份，防止修改坏了。
   cp redis.conf redis.conf.bck



10. 修改配置文件
    vi redis.conf

8. 启动redis

redis-server redis.conf 指定配置文件启动

9. 开机自启redis
   每次手动启动麻烦，可以编写配置文件 设置开机启动。
   创建配置文件 vi /etc/systemd/system/redis.service 文件内容为：

[Unit]
Description=redis-server
After=network.target

[Service]
Type=forking
ExecStart=/usr/local/bin/redis-server /usr/local/src/redis-7.0.5/redis.conf
PrivateTmp=true

[Install]
WantedBy=multi-user.target

重载系统服务
systemctl daemon-reload

打开开机自启systemctl enable redis

启动redissystemctl start redis 查看redis状态systemctl status redis 停止redissystemctl stop redis 重启redissystemctl restart redis

4. Redis客户端

• 命令行客户端
• 图形化桌面客户端

1. 命令行客户端

命令格式: redis-cli [options] [commonds]

进入redis安装目录 cd /usr/local/bin

打开客户端 连接redis redis-cli -h 192.168.137.136 -p 6379 -a 123456

测试连接是否成功 ping

2. 图形化界面客户端

https://github.com/lework/RedisDesktopManager-Windows

二、Redis 常见命令

1. Redis 的数据结构

官方文档查询命令：https://redis.io/commands/

2. 通用命令

通用指令是部分数据类型都可以使用的指令，常见的有：

• keys : 查看符合模板的所有key，不建议在生产环境设备上使用
• del : 删除一个指定的key
• exists : 判断key是否存在
• expire : 给一个key设置有效期，到期该key被自动删除
• ttl : 查看一个key的剩余有效期，-1 永久，-2 已过期删除
• help : 通过help [command] 查看一个命令的具体用法

3. String 类型

4. Hash 类型

5. List 类型

5. Set 类型

6. SortedSet 类型

7. key的命名

三、Redis的Java客户端

1. Jedis 客户端

官方网址: https://github.com/redis/jedis

1. 引入依赖

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

2. 建立连接

import org.junit.jupiter.api.BeforeEach;
import redis.clients.jedis.Jedis;

public class JedisTest {

    private Jedis jedis;

    @BeforeEach
    public void setUp() {
        // 建立连接
        jedis = new Jedis("192.168.137.136", 6379);
        // 密码
        jedis.auth("123456");
        // 选择库
        jedis.select(0);
    }
}

3. 测试

@Test
    public void testString() {
        // 插入数据
        jedis.set("name", "Jack");
        // 获取数据
        String value = jedis.get("name");
        // 打印
        System.out.println(value);
    }

    @Test
    public void testHash() {
        // 插入数据
        jedis.hset("user:1", "name", "Tom");
        jedis.hset("user:1", "age", "18");
        // 获取数据
        String name = jedis.hget("user:1", "name");
        // 打印
        System.out.println(name);

        Map<String, String> map = jedis.hgetAll("user:1");
        map.forEach((s, s2) -> System.out.println(s + ":" + s2));
    }

4. 释放资源

@AfterEach
    public void close() {
        if (jedis != null) {
            jedis.close();
        }
    }

2. Jedis 连接池

Jedis本身是线程不安全的，并且频繁的创建和销毁连接会有性能损耗，因此使用Jedis连接池代替Jedis的直连方式。

package util;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

public class JedisConnectionFactory {

    private static final JedisPool jedisPool;

    static {
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        // 最大连接数
        jedisPoolConfig.setMaxTotal(8);
        // 最大空闲连接
        jedisPoolConfig.setMaxIdle(8);
        // 做小空闲连接
        jedisPoolConfig.setMinIdle(0);
        // 最长等待时间, ms
        jedisPoolConfig.setMaxWaitMillis(200);
        jedisPool = new JedisPool(jedisPoolConfig, "192.168.137.136", 6379, 1000, "123456");
    }

    // 获取Jedis对象
    public static Jedis getJedis(){
        return jedisPool.getResource();
    }
}

3. Spring Data Redis 简介

https://spring.io/projects/spring-data-redis#support

4. Spring Data Redis 快速入门

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. 配置文件

spring:
  redis:
    host: 192.168.137.136
    port: 6379
    password: 123456
    lettuce:
      pool:
        max-active: 8
        max-idle: 8
        min-idle: 0
        max-wait: 100ms

3. 测试

import com.heima.JedisApplication;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;

@SpringBootTest(classes = JedisApplication.class)
public class JedisTest {

    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    public void testString() {
        redisTemplate.opsForValue().set("name", "jack"); //会序列化
        String name = (String) redisTemplate.opsForValue().get("name");
        System.out.println(name);
    }
}

5. 改变RedisTemplate序列化方式

• RedisTemplat 会把 key、value 当成java对象，进行序列化。可读性差，存储占用大。

• 引入jackson依赖

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
</dependency>

• 修改RedisTemplate 序列化方式

package com.heima.config;

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.RedisSerializer;

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory){
        // 创建RedisTemplate
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        // 设置连接工厂
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        // 设置序列化工具
        GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
        // key和hashkey采用 string序列化
        redisTemplate.setKeySerializer(RedisSerializer.string());
        redisTemplate.setHashKeySerializer(RedisSerializer.string());
        // value和hashvalue采用json序列化
        redisTemplate.setValueSerializer(genericJackson2JsonRedisSerializer);
        redisTemplate.setHashValueSerializer(genericJackson2JsonRedisSerializer);
        return redisTemplate;
    }
}

---

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.heima.JedisApplication;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.StringRedisTemplate;

@SpringBootTest(classes = JedisApplication.class)
public class JedisTest {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    // JSON工具
    private static final ObjectMapper mapper = new ObjectMapper();

    @Test
    public void testString() throws JsonProcessingException {
        // 准备对象
        Employee employee = new Employee("张三", 18);
        // 手动序列化
        String json = mapper.writeValueAsString(employee);
        // 插入数据
        stringRedisTemplate.opsForValue().set("user", json);
        // 读取数据
        String s = stringRedisTemplate.opsForValue().get("user");
        // 反序列化
        Employee emp = mapper.readValue(s, Employee.class);
        // 打印
        System.out.println(emp);
    }
}

@Data
@NoArgsConstructor //空参构造器，jackson工具反射时需要
@AllArgsConstructor
class Employee {
    private String name;
    private Integer age;
}