Redis学习延申--初识泛型

已于 2023-10-29 14:56:15 修改
阅读量100 收藏
点赞数
文章标签： redis 学习 数据库
于 2023-10-29 14:55:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/YangLanLing/article/details/134102597
版权

目录

前言

一、泛型概念

 二、泛型的三种使用场景

1、泛型类

（1）定义

（2）泛型类的使用 

2、泛型接口

3、泛型方法（本文项目种使用的就是泛型方法）

(1)泛型方法的定义

三、项目示例

前言

  之前写了两个防止缓存穿透和缓存击穿的方法。但是存在局限，只能适用于Shop对象，如果将Consumer对象也存在缓存击穿和穿透的隐患，需要处理。最简单的处理就是，复制之前的两个方法，修改对象。但是这样会造成代码的重复，而且万一以后再有这样的问题，又要复制一份代码。这对系统而言，是极大的负担。

        所以，最好的方法就是对原先的两个方法进行封装，改造成适用于其他任何类的方法，也就是工具类方法，这时候就要用到泛型了。先简单看下成果。

public <R, ID> R queryWithMutex(String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long time, TimeUnit unit){
#具体代码
}

一、泛型概念

泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参列表，普通方法的形参列表中，每个形参的数据类型是确定的，而变量是一个参数。在调用普通方法时需要传入对应形参数据类型的变量（实参），若传入的实参与形参定义的数据类型不匹配，则会报错。

那参数化类型是什么？以方法的定义为例，在方法定义时，将方法签名中的形参的数据类型也设置为参数（也可称之为类型参数），在调用该方法时再从外部传入一个具体的数据类型和变量。 

泛型的本质是为了将类型参数化， 也就是说在泛型使用过程中，数据类型被设置为一个参数，在使用时再从外部传入一个数据类型；而一旦传入了具体的数据类型后，传入变量（实参）的数据类型如果不匹配，编译器就会直接报错。这种参数化类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。

 二、泛型的三种使用场景

1、泛型类

（1）定义

(1-1)类型参数用于类的定义中，则该类被称为泛型类。通过泛型可以完成对一组类的操作对外开放相同的接口。最典型的就是各种容器类，如：List、Set、Map等。

泛型类的基本语法如下： 

class 类名称 <泛型标识> {
  private 泛型标识 /*（成员变量类型）*/ 变量名; 
  .....

  }
}

  • 尖括号 <> 中的 泛型标识被称作是类型参数，用于指代任何数据类型。

  •  泛型标识是任意设置的（如果你想可以设置为 Hello都行），Java 常见的泛型标识以及其代表含义如下：
  T ：代表一般的任何类。
  E ：代表 Element 元素的意思，或者 Exception 异常的意思。
  K ：代表 Key 的意思。
  V ：代表 Value 的意思，通常与 K 一起配合使用。
  S ：代表 Subtype 的意思。
  ？ - 表示不确定的 java 类型

 举例如下:

public class Box<T> {
   
  private T t;
 
  public void add(T t) {
    this.t = t;
  }
 
  public T get() {
    return t;
  }
 
  public static void main(String[] args) {
    Box<Integer> integerBox = new Box<Integer>();
    Box<String> stringBox = new Box<String>();
 
    integerBox.add(new Integer(10));
    stringBox.add(new String("菜鸟教程"));
 
    System.out.printf("整型值为 :%d\n\n", integerBox.get());
    System.out.printf("字符串为 :%s\n", stringBox.get());
  }
}
  • 在泛型类中，类型参数定义的位置有三处，分别为： 

  1.非静态的成员属性类型 --private T t;
  2.非静态方法的形参类型（包括非静态成员方法和构造器）--public void add(T t){}
  3.非静态的成员方法的返回值类型--public T get(){}

 (1-2)泛型类中的静态方法和静态变量不可以使用泛型类所声明的类型参数。因为静态方法会先于类进行加载，而此时类的具体参数类型还未确定，就会报错。

例子如下：

public class Test<T> {    
    public static T one;   // 编译错误    
    public static T show(T one){ // 编译错误    
        return null;    
    }    
}

