Redis

彩色的传说柠檬

于 2024-01-24 08:55:42 发布

阅读量791

点赞数 22

文章标签： redis 数据库缓存

本文链接：https://blog.csdn.net/Jinwsnmaodianshu/article/details/135786558

版权

1.Redis发布与订阅

什么是发布与订阅

Redis 发布订阅 (pub/sub) 是一种消息通信模式：发送者 (pub) 发送消息，订阅者 (sub) 接收消息。

Redis 客户端可以订阅任意数量的频道。

使用场景

聊天室、公告牌、服务之间利用消息解耦都可以使用发布订阅模式。

发布与订阅的命令

订阅消息

2、打开另一个客户端，给channel1发布消息hello

publish channel1 hello

在另一边就能接收到消息了

2.Redis事务

Redis简介

一, Redis事务概念

Redis 事务的本质是一组命令的集合。事务支持一次执行多个命令，一个事务中所有命令都会被序列化。在事务执行过程，会按照顺序串行化执行队列中的命令，其他客户端提交的命令请求不会插入到事务执行命令序列中。
总结说：redis事务就是一次性、顺序性、排他性的执行一个队列中的一系列命令

二、Redis事务没有隔离级别的概念

批量操作在发送 EXEC 命令前被放入队列缓存，并不会被实际执行，也就不存在事务内的查询要看到事务里的更新，事务外查询不能看到。

三、Redis不保证原子性

Redis中，单条命令是原子性执行的，但事务不保证原子性，且没有回滚。事务中任意命令执行失败，其余的命令仍会被执行。

四、Redis事务的三个阶段

开始事务
MULIT   //标记事务的开始
命令入队
INCR 命令  //多条命令按顺序入队
执行事务
EXEC  //执行事务

五 Redis使用案列

Redis事务冲突

双十一去购物的时候使用同一张银行卡去付款

10000

一个请求想给金额减8000

一个请求想给金额减5000

一个请求想给金额减1000

导致结果为-4000.

对于以上事务冲突问题，我们通过加锁的方式解决

悲观锁

即很悲观，每次去拿数据时都认为别人会修改，所以在每次获取数据时都上锁，使别人无法获取数据直至你使用完写回为止。

传统的关系型数据库里面用到了很多这种锁机制，比如行锁、表锁、读锁、写锁，都是在进行操作之前先上锁

缺点：效率较低，只能一个人一个人的使用

乐观锁

即比较乐观，每次拿数据时都认为别人不会修改，所以不进行上锁，但是在更新时会判断一下在此期间有没有人去更新这个数据（采用版本号机制）。

乐观锁适用于读操作较多的应用类型，提高吞吐量。例如：抢票

利用check-and-set机制实现事务

WATCH key[key...]（乐观锁的使用）
在执行multi之前，先执行watch key1 [key2]来监视一个或多个key，如果在事务执行之前这个(或这些) key 被其他命令所改动，那么事务将被打断。

例:在第一个窗口中对balance进行修改自动打断第二个窗口中的事务

127.0.0.1:6379> set age 23
OK
127.0.0.1:6379> watch age //开始监视 age
OK
127.0.0.1:6379> set age 24 //在 EXEC 之前，age 的值被修改了
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379> set age 25
QUEUED
127.0.0.1:6379> get age
QUEUED
127.0.0.1:6379> exec //触发 EXEC
(nil) //事务无法被执行

unwatch：取消对所有key监控

3.Redis的使用

4.Java操作redis

创建springboot项目在pom里面添加依赖

<!--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>
      <version>2.11.1</version>
    </dependency>
    <dependency>
      <groupId>redis.clients</groupId>
      <artifactId>jedis</artifactId>
    </dependency>

创建连接

 
    @Test
    void contextLoads() {
        //建立连接
        Jedis jd=new Jedis("192.168.184.33",6379);
        //输入密码
        jd.auth("yml");
        //选择库
        jd.select(1);
        //插入数据, 方法名就是redis里面的命令
        jd.set("name","张三");
        //获取数据
        System.out.println(jd.get("name"));
        //关闭连接
        if (jd!=null){
            jd.close();
        }
    }

