redis基础入门

一、redis相关介绍

1. Redis是流行NoSQL数据库之一，并且是单线程的（多线程cpu上下文会切换，耗时），基于内存，cpu不是内存瓶颈，而是机器的内存和网络带宽。 因为redis的数据是存于内存中的，对于内存系统来说，如果没有上下文切换，效率就是最高的。多次读写都是写在一个cpu上，在内存情况下，这个是最佳的方案。官方统计 redis每秒读11w，写8w。是用c写的，不比memecache差。
2. linux默认使用16个数据库，使用RDM软件可以看到16个库
3. 五大基本数据类型：list、set、String、Hash、zset

二、linux安装redis

https://blog.csdn.net/weixin_40496191/article/details/121028500

三、redis常用操作（命令行）

1. String
   1）切换库：select 1,2,3…
   2）设置键值对： set key value
   3）设置键值对（不存在才会成功）：setnx key value
   4）设置键值对（带过期时间）：setex key 10 value
   5）设置键值对(批量)：mset key1 value1 key2 value2
   6）查询键值：get key
   7）查询键值(批量)：mget key1 key2
   4）查看库里的键情况：keys *
   5）查看库里的大小：dbsize
   6） 清空当前数据库：flushdb
   7） 清空所有数据库：flushall
   8） 查看键是否存在：exists key
   9） 删除：del key
   10） 设置过期时间：expire key 10（单位s）
   11） 查看剩余时间：ttl key
   12） 追加值,key不存在则新建：append key value
   13） 查看长度：strlen key
   14） 加1，比如浏览量：incr counts
   15） 减1：decr counts
   16） 加10：incrby key 10
   17） 截取：GETRANGE key start end（0 -1是全部）
   18） 替换：zhanzhk —》setrange key 1 555–》z555zhk
   19） 取出并且设置，值取原来：getset key value
   20） 存对象：mset zk:1 {name1:zhanzhk1,age:8}
   21） 取对象：mget zk:1
   22） 存对象（可以实现复用，比如mset 好文章：文章1：浏览量）：mset zk:1:name1 zhanzhk1 zk:1:age 8 。
   23） 取对象：mget zk:1:name1 zk:1:age
2. list（元素可重复）
   l开头：集合的进出顺序跟栈一样，先进后出。
   r开头：先进先出
   1） 查看集合元素：lrange key 0 -1
   2） 插入集合元素到第一位：lpush key value
   3） 插入集合元素到最后一位：rpush key value
   4） 删除第一位元素：lpop key
   5） 删除最后一位元素：rpop key
   6） 下标查找元素：lindex key 0
   7） 长度：llen key
   8） 移除指定元素的个数：lrem key 数量 元素
   9） 截取：ltrim key 0 1
   10） 移除并且添加到其他集合：rpoplpush key1 key2
   11） 是否存在集合：exists list
   12） 替换值：lset key index value
   13） 往某个元素前后插入值：linsert key before/after 集合元素 新元素
   14） 实际上算是个链表结构，往收尾插入效率最高，往中间插入效率低。
3. set（无序不重复集合）
   1） 集合添加元素：sadd key value
   2） 查看集合元素：smembers key
   3） 判断是否存在某个元素：sismember key value
   4） 查看元素个数：scard key
   5） 移除元素：srem key value
   6） 随机抽取：srandmember key count（不写默认1个）
   7） 删除指定元素：srem key value
   8） 移动指定元素到另一个集合：smove key key2 value
   9） 以第一个key为基础，查看第二个key和第一个的差集：sdiff key1 key2
   10） 以第一个key为基础，查看第二个key和第一个的交集：sinter key1 key2（共同好友）
   11） 并集：sunion key1 key2
4. zset（有序不重复集合）
   1）添加：zadd key value key1
   2）查看：zrange key 0 -1
   3）按照序号排序：zrangebyscore key -inf 5
   4） 按照序号排序（无穷大）：zrangebyscore key -inf +inf
   5） 按照序号排序陪参数：zrangebyscore key -inf +inf withscores
   6） 移除元素：zrem key zzk10
   7） 查看数量：zcard key
   8） 查看区间数量：zcount key 0 100
5. hash（当做map）
   1） 添加元素： hset key key1 value1 key2 value2
   2） 查看元素：hget key key1
   3） 查看所有元素：hgetall key
   4） 删除集合元素：hdel key key1
   5） 查看集合长度：hlen key key1
   6） 查看某个元素是否存在：hexists key key1
   7） 查看所有的key：hkeys key
   8） 查看所有的值：hvals key
   9） 某个属性自增：hincrby key key1 1
   10） key不存在创建，存在不创建：hsetnx key key1 value