（1-3）泛型类不只接受一个类型参数，它还可以接受多个类型参数

（2）泛型类的使用 

在创建泛型类的对象时，必须指定类型参数 T 的具体数据类型，即尖括号 <> 中传入的什么数据类型，T 便会被替换成对应的类型。如果 <> 中什么都不传入，则默认是 < Object >。 

2、泛型接口

泛型接口和泛型类的定义差不多，基本语法如下：

public interface 接口名<类型参数> {
    ...
}

举例如下：

public interface Inter<T> {
    public abstract void show(T t);
}

3、泛型方法（本文项目种使用的就是泛型方法）

(1)泛型方法的定义

当在一个方法签名中的返回值前面声明了一个 < T > 时，该方法就被声明为一个泛型方法。< T >表明该方法声明了一个类型参数 T，并且这个类型参数 T 只能在该方法中使用。当然，泛型方法中也可以使用泛型类中定义的泛型参数。

基本语法如下：

public <类型参数> 返回类型 方法名（类型参数 变量名） {
    ...
}

注意：

只有在方法签名中声明了< T >的方法才是泛型方法，仅使用了泛型类定义的类型参数的方法并不是泛型方法。

public class Test<U> {
	// 该方法只是使用了泛型类定义的类型参数，不是泛型方法
	public void testMethod(U u){
		System.out.println(u);
	}
	
	// <T> 真正声明了下面的方法是一个泛型方法
	public <T> T testMethod1(T t){
		return t;
	}
}

泛型方法中可以同时声明多个类型参数。 

public class TestMethod<U> {
	public <T, S> T testMethod(T t, S s) {
		return null;
	}
}

（3）泛型方法中也可以使用泛型类中定义的泛型参数。

public class TestMethod<U> {
	public <T> U testMethod(T t, U u) {
		return u;
	}
}

（4）特别注意的是：泛型类中定义的类型参数和泛型方法中定义的类型参数是相互独立的，它们一点关系都没有。 

public class Test<T> {
	public void testMethod(T t) {
		System.out.println(t);
	}
	
	public <T> T testMethod1(T t) {
		return t;
	}
}

        上面代码中，Test< T > 是泛型类，testMethod() 是泛型类中的普通方法，其使用的类型参数是与泛型类中定义的类型参数。而 testMethod1() 是一个泛型方法，他使用的类型参数是与方法签名中声明的类型参数。
        虽然泛型类中定义的类型参数标识和泛型方法中定义的类型参数标识都为< T >，但它们彼此之间是相互独立的。也就是说，泛型方法始终以自己声明的类型参数为准。

三、项目示例

原先代码：

//互斥锁
public Shop queryWithMutex(Long id) {
        String key = CACHE_SHOP_KEY + id;
        // 1.从redis查询商铺缓存
        String shopJson = stringRedisTemplate.opsForValue().get(key);
        // 2.判断是否存在
        if (StrUtil.isNotBlank(shopJson)) {
            // 3.存在，直接返回
            return JSONUtil.toBean(shopJson, Shop.class);
        }
        // 判断命中的是否是空值
        if (shopJson != null) {
            // 返回一个错误信息
            return null;
        }
 
        // 4.实现缓存重建
        // 4.1.获取互斥锁
        String lockKey = LOCK_SHOP_KEY + id;
        Shop shops = new Shop();
        try {
            boolean isLock = tryLock(lockKey);
            // 4.2.判断是否获取成功
            if (!isLock) {
                // 4.3.获取锁失败，休眠并重试
                Thread.sleep(50);
                return queryWithMutex1(id);
            }
            // 4.4.获取锁成功，根据id查询数据库
            Shop shop = getById(id);
            // 5.不存在，返回错误
            if (shop == null) {
                // 将空值写入redis
                stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
                // 返回错误信息
                return null;
            }
            // 6.存在，写入redis
            shops = shop;
            stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(shop),CACHE_SHOP_TTL,TimeUnit.MINUTES);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }finally {
            // 7.释放锁
            unlock(lockKey);
        }
        // 8.返回
        return shops;
    }
