bash
127.0.0.1:6379> set name 666
OK
127.0.0.1:6379> get name
"666"
127.0.0.1:6379> setex name2 3 888
OK
127.0.0.1:6379> get name2
(nil)
127.0.0.1:6379> setnx name2 888
(integer) 1
127.0.0.1:6379> setnx name2 555
(integer) 0
127.0.0.1:6379> keys *
1) "name2"
2) "name"
127.0.0.1:6379> get name2
"888"

bash
127.0.0.1:6379> hset table1 name wangwu			// 设置table1表中的name字段值为wangwu
(integer) 1
127.0.0.1:6379> hget table1 name				// 获取存储在table1表中的name字段
"wangwu"
127.0.0.1:6379> hdel table1 name				// 删除存储在table1表中的name字段
(integer) 1
127.0.0.1:6379> hget table1 name				// 此时已经被删除了，得到的是nil
(nil)
127.0.0.1:6379> hset table1 name lisi			// 设置table1表中的name字段值为lisi
(integer) 1
127.0.0.1:6379> hset table1 age 10				// 设置table1表中的age字段值为10
(integer) 1
127.0.0.1:6379> hkeys table1					// 获取哈希表中所有字段
1) "name"
2) "age"
127.0.0.1:6379> hvals table1					// 获取哈希表中所有值
1) "wangwu"
2) "10"
127.0.0.1:6379> hgetall table1					// 获取在哈希表中指定key的所有字段和值
1) "name"
2) "wangwu"
3) "age"
4) "10"

bash
127.0.0.1:6379> lpush list a b c	// 将a、b、c插入到列表头部
(integer) 3
127.0.0.1:6379> lrange list 0 -1	// 查询从0到-1位置的元素,-1表示最后一个值
1) "c"	// c在最前面是因为列表是按照插入顺序排序的，最后插入的在最前面
2) "b"
3) "a"
127.0.0.1:6379> rpop list	// 删除最后一个元素，并得到值，a是最先插入的，所以是最后一个
"a"
127.0.0.1:6379> llen list	// 获取长度
(integer) 2
127.0.0.1:6379> brpop list 3  // 移除列表的最后一个元素，如果列表没有值，会阻塞timeout秒，否则删除
1) "list"
2) "b"
127.0.0.1:6379> brpop list 3
1) "list"
2) "c"
127.0.0.1:6379> brpop list 3	// 阻塞3秒
(nil)
(3.09s)

bash
127.0.0.1:6379> zadd sortset 3 a 1 c 2 b	// 向集合sortset添加值与分数
(integer) 3
127.0.0.1:6379> zrange sortset 0 -1			// 查询，按照分数从小到大排序，最小的在最前面
1) "c"
2) "b"
3) "a"
127.0.0.1:6379> zincrby sortset 3 c			// 为字段c加3分
"4"
127.0.0.1:6379> zrange sortset 0 -1			// 查询，此时c>a>b在最下面
1) "b"
2) "a"
3) "c"
127.0.0.1:6379> zrem sortset a b c			// 删除有序集合元素
(integer) 3
127.0.0.1:6379> zrange sortset 0 -1
(empty list or set)
127.0.0.1:6379>

bash
127.0.0.1:6379> keys *		// 查看所有的key
1) "name"
2) "table2"
3) "table1"
4) "NewName"
5) "set"
127.0.0.1:6379> exists name		// 查看某个key是否存在，存在返回1，不存在返回0
(integer) 1
127.0.0.1:6379> exists abc
(integer) 0
127.0.0.1:6379> type name	// 查看key的类型 
string
127.0.0.1:6379> type set
set
127.0.0.1:6379> type table1
hash
127.0.0.1:6379> ttl name		// 查看key的剩余存活时间，-1表示永久存活
(integer) -1
127.0.0.1:6379> setex test 10 test	// 设置test字段存活时间10s，值为test
OK
127.0.0.1:6379> ttl test	// 查看test
(integer) 8
127.0.0.1:6379> ttl test
(integer) 2
127.0.0.1:6379> keys *		// 查看所有key
1) "name"
2) "table2"
3) "table1"
4) "NewName"
5) "set"
127.0.0.1:6379> del name	// 删除name字段
(integer) 1
127.0.0.1:6379> keys *		// 查看所有key，此时name字段就不存在了
1) "table2"
2) "table1"
3) "NewName"
4) "set"

java
@SpringBootTest
class RedisTestApplicationTests {

    @Test
    void contextLoads() {
        //1. 获取连接
        Jedis jedis = new Jedis("localhost", 6379);
        //2. 执行具体操作
        jedis.set("name", "zhangsan");

        jedis.hset("stu", "name", "Jerry");
        jedis.hset("stu", "age", "18");
        jedis.hset("stu", "num", "4204000400");

        Map<String, String> map = jedis.hgetAll("stu");
        Set<String> keySet = map.keySet();
        for (String key : keySet) {
            String value = map.get(key);
            System.out.println(key + ":" + value);
        }
        String name = jedis.get("name");
        System.out.println(name);
        //3. 关闭连接
        jedis.close();
    }

}

java
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;