6. genpos（地图）
   1） 新增：geoadd china:city 精度 纬度 地点名
   2） 距离：geodist china:city 地点名 地点名
   3） 距离1：geodist china:city 地点名 地点名 km
   4） 扫描半径：georadius china:city 经度 纬度 5000 km
   5） 扫描半径，经纬度指定数量：georadius china:city 经度 纬度 5000 km withdist withcoord count 数量
   6） 找出某个城市周边的城市：georadiusbymember china:city 地点名 400 km
   7） 可以用zset命令查看：zrange china:city 0 -1
7. hyperloglog（允许容错）
   1. 添加元素：pfadd hype1 a b c pfadd hype2 a b c
   2. 合并并集：pfmerage hype3 hype1 hype2
   3. 查看数量：pfcount hype1
8. bitmaps
   1. 都是操作二进制位进行记录，只有0和1两种状态，只有两种状态的情况可以使用
   2. 添加打卡记录（一周打卡例子）：setbit sign 1 0 setbit sign 2 0 setbit sign 3 1
   3. 获取打卡：getbit sign 1
   4. 统计打卡记录：bitcount sign

四、redis常用操作（java）

1. string

package redis.jedis;

import redis.clients.jedis.Jedis;

import java.util.Set;

/**
 * @author 天真热
 * @create 2021-09-25 20:47
 * @desc
 **/
public class Redis_String {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("192.168.248.11", 6379);
        //设置键值对
        jedis.set("name", "zzk");
        //设置键值对（不存在才会成功）
        jedis.setnx("name", "zzk");
        //设置键值对（带过期时间）
        jedis.setex("name", 10, "zzk");
        //查询键值
        String name = jedis.get("name");
        //查看库里的键情况
        Set all = jedis.keys("*");
        //查看库里的大小
        Long size = jedis.dbSize();
        //清空当前数据库
        jedis.flushDB();
        //清空所有数据库
        jedis.flushAll();
        //查看键是否存在
        Boolean exist = jedis.exists("name");
        //删除元素
        jedis.del("name");
        //设置过期时间
        jedis.expire("name", 10);
        //查看剩余时间
        jedis.ttl("name");
        //追加值,key不存在则新建
        jedis.append("name", "zzk");
        //查看长度
        jedis.strlen("name");
        //加1，比如浏览量
        jedis.incr("age");
        //减1
        jedis.decr("age");
        //加10
        jedis.incrBy("age", 10);
        //截取
        jedis.getrange("name", 0, -1);
        //截取
        jedis.setrange("name", 1, "zhanzhk");
        //取出并且设置，值取原来
        jedis.getSet("name", "zahznhk");
        //存对象
        jedis.mset("zk:1", "{name1:zhanzhk1,age:8}");
        //取对象
        jedis.get("zk:1");

        jedis.close();
    }
}

2. list（元素可重复）

package redis.jedis;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.ListPosition;

/**
 * @author 天真热
 * @create 2021-09-25 20:47
 * @desc
 **/
public class Redis_list {
    public static void main(String[] args) {
        //l开头：集合的进出顺序跟栈一样，先进后出。
        //r开头：先进先出
        //实际上算是个链表结构，往收尾插入效率最高，往中间插入效率低。
        Jedis jedis = new Jedis("192.168.248.11", 6379);
        //查看集合元素
        jedis.lrange("name", 0, -1);
        //插入集合元素到第一位
        jedis.lpush("name", "zzk");
        //插入集合元素到最后一位
        jedis.rpush("name", "zzk");
        //删除第一位元素
        jedis.lpop("name");
        //下标查找元素
        jedis.lindex("name", 1);
        //长度
        jedis.llen("name");
        //移除指定元素的数量
        jedis.lrem("name", 10, "zzk");
        //截取
        jedis.ltrim("name", 0, 1);
        //移除并且添加到其他集合
        jedis.rpoplpush("name", "name1");
        //是否存在集合
        jedis.exists("name");
        //替换值
        jedis.lset("name", 1, "zzk");
        //往某个元素前后插入值
        jedis.linsert("name", ListPosition.BEFORE, "zzk", "zhanzhk");
        jedis.linsert("name", ListPosition.AFTER, "zzk", "zhanzhk");

        jedis.close();
    }
}

