Redis快速入门

Redis

初识Redis

SQL：关系型数据库

结构化（Structured）

关联的（Relational）

SQL查询

ACID

NoSQL：非关系型数据库

非结构化

无关联的

非SQL

BASE

认识Redis

Redis全称：Remote Dictionary Server，远程词典服务器，是一个基于内存的键值型NoSQL数据库。

特征：

​ 键值型，value支持多种不同数据结构，功能丰富

​ 单线程，每个命令具备原子性

​ 低延迟，速度快（基于内存、IO多路复用、良好的代码）

​ 支持数据持久化

​ 支持主从集群、分片集群

安装Redis

1、下载gcc

2、将redis安装包放到 /usr/local/src/下并解压

3、进入到redis的安装目录，运行编译命令

make && make install

4、使用 redis-server运行redis

5、指定配置启动

远程连接Redis

1.bind 127.0.0.1改为 #bind 127.0.0.1 (注释掉)
2.protected-mode yes 改为 protected-mode no
3.加入 daemonize no(这个是是否在后台启动不占用一个主程窗口)

Redis常见命令

数据结构

Redis是一个key-value的数据库，key一般是String类型，不过value的类型多种多样：

基本类型:String、Hash、List、Set、SortedSet

特殊类型：GEO、BitMap、HyperLog

操作Redis

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

执行下面的命令，可以让redis开机自启：

systemctl enable redis

通用命令

​ KEYS：查看符合模板的所有key

​ DEL：删除一个指定的KEY

​ EXISTS：判断key是否存在

​ EXPIRE：给一个key设置有效期，有效期到期时该key会被自动删除

​ TTL：查看一个KEY的剩余有效期

String类型

String类型，也就是字符串类型，时Redis中最简单的存储类型。

根据字符串的格式不同，又可以分为3类：

​ string：普通字符串

​ int：整数类型，可以自增、自减

​ float：浮点类型，可以自增、自减

不管哪种格式，底层都是字节数组形式存储，只不过是编码方式不同。字符串类型的最大空间不能超过512m

String的常见命令：

​ SET：添加或者修改已经存在的一个String类型的键值对

​ GET：根据key获取String类型的value

​ MSET：批量添加多个String类型的键值对

​ MGET：根据多个key获取多个String类型的value

​ INCR：让一个整型的key自增1

​ INCRBY：让一个整型的key自增并指定步长，例如：incrby num 2 让num值自增2

​ INCRBYFLOAT：让一个浮点类型的数字自增并指定步长

​ SETNX：添加一个String类型的键值对，前提是这个key不存在，否则不执行2

​ SETEX：添加一个String类型的键值对，并指定有效期

Redis的key的格式：

【项目名】：【业务名】：【类型】：【id】

Hash类型

Hash类型，也叫散列，其value是一个无序字典，类似于Java中的HashMap结构

Hash的常见命令：

​ HSET key field value：添加或者修改hash类型key的field值

​ HGET key field：获取一个hash类型的field的值

​ HMSET：批量添加多个hash类型key的field的值

​ HMGET：批量获取多个hash类型key的field的值

​ HGETALL：获取一个hash类型的key中的所有的field和value

​ HKEYS：获取一个hash类型的key中的所有的field

​ HVALS：获取一个hash类型的key中的所有的value

​ HINCRBY：让一个hash类型key的字段值自增并指定步长

​ HSETNX：添加一个hash类型的key的field值，前提是这个field不存在，否则不执行

List类型

Redis中的List类型与Java中的LinkedList类似，可以看作是一个双向链表结构。既可以支持正向检索也可以支持反向检索。

List的常见命令有：

​ LPUSH key element：向列表左侧插入一个或多个元素

​ LPOP key：移除并返回列表左侧第一个元素，没有返回nil

​ RPUSH key element:向列表右侧插入一个或多个元素

​ RPOP key：一处并返回列表右侧第一个元素

​ LRANGE key star end：返回一段角标范围内的所有元素

​ BLPOP和BRPOP：与LPOP和RPOP类似，只不过在没有元素时等待指定时间，而不是直接返回nil

Set类型

Redis的Set结构与Java中的HashSet类似，可以看作是一个value为null的HashMap。因为也是一个hash表，因此具备HashSet类似的特征：

Set常见的命令有：

​ SADD key member：向set中添加一个或多个元素

​ SREM key member：移除set中的指定元素

​ SCARD key：返回set中元素的个数

​ SISMEMBER key mamber：判断一个元素是否存在于set中

多集合操作：

​ SMEMBERS：获取set中的所有元素

​ SINTER key1 key2…:求交集

​ SDIFF key1 key2…:求差集

​ SUNION key1 key2…:求并集

SortedSet类型

