【redis笔记】 - 技术栈

Redis简介

安装步骤

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

字符串string

哈希hash 适合存储对象

列表list 按照插入顺序排序，可以有重复元素

集合set 无序集合，没有重复元素

有序集合sorted set 有序集合，没有重复元素

Redis常用通用命令，任何类型都可以使用

keys * ：查看所有的key

ttl name：如果返回-1，说明存活时间是永久的

在java种操作redis

使用客户端Jedis

jedis的maven坐标

xml 复制代码

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

使用jedis操作redis的步骤：

①获取链接

②执行操作

③关闭链接

java 复制代码

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

import java.util.Set;

public class TestRedis {
    @Test
    public void test01(){
//        1获取链接
        Jedis jedis = new Jedis("localhost", 6379);


//        2执行具体的操作
        jedis.set("username","xiaoming");
        String username = jedis.get("username");
        System.out.println(username);

        jedis.del(username);

        String s = jedis.get(username);
        System.out.println(s);

        jedis.hset("hset1","value","1");
        String hget = jedis.hget("hset1", "value");
        System.out.println(hget);

        Set<String> keys = jedis.keys("*");
        for(String key:keys){
            System.out.println(key);
        }
//        3关闭连接
        jedis.close();
    }
}

在Java种操作redis进阶

使用spring data redis

redis相关配置

yml 复制代码

spring:
  application:
    #应用的名称，可选
    name: reggie_take_out
  redis:
    host: localhost
    prot: 6379
    #password: 123456
    #默认是0号数据库 换数据库命令  select 1 进入1号数据库
    #最多有16个数据库
    database: 0
    jedis:
#      redis连接池配置
      pool:
        max-active: 8
        max-wait: 1ms
        max-idle: 4
        min-idle: 0

导入依赖包

xml 复制代码

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

改变序列化方式

提供配置类

java 复制代码

package com.xue.reggie.config;

import org.springframework.cache.annotation.CachingConfigurerSupport;
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 {
    public RedisTemplate<Object,Object> redisTemplate(RedisConnectionFactory connectionFactory){
        RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();

//        默认的key序列化器为：JdkSerializationRedisSerializer
        redisTemplate.setKeySerializer(new StringRedisSerializer());
//        把hash的field的序列化也改成string
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());

        redisTemplate.setConnectionFactory(connectionFactory);

        return redisTemplate;

    }
}

使用

java 复制代码

import com.xue.reggie.ReggieApplication;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.*;
import org.springframework.test.context.junit4.SpringRunner;
import redis.clients.jedis.Jedis;

import javax.annotation.Resource;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;

@SpringBootTest(classes = ReggieApplication.class)
//测试启动器
@RunWith(SpringRunner.class)
public class TestRedis {

    @Resource
    private RedisTemplate redisTemplate;

    @Test
    public void test01(){
//        1获取链接
        Jedis jedis = new Jedis("localhost", 6379);


//        2执行具体的操作
        jedis.set("username","xiaoming");
        String username = jedis.get("username");
        System.out.println(username);

        jedis.del(username);

        String s = jedis.get(username);
        System.out.println(s);

        jedis.hset("hset1","value","1");
        String hget = jedis.hget("hset1", "value");
        System.out.println(hget);

        Set<String> keys = jedis.keys("*");
        for(String key:keys){
            System.out.println(key);
        }
//        3关闭连接
        jedis.close();
    }

