Redis笔记

什么是 Redis ?

Redis是一个基于内存的key-value结构数据库。

• 基于内存存储，读写性能高

• 适合存储热点数据（热点商品、资讯、新闻)

• 企业应用广泛

Redis是用C语言开发的一个开源的高性能键值对(key-value)数据库，官方提供的数据是可以达到100000+的QPS(每秒内查询次数）。它存储的value类型比较丰富，也被称为结构化的NoSql数据库。

NoSql (Not only SQL)，不仅仅是SQL，泛指非关系型数据库。NoSql数据库并不是要取代关系型数据库，而是关系型数据库的补充。

Redis应用场景

• 缓存
• 任务队列
• 消息队列
• 分布式锁

配置

在配置文件中修改，执行时使用redis-server后面跟上配置文件

• 设置密码

requirepass xxx（xxx就是密码 ）

使用密码：

登录后使用auth xxx（xxx就是密码 ）

登录时使用redis-cli -a xxx（xxx就是密码 ）

• 后台运行

修改daemonize no为daemonize yes

• 修改端口号

port xxx

• 开启远程连接

注释掉bind 127.0.0.1

• 修改数据库数量

databases 16（16就是数量）

Redis数据类型

Redis存储的是key-value结构的数据，其中key是字符串类型，value有5种常用的数据类型:

• string 普通字符串，常用
• hash适合存储对象
• list按照插入顺序排序，可以有重复元素
• set无序集合，没有重复元素
• sorted set有序集合，,没有重复元素

Redis常用命令

字符串string操作命令

Redis中字符串类型常用命令:

• SET key value
  设置指定key的值
• GET key
  获取指定key的值
• SETEX key seconds value
  设置指定key的值，并将key的过期时间设为seconds秒
• SETNX key value
  只有在key不存在时设置key的值

哈希hash 操作命令

Redis hash是一个string类型的 field和value的映射表，hash特别适合用于存储对象，常用命令:

• HSET key field value
  将哈希表key 中的字段field 的值设为value
• HGET key field
  获取存储在哈希表中指定字段的值
• HDEL key field
  删除存储在哈希表中的指定字段
• HKEYS key
  获取哈希表中所有字段
• HVALS key
  获取哈希表中所有值
• HGETALL key
  获取在哈希表中指定key的所有字段和值

列表list操作命令

Redis列表是简单的字符串列表，按照插入顺序排序，常用命令:

• LPUSH key value1 [value2]
  将一个或多个值插入到列表头部
• LRANGE key start stop
  获取列表指定范围（从start到stop）内的元素
• RPOP key
  移除并获取列表最后一个元素
• LPOP key
  移除并获取列表第一个元素
• LLEN key
  获取列表长度
• BRPOP key1 [key2 ] timeout
  移出并获取列表的最后一个元素，如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止

集合set操作命令

Redis set 是string类型的无序集合。集合成员是唯一的，这就意味着集合中不能出现重复的数据，常用命令:

• SADD key member1 [member2]
  向集合添加一个或多个成员

• SMEMBERS key
  返回集合中的所有成员

• SCARD key
  获取集合的成员数

• SINTER key1 [key2]
  返回给定所有集合的交集

• SUNION key1 [key2]
  返回所有给定集合的并集

• SDIFF key1 [key2]
  返回给定所有集合的差集

• SREM key member1[member2]

  移除集合中一个或多个成员

有序集合sorted set操作命令

Redis sorted set有序集合是string类型元素的集合，且不允许重复的成员。

每个元素都会关联一个double类型的分数(score)。

redis正是通过分数来为集合中的成员进行从小到大排序。

有序集合的成员是唯一的，但分数却可以重复。

常用命令:

• ZADD key score1 member1 [score2 member2]
  向有序集合添加一个或多个成员，或者更新已存在成员的分数
• ZRANGE key start stop [WITHSCORES]
  通过索引区间返回有序集合中指定区间内的成员
• ZINCRBY key increment member
  有序集合中对指定成员的分数加上增量increment
• ZREM key member [member …]
  移除有序集合中的一个或多个成员

通用命令

• KEYS pattern
  查找所有符合给定模式( pattern)的 key
• EXISTS key
  检查给定key是否存在
• TYPE key
  返回key所储存的值的类型
• TTL key
  返回给定 key的剩余生存时间(TTL, time to live)，以秒为单位
• DEL key
  该命令用于在key存在是删除key

在Java中操作Redis

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

• Jedis
• Lettuce
• Redisson

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

Jedis

Jedis的maven坐标:

<dependency>
    <groupld>redis.clients</groupld>
    <artifactld>jedis</artifactld>
    <version>2.8.0</version>
</dependency>

使用Jedis操作Redis的步骤:

1. 获取连接
2. 执行操作
3. 关闭连接

@Test
public void testRedis(){
	//1获取连接
	Jedis jedis = new Jedis("localhost", 6379);
	
    //2执行具体的操作
	jedis.set("username", "xiaoming");
	
    //3关闭连接
	jedis.close();
}

Spring Data Redis

在Spring Boot项目中，可以使用Spring Data Redis来简化Redis操作，maven坐标:

<dependency>
	<groupld>org.springframework.boot</groupld>
    <artifactld>spring-boot-starter-data-redis</artifactld></dependency>

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

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

配置文件application.yml：

#Redis相关配置
redis:
  host: localhost
  port: 6379
  password: 123456
  database: 0 #操作的是0号数据库
  jedis:
    #Redis连接池配置pool:
    max-active: 8 #最大连接数
    max-wait: 1ms #连接池最大阻塞等待时间
    max-idle: 4 #连接池中的最大空闲连接
    min-idle: 0 #连接池中的最小空闲连接

修改序列化器（RedisConfig配置类）

package com.jihua.config;

import org.springframework.cache.annotation.CachingConfigurerSupport;
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配置类
 */

@Configuration
public class RedisConfig extends CachingConfigurerSupport {

    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory) {

        RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();

        //默认的Key序列化器为：JdkSerializationRedisSerializer
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());

        redisTemplate.setConnectionFactory(connectionFactory);

        return redisTemplate;
    }

}