//逻辑过期
private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);
    public Shop  queryWithLogicalExpire(Long id) {
        String key = CACHE_SHOP_KEY + id;
        // 1.从redis查询商铺缓存
        String json = stringRedisTemplate.opsForValue().get(key);
        // 2.判断是否存在
        if (StrUtil.isBlank(json)) {
            // 3.存在，直接返回
            return null;
        }
        // 4.命中，需要先把json反序列化为对象
        RedisData redisData = JSONUtil.toBean(json, RedisData.class);
        Shop shop = JSONUtil.toBean((JSONObject) redisData.getData(), Shop.class);
        LocalDateTime expireTime = redisData.getExpireTime();
        // 5.判断是否过期
        if(expireTime.isAfter(LocalDateTime.now())) {
            // 5.1.未过期，直接返回店铺信息
            return shop;
        }
        // 5.2.已过期，需要缓存重建
        // 6.缓存重建
        // 6.1.获取互斥锁
        String lockKey = LOCK_SHOP_KEY + id;
        boolean isLock = tryLock(lockKey);
        // 6.2.判断是否获取锁成功
        if (isLock){
            // 6.3.成功，开启独立线程，实现缓存重建
            CACHE_REBUILD_EXECUTOR.submit(() -> {
                try {
                    // 查询数据库
                    // 重建缓存
                    this.saveShop2Redis(id,20L);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }finally {
                    // 释放锁
                    unlock(lockKey);
                }
            });
        }
        // 6.4.返回过期的商铺信息
        return shop;
    }
 
    private Shop saveShop2Redis(Long id,Long expireSeconds){
        //查询店铺
        Shop shop = getById(id);
        //封装过期时间
        RedisData redisData = new RedisData();
        redisData.setData(shop);
        redisData.setExpireTime(LocalDateTime.now().plusSeconds(expireSeconds));
        //写入Redis
        stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + id,JSONUtil.toJsonStr(redisData));
        return  shop;
    }
//获取锁，释放锁
 private boolean tryLock(String key) {
        Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);
        return BooleanUtil.isTrue(flag);
 }
 
private void unlock(String key) {
        stringRedisTemplate.delete(key);
}

修改为泛型后：

//空值
 public <R, ID> R queryWithMutex(
            String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long time, TimeUnit unit) {
        String key = keyPrefix + id;
        // 1.从redis查询商铺缓存
        String shopJson = stringRedisTemplate.opsForValue().get(key);
        // 2.判断是否存在
        if (StrUtil.isNotBlank(shopJson)) {
            // 3.存在，直接返回
            return JSONUtil.toBean(shopJson, type);
        }
        // 判断命中的是否是空值
        if (shopJson != null) {
            // 返回一个错误信息
            return null;
        }

        // 4.实现缓存重建
        // 4.1.获取互斥锁
        String lockKey = LOCK_SHOP_KEY + id;
        R r = null;
        try {
            boolean isLock = tryLock(lockKey);
            // 4.2.判断是否获取成功
            if (!isLock) {
                // 4.3.获取锁失败，休眠并重试
                Thread.sleep(50);
                return queryWithMutex(keyPrefix, id, type, dbFallback, time, unit);
            }
            // 4.4.获取锁成功，根据id查询数据库
            r = dbFallback.apply(id);
            // 5.不存在，返回错误
            if (r == null) {
                // 将空值写入redis
                stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
                // 返回错误信息
                return null;
            }
            // 6.存在，写入redis
            this.set(key, r, time, unit);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }finally {
            // 7.释放锁
            unlock(lockKey);
        }
        // 8.返回
        return r;
    }