SpringBoot整合配置文件

编写配置类

package com.aaa.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import redis.clients.jedis.JedisPoolConfig;

import java.time.Duration;

@EnableCaching//开启缓存
@Configuration
public class RedisConfig extends CachingConfigurerSupport {
  /**
     * 连接池的设置
     *
     * @return
     */
    @Bean
    public JedisPoolConfig getJedisPoolConfig() {
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        return jedisPoolConfig;
    }
    /**
     * RedisTemplate
     * @param factory
     * @return
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        // 指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        // 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会跑出异常
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        template.setConnectionFactory(factory);
        //key序列化方式
        template.setKeySerializer(redisSerializer);
        //value序列化
        template.setValueSerializer(jackson2JsonRedisSerializer);
        //value hashmap序列化
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        return template;
    }
    /**
     * 缓存处理
     * @param factory
     * @return
     */
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        //解决查询缓存转换异常的问题
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        // 配置序列化（解决乱码的问题）,过期时间600秒
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofSeconds(600))
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer))
                .disableCachingNullValues();
        RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
                .cacheDefaults(config)
                .build();
        return cacheManager;
    }
}

编写测试代码

spring-data-redis针对jedis提供了如下功能：

1. 连接池自动管理，提供了一个高度封装的“RedisTemplate”类

2. RedisTemplate 对五种数据结构分别定义了操作

操作字符串

redisTemplate.opsForValue();

操作hash

redisTemplate.opsForHash();

操作list

redisTemplate.opsForList();

操作set

redisTemplate.opsForSet();

操作有序set

redisTemplate.opsForZSet();

String类的常用方法

判断是否有key所对应的值，有则返回true，没有则返回false
redisTemplate.hasKey(key)   
有则取出key值所对应的值
redisTemplate.opsForValue().get(key)
redisTemplate.opsForValue().set("key","val")
删除单个key值
redisTemplate.delete(key)
批量删除key
redisTemplate.delete(keys) //其中keys:Collection<K> keys
 void set(K key, V value);
    redisTemplate.opsForValue().set("num","123");
    redisTemplate.opsForValue().get("num")  输出结果为123
 
 
 void set(K key, V value, long timeout, TimeUnit unit); 
 
    redisTemplate.opsForValue().set("num","123",10, TimeUnit.SECONDS);
    redisTemplate.opsForValue().get("num")设置的是10秒失效，十秒之内查询有结果，十秒之后返回为null
 
 
            TimeUnit.DAYS          //天
            TimeUnit.HOURS         //小时
            TimeUnit.MINUTES       //分钟
            TimeUnit.SECONDS       //秒
            TimeUnit.MILLISECONDS  //毫秒 
 
 
 void set(K key, V value, long offset);
 
覆写(overwrite)给定 key 所储存的字符串值，从偏移量 offset 开始
 
 
    template.opsForValue().set("key","hello world");
    template.opsForValue().set("key","redis", 6);
    System.out.println("***************"+template.opsForValue().get("key"));
    结果：***************hello redis
 
 
 V get(Object key);
 
    template.opsForValue().set("key","hello world");
    System.out.println("***************"+template.opsForValue().get("key"));
    结果：***************hello world
 
 
getAndSet V getAndSet(K key, V value); 
 
设置键的字符串值并返回其旧值
 
    template.opsForValue().set("getSetTest","test");
    System.out.println(template.opsForValue().getAndSet("getSetTest","test2"));
    结果：test
 
append Integer append(K key, String value);
 
如果key已经存在并且是一个字符串，则该命令将该值追加到字符串的末尾。如果键不存在，则它被创建并设置为空字符串，因此APPEND在这种特殊情况下将类似于SET。
 
    template.opsForValue().append("test","Hello");
    System.out.println(template.opsForValue().get("test"));
    template.opsForValue().append("test","world");
    System.out.println(template.opsForValue().get("test"));
    Hello
    Helloworld
 