3. set（无序不重复集合）

package redis.jedis;

import redis.clients.jedis.Jedis;

/**
 * @author 天真热
 * @create 2021-09-25 20:47
 * @desc
 **/
public class Redis_set {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("192.168.248.11", 6379);
        //集合添加元素
        jedis.sadd("name", "zzk");
        //查看集合元素
        jedis.smembers("name");
        //判断是否存在某个元素
        jedis.sismember("name", "zzk");
        //查看元素个数
        jedis.scard("name");
        //移除元素
        jedis.srem("name", "zzk");
        //随机抽取,不写默认1个
        jedis.srandmember("name", 2);
        //移动指定元素到另一个集合
        jedis.smove("name", "name1", "zzk");
        //以第一个key为基础，查看第二个key和第一个的差集
        jedis.sdiff("name", "name1");
        //以第一个key为基础，查看第二个key和第一个的交集
        jedis.sinter("name", "name1");
        //并集
        jedis.sunion("name", "name1");

        jedis.close();
    }
}

4. zset（有序不重复集合）

package redis.jedis;

import redis.clients.jedis.Jedis;

/**
 * @author 天真热
 * @create 2021-09-25 20:47
 * @desc
 **/
public class Redis_zset {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("192.168.248.11", 6379);
        //添加
        jedis.zadd("name", 1, "zzk");
        //查看
        jedis.zrange("name", 0, -1);
        //按照序号排序
        jedis.zrangeByScore("name", 0, -1);
        //按照序号排序陪参数：zrangebyscore key -inf + inf withscores
        //查看数量
        jedis.zcard("name");
        //查看区间数量
        jedis.zcount("name", 0, 100);

        jedis.close();
    }
}

5. hash（当做map）

package redis.jedis;

import redis.clients.jedis.Jedis;

import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * @author 天真热
 * @create 2021-09-25 20:47
 * @desc
 **/
public class Redis_hash {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("192.168.248.11", 6379);
        //添加元素
        jedis.hset("name", "type1", "zzk");
        //查看元素
        String type1 = jedis.hget("name", "type1");
        //查看所有元素
        Map all = jedis.hgetAll("name");
        //删除集合元素
        jedis.hdel("name", "type1");
        //查看集合长度
        jedis.hlen("name");
        //查看某个元素是否存在
        jedis.hexists("name", "type1");
        //查看所有的key
        Set allkey = jedis.hkeys("name");
        //查看所有的值
        List allvalue = jedis.hvals("name");
        //某个属性自增
        jedis.hincrBy("name", "age", 1);
        //key不存在创建，存在不创建
        jedis.hsetnx("name", "type1", "zzk");

        jedis.close();
    }
}

6. genpos

package redis.jedis;

import redis.clients.jedis.GeoUnit;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.params.GeoRadiusParam;

/**
 * @author 天真热
 * @create 2021-09-25 20:47
 * @desc
 **/
public class Redis_genpos {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("192.168.248.11", 6379);
        //新增
        jedis.geoadd("china:city", 125.01, 95.25, "beijing");
        jedis.geoadd("china:city", 122.01, 91.25, "shanghai");
        jedis.geoadd("china:city", 120.01, 88.25, "chongqing");
        //距离
        jedis.geodist("china:city", "beijing", "shanghai");
        //距离指定带单位
        jedis.geodist("china:city", "beijing", "shanghai", GeoUnit.KM);
        //扫描半径
        jedis.georadius("china:city", 125.01, 95.25, 5000, GeoUnit.KM);
        //扫描半径，经纬度指定数量
        jedis.georadius("china:city", 125.01, 95.25, 5000, GeoUnit.KM, new GeoRadiusParam().count(2));
        //找出某个城市周边的城市
        jedis.georadiusByMember("china:city", "chongqing", 5000, GeoUnit.KM);
        //可以用zset命令查看
        jedis.zrange("china:city", 0, -1);

        jedis.close();

    }
}

7. hyperloglog（允许容错）

package redis.jedis;

import redis.clients.jedis.Jedis;

/**
 * @author 天真热
 * @create 2021-09-25 20:47
 * @desc
 **/
public class Redis_hyperloglog {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("192.168.248.11", 6379);
        //添加元素
        jedis.pfadd("name", "zzk");
        jedis.pfadd("name", "zzk1");
        jedis.pfadd("name", "zzk2");
        jedis.pfadd("name1", "zzk2");
        jedis.pfadd("name1", "zzk3");
        jedis.pfadd("name1", "zzk4");
        //合并并集
        jedis.pfmerge("name", "name1");
        //查看数量
        jedis.pfcount("name");