//逻辑删除
public <R, ID> R queryWithLogicalExpire(
            String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long time, TimeUnit unit) {
        String key = keyPrefix + id;
        // 1.从redis查询商铺缓存
        String json = stringRedisTemplate.opsForValue().get(key);
        // 2.判断是否存在
        if (StrUtil.isBlank(json)) {
            // 3.存在，直接返回
            return null;
        }
        // 4.命中，需要先把json反序列化为对象
        RedisData redisData = JSONUtil.toBean(json, RedisData.class);
        R r = JSONUtil.toBean((JSONObject) redisData.getData(), type);
        LocalDateTime expireTime = redisData.getExpireTime();
        // 5.判断是否过期
        if(expireTime.isAfter(LocalDateTime.now())) {
            // 5.1.未过期，直接返回店铺信息
            return r;
        }
        // 5.2.已过期，需要缓存重建
        // 6.缓存重建
        // 6.1.获取互斥锁
        String lockKey = LOCK_SHOP_KEY + id;
        boolean isLock = tryLock(lockKey);
        // 6.2.判断是否获取锁成功
        if (isLock){
            // 6.3.成功，开启独立线程，实现缓存重建
            CACHE_REBUILD_EXECUTOR.submit(() -> {
                try {
                    // 查询数据库
                    R newR = dbFallback.apply(id);
                    // 重建缓存
                    this.setWithLogicalExpire(key, newR, time, unit);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }finally {
                    // 释放锁
                    unlock(lockKey);
                }
            });
        }
        // 6.4.返回过期的商铺信息
        return r;
    }

项目代码中，还涉及到一点函数式接口--Function<ID, R> dbFallback。