    /**
     * 操作普通string
     */
    @Test
    public void test02(){
//        普通
        ValueOperations valueOperations = redisTemplate.opsForValue();

//        set 无序不重复
        SetOperations setOperations = redisTemplate.opsForSet();
//        有序 可重复
        ListOperations listOperations = redisTemplate.opsForList();
//        有序 不可重复
        ZSetOperations zSetOperations = redisTemplate.opsForZSet();

        valueOperations.set("city","beijing");
        String city = (String)valueOperations.get("city");

//        设置只存在10秒钟
        valueOperations.set("k1","value1",10l, TimeUnit.SECONDS);
        System.out.println(city);

        Boolean b = valueOperations.setIfAbsent("city", "1234");
        System.out.println(b);
//        此时输出false，证明redis里面已经有"city"这个key了，虽然值不一样把

    }
    /**
     * 操作hash
     */
    @Test
    public void test03(){
        //        哈希 key-feild-value
//        存值
        HashOperations hashOperations = redisTemplate.opsForHash();
        hashOperations.put("key1","hashkey1","value1");
        hashOperations.put("key1","hashkey2","value2");

//        取值
        String o = (String) hashOperations.get("key1", "hashkey1");
        System.out.println(o);

//        获得hash结构种的所有字段
        Set keys = hashOperations.keys("key1");
        for (Object key : keys) {
            System.out.println(key);
        }
//        获得hash结构种的所有值  返回值是List
        List values = hashOperations.values("key1");
        for (Object value : values) {
            System.out.println(value);
        }
    }
    /**
     * 操作list
     */
    @Test
    public void test04(){
        ListOperations listOperations = redisTemplate.opsForList();
        listOperations.leftPushAll("mylist","a","b","v");

//        取值
        List<String> mylist = listOperations.range("mylist", 0, -1);
        for (String o : mylist) {
            System.out.println(o);//v b a
        }

        Object o = listOperations.leftPop("mylist");
        System.out.println(o);

//        获得列表长度len
        Long mylist1 = listOperations.size("mylist");
        int llist = mylist1.intValue();
        for (int i = 0; i < llist; i++) {
            String mylist2 =(String) listOperations.rightPop("mylist");
            System.out.println(mylist2);
        }

    }

    /**
     * set类型的数据
     */
    @Test
    public void test05(){
        SetOperations setOperations = redisTemplate.opsForSet();
        setOperations.add("myset","a","b","c","a");
//        取值
        Set myset = setOperations.members("myset");
        for (Object o : myset) {
            System.out.println(o);
        }

//        删除成员
        Long remove = setOperations.remove("myset", "a");
        System.out.println(remove);
    }
    /**
     * 操作zset
     */
    @Test
    public void test06(){
        ZSetOperations zSetOperations = redisTemplate.opsForZSet();
        zSetOperations.add("myzset","a",10.0);
        zSetOperations.add("myzset","b",12.0);
        zSetOperations.add("myzset","a",11.0);

        Set<String> myzset = zSetOperations.range("myzset", 0, -1);
        for (String s : myzset) {
            System.out.println(s);
        }

//        修改分数
        zSetOperations.incrementScore("myset","b",-5.0);

        zSetOperations.remove("myset","a");

    }
        /**
     * 通用操作
     */
    @Test
    public void testCommon(){
        Set<String> keys = redisTemplate.keys("*");
        for (String key : keys) {
            System.out.println(key);
        }
//判断是否存在
        Boolean myset = redisTemplate.hasKey("myset");
//        删除指定的key
        redisTemplate.delete("myset");
//        获取指定key对应的value的数据类型
        DataType myset1 = redisTemplate.type("myset");
        System.out.println(myset1);
    }
}

使用redis

1、RedisTemplate和StringRedisTemplate的区别

区别在于StringRedisTemplate只操作字符串，而RedisTemplate操作对象

两者的关系是StringRedisTemplate继承RedisTemplate。
两者的数据是不共通的；也就是说StringRedisTemplate只能管理StringRedisTemplate里面的数据，RedisTemplate只能管理RedisTemplate中的数据。
SDR默认采用的序列化策略有两种，一种是String的序列化策略，一种是JDK的序列化策略。

StringRedisTemplate默认采用的是String的序列化策略，保存的key和value都是采用此策略序列化保存的。

RedisTemplate默认采用的是JDK的序列化策略，保存的key和value都是采用此策略序列化保存的。

RedisTemplate默认使用的序列类在在操作数据的时候，比如说存入数据会将数据先序列化成字节数组然后在存入Redis数据库，这个时候打开Redis查看的时候，你会看到你的数据不是以可读的形式展现的，而是以字节数组显示，类似下面

当然从Redis获取数据的时候也会默认将数据当做字节数组转化，这都是根据序列化策略来决定的。

而stringredistemplate，默认存入的数据就是原文，因为stringRedistemplate默认使用的是string序列化策略，使用stringredistemplate默认存入数据长这个样：

2、setKeySerializer和setHashKeySerializer

setEnableDefaultSerializer(false);

关闭redis默认序列化器
setKeySerializer();

设置string字符串的key的序列化器
setValueSerializer();

设置string字符串的value的序列化器
setStringSerializer();

设置String的序列化器
setHashKeySerializer();

设置hash的value的序列化器
setHashValueSerializer();

设置hash的value的序列化器