Redis-01-基础-redis简介安装、数据类型、常用命令、使用Spring Data Redis封装好的命令方法操作redis

vim /usr/local/redis-4.0.0/redis.conf
查找: /dae
修改: daemonize no => daemonize yes
重新启动(得加上配置文件作为参数):  src/redis-server ./redis.conf

./redis-cli -h localhost -p 6379
auth 123456

./redis-cli -h localhost -p 6379 -a 123456

# 打开6379 端口
firewall-cmd --zone=public --add-port=6379/tcp --permanent
# 立即生效
firewall-cmd --reload
# 查看开放端口
firewall-cmd --zone=public --list-ports

./redis-cli -h 192.168.141.100 -p 6379 -a 123456

# 进入Redis安装目录
cd /usr/local/redis-4.0.0
# 启动Redis服务，指定使用的配置文件
./src/redis-server ./redis.conf

/usr/local/redis-4.0.0/src/redis-server /usr/local/redis-4.0.0/redis.conf

# 设置值 name="xiaoming"
set name xiaoming
# 返回 "xiaoming"
get name

# 返回 nil
get age
set age 18
# 返回 "18"
get age

# 重新设置 age = "30"
set age 30
# 再get 就返回 "30" 了
get age


# 设置 city="beijing"  但是该变量只能存活10s (很适用于验证码的失效处理)
setex city 10 beijing
# 10s内 返回 “beijing”
get city
# 10s后 返回 nil
get city

# 返回1 表示设置成功
setnx id 123
# setnx 再次设置id的值  id已经有值了 设置不成功 返回0
setnx id 456
# 肯定返回123啦
get id

# key=001 实际中可以是id为001的用户
# 设置001用户的信息
hset 001 name xiaoming
# 继续设置001用户的信息
hset 001 age 18
# 获取001用户的信息："xiaoming"
hget 001 name
# 获取001用户的信息 "18"
hget 001 age
# 获取所有字段： 1) "name"  2) "age"
hkeys 001

# 删除用户001的age属性
hdel 001 age
# 此时再获取age自然返回: nil 了
hget 001 age
# 也只有: 1) "name" 了
hkeys 001

hset 001 age 20

# 获取key=001 中所有 keys: 1) "name" 2) "age"
hkeys 001

# 获取key=001 中所有 values: 1) "xiaoming"  2) "20"
hvals 001

# 获取key=001 中所有 key和value: 1) "name" 2) "xiaoming" 3) "age" 4) "20"
hgetall 001

# 获取压根儿就不存在的，肯定返回 nil 了
hget 002 abc

# ctrl + l 也可以清屏
# l:左边  左边一次性插入 “a b c”
lpush mylist a b c
# 查询指定范围的值 起点0 终点-1表示就是list末尾： 1) "c" 2) "b" 3) "a"
lrange mylist 0 -1
# 再插入一个值: "whu"
lpush mylist whu
# 查看所有元素： 1) "whu" 2) "c" 3) "b" 4) "a"   【有点类似栈(双端队列更好)啊】
lrange mylist 0 -1
# 列表里可以有重复元素
lpush mylist a
# 1) "a" 2) "whu" 3) "c" 4) "b"  5) "a"
lrange mylist 0 -1

# 弹出右边第一个元素 (也就是第一个入队的元素 看成队列就是队头) 返回 第5个"a"
rpop mylist
# 第5个a没有了: 1) "a" 2) "whu" 3) "c" 4) "b"
lrange mylist 0 -1
# 肯定返回b了 
rpop mylist
# 队头的b又没有了： 1) "a" 2) "whu" 3) "c"
lrange mylist 0 -1

# list的长度： 3
llen mylist

# 弹出mylist最后一个元素 c
brpop mylist 10
# 弹出mylist最后一个元素 whu
brpop mylist 10
# 弹出mylist最后一个元素 a
brpop mylist 10
# 队列里没有元素了: (empty list or set)
lrange mylist 0 -1
# mulist没有元素了，被阻塞, 超时时间我们设置为10s, 10s后还是没有找到列表元素弹出，就返回 nil 了
brpop mylist 10

# 向集合中加入4个元素
sadd myset a b c d
# 查看集合元素： 1) "d" 2) "c" 3) "b" 4) "a"   集合肯定是无序的啦
smembers myset