蓝色ling
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
项目-19-初识Elasticsearch
Guo_Chuang的博客
06-25 135
1. 初识Elasticsearch Elasticsearch入门 一个分布式的、Restful风格的搜索引擎。 支持对各种类型的数据的检索。 搜索速度快，可以提供实时的搜索服务。 便于水平扩展，每秒可以处理PB级海量数据。 Elasticsearch术语 ： 索引、类型、文档、字段。 集群、节点、分片、副本。 Elasticsearch与数据库的对比： Elasticsearch 数据库 索引 database 类型 table 文档 一行数据 字段 一列数据
Redis --- 高级篇
shuai_h的博客
01-09 1295
Redis分布式缓存
初识Redis(一)--Redis数据类型和数据抽象简介
qq_40151840的博客
02-26 314
初识Redis(一)–Redis数据类型和数据抽象简介 一、概述 Redis（Remote Dictionary Server，远程字典服务 ）并不只是简单的键值存储(key-value store )，它实际上是一个数据结构服务器（Data Structure Server），支持不同类型的值。 这意味着，尽管在传统的键值存储中，我们将字符串键与字符串值相关联（associated string...
Redis高级篇-多级缓存
无私のZ的博客
09-13 1773
Redis高级篇-多级缓存
Redis-黑马程序员
Kim-Hyunyeon的博客
03-17 1339
Redis，英文全称是Remote Dictionary Server（远程字典服务），是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。 与MySQL数据库不同的是，Redis的数据是存在内存中的。它的读写速度非常快，每秒可以处理超过10万次读写操作。因此redis被广泛应用于缓存，另外，Redis也经常用来做分布式锁。除此之外，Redis支持事务、持久化、LUA 脚本、LRU 驱动事件、多种集群方案。
计算机笔记--【Redis高级】
qq_40720821的博客
05-22 705
Redis笔记，多级缓存，缓存
初识redis
zhu061034的博客
10-13 160
什么是NoSQL NoSQL，泛指非关系型的数据库，NoSQL即Not-Only SQL，它可以作为关系型数据库的良好补充。随着互联网web2.0网站的兴起，非关系型的数据库现在成了一个极其热门的新领域，非关系数据库产品的发展非常迅速。而传统的关系数据库在应付web2.0网站，特别是超大规模和高并发的SNS类型的web2.0纯动态网站已经显得力不从心，暴露了很多难以克服的问题，例如：
Redis高级客户端Lettuce详解
Throwable
02-06 6876
前提 Lettuce是一个Redis的Java驱动包，初识她的时候是使用RedisTemplate的时候遇到点问题Debug到底层的一些源码，发现spring-data-redis的驱动包在某个版本之后替换为Lettuce。Lettuce翻译为生菜，没错，就是吃的那种生菜，所以它的Logo长这样： 既然能被Spring生态所认可，Lettuce想必有过人之处，于是笔者花时间阅读她的官方文档，整理...
Redis三 高级篇-2. 多级缓存
weixin_43695916的博客
02-16 362
redis
redis-stack-server 7.2.0 安装包合集
04-03
redis-stack-server-7.2.0-v9.arm64.snap redis-stack-server-7.2.0-v9.bionic.arm64.tar.gz redis-stack-server-7.2.0-v9.bionic.x86_64.tar.gz redis-stack-server-7.2.0-v9.bullseye.x86_64.tar.gz redis-stack-...
Redis稳定版 Redis-x64-5.0.14.1.zip
07-21
本次提供的版本是Redis的稳定版——Redis-x64-5.0.14.1，针对64位操作系统设计。在深入探讨Redis之前，我们先了解下Redis的基本特性。 1. **数据类型**: Redis支持五大数据类型：字符串(String)、哈希(Hash)、列表...
Redis-x64-5.0.14.1
03-01
这个名为"Redis-x64-5.0.14.1"的压缩包是Redis针对Windows操作系统的64位版本，版本号为5.0.14.1。在Windows上运行Redis可能与Linux环境有所不同，但仍然提供了相同的核心功能。 1. **Redis的特性**： - **内存...
redis2-nginx-module-0.15
07-18
**Redis2-NGINX-Module 0.15 知识详解** Redis2-NGINX-Module 是一个用于 NGINX Web 服务器的扩展模块，它允许开发者将 NGINX 与 Redis 数据库集成，实现高效的数据缓存和交互。这个版本是 0.15，它提供了一系列...
Redis-x64-3.0.504安装包
10-11
Redis-x64-3.0.504安装包是一个针对64位操作系统的Redis数据库服务器的安装程序。Redis是一款高性能、开源、基于键值对的数据存储系统，广泛应用于缓存、数据库、消息中间件等多个场景。这个版本是3.0.504，代表着在...
Windows环境安装Redis和Redis Desktop Manager图文详解教程
谷哥的小弟
07-07 1216
Redis是一个开源的高性能键值对数据库，以其卓越的读写速度而著称，广泛用于数据库、缓存和消息代理。它主要将数据存储在内存中，从而实现快速的数据处理，同时提供了数据持久化功能，以防止系统故障时数据丢失。Redis支持多种数据类型，包括键值对、列表、集合、有序集合、散列、HyperLogLogs和地理空间索引，满足不同场景的数据存储需求。它的原子操作确保了在多线程环境中的数据一致性和完整性，而发布/订阅功能则允许多个客户端订阅频道，实现消息的实时传递。
7.10日学习打卡----初学Redis（五）
最新发布
m0_74436895的博客
07-11 775
经历了 1次pipeline(n条命令) = 1次网络时间 + n次命令时间，这大大减少了网络时间的开销，这就是流水线。执行一条命令在redis端可能需要几百微秒，而在网络光纤中传输只花费了13毫秒。注意在执行批量操作而没有使用pipeline功能，会将大量的时间耗费在每一次网络传输的过程上；而使用pipeline后，只需要经过一次网络传输，然后批量在redis端进行命令操作。这会大大提高了效率。
redis-cli 连接Redis
一个写了10年bug的程序员日常笔记。
07-08 479
redis-cli 是原生 Redis 自带的命令行工具，您可以在云主机或本地设备上通过 redis-cli 连接 Redis 数据库，进行数据管理。redis-cli 客户端的使用方法，请参考官方文档。
8、Redis 的线程模型、I/O 模型和多线程
qq_29434541的博客
07-07 914
Redis 基于 Reactor 模式开发了网络事件处理器 - 文件事件处理器（file event handler，简称 FEH）。该处理器是单线程的，所以 Redis 设计为单线程模型。通过 I/O 多路复用同时监听多个 socket，根据 socket 当前执行的事件选择对应的事件处理器。当被监听的 socket 准备好执行 accept、read、write、close 等操作时，FEH 调用 socket 关联的事件处理器处理事件。
redis-cli --bigkeys
03-14
redis-cli --bigkeys是Redis命令行工具的一个选项，用于查找并列出占用内存较大的键。当Redis数据库中存在大量的键值对时，有时候需要找出占用内存较多的键，以便进行优化或者释放内存空间。 使用redis-cli --...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值