• Redis快速上手篇(三)(事务+Idea的连接和使用)

    Redis事务

    可以一次执行多个命令，本质是一组命令的集合。一个事务中的 所有命令都会序列化，按顺序地串行化执行而不会被其它命令插入，不许加塞。

    单独的隔离的操作

    官网说明

    https://redis.io/docs/interact/transactions/

    MULTI、EXEC、DISCARD、WATCH。这四个指令构成了 redis 事务处理的基础。

            1.MULTI 用来组装一个事务；将命令存放到一个队列里面

            2.EXEC 用来执行一个事务；相当于mysql的//commit

            3.DISCARD 用来取消一个事务；相当于mysql的//rollback

            4.WATCH 用来监视一些 key，一旦这些 key 在事务执行之前被改变，则取消事务的执行。

    结束后统一执行

    有关事务，经常会遇到的是两类错误：

    调用 EXEC 之前的错误 如语法错误，事务不会被执行

    调用 EXEC 之后的错误 如重复建，事务不会理睬错误（不会影响接下来的其他命令的执行）

    WATCH

    “WATCH”可以帮我们实现类似于“乐观锁”的效果，即 CAS（check and set）。

    WATCH 本身的作用是“监视 key 是否被改动过”，而且支持同时监视多个 key，只要还没真正触发事务，WATCH 都会尽职尽责的监视，一旦发现某个 key 被修改了，在执行 EXEC 时就会返回 nil，表示事务无法触发。

    在 multi 之前 set year 修改了值所以 nil

    事务回滚(discard)

    事务冲突

    比如涉及金钱的操作，导致金额负数

    解决方案

    悲观锁(Pessimistic Lock)

    顾名思义，就是很悲观

    每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，

    这样别人想拿这个数据就会block直到它拿到锁。

    传统的关系型数据库里边就用到了很多这种锁机制，

    比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。

    每次都会上锁影响效率

    乐观锁(Optimistic Lock)

    顾名思义，就是很乐观

    每次去拿数据的时候都认为别人不会修改，所以不会上锁，

    但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，

    可以使用版本号等机制。乐观锁适用于多读的应用类型，

    这样可以提高吞吐量。Redis就是利用这种check-and-set机制实现事务的。

    redis与idea的连接

    ssm

    添加redis的依赖

    1. <dependency>
    2.     <groupId>redis.clients</groupId>
    3.     <artifactId>jedis</artifactId>
    4.     <version>3.2.0</version>
    5. </dependency>

    Jedis jds = new Jedis("IP")

    jds.auth("密码")

    jds.select(数据库)

    spring boot

    加入redis的依赖

    1. <dependency>
    2.     <groupId>org.springframework.boot</groupId>
    3.     <artifactId>spring-boot-starter-data-redis</artifactId>
    4. </dependency>
    5.  
    6.  
    7. <dependency>
    8.     <groupId>org.apache.commons</groupId>
    9.     <artifactId>commons-pool2</artifactId>
    10.     <version>2.6.0</version>
    11. </dependency>
    12.  
    13.  
    14. <dependency>
    15.     <groupId>redis.clients</groupId>
    16.     <artifactId>jedis</artifactId>
    17. </dependency>

    编写配置文件

    1. #设置reis的索引
    2. spring.redis.database=15
    3. #设置连接redis的密码
    4. spring.redis.password=yyl
    5. #设置的redis的服务器
    6. spring.redis.host=192.168.159.34
    7. #端口号
    8. spring.redis.port=6379
    9. #连接超时时间（毫秒）
    10. spring.redis.timeout=1800000
    11. #连接池最大连接数（使用负值表示没有限制）
    12. spring.redis.lettuce.pool.max-active=20
    13. #最大阻塞等待时间(负数表示没限制)
    14. spring.redis.lettuce.pool.max-wait=-1
    15. #连接池中的最大空闲连接
    16. spring.redis.lettuce.pool.max-idle=5
    17. #连接池中的最小空闲连接
    18. spring.redis.lettuce.pool.min-idle=0

    设置配置类

    1. package com.example.demo;
    2.  
    3.  
    4. import com.fasterxml.jackson.annotation.JsonAutoDetect;
    5. import com.fasterxml.jackson.annotation.PropertyAccessor;
    6. import com.fasterxml.jackson.databind.ObjectMapper;
    7. import org.springframework.cache.CacheManager;
    8. import org.springframework.cache.annotation.CachingConfigurerSupport;
    9. import org.springframework.cache.annotation.EnableCaching;
    10. import org.springframework.context.annotation.Bean;
    11. import org.springframework.context.annotation.Configuration;
    12. import org.springframework.data.redis.cache.RedisCacheConfiguration;
    13. import org.springframework.data.redis.cache.RedisCacheManager;
    14. import org.springframework.data.redis.connection.RedisConnectionFactory;
    15. import org.springframework.data.redis.core.RedisTemplate;
    16. import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
    17. import org.springframework.data.redis.serializer.RedisSerializationContext;
    18. import org.springframework.data.redis.serializer.RedisSerializer;
    19. import org.springframework.data.redis.serializer.StringRedisSerializer;
    20.  
    21.  
    22. import java.time.Duration;
    23.  
    24.  
    25. @EnableCaching
    26. @Configuration
    27. public class RedisConfig extends CachingConfigurerSupport {
    28.   /**
    29.      * 连接池的设置
    30.      *
    31.      * @return
    32.      */
    33.     @Bean
    34.     public JedisPoolConfig getJedisPoolConfig() {
    35.         JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
    36.         return jedisPoolConfig;
    37.     }
    38.  
    39.  
    40.     /**
    41.      * RedisTemplate
    42.      * @param factory
    43.      * @return
    44.      */
    45.     @Bean
    46.     public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
    47.         RedisTemplate<String, Object> template = new RedisTemplate<>();
    48.         RedisSerializer<String> redisSerializer = new StringRedisSerializer();
    49.         Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
    50.         ObjectMapper om = new ObjectMapper();
    51.         // 指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public
    52.         om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
    53.         // 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会跑出异常
    54.         om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
    55.         jackson2JsonRedisSerializer.setObjectMapper(om);
    56.         template.setConnectionFactory(factory);
    57.         //key序列化方式
    58.         template.setKeySerializer(redisSerializer);
    59.         //value序列化
    60.         template.setValueSerializer(jackson2JsonRedisSerializer);
    61.         //value hashmap序列化
    62.         template.setHashValueSerializer(jackson2JsonRedisSerializer);
    63.         return template;
    64.     }
    65.  
    66.  
    67.     /**
    68.      * 缓存处理
    69.      * @param factory
    70.      * @return
    71.      */
    72.     @Bean
    73.     public CacheManager cacheManager(RedisConnectionFactory factory) {
    74.         RedisSerializer<String> redisSerializer = new StringRedisSerializer();
    75.         Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
    76. //解决查询缓存转换异常的问题
    77.         ObjectMapper om = new ObjectMapper();
    78.         om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
    79.         om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
    80.         jackson2JsonRedisSerializer.setObjectMapper(om);
    81. // 配置序列化（解决乱码的问题）,过期时间600秒
    82.         RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
    83.                 .entryTtl(Duration.ofSeconds(600))
    84.                 .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
    85.                 .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer))
    86.                 .disableCachingNullValues();
    87.         RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
    88.                 .cacheDefaults(config)
    89.                 .build();
    90.         return cacheManager;
    91.     }
    92. }

    编写测试代码

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

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

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

    操作字符串

    redisTemplate.opsForValue();

    操作hash

    redisTemplate.opsForHash();

    操作list

    redisTemplate.opsForList();

    操作set

    redisTemplate.opsForSet();

    操作有序set

    redisTemplate.opsForZSet();

    String类型与List类型

    Set类型
    1. 添加元素
    2. redisTemplate.opsForSet().add(key, values)
    3. 移除元素(单个值、多个值)
    4. redisTemplate.opsForSet().remove(key, values)
    5.  
    6.  
    7. 删除并且返回一个随机的元素
    8.  
    9. redisTemplate.opsForSet().pop(key)
    10.  
    11.  
    12. 获取集合的大小
    13.  
    14. redisTemplate.opsForSet().size(key)
    15.  
    16.  
    17. 判断集合是否包含value
    18. redisTemplate.opsForSet().isMember(key, value)
    19.  
    20.  
    21. 获取两个集合的交集(key对应的无序集合与otherKey对应的无序集合求交集)
    22. redisTemplate.opsForSet().intersect(key, otherKey)
    23.  
    24.  
    25. 获取多个集合的交集(Collection var2)
    26.  
    27.  
    28. redisTemplate.opsForSet().intersect(key, otherKeys)
    29.  
    30.  
    31. key集合与otherKey集合的交集存储到destKey集合中(其中otherKey可以为单个值或者集合)
    32.  
    33.  
    34. redisTemplate.opsForSet().intersectAndStore(key, otherKey, destKey)
    35.  
    36.  
    37. key集合与多个集合的交集存储到destKey无序集合中
    38.  
    39.  
    40. redisTemplate.opsForSet().intersectAndStore(key, otherKeys, destKey)
    41.  
    42.  
    43. 获取两个或者多个集合的并集(otherKeys可以为单个值或者是集合)
    44.  
    45.  
    46. redisTemplate.opsForSet().union(key, otherKeys)
    47.  
    48.  
    49. key集合与otherKey集合的并集存储到destKey中(otherKeys可以为单个值或者是集合)
    50.  
    51.  
    52. redisTemplate.opsForSet().unionAndStore(key, otherKey, destKey)
    53.  
    54.  
    55. 获取两个或者多个集合的差集(otherKeys可以为单个值或者是集合)
    56.  
    57.  
    58. redisTemplate.opsForSet().difference(key, otherKeys)
    59.  
    60.  
    61. 差集存储到destKey中(otherKeys可以为单个值或者集合)
    62.  
    63.  
    64. redisTemplate.opsForSet().differenceAndStore(key, otherKey, destKey)
    65.  
    66.  
    67. 随机获取集合中的一个元素
    68.  
    69.  
    70. redisTemplate.opsForSet().randomMember(key)
    71.  
    72.  
    73. 获取集合中的所有元素
    74.  
    75.  
    76. redisTemplate.opsForSet().members(key)
    77.  
    78.  
    79. 随机获取集合中count个元素
    80.  
    81.  
    82. redisTemplate.opsForSet().randomMembers(key, count)
    83.  
    84.  
    85. 获取多个key无序集合中的元素（去重），count表示个数
    86.  
    87.  
    88. redisTemplate.opsForSet().distinctRandomMembers(key, count)
    89.  
    90.  
    91. 遍历set类似于Interator(ScanOptions.NONE为显示所有的)
    92.  
    93.  
    94. redisTemplate.opsForSet().scan(key, options)
    Hash类型
    1. Long delete(H key, Object... hashKeys);
    2. 删除给定的哈希hashKeys
    3.  
    4.     System.out.println(template.opsForHash().delete("redisHash","name"));
    5.     System.out.println(template.opsForHash().entries("redisHash"));
    6.     1
    7.     {class=6, age=28.1}
    8.  
    9. Boolean hasKey(H key, Object hashKey);
    10. 确定哈希hashKey是否存在
    11.     System.out.println(template.opsForHash().hasKey("redisHash","666"));
    12.     System.out.println(template.opsForHash().hasKey("redisHash","777"));
    13.     true
    14.     false
    15.  
    16. HV get(H key, Object hashKey);
    17. 从键中的哈希获取给定hashKey的值
    18.     System.out.println(template.opsForHash().get("redisHash","age"));
    19.     26
    20.  
    21.  Set<HK> keys(H key);
    22. 获取key所对应的散列表的key
    23.     System.out.println(template.opsForHash().keys("redisHash"));
    24.     //redisHash所对应的散列表为{class=1, name=666, age=27}
    25.     [name, class, age]
    26.  
    27. Long size(H key);
    28. 获取key所对应的散列表的大小个数
    29.     System.out.println(template.opsForHash().size("redisHash"));
    30.     //redisHash所对应的散列表为{class=1, name=666, age=27}
    31.     3
    32.  
    33.  void putAll(H key, Map<? extends HK, ? extends HV> m);
    34. 使用m中提供的多个散列字段设置到key对应的散列表中
    35.  
    36.     Map<String,Object> testMap = new HashMap();
    37.     testMap.put("name","666");
    38.     testMap.put("age",27);
    39.     testMap.put("class","1");
    40.     template.opsForHash().putAll("redisHash1",testMap);
    41.     System.out.println(template.opsForHash().entries("redisHash1"));
    42.     {class=1, name=jack, age=27}
    43.  
    44.  void put(H key, HK hashKey, HV value);
    45. 设置散列hashKey的值
    46.  
    47.     template.opsForHash().put("redisHash","name","666");
    48.     template.opsForHash().put("redisHash","age",26);
    49.     template.opsForHash().put("redisHash","class","6");
    50.     System.out.println(template.opsForHash().entries("redisHash"));
    51.     {age=26, class=6, name=666}
    52.  
    53.  List<HV> values(H key);
    54. 获取整个哈希存储的值根据密钥
    55.     System.out.println(template.opsForHash().values("redisHash"));
    56.     [tom, 26, 6]
    57.  
    58.  Map<HK, HV> entries(H key);
    59. 获取整个哈希存储根据密钥
    60.     System.out.println(template.opsForHash().entries("redisHash"));
    61.     {age=26, class=6, name=tom}
    62.  
    63.  Cursor<Map.Entry<HK, HV>> scan(H key, ScanOptions options);
    64. 使用Cursor在key的hash中迭代，相当于迭代器。
    65.     Cursor<Map.Entry<Object, Object>> curosr = template.opsForHash().scan("redisHash", 
    66.       ScanOptions.ScanOptions.NONE);
    67.         while(curosr.hasNext()){
    68.             Map.Entry<Object, Object> entry = curosr.next();
    69.             System.out.println(entry.getKey()+":"+entry.getValue());
    70.         }
    71.     age:27
    72.     class:6
    73.     name:666

    命令

    操作

    返回值

    hash.delete(H key, Object... hashKeys)

    删除，可以传入多个map的key【hdel】

    Long

    hash.hasKey(key, hashKey)

    查看hash中的某个hashKey是否存在【hexists】

    Boolean

    hash.get(key, hashKey)

    获取值【hget】

    Object（HV 泛型约束对象）

    hash.multiGet(H key, Collection hashKeys)

    批量获取集合中的key对应的值【hmget】

    List

    hash.increment(H key, HK hashKey, long delta)

    对值进行+(delta值)操作【】

    Long

    hash.increment(H key, HK hashKey, double delta)

    ~

    double

    hash.keys(key)

    返回map内hashKey的集合【hkeys】

    Set

    hash.lengthOfValue(H key, HK hashKey)

    返回查询键关联的值的长度，为null则返回0【hstrlen】

    Long

    hash.size(H key)

    获取hashKey的个数【hlen】

    Long

    hash.putAll(H key, Map m)

    相当于map的putAll【hmset】

    void

    hash.put(H key, HK hashKey, HV value)

    设置值，添加hashKey-value，hashKay相当于map的key 【hset】

    void

    hash.putIfAbsent(H key, HK hashKey, HV value)

    仅当hashKey不存在时设置值

    Boolean

    hash.values(key)

    返回value的集合【hvals】

    List

    hase.entries(H key)

    获取map【hgetall】

    Map

    hash.scan(H key, ScanOptions options)

    基于游标的迭代查询【hscan】

    Cursor>（返回的Cursor要手动关闭，见下面示例2）

    hash.getOperations()

    返回RedisOperation，它就是redis操作的接口

    RedisOperations

    ZSet类型
    1. Boolean add(K key, V value, double score);
    2. 新增一个有序集合，存在的话为false，不存在的话为true
    3.   
    4.   System.out.println(template.opsForZSet().add("zset1","zset-1",1.0));
    5.   true
    6.  Long add(K key, Set<TypedTuple<V>> tuples);
    7. 新增一个有序集合
    8.     ZSetOperations.TypedTuple<Object> objectTypedTuple1 = new DefaultTypedTuple<>("zset-5",9.6);
    9.     ZSetOperations.TypedTuple<Object> objectTypedTuple2 = new DefaultTypedTuple<>("zset-6",9.9);
    10.     Set<ZSetOperations.TypedTuple<Object>> tuples = new HashSet>();
    11.     tuples.add(objectTypedTuple1);
    12.     tuples.add(objectTypedTuple2);
    13.     System.out.println(template.opsForZSet().add("zset1",tuples));
    14.     System.out.println(template.opsForZSet().range("zset1",0,-1));
    15.     [zset-1, zset-2, zset-3, zset-4, zset-5, zset-6]
    16. Long remove(K key, Object... values);
    17. 从有序集合中移除一个或者多个元素
    18.    System.out.println(template.opsForZSet().range("zset1",0,-1));
    19.    System.out.println(template.opsForZSet().remove("zset1","zset-6"));
    20.     System.out.println(template.opsForZSet().range("zset1",0,-1));
    21.     [zset-1, zset-2, zset-3, zset-4, zset-5, zset-6]
    22.     1
    23.     [zset-1, zset-2, zset-3, zset-4, zset-5]
    24.  Long rank(K key, Object o);
    25. 返回有序集中指定成员的排名，其中有序集成员按分数值递增(从小到大)顺序排列
    26.  
    27.     System.out.println(template.opsForZSet().range("zset1",0,-1));
    28.     System.out.println(template.opsForZSet().rank("zset1","zset-2"));
    29.     [zset-2, zset-1, zset-3, zset-4, zset-5]
    30.     0   //表明排名第一
    31.  
    32. Set<V> range(K key, long start, long end);
    33. 通过索引区间返回有序集合成指定区间内的成员，其中有序集成员按分数值递增(从小到大)顺序排列
    34.     System.out.println(template.opsForZSet().range("zset1",0,-1));
    35.     [zset-2, zset-1, zset-3, zset-4, zset-5]
    36. Long count(K key, double min, double max);
    37. 通过分数返回有序集合指定区间内的成员个数
    38.  
    39.     System.out.println(template.opsForZSet().rangeByScore("zset1",0,5));
    40.     System.out.println(template.opsForZSet().count("zset1",0,5));
    41.     [zset-2, zset-1, zset-3]
    42.     3
    43.  
    44. Long size(K key);
    45. 获取有序集合的成员数，内部调用的就是zCard方法
    46.  
    47.     System.out.println(template.opsForZSet().size("zset1"));
    48.     6
    49.  
    50.  
    51.  Double score(K key, Object o);
    52. 获取指定成员的score值
    53.  
    54.     System.out.println(template.opsForZSet().score("zset1","zset-1"));
    55.     2.2
    56.  
    57.  
    58. Long removeRange(K key, long start, long end);
    59. 移除指定索引位置的成员，其中有序集成员按分数值递增(从小到大)顺序排列
    60.  
    61.     System.out.println(template.opsForZSet().range("zset2",0,-1));
    62.     System.out.println(template.opsForZSet().removeRange("zset2",1,2));
    63.     System.out.println(template.opsForZSet().range("zset2",0,-1));
    64.     [zset-1, zset-2, zset-3, zset-4]
    65.     2
    66.     [zset-1, zset-4]
    67.  
    68.  
    69. Cursor<TypedTuple<V>> scan(K key, ScanOptions options);
    70. 遍历zset
    71.     Cursor<ZSetOperations.TypedTuple<Object>> cursor = template.opsForZSet().scan("zzset1", ScanOptions.NONE);
    72.         while (cursor.hasNext()){
    73.            ZSetOperations.TypedTuple<Object> item = cursor.next();
    74.            System.out.println(item.getValue() + ":" + item.getScore());
    75.         }
    76.     zset-1:1.0
    77.     zset-2:2.0
    78.     zset-3:3.0
    79.     zset-4:6.0

  • 相关阅读:
    spring MVC基础步骤
    计算机网络408 2017
    信创大潮下，产业金融路在何方？
    传输层和网络层的checksum区别，TCP cksum为何包含伪首部
    电子数据取证-流程与技术
    EtherCAT转Modbus-TCP协议网关与DCS连接的配置方法
    LeetCode 441. 排列硬币
    利用jar包构建Docker 镜像
    智华计算机终端保护检查系统使用笔记
    Node.js - nvm管理node.js版本
  • 原文地址：https://blog.csdn.net/Z15800020057/article/details/134012383