# 继续加入两个重复的元素，返回0， 肯定加入失败， 因为集合元素 不能重复
sadd myset a b
# 查看集合元素, 还是那四个： 1) "c" 2) "b" 3) "a" 4) "d"  （当然，他是无序的）
smembers myset

# 获取集合成员数量： 4
scard myset

# 再创建一个集合，以便进行集合运算
sadd myset2 a b x y
# 1) "y" 2) "x" 3) "b" 4) "a"
smembers myset2

# 求两个集合的交集： 1) "b" 2) "a"
sinter myset myset2

# 求2个集合的并集： 1) "a" 2) "d" 3) "c" 4) "b" 5) "y" 6) "x"
sunion myset myset2

# 两个集合差集
# myset - myset2 = {a,b,c,d}-{a,b,x,y}={c,d}
sdiff myset myset2
# myset2 - myset = {a,b,x,y}-{a,b,c,d}={x,y}
sdiff myset2 myset

# 移除集合中的元素： a b c  【本来myset中是a b c d 现在移除了a b c】
srem myset a b c
# 只剩下 d 了
smembers myset

# 新建有序集合myset3 向里面添加两个元素 a 和 b 分数分别是10.0 和 9.0 也就是b会排在前面
zadd myset3 10.0 a 9.0 b
# 查看有序集合所有元素： b a  【b果然排在前面】
zrange myset3 0 -1
# 再插入一个元素c, 分数9.9 界于二者之间
zadd myset3 9.9 c
# 再查看所有，确实根据分值排序的： 1) "b" 2) "c" 3) "a"
zrange myset3 0 -1
# 查看所有，元素和分数一起展示： 1) "b" 2) "9" 3) "c" 4) "9.9000000000000004" 5) "a" 6) "10"
zrange myset3 0 -1 withscores

# b的分值加20，返回： 29   【20+9=29】
zincrby myset3 20 b
# b分值现在最大，就跑到最后面去了： 1) "c" 2) "a" 3) "b"
zrange myset3 0 -1

# 删除有序集合myset3里的元素b
zrem myset3 b
# 再查看所有，b没有了： 1) "c" 2) "a"
zrange myset3 0 -1

# 列出来 所有的 key: "id" "name" "age" "myset" "001" "myset2" "myset3"
keys *

# 查看 name 这个key 是否存在  返回:1 表示存在
exists name
# 查看 sex 这个key 是否存在  返回:0 表示不存在
exists sex

# 查看 name(这个key对应值) 的类型： string
type name
# set 普通set集合
type myset
# zset 有序集合
type myset3
# hash 类型
type 001

# 查看指定key的存活时间 -1 表示永久
# 查看name的存活时间： -1  永久存活
ttl name

# 新建 school=”whu“  过期时间为100s
setex school 100 whu
# 等一会儿再去执行, 返回： 46   【还有46s 该key就失效了】
ttl school
# 过期后再查看，返回： -2  就是表示已经过期了
ttl school

# del key 删除指定 key
del id
# 发现少了 "id"
keys *
# 一次性删除多个key
del name age 001
# 果然就剩下3了： "myset"  "myset2"  "myset3"
keys *

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>cn.whu</groupId>
  <artifactId>jedis_demo</artifactId>
  <packaging>war</packaging>
  <version>1.0-SNAPSHOT</version>
  <dependencies>
    <!-- junit测试包 -->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>
    <!-- jedis依赖包 -->
    <dependency>
      <groupId>redis.clients</groupId>
      <artifactId>jedis</artifactId>
      <version>2.8.0</version>
    </dependency>
  </dependencies>
</project>

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

package cn.whu.test;

import org.junit.Test;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Tuple;

import java.util.Set;

/**
 * 使用jedis操作Redis
 */
public class JedisTest {