@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.setValueSerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new StringRedisSerializer());
        redisTemplate.setConnectionFactory(connectionFactory);

        return redisTemplate;
    }
}

java
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;
import org.springframework.data.redis.core.ValueOperations;

import java.util.concurrent.TimeUnit;

@SpringBootTest
class Demo1ApplicationTests {

    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    void test1() {
        // 设置string
        redisTemplate.opsForValue().set("name","zhangsan");

        // 获得string
        String name = (String) redisTemplate.opsForValue().get("name");
        System.out.println(name);

        // 设置string的超时时间(timeout是一个long型变量,TimeUnit是一个工具类，可以设置秒分时这种)
        redisTemplate.opsForValue().set("key1","value1",10L, TimeUnit.SECONDS);

        // 当某个key不存在，才执行设置操作，否则不执行
        // 返回boolean类型的值，如果是true，说明执行成功，否则失败
        Boolean aBoolean = redisTemplate.opsForValue().setIfAbsent("key1", "value2");
        System.out.println(aBoolean);

    }
}

java
@Test
void hashTest() {
    HashOperations hashOperations = redisTemplate.opsForHash();
    // put(哪个hash表，什么字段，什么值)
    hashOperations.put("4204000400", "name", "Hades");
    hashOperations.put("4204000400", "age", "18");
    hashOperations.put("4204000400", "hobby", "Apex");
    //获取map集合
    Map<String, String> map = hashOperations.entries("4204000400");
    Set<String> keySet = map.keySet();
    // 获取方式和Java的hash操作一致
    for (String hashKey : keySet) {
        System.out.println(hashKey + ":" + map.get(hashKey));
    }
    System.out.println("----------------");
    //只获取keys
    Set<String> keys = hashOperations.keys("4204000400");
    for (String key : keys) {
        System.out.println(key);
    }
    System.out.println("----------------");
    //只获取values
    List<String> values = hashOperations.values("4204000400");
    for (String value : values) {
        System.out.println(value);
    }
}

java
@Test
void listTest() {
    ListOperations listOperations = redisTemplate.opsForList();
    //存数据
    // 为testData列表添加A
    listOperations.leftPush("testData", "A");
    // 多值添加
    listOperations.leftPushAll("testData", "B", "C", "D");
    // 遵循先进后出原则，所以A是在最下面依次往上
    List<String> testDatas = listOperations.range("testData", 0, -1);
    //遍历
    for (String tableData : testDatas) {
        System.out.print(tableData + " ");
    }
    System.out.println();
    //获取当前list长度，用于遍历
    Long size = listOperations.size("testData");
    int value = size.intValue();
    //遍历输出并删除
    for (int i = 0; i < value; i++) {
        System.out.print(listOperations.leftPop("testData") + " ");
    }
    //最后输出一下当前list长度
    System.out.println();
    System.out.println(listOperations.size("testData"));
}

java
@Test
void setTest() {
    SetOperations setOperations = redisTemplate.opsForSet();
    //存数据，这里存了两个a
    setOperations.add("tmp", "a", "b", "c", "d", "a");
    //遍历输出(跟Java差不多)
    Set<String> tmpData = setOperations.members("tmp");
    for (String value : tmpData) {
        System.out.print(value + " ");
    }
    System.out.println();
    System.out.println("---------------");
    //删除多值
    setOperations.remove("tmp", "b", "c");
    //再次遍历输出
    tmpData = setOperations.members("tmp");
    for (String value : tmpData) {
        System.out.print(value + " ");
    }
}

java
@Test
void zsetTest() {
    ZSetOperations zSetOperations = redisTemplate.opsForZSet();
    //存scope值
    zSetOperations.add("myZset", "a", 0.0);
    zSetOperations.add("myZset", "b", 1.0);
    zSetOperations.add("myZset", "c", 2.0);
    zSetOperations.add("myZset", "a", 3.0);
    //遍历所有
    Set<String> myZset = zSetOperations.range("myZset", 0, -1);
    for (String s : myZset) {
        System.out.println(s);
    }
    //修改scope
    zSetOperations.incrementScore("myZset", "b", 4.0);
    //取值
    System.out.println("--------------------");
    myZset = zSetOperations.range("myZset", 0, -1);
    for (String s : myZset) {
        System.out.println(s);
    }
    //删除成员
    zSetOperations.remove("myZset", "a", "b");
    //取值
    System.out.println("-------------------");
    myZset = zSetOperations.range("myZset", 0, -1);
    for (String s : myZset) {
        System.out.println(s);
    }
}

java
@Test
void commonTest() {
    //查看所有key(keys *)
    Set<String> keys = redisTemplate.keys("*");
    for (String key : keys) {
        System.out.println(key);
    }
    //查看是否存在指定key
    System.out.println("----------------------------");
    System.out.println(redisTemplate.hasKey("Random"));
    System.out.println("----------------------------");
    //删除指定key，并再次查看
    redisTemplate.delete("myZset");
    keys = redisTemplate.keys("*");
    for (String key : keys) {
        System.out.println(key);
    }
    System.out.println("----------------------------");
    //输出指定key的类型
    System.out.println(redisTemplate.type("tmp"));
}