AI 助理
文档备案控制台
开发者社区 云原生 中间件 文章 正文

springboot集成图片验证+redis缓存一步到位

2023-12-24 294
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： springboot集成图片验证+redis缓存一步到位

1.图片验证与缓存依赖：

<!--        验证码-->
        <dependency>
            <groupId>com.github.whvcse</groupId>
            <artifactId>easy-captcha</artifactId>
            <version>1.6.2</version>
        </dependency>
<!--        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>
    </dependencies>

2.redis配置:在application.properties中加入配置
spring.redis.host=localhost
spring.redis.port=6379
spring.redis.database= 0
spring.redis.timeout=1800000
spring.redis.lettuce.pool.max-active=20
spring.redis.lettuce.pool.max-wait=-1

最大阻塞等待时间(负数表示没限制)

spring.redis.lettuce.pool.max-idle=5
spring.redis.lettuce.pool.min-idle=0

最小空闲

3.redis工具类：

    注意之所以每加static是因为咱们是注入形式调用的，而不是通过类名调用，这里是通过spring对象帮我们调用。注意！！！同时@component注解不要忘记加！

```package com.laoyang.educms.utils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import javax.annotation.Resource;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**

  • @author:Kevin
  • @create: 2022-10-05 14:30

  • @Description:
    */
    @Component
    public class redisutils {
    @Autowired
    private RedisTemplate redisTemplate;

    // =============================common============================

    /**

    • 指定缓存失效时间
      *
    • @param key 键

    • @param time 时间(秒)
      */
      public boolean expire(String key, long time) {
      try { 

       if (time > 0) {
     redisTemplate.expire(key, time, TimeUnit.SECONDS);
 }
 return true;

      } catch (Exception e) { 

       e.printStackTrace();
 return false;

      }
      }

      /**

    • 根据key 获取过期时间
      *
    • @param key 键 不能为null
    • @return 时间(秒) 返回0代表为永久有效
      */
      public long getExpire(String key) {
      return redisTemplate.getExpire(key, TimeUnit.SECONDS);
      }
/**
 * 判断key是否存在
 *
 * @param key 键
 * @return true 存在 false不存在
 */
public  boolean hasKey(String key) {
    try {
        return redisTemplate.hasKey(key);
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}


/**
 * 删除缓存
 *
 * @param key 可以传一个值 或多个
 */
@SuppressWarnings("unchecked")
public  void del(String... key) {
    if (key != null && key.length > 0) {
        if (key.length == 1) {
            redisTemplate.delete(key[0]);
        } else {
            redisTemplate.delete(CollectionUtils.arrayToList(key));
        }
    }
}


// ============================String=============================

/**
 * 普通缓存获取
 *
 * @param key 键
 * @return 值
 */
public  Object get(String key) {
    return key == null ? null : redisTemplate.opsForValue().get(key);
}

/**
 * 普通缓存放入
 *
 * @param key   键
 * @param value 值
 * @return true成功 false失败
 */

public  boolean set(String key, Object value) {
    try {
        redisTemplate.opsForValue().set(key, value);
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}


/**
 * 普通缓存放入并设置时间
 *
 * @param key   键
 * @param value 值
 * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
 * @return true成功 false 失败
 */

public  boolean set(String key, Object value, long time) {
    try {
        if (time > 0) {
            redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
        } else {
            set(key, value);
        }
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}


/**
 * 递增
 *
 * @param key   键
 * @param delta 要增加几(大于0)
 */
public  long incr(String key, long delta) {
    if (delta < 0) {
        throw new RuntimeException("递增因子必须大于0");
    }
    return redisTemplate.opsForValue().increment(key, delta);
}


/**
 * 递减
 *
 * @param key   键
 * @param delta 要减少几(小于0)
 */
public  long decr(String key, long delta) {
    if (delta < 0) {
        throw new RuntimeException("递减因子必须大于0");
    }
    return redisTemplate.opsForValue().increment(key, -delta);
}


// ================================Map=================================

/**
 * HashGet
 *
 * @param key  键 不能为null
 * @param item 项 不能为null
 */
public  Object hget(String key, String item) {
    return redisTemplate.opsForHash().get(key, item);
}

/**
 * 获取hashKey对应的所有键值
 *
 * @param key 键
 * @return 对应的多个键值
 */
public  Map<Object, Object> hmget(String key) {
    return redisTemplate.opsForHash().entries(key);
}

/**
 * HashSet
 *
 * @param key 键
 * @param map 对应多个键值
 */
public  boolean hmset(String key, Map<String, Object> map) {
    try {
        redisTemplate.opsForHash().putAll(key, map);
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}


/**
 * HashSet 并设置时间
 *
 * @param key  键
 * @param map  对应多个键值
 * @param time 时间(秒)
 * @return true成功 false失败
 */
public  boolean hmset(String key, Map<String, Object> map, long time) {
    try {
        redisTemplate.opsForHash().putAll(key, map);
        if (time > 0) {
            expire(key, time);
        }
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}


/**
 * 向一张hash表中放入数据,如果不存在将创建
 *
 * @param key   键
 * @param item  项
 * @param value 值
 * @return true 成功 false失败
 */
public  boolean hset(String key, String item, Object value) {
    try {
        redisTemplate.opsForHash().put(key, item, value);
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}

/**
 * 向一张hash表中放入数据,如果不存在将创建
 *
 * @param key   键
 * @param item  项
 * @param value 值
 * @param time  时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
 * @return true 成功 false失败
 */
public  boolean hset(String key, String item, Object value, long time) {
    try {
        redisTemplate.opsForHash().put(key, item, value);
        if (time > 0) {
            expire(key, time);
        }
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}


/**
 * 删除hash表中的值
 *
 * @param key  键 不能为null
 * @param item 项 可以使多个 不能为null
 */
public  void hdel(String key, Object... item) {
    redisTemplate.opsForHash().delete(key, item);
}


/**
 * 判断hash表中是否有该项的值
 *
 * @param key  键 不能为null
 * @param item 项 不能为null
 * @return true 存在 false不存在
 */
public  boolean hHasKey(String key, String item) {
    return redisTemplate.opsForHash().hasKey(key, item);
}


/**
 * hash递增 如果不存在,就会创建一个 并把新增后的值返回
 *
 * @param key  键
 * @param item 项
 * @param by   要增加几(大于0)
 */
public  double hincr(String key, String item, double by) {
    return redisTemplate.opsForHash().increment(key, item, by);
}


/**
 * hash递减
 *
 * @param key  键
 * @param item 项
 * @param by   要减少记(小于0)
 */
public  double hdecr(String key, String item, double by) {
    return redisTemplate.opsForHash().increment(key, item, -by);
}


// ============================set=============================

/**
 * 根据key获取Set中的所有值
 *
 * @param key 键
 */
public  Set<Object> sGet(String key) {
    try {
        return redisTemplate.opsForSet().members(key);
    } catch (Exception e) {
        e.printStackTrace();
        return null;
    }
}


/**
 * 根据value从一个set中查询,是否存在
 *
 * @param key   键
 * @param value 值
 * @return true 存在 false不存在
 */
public  boolean sHasKey(String key, Object value) {
    try {
        return redisTemplate.opsForSet().isMember(key, value);
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}


/**
 * 将数据放入set缓存
 *
 * @param key    键
 * @param values 值 可以是多个
 * @return 成功个数
 */
public  long sSet(String key, Object... values) {
    try {
        return redisTemplate.opsForSet().add(key, values);
    } catch (Exception e) {
        e.printStackTrace();
        return 0;
    }
}


/**
 * 将set数据放入缓存
 *
 * @param key    键
 * @param time   时间(秒)
 * @param values 值 可以是多个
 * @return 成功个数
 */
public  long sSetAndTime(String key, long time, Object... values) {
    try {
        Long count = redisTemplate.opsForSet().add(key, values);
        if (time > 0)
            expire(key, time);
        return count;
    } catch (Exception e) {
        e.printStackTrace();
        return 0;
    }
}


/**
 * 获取set缓存的长度
 *
 * @param key 键
 */
public  long sGetSetSize(String key) {
    try {
        return redisTemplate.opsForSet().size(key);
    } catch (Exception e) {
        e.printStackTrace();
        return 0;
    }
}


/**
 * 移除值为value的
 *
 * @param key    键
 * @param values 值 可以是多个
 * @return 移除的个数
 */

public  long setRemove(String key, Object... values) {
    try {
        Long count = redisTemplate.opsForSet().remove(key, values);
        return count;
    } catch (Exception e) {
        e.printStackTrace();
        return 0;
    }
}

// ===============================list=================================

/**
 * 获取list缓存的内容
 *
 * @param key   键
 * @param start 开始
 * @param end   结束 0 到 -1代表所有值
 */
public  List<Object> lGet(String key, long start, long end) {
    try {
        return redisTemplate.opsForList().range(key, start, end);
    } catch (Exception e) {
        e.printStackTrace();
        return null;
    }
}


/**
 * 获取list缓存的长度
 *
 * @param key 键
 */
public  long lGetListSize(String key) {
    try {
        return redisTemplate.opsForList().size(key);
    } catch (Exception e) {
        e.printStackTrace();
        return 0;
    }
}


/**
 * 通过索引 获取list中的值
 *
 * @param key   键
 * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
 */
public  Object lGetIndex(String key, long index) {
    try {
        return redisTemplate.opsForList().index(key, index);
    } catch (Exception e) {
        e.printStackTrace();
        return null;
    }
}


/**
 * 将list放入缓存
 *
 * @param key   键
 * @param value 值
 */
public  boolean lSet(String key, Object value) {
    try {
        redisTemplate.opsForList().rightPush(key, value);
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}


/**
 * 将list放入缓存
 *
 * @param key   键
 * @param value 值
 * @param time  时间(秒)
 */
public  boolean lSet(String key, Object value, long time) {
    try {
        redisTemplate.opsForList().rightPush(key, value);
        if (time > 0)
            expire(key, time);
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }

}


/**
 * 将list放入缓存
 *
 * @param key   键
 * @param value 值
 * @return
 */
public  boolean lSet(String key, List<Object> value) {
    try {
        redisTemplate.opsForList().rightPushAll(key, value);
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }

}


/**
 * 将list放入缓存
 *
 * @param key   键
 * @param value 值
 * @param time  时间(秒)
 * @return
 */
public  boolean lSet(String key, List<Object> value, long time) {
    try {
        redisTemplate.opsForList().rightPushAll(key, value);
        if (time > 0)
            expire(key, time);
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}


/**
 * 根据索引修改list中的某条数据
 *
 * @param key   键
 * @param index 索引
 * @param value 值
 * @return
 */

public  boolean lUpdateIndex(String key, long index, Object value) {
    try {
        redisTemplate.opsForList().set(key, index, value);
        return true;
    } catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}


/**
 * 移除N个值为value
 *
 * @param key   键
 * @param count 移除多少个
 * @param value 值
 * @return 移除的个数
 */

public  long lRemove(String key, long count, Object value) {
    try {
        Long remove = redisTemplate.opsForList().remove(key, count, value);
        return remove;
    } catch (Exception e) {
        e.printStackTrace();
        return 0;
    }

}

}
```