    @Test
    public void testRedis(){
        //1. 获取连接
        Jedis jedis = new Jedis("localhost", 6379);//就类似jdbc里的connection

        //2. 执行具体操作
        // 设置值
        jedis.set("name","xiaoming");
        jedis.set("username","daming");

        // 获取值
        String username = jedis.get("username");
        System.out.println(username);//daming

        // 删除key
        jedis.del("username");
        System.out.println(jedis.get("username"));//null

        // 2.2 设置 hash 类型的值
        jedis.hset("myhash","age","18");
        String age = jedis.hget("myhash","age");
        System.out.println(age);//18

        // 还有一系列操作 之前学过命令 这里就肯定会写方法

        // eg： 2.3 zset 操作
        jedis.zadd("myzset",1.0,"hza");
        jedis.zadd("myzset",3.0,"yth");
        jedis.zadd("myzset",2.0,"lml");
        Set<String> myzset = jedis.zrange("myzset", 0, -1);
        System.out.println(myzset);//[hza, lml, yth]
        Set<Tuple> tuples = jedis.zrangeWithScores("myzset", 0l, -1l);
        System.out.println(tuples);//[[[104, 122, 97],1.0], [[108, 109, 108],2.0], [[121, 116, 104],3.0]]
        for (Tuple tuple : tuples) {
            System.out.println(tuple.getElement()+"\t"+tuple.getScore());
            //hza	1.0
            //lml	2.0
            //yth	3.0
        }

        // 2.4 通用操作
        // keys *
        Set<String> keys = jedis.keys("*");
        System.out.println(keys);//[name, myhash, myset3, myset2, myzset, myset]

        //3. 关闭连接
        jedis.close();
    }
}

<dependency>
	<groupId>org.springframework.data</groupId>
	<artifactId>spring-data-redis</artifactId>
	<version>2.4.8</version>
</dependency>

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.4.5</version>
    <relativePath/>
  </parent>

  <groupId>cn.whu</groupId>
  <artifactId>springdataredis_demo</artifactId>
  <packaging>war</packaging>
  <version>1.0-SNAPSHOT</version>

  <properties>
    <java.version>1.8</java.version>
  </properties>

  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
  </dependencies>
  
  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
        <version>2.4.5</version>
      </plugin>
    </plugins>
  </build>

</project>

@SpringBootApplication
public class App {
    public static void main(String[] args) {
        SpringApplication.run(App.class,args);
    }
}

spring:
  application:
    name: springdataredis_demo
  #Redis相关配置
  redis:
    host: localhost
    port: 6379
    #password: 123456
    database: 0 #操作的是0号数据库 (redis服务启动，默认提供了16个数据库)
    jedis:
      #Redis连接池配置
      pool:
        max-active: 8 #最大连接数
        max-wait: 1ms #连接池最大阻塞等待时间
        max-idle: 4 #连接池中的最大空闲连接
        min-idle: 0 #连接池中的最小空闲连接

package com.itheima.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;
    }

}

@SpringBootTest
@RunWith(SpringRunner.class)
public class SpringDataRedisTest {

    // 注入RedisTemplate 一个高度封装的类 用来方便地操作redis
    // 只要yml配置文件写了redis配置 spring就自动装配(bean中没有时帮你new) 这里就可以注入RedisTemplate
    @Autowired
    private RedisTemplate redisTemplate;

}

/**
 * 操作String类型数据
 * @throws InterruptedException
 */
@Test
public void testString() throws InterruptedException {
    // 获取string类型操作器
    ValueOperations vops = redisTemplate.opsForValue();

    // 设置普通 key-value 类型
    vops.set("city","beijing");
    vops.set("city123","beijing123");

    // 根据key获取值
    String city123 = (String) vops.get("city123");
    System.out.println(city123);

    // 设置过期时间  (验证码1234 过期时间1 单位s)
    vops.set("code","1234",1l, TimeUnit.SECONDS);
    String code = (String) vops.get("code");
    System.out.println(code); // "1234"
    Thread.sleep(1*1000);//休息1s 等待过期
    code = (String) vops.get("code");
    System.out.println(code); // null

    // 如果不存在才设置
    System.out.println(vops.setIfAbsent("city123","whu"));// false 表示设置失败
    System.out.println(vops.setIfAbsent("addr","whu"));// true 表示设置成功
    System.out.println(vops.get("city123"));// beijing123 已经存在 设置失败 还是原来的值
    System.out.println(vops.get("addr"));// whu 原来没有 设置成功
}

/**
 * 操作Hash类型数据
 */
@Test
public void testHash(){
    // 获取Hash操作对象
    HashOperations hops = redisTemplate.opsForHash();

    // 存值: 设置hash类型的值 (模拟存储id=002的对象 给这个对象设置了3个属性)
    hops.put("002","name","zhangsan");
    hops.put("002","age","20");
    hops.put("002","address","guangzhou1");
    // 取值:
    String name = (String) hops.get("002", "name");
    System.out.println(name); // zhangsan

    // 获得hash结构中所有字段
    Set keys = hops.keys("002"); // 获取key=002的所有 hash类型的key
    System.out.println(keys); // [name, age, address]

    // 获取hash结构中所有的值
    List values = hops.values("002");// 获取key=002的hash类型, 所有的value
    System.out.println(values);// [zhangsan, 20, guangzhou1]

}