size Long size(K key);
返回key所对应的value值得长度
 
    template.opsForValue().set("key","hello world");
    System.out.println("***************"+template.opsForValue().size("key"));
    ***************11

List类常用的方法

通过索引获取列表中的元素
redisTemplate.opsForList().index(key, index)
 
获取列表指定范围内的元素(start开始位置, 0是开始位置，end 结束位置, -1返回所有)
redisTemplate.opsForList().range(key, start, end)
 
存储在list的头部，即添加一个就把它放在最前面的索引处
redisTemplate.opsForList().leftPush(key, value)  
 
把多个值存入List中(value可以是多个值，也可以是一个Collection value)
redisTemplate.opsForList().leftPushAll(key, value)
 
List存在的时候再加入
redisTemplate.opsForList().leftPushIfPresent(key, value)
 
 
如果pivot处值存在则在pivot前面添加
redisTemplate.opsForList().leftPush(key, pivot, value)
 
 
按照先进先出的顺序来添加(value可以是多个值，或者是Collection var2)
redisTemplate.opsForList().rightPush(key, value)
 
redisTemplate.opsForList().rightPushAll(key, value)
在pivot元素的右边添加值
 
redisTemplate.opsForList().rightPush(key, pivot, value)
 
设置指定索引处元素的值
 
redisTemplate.opsForList().set(key, index, value)
 
移除并获取列表中第一个元素(如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止)
 
redisTemplate.opsForList().leftPop(key)
 
redisTemplate.opsForList().leftPop(key, timeout, unit)
 
移除并获取列表最后一个元素
 
redisTemplate.opsForList().rightPop(key)
 
 
redisTemplate.opsForList().rightPop(key, timeout, unit)
从一个队列的右边弹出一个元素并将这个元素放入另一个指定队列的最左边
 
 
redisTemplate.opsForList().rightPopAndLeftPush(sourceKey, destinationKey)
 
 
redisTemplate.opsForList().rightPopAndLeftPush(sourceKey, destinationKey, timeout, unit)
 
 
删除集合中值等于value的元素(index=0, 删除所有值等于value的元素; index>0, 从头部开始删除第一个值等于value的元素; index<0, 从尾部开始删除第一个值等于value的元素)
 
 
redisTemplate.opsForList().remove(key, index, value)
 
 
将List列表进行剪裁
 
redisTemplate.opsForList().trim(key, start, end)
 
 
获取当前key的List列表长度
redisTemplate.opsForList().size(key)

Set类常用的方法

添加元素
redisTemplate.opsForSet().add(key, values)
移除元素(单个值、多个值)
redisTemplate.opsForSet().remove(key, values)
 
 
删除并且返回一个随机的元素
 
redisTemplate.opsForSet().pop(key)
 
 
获取集合的大小
 
redisTemplate.opsForSet().size(key)
 
 
判断集合是否包含value
redisTemplate.opsForSet().isMember(key, value)
 
 
获取两个集合的交集(key对应的无序集合与otherKey对应的无序集合求交集)
redisTemplate.opsForSet().intersect(key, otherKey)
 
 
获取多个集合的交集(Collection var2)
 
 
redisTemplate.opsForSet().intersect(key, otherKeys)
 
 
key集合与otherKey集合的交集存储到destKey集合中(其中otherKey可以为单个值或者集合)
 
 
redisTemplate.opsForSet().intersectAndStore(key, otherKey, destKey)
 
 
key集合与多个集合的交集存储到destKey无序集合中
 
 
redisTemplate.opsForSet().intersectAndStore(key, otherKeys, destKey)
 
 
获取两个或者多个集合的并集(otherKeys可以为单个值或者是集合)
 
 
redisTemplate.opsForSet().union(key, otherKeys)
 
 
key集合与otherKey集合的并集存储到destKey中(otherKeys可以为单个值或者是集合)
 
 
redisTemplate.opsForSet().unionAndStore(key, otherKey, destKey)
 
 
获取两个或者多个集合的差集(otherKeys可以为单个值或者是集合)
 
 
redisTemplate.opsForSet().difference(key, otherKeys)
 
 
差集存储到destKey中(otherKeys可以为单个值或者集合)
 
 
redisTemplate.opsForSet().differenceAndStore(key, otherKey, destKey)
 
 
随机获取集合中的一个元素
 
 
redisTemplate.opsForSet().randomMember(key)
 
 
获取集合中的所有元素
 
 
redisTemplate.opsForSet().members(key)
 
 
随机获取集合中count个元素
 
 
redisTemplate.opsForSet().randomMembers(key, count)
 
 
获取多个key无序集合中的元素（去重），count表示个数
 
 
redisTemplate.opsForSet().distinctRandomMembers(key, count)
 
 
遍历set类似于Interator(ScanOptions.NONE为显示所有的)
 
 
redisTemplate.opsForSet().scan(key, options)