文章标签：
云数据库 Tair（兼容 Redis）
缓存
Java
NoSQL
Redis
关键词：
springboot云数据库 Tair（兼容 Redis）
Spring Boot图片
redis缓存
云数据库 Tair（兼容 Redis）缓存
云数据库 Tair（兼容 Redis）Springboot
游客f5tatfcr46lrm
目录
相关文章
技术自由圈/原疯狂创客圈
|
9月前
|
缓存 NoSQL 关系型数据库
美团面试：MySQL有1000w数据，redis只存20w的数据，如何做 缓存 设计？
美团面试：MySQL有1000w数据，redis只存20w的数据，如何做 缓存 设计？
技术自由圈/原疯狂创客圈
1283 12
美团面试：MySQL有1000w数据，redis只存20w的数据，如何做 缓存 设计？
aliyun9170107523-43660
|
4月前
|
缓存 负载均衡 监控
135_负载均衡：Redis缓存 - 提高缓存命中率的配置与最佳实践
在现代大型语言模型（LLM）部署架构中，缓存系统扮演着至关重要的角色。随着LLM应用规模的不断扩大和用户需求的持续增长，如何构建高效、可靠的缓存架构成为系统性能优化的核心挑战。Redis作为业界领先的内存数据库，因其高性能、丰富的数据结构和灵活的配置选项，已成为LLM部署中首选的缓存解决方案。
aliyun9170107523-43660
528 25
varin
|
5月前
|
存储 缓存 NoSQL
Redis专题-实战篇二-商户查询缓存
本文介绍了缓存的基本概念、应用场景及实现方式，涵盖Redis缓存设计、缓存更新策略、缓存穿透问题及其解决方案。重点讲解了缓存空对象与布隆过滤器的使用，并通过代码示例演示了商铺查询的缓存优化实践。
varin
268 1
Redis专题-实战篇二-商户查询缓存
蒋星熠Jaxonic
|
4月前
|
缓存 运维 监控
Redis 7.0 高性能缓存架构设计与优化
🌟蒋星熠Jaxonic，技术宇宙中的星际旅人。深耕Redis 7.0高性能缓存架构，探索函数化编程、多层缓存、集群优化与分片消息系统，用代码在二进制星河中谱写极客诗篇。
蒋星熠Jaxonic
485 3
pickstar-33775
|
9月前
|
缓存 NoSQL Java
Redis+Caffeine构建高性能二级缓存
大家好，我是摘星。今天为大家带来的是Redis+Caffeine构建高性能二级缓存，废话不多说直接开始~
pickstar-33775
1274 0
游客y6nbucfgpbrn4
|
5月前
|
缓存 NoSQL 关系型数据库
Redis缓存和分布式锁
Redis 是一种高性能的键值存储系统，广泛用于缓存、消息队列和内存数据库。其典型应用包括缓解关系型数据库压力，通过缓存热点数据提高查询效率，支持高并发访问。此外，Redis 还可用于实现分布式锁，解决分布式系统中的资源竞争问题。文章还探讨了缓存的更新策略、缓存穿透与雪崩的解决方案，以及 Redlock 算法等关键技术。
游客y6nbucfgpbrn4
205 0
蓝易云
|
9月前
|
消息中间件 缓存 NoSQL
基于Spring Data Redis与RabbitMQ实现字符串缓存和计数功能（数据同步）
总的来说，借助Spring Data Redis和RabbitMQ，我们可以轻松实现字符串缓存和计数的功能。而关键的部分不过是一些"厨房的套路"，一旦你掌握了这些套路，那么你就像厨师一样可以准备出一道道饕餮美食了。通过这种方式促进数据处理效率无疑将大大提高我们的生产力。
蓝易云
302 32
计算机程序设计的泡泡Y2013070224
|
4月前
|
JavaScript Java 关系型数据库
基于springboot的项目管理系统
本文探讨项目管理系统在现代企业中的应用与实现，分析其研究背景、意义及现状，阐述基于SSM、Java、MySQL和Vue等技术构建系统的关键方法，展现其在提升管理效率、协同水平与风险管控方面的价值。
计算机程序设计的泡泡Y2013070224
405 43
计算机程序设计的泡泡Y2013070224
|
4月前
|
搜索推荐 JavaScript Java
基于springboot的儿童家长教育能力提升学习系统
本系统聚焦儿童家长教育能力提升，针对家庭教育中理念混乱、时间不足、个性化服务缺失等问题，构建科学、系统、个性化的在线学习平台。融合Spring Boot、Vue等先进技术，整合优质教育资源，提供高效便捷的学习路径，助力家长掌握科学育儿方法，促进儿童全面健康发展，推动家庭和谐与社会进步。
计算机程序设计的泡泡Y2013070224
227 5
云原生