/**
 * 操作List类型的数据
 */
@Test
public void testList(){
    // 获取list类型操作对象
    ListOperations lops = redisTemplate.opsForList();
    redisTemplate.delete("mylist");//提前有就先删除 以便重复访问

    // 存值
    lops.leftPush("mylist","a");//一次存一个值
    lops.leftPushAll("mylist","b","c","d");//一次存多个值

    // 取值
    List mylist = lops.range("mylist", 0, -1);
    System.out.println(mylist); // [d, c, b, a]  按照插入顺序排序 (看成从左往右插入的队列即可)

    // 获得列表长度
    int size = lops.size("mylist").intValue();

    // 出队列 (想造队列 得从右边出啦)
    for (int i = 0; i < size; i++) {
        String element = (String) lops.rightPop("mylist");
        System.out.print(element+" ");
    }
    System.out.println();
}

/**
 * 操作set类型的数据
 */
@Test
public void testSet(){
    // 获取set类型操作对象
    SetOperations sops = redisTemplate.opsForSet();
    redisTemplate.delete("myset");

    // 存值
    sops.add("myset","a","b","c","d","a","b");//集合不能有重复 所有 a b 只能存一份

    // 长度
    Long size = sops.size("myset");
    System.out.println(size);//4


    // 取值
    Set<String> myset = sops.members("myset");//set无需 自然无需指定获取值的下标范围
    System.out.println(myset); // [d, a, c, b]  无序输出

    // 删除成员
    sops.remove("myset","a","b");
    System.out.println(sops.members("myset"));//[d, c]  a,b被删除了呀
}

/**
 * 操作ZSet类型的数据
 * ZSet 是有序集合，不允许重复，通过分数来排序
 */
@Test
public void testZSet() {
    // 获取set类型操作对象
    ZSetOperations zsops = redisTemplate.opsForZSet();
    redisTemplate.delete("myzset");

    // 存值
    zsops.add("myzset", "a", 1.0); // 注意value-score 的顺序(相对于redis命令)改了下
    zsops.add("myzset", "b", 2.0);
    zsops.add("myzset", "c", 3.0);
    zsops.add("myzset", "a", 4.0); // 验证是否不能有重复  【会覆盖之前的a】

    // 取值
    Set<String> myzset = zsops.range("myzset", 0, -1);
    System.out.println(myzset);

    // 取值+取score
    Set<ZSetOperations.TypedTuple> zset = zsops.rangeWithScores("myzset", 0, -1);
    for (ZSetOperations.TypedTuple t : zset) {
        System.out.println(t.getValue() + "\t" + t.getScore());
        //b	2.0
        //c	3.0
        //a	4.0   // 虽然不能插入重复的a 但是score却被更新了
    }

    // 修改分数
    zsops.incrementScore("myzset", "b", 20.0);//给"b"+20分
    System.out.println(zsops.range("myzset", 0, -1));//[c, a, b]  b现在最大 排最后了

    // 删除成员
    zsops.remove("myzset", "a", "b");
    System.out.println(zsops.range("myzset", 0, -1));//[c]  a、b被删了 只剩下c了

}

/**
 * 通用操作: 针对不同的数据类型都可以操作
 */
@Test
public void testCommon(){

    // 获取redis中所有的key
    Set<String> keys = redisTemplate.keys("*");
    System.out.println(keys);
    // [myzset, myset2, city, addr, myset3, �� t city, city123, name, myset, 002, myhash]


    // 判断某个key是否存在
    Boolean myzset = redisTemplate.hasKey("myzset");
    System.out.println(myzset);//true
    Boolean abc = redisTemplate.hasKey("abc");
    System.out.println(abc);//false

    // 重命名key
    redisTemplate.opsForValue().set("city","anhui");// 先设置一个key把 方便重复执行
    // 重命名
    redisTemplate.rename("city","city2");
    System.out.println(redisTemplate.hasKey("city"));//false
    System.out.println(redisTemplate.hasKey("city2"));//true

    // 删除指定key
    redisTemplate.delete("city2");
    System.out.println(redisTemplate.hasKey("city2"));//false

    // 获取指定key对应的value的数据类型
    DataType dataType = redisTemplate.type("myset");
    System.out.println(dataType);//SET
    System.out.println(dataType.name());//SET
}