Hash类常用的方法

Long delete(H key, Object... hashKeys);
删除给定的哈希hashKeys
 
    System.out.println(template.opsForHash().delete("redisHash","name"));
    System.out.println(template.opsForHash().entries("redisHash"));
    1
    {class=6, age=28.1}
 
Boolean hasKey(H key, Object hashKey);
确定哈希hashKey是否存在
    System.out.println(template.opsForHash().hasKey("redisHash","666"));
    System.out.println(template.opsForHash().hasKey("redisHash","777"));
    true
    false
 
HV get(H key, Object hashKey);
从键中的哈希获取给定hashKey的值
    System.out.println(template.opsForHash().get("redisHash","age"));
    26
 
 Set<HK> keys(H key);
获取key所对应的散列表的key
    System.out.println(template.opsForHash().keys("redisHash"));
    //redisHash所对应的散列表为{class=1, name=666, age=27}
    [name, class, age]
 
Long size(H key);
获取key所对应的散列表的大小个数
    System.out.println(template.opsForHash().size("redisHash"));
    //redisHash所对应的散列表为{class=1, name=666, age=27}
    3
 
 void putAll(H key, Map<? extends HK, ? extends HV> m);
使用m中提供的多个散列字段设置到key对应的散列表中
 
    Map<String,Object> testMap = new HashMap();
    testMap.put("name","666");
    testMap.put("age",27);
    testMap.put("class","1");
    template.opsForHash().putAll("redisHash1",testMap);
    System.out.println(template.opsForHash().entries("redisHash1"));
    {class=1, name=jack, age=27}
 
 void put(H key, HK hashKey, HV value);
设置散列hashKey的值
 
    template.opsForHash().put("redisHash","name","666");
    template.opsForHash().put("redisHash","age",26);
    template.opsForHash().put("redisHash","class","6");
    System.out.println(template.opsForHash().entries("redisHash"));
    {age=26, class=6, name=666}
 
 List<HV> values(H key);
获取整个哈希存储的值根据密钥
    System.out.println(template.opsForHash().values("redisHash"));
    [tom, 26, 6]
 
 Map<HK, HV> entries(H key);
获取整个哈希存储根据密钥
    System.out.println(template.opsForHash().entries("redisHash"));
    {age=26, class=6, name=tom}
 
 Cursor<Map.Entry<HK, HV>> scan(H key, ScanOptions options);
使用Cursor在key的hash中迭代，相当于迭代器。
    Cursor<Map.Entry<Object, Object>> curosr = template.opsForHash().scan("redisHash", 
      ScanOptions.ScanOptions.NONE);
        while(curosr.hasNext()){
            Map.Entry<Object, Object> entry = curosr.next();
            System.out.println(entry.getKey()+":"+entry.getValue());
        }
    age:27
    class:6
    name:666

5SpringBoot基于Redis的缓存

彩色的传说柠檬

关注

22
点赞
踩
13

收藏

觉得还不错? 一键收藏
1
评论
Redis

Redis 事务的本质是一组命令的集合。事务支持一次执行多个命令，一个事务中所有命令都会被序列化。在事务执行过程，会按照顺序串行化执行队列中的命令，其他客户端提交的命令请求不会插入到事务执行命令序列中。总结说：redis事务就是一次性、顺序性、排他性的执行一个队列中的一系列命令。
复制链接

扫一扫