        jedis.close();
    }
}

8. bitmaps

package redis.jedis;

import redis.clients.jedis.Jedis;

/**
 * @author 天真热
 * @create 2021-09-25 20:47
 * @desc
 **/
public class Redis_bitmaps {
    public static void main(String[] args) {
        // 都是操作二进制位进行记录，只有0和1两种状态，只有两种状态的情况可以使用
        Jedis jedis = new Jedis("192.168.248.11", 6379);
        //添加打卡记录（一周打卡例子）
        jedis.setbit("sign", 1, true);
        jedis.setbit("sign", 2, true);
        jedis.setbit("sign", 3, false);
        jedis.setbit("sign", 4, true);
        jedis.setbit("sign", 5, false);
        jedis.setbit("sign", 6, true);
        jedis.setbit("sign", 7, true);
        //获取打卡
        jedis.getbit("sign", 1);
        //统计打卡记录
        jedis.bitcount("sign");

        jedis.close();
    }
}

五、springboot整合redis

pom文件

 

        
            org.springframework.boot
            spring-boot-starter
        
        
            org.springframework.boot
            spring-boot-starter-web
        

        
            org.springframework.boot
            spring-boot-starter-test
            test
        


        
        
            org.projectlombok
            lombok
        


        
            redis.clients
            jedis
            3.2.0
        


        
        
            org.springframework.boot
            spring-boot-starter-data-redis
        
    

配置文件

server:
  port: 8090

spring:
  redis:
    host: 192.168.248.11
    port: 6379

配置类

package redis.redis.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.beans.factory.annotation.Configurable;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.StringRedisConnection;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.net.UnknownHostException;

/**
 * @author 天真热
 * @create 2021-09-27 21:35
 * @desc
 **/
@Configuration
public class RedisConfig {

    /**
     * 自定义RedisTemplate
     *
     * @param redisConnectionFactory
     * @return
     * @throws UnknownHostException
     */
    @Bean
    @SuppressWarnings("all")
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
        //为了开发方便，一般使用类型
        RedisTemplate template = new RedisTemplate();
        //连接工厂，默认
        template.setConnectionFactory(redisConnectionFactory);
        //Json序列化配置
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        //使用ObjectMapper进行转义
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        //String序列化配置
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        //key采用String方式序列化
        template.setKeySerializer(stringRedisSerializer);
        //hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        //value序列化采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        //hash的value序列化采用jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);

        template.afterPropertiesSet();

        return template;
    }

}

redis调用工具类

package redis.redis.utils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.data.redis.core.*;
import org.springframework.stereotype.Component;

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

@Component
public class RedisUtil {
    @Autowired
    @Qualifier("redisTemplate")
    public static RedisTemplate redisTemplate;

    @Resource
    public void setRedisTemplate(RedisTemplate redisTemplate) {
        this.redisTemplate = redisTemplate;
    }


    //**********************************String类型，按需编写工具类***************************************
    public static void StringSetMethod() {
        ValueOperations valueOperations = redisTemplate.opsForValue();
        valueOperations.set("name", "zzk");
    }

    public static String StringGetMethod() {
        ValueOperations valueOperations = redisTemplate.opsForValue();
        return objToString(valueOperations.get("name"));
    }

    //**********************************list类型，按需编写工具类***************************************
    public static void listMethod() {
        ListOperations listOperations = redisTemplate.opsForList();
        listOperations.leftPush("name", "zzk");
    }

    //**********************************set类型，按需编写工具类***************************************
    public static void setMethod() {
        SetOperations setOperations = redisTemplate.opsForSet();
        setOperations.add("name", "zzk");
    }

    //**********************************zset类型，按需编写工具类***************************************
    public static void zsetMethod() {
        ZSetOperations zsetOperations = redisTemplate.opsForZSet();
        zsetOperations.add("name", 1, 1d);
    }

    //**********************************hsah类型，按需编写工具类***************************************
    public static void hashMethod() {
        HashOperations hashOperations = redisTemplate.opsForHash();
        hashOperations.put("name", "type1", "zzk");
    }

    public static String objToString(Object obj) {
        if (obj == null) {
            return "";
        } else {
            return obj.toString();
        }
    }
}