String类型数据操作

@Test
public void testString(){
    redisTemplate.opsForValue().set("city123", "beijing");
    String value = (String) redisTemplate.opsForValue().get("city123");
    System.out.println(value);//beijing
    
    redisTemplate.opsForValue().set("key1", "value1", 10l, TimeUnit.SECONDS);
    Boolean aBoolean = redisTemplate.opsForValue().setIfAbsent("city123", "nanjing");
    System.out.println(aBoolean);//false
}

Hash类型数据操作

/**
 *操作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) hash0perations.get("002", "age");
    System.out.println(age);//20
    
    //获得hash结构中的所有字段
	Set keys = hashOperations.keys("002");
    
    //获得hash结构中的所有值
	List values = hashOperations.values("002");
}

List类型数据操作

/**
 *操作List类型的数据
 */
@Test
public void testList(){
    List0perations listOperations = redisTemplate.opsForList();
    //存值
    list0perations.leftPush("mylist", "a");
    listOperations.leftPushAll("mylist", "b", "c", "d");
    //取值
    List<String> mylist = listOperations.range("mylist", 0, -1);
    
    //获得列表长度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类型数据操作

/**
 *操作Set类型的数据
 */
@Test
public void testSet(){
    SetOperations set0perations = redisTemplate.opsForSet();
    
    //存值
    set0perations.add("myset", "a", "b", "c", "a");
    
    //取值
    Set<String> myset = setOperations.members("myset");
    for (String o : myset){
    	System.out.println(o);
    }//c b a
    
    //删除成员
    set0perations.remove("myset", "a", "b");
	
    //取值
    myset = setOperations.members("myset");
    for (String o : myset){
    	System.out.println(o);
    }//c
}

ZSet类型数据操作

/**
 *操作ZSet类型的数据
 */
@Test
public void testzset(){
    ZSet0perations zSet0perations = 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 = zSet0perations.range("myZset", 0, -1);
    for (string s : myzset) {
		System.out.println(s);
	}//b c a

    //修改分数
    zSet0perations.incrementScore("myZset", "b", 20.0);
    //取值
    myZset = zSet0perations.range("myZset", 0, -1);
    for (string s : myzset) {
		System.out.println(s);
	}//c a b
    
    //删除成员
    zSetOperations.remove("myZset", "a", "b");
    //取值
    myZset = zSet0perations.range("myZset", 0, -1);
    for (string s : myzset) {
		System.out.println(s);
	}//c
 }

通用操作

/*
 *通用操作，针对不同的数据类型都可以操作
 */
@Test
public void testCommon(){
	//获取Redis中所有的key
	Set<String> keys = redisTemplate.keys("*");
    
    //判断某个key是否存在
	Boolean boolean = redisTemplate.hasKey("name");
    
    //删除指定key
    redisTemplate.delete("name");
	
    //获取指定key对应的value的数据类型
    DataType dataType = redisTemplate.type("myset");
    System.out.println(dataType.name());
}