中间件

热门文章

最新文章

  • 1
    重塑云上的 Java 语言
  • 2
    3分钟，了解阿里云热门开发者工具 Cloud Toolkit
  • 3
    【沉淀】从网络中间件到搜索，从移动开发到分布式计算平台，阿里高级专家李睿博谈自己的折腾路
  • 4
    Java编码技巧之高效代码50例
  • 5
    分布式服务框架Dubbo疯狂更新！阿里开源要搞大事情？
  • 6
    一键托管，阿里云全链路追踪服务正式商用：成本仅自建1/5或更少
  • 7
    开发者说：Sentinel 流控功能在 SpringMVC/SpringBoot 上的实践
  • 8
    Kafka、RabbitMQ、RocketMQ 消息中间件的对比 | 消息发送性能篇
  • 9
    首届阿里巴巴中间件技术峰会资料回顾
  • 10
    Spring Cloud Config 规范
  • 1
    领航智联时代：阿里云 MQTT+Kafka 车/物联网实时数据分析解决方案
    97
  • 2
    构建开放智能体生态：AgentScope 如何用 A2A 协议与 Nacos 打通协作壁垒？
    305
  • 3
    用 AgentScope Java 开家 AI 奶茶店
    254
  • 4
    从“工具过载”到“精准调用”：破解 Agent 工具管理难题
    136
  • 5
    数据跨境、隐私泄露、审计溯源——出海企业三大安全必答题
    103
  • 6
    RUM 链路打通实战：打破移动端可观测性黑洞
    85
  • 7
    从 ReAct 到 Ralph Loop：AI Agent 的持续迭代范式
    293
  • 8
    阿里开源 Assistant Agent，助力企业快速构建答疑、诊断智能助手
    592
  • 9
    面向多租户云的 IO 智能诊断：从异常发现到分钟级定位
    257
  • 10
    阿里云微服务引擎 MSE 及 API 网关 2025 年 12 月产品动态
    206

    • 相关课程

    更多
  • 事件总线EventBridge生态集成课程
  • 消息队列 RocketMQ 消息集成

    • 相关电子书

    更多
  • 阿里邮箱—安全高效集成
  • 集成智能接入网关APP：优化企业级移动办公网络
  • 云效助力企业集成安全到DevOps中

    • 相关实验场景

    更多
  • 通过云原生API网关进行AI缓存
  • AnalyticDB Zero-ETL：简单易用零成本的一站式数据分析
    • 下一篇
    第五届伏魔挑战赛如约来袭，诚邀各路高手来战！