Redis笔记

查询所有key 支持通配符* ？等

语法：keys  patterm    例：keys * 查询所有

删除key 

语法：del key [key.......]  例：del name  删除多个 空格分开 

判断key存在

语法：exists key

有限期后删除key,和查看有效期

语法：explre key time(单位s)

语法：ttl key  返回： -1 永久存在 ， -2 已删除

---

String

添加 key（同名添加=修改）

语法：set key value

语法：mset  key value key value key value 例：mset k1 v1 k2 v2

获取 get

语法：get key

语法：mget keys

自增

语法：incr key

语法：incrby key 步长

语法：incrbyfloat key 步长(浮点数）

新增

语法：setnx key value (不存在key,才新增)

语法：setex key time value  (新增有效期key)

---

层级化格式

语法：set key:key:key   JSON字符串

例：set sqy:user:1  '{“id":1,"name":"张三"}'

Hash

存取

语法：hset key 字段  value   例:hset sqy:user:3 name sqy

语法：hmset  key 字段  value 字段  value   例： hmset sqy:user:4 name 张三 age 20

语法：hget key 字段  例：hget sqy:user:4 age

语法：hmget key 字段 字段 字段  例：hmget sqy:user:4 name age

语法：hgetall key 例： hgetall sqy:user:3

语法：hsetnx key 字段  value (不存在key,才新增)

获取所有字段和值

语法:hkeys key

语法:hvals key

自增

语法：hincrby key 字段 步长  例：hincrby sqy:user:3 age 2

List(有序、可重复、链式）

插入·移除

语法：lpush/rpush key  arr  例：lpush arr 2 3 4

语法：lpop/rpop key  arr  例：lpush arr 2 3 4

获取多个

语法：lrange key str end  例：lrange arr 0 4

等待获取

语法：blpop key

set(无序、不重复、哈希)

添加、删除

语法：sadd key  value

语法：serm key  value

查

命令：scard  key  返回元素个数

命令：sismember key value  判断元素死否存在

命令：smembers key 返回所有元素

命令：sintering k1 k2 交集

命令：sdiff  k1 k2 差集

命令：sunion   k1 k2 并集

Java Jedis

pom.xml maven引入

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

测试实现

package com.sqy.test;

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

import java.util.Map;

public class JedisTest {
    public Jedis jedis;

    @BeforeEach
    void setUp() {
        //连接
        jedis=new Jedis("127.0.0.1",6379);
        //密码
//        jedis.auth("123456");
        //选择库
        jedis.select(0);
    }

    @Test
    void textString(){
        String set = jedis.set("name", "张三");
        System.out.println("存入set"+set);
        String s = jedis.get("name");
        System.out.println("取出数据"+s);
    }
    @Test
    void textHash(){
        jedis.hset("user:1","name","sqy");
        jedis.hset("user:1","age","11");

        Map<String, String> stringStringMap = jedis.hgetAll("user:1");
        System.out.println(stringStringMap);
    }

    @AfterEach
    void tearDown() {
        if(jedis!=null){
            jedis.close();
        }
    }
}

结果

Java Jedis线程池

连接池工具类

package util;

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


public class JedisUtils {

    private static JedisPool pool;
    //静态代码在项目中，如果被使用只会加载一次
    static {
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        //最大连接数
        jedisPoolConfig.setMaxTotal(8);
        //最大空闲连接
        jedisPoolConfig.setMaxIdle(8);
        //最小空闲连接
        jedisPoolConfig.setMinIdle(0);
        //等待时长
        jedisPoolConfig.setMaxWaitMillis(1000);
        //连接池
        pool = new JedisPool(jedisPoolConfig, "centos", 6379, 1000, "123456");


    }
    public static Jedis getRedis() {
//        3:从连接池中获取一个连接
        Jedis jedis = pool.getResource();//获取一个连接
        return jedis;
    }

    public static void close(Jedis jedis) {
        if(jedis!=null){
            jedis.close();
        }
    }
}

Springboot RedisTemplate

maven导入依赖  pom.xml

<!--        //redis-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        
<!--        连接池-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

配置连接redis和配置连接池

application.yml

spring:
  data:
    redis:
      host: centos
      port: 6379
      password: 123456
      lettuce:
        pool:
          max-active: 8 #?????
          max-idle: 8 #??????
          min-idle: 0
          max-wait: 1000
server:
  port: 80

测试

package com.sqy.springbootredis;

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;

@SpringBootTest
class SpringbootRedisApplicationTests {
    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    void contextLoads() {
        redisTemplate.opsForValue().set("springname","sqyspringboot");

        Object springname = redisTemplate.opsForValue().get("springname");
        System.out.println(springname.toString());
    }

}

结果

序列化

添加Bean/改写key和value

RedisConfig

package com.sqy.springbootredis.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 redisConnectionFactory){

        //创建
        RedisTemplate<String, Object> template = new RedisTemplate<>();

        //连接工厂
        template.setConnectionFactory(redisConnectionFactory);

        //Json序列化工具
        GenericJackson2JsonRedisSerializer jsonRedisSerializer =
                new GenericJackson2JsonRedisSerializer();

        //key序列化
        template.setKeySerializer(RedisSerializer.string());
        template.setHashKeySerializer(RedisSerializer.string());

        //value序列化
        template.setValueSerializer(jsonRedisSerializer);
        template.setHashValueSerializer(jsonRedisSerializer);

        //返回
        return template;

    }
}

结果

StringRedisTemplate手动完成对象序列化，解决内存占用（@class)

直接使用

package com.sqy.springbootredis;


import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.sqy.springbootredis.pojo.User;
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.StringRedisTemplate;

@SpringBootTest
public class RedisStringTemplate {

    @Autowired
    StringRedisTemplate stringRedisTemplate;
    private static final ObjectMapper objectMapper=new ObjectMapper();


    @Test
    void test(){
        stringRedisTemplate.opsForValue().set("name","张三");

    }

    @Test
    void setUser() throws JsonProcessingException {

        User user1 = new User("张三", 10);
        String s = objectMapper.writeValueAsString(user1);
        stringRedisTemplate.opsForValue().set("user:200",s);

        String s1 = stringRedisTemplate.opsForValue().get("user:200");
        User user = objectMapper.readValue(s1, User.class);
        System.out.println(user.toString());
    }
}

结果