Redis中SortedSet是一个可排序的Set集合，与Java中的TreeSet有些类似，但底层数据结构却差别很大。SortedSet中的每一个元素都带有一个score属性，可以基于score属性对元素排序，底层的实现是一个跳表（SkipList）加Hash表。

SortedSet的常见命令：

​ ZADD key score member：添加一个或多个元素到sorted set，如果已经存在则更新其score值

​ ZREM key member：删除sorted set中的一个指定元素

​ ZSCORE key member：获取sorted set中的指定元素的score值

​ ZRANK key member：获取sorted set中的指定元素的排名

​ ZCARD key：获取sorted set中的元素个数

​ ZCOUNT key min max：统计score值在给定范围内的所有元素的个数

​ ZINCRBY key increment member：让sorted set中的指定元素自增，步长为指定的increment值

​ ZRANGE key min max：按照score排序后，获取指定排名范围内的元素

​ ZRANGEBYSCORE key min max：按照score排序后，获取指定score范围内的元素

​ ZDIFF、ZINTER、ZUNION：求差集、交集、并集

​ ps：所有的排名默认是升序，如果要降序则在命令的Z后面添加REV即可

Redis命令行客户端

redis安装完成后自带了命令行客户端：redis-cli，使用方式如下：

redis-cli [options] [commonds]

其中常见的options有：

-h 127.0.0.1 指定要连接的redis节点的ip地址，默认是127.0.0.1

-p 6379 指定要连接redis节点的端口，默认是6379

-a 123321：指定redis的访问密码

其中commonds就是Redis的操作命令，例如：

ping：与redis服务端做心跳测试，服务端正常会返回pong

不指定commond时，会进入redis- cli控制台

Redis的java客户端

添加依赖：

<dependencies>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.7.0</version>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>RELEASE</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>

测试：

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

public class setUp {
    private Jedis jedis;

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

    @Test
    void testString(){
        String result = jedis.set("name" ,"张三");
        System.out.println("result="+result);
        String name = jedis.get("name");
        System.out.println("name = "+name);
    }

    @AfterEach
    void tearDown(){
        //释放资源
        if(jedis !=null){
            jedis.close();
        }
    }
}

Jedis连接池

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

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

public class JedisConnectionFactory {
    private static final JedisPool JEDIS_POOL;

    static{
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        //最大连接
        jedisPoolConfig.setMaxTotal(8);
        //最大空闲连接
        jedisPoolConfig.setMaxIdle(8);
        //最小空闲连接
        jedisPoolConfig.setMinIdle(0);
        //设置最长的等待时间，ms
        jedisPoolConfig.setMaxWaitMillis(200);
        JEDIS_POOL = new JedisPool(jedisPoolConfig , "192.168.20.128" ,
                6379 , 1000 , "123456");
    }

    //获取连接池对象
    public static Jedis getJedis(){
        return JEDIS_POOL.getResource();
    }
}

SpringDataRedis快速入门

1、引入依赖

  <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</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>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
            <version>2.10.0</version>
        </dependency>
    </dependencies>

2、配置文件

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

SpringDataRedis的使用步骤：

1、引入spring-boot-starter-data-redis依赖

2、在application.yml配置Redis信息

3、注入RedisTemplate

Redis序列化工具解决汉字转换成二进制问题

package com.example.spring_boot_redis.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 connectionFactory){
        //创建RedisTemplate对象
        RedisTemplate<String , Object> template = new RedisTemplate<>();
        //设置连接工厂
        template.setConnectionFactory(connectionFactory);
        //创建JSON序列化工具
        GenericJackson2JsonRedisSerializer jsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
        //设置Key的序列化
        template.setKeySerializer(RedisSerializer.string());
        template.setHashKeySerializer(RedisSerializer.string());
        //设置Value的序列化
        template.setValueSerializer(jsonRedisSerializer);
        template.setHashValueSerializer(RedisSerializer.json());
        //返回
        return template;
    }
}

为了节省内存空间，我们并不会使用JSON序列化器来处理value，而是统一使用String序列化器，要求只能存储String类型的key和value。当需要存储Java对象时，手动完成对象的序列化和反序列化。

Spring默认提供了一个StringRedisTemplate类，它的key和value的序列化方式默认就是String方式。省去了我们自定义RedisTemplate的过程：

@Autowired
    private StringRedisTemplate stringRedisTemplate;

    private static final ObjectMapper mapper = new ObjectMapper();
@Test
    void testStringTemplate() throws JsonProcessingException {
        User user  = new User();
        user.setGender("男");
        user.setAge(25);
        user.setName("虎哥");
        //手动序列化
        String json = mapper.writeValueAsString(user);
        //写入一条数据到redis
        stringRedisTemplate.opsForValue().set("user:2" , json);
        //读取数据
        String val = stringRedisTemplate.opsForValue().get("user:2");
        //反序列化
        User user1 = mapper.readValue(val , User.class);
        System.out.println(user1);
    }

(完)