Redis 使用大全---java

已于 2024-05-11 09:09:32 修改
阅读量175 收藏
点赞数 3
文章标签： java redis
于 2024-05-11 09:05:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35227199/article/details/138697748
版权 
package com.cac.cc.common;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson2.JSONObject;
import com.caac.emergency.dto.system.PageDto;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.poi.ss.formula.functions.T;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Repository;

import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;

@Repository
@Slf4j
@RequiredArgsConstructor(onConstructor = @__(@Autowired))
public class RedisClient {
    private final StringRedisTemplate stringRedisTemplate;


    public <T> boolean set(String key, T value) {

        try {

            //任意类型转换成String
            String val = beanToString(value);

            if (val == null || val.length() <= 0) {
                return false;
            }

            stringRedisTemplate.opsForValue().set(key, val);
            return true;
        } catch (Exception e) {
            log.error("系统错误:" + e.getMessage(), e);
            return false;
        }
    }

    public <T> boolean delete(String key) {

        try {
            stringRedisTemplate.delete(key);
            return true;
        } catch (Exception e) {
            log.error("系统错误:" + e.getMessage(), e);
            return false;
        }
    }

    public <T> Long getLock(String key, long time, TimeUnit type) {

        try {
            Long res = stringRedisTemplate.opsForValue().increment(key);
            stringRedisTemplate.expire(key, time, type);
            return res;
        } catch (Exception e) {
            log.error("系统错误:" + e.getMessage(), e);
            return Long.valueOf(0);
        }
    }

    public <T> boolean set(String key, T value, long time, TimeUnit type) {

        try {

            //任意类型转换成String
            String val = beanToString(value);

            if (val == null || val.length() <= 0) {
                return false;
            }

            stringRedisTemplate.opsForValue().set(key, val, time, type);
            return true;
        } catch (Exception e) {
            log.error("系统错误:" + e.getMessage(), e);
            return false;
        }
    }

    public <T> T get(String key, Class<T> clazz) {
        try {
            String value = stringRedisTemplate.opsForValue().get(key);

            return stringToBean(value, clazz);
        } catch (Exception e) {
            log.error("系统错误:" + e.getMessage(), e);
            return null;
        }
    }

    public <T> List<T> getList(String key, Class<T> clazz) {
        try {
            String value = stringRedisTemplate.opsForValue().get(key);
            return stringToList(value, clazz);
        } catch (Exception e) {
            log.error("系统错误:" + e.getMessage(), e);
            return null;
        }
    }

    /**
     * key计数
     *
     * @param key
     * @return
     */
    public synchronized Integer setCount(String key) {
        try {
            Integer count = this.get(key, Integer.class);
            if (count == null) {
                count = 1;
            } else {
                count++;
            }
            this.set(key, count);
            return count;
        } catch (Exception e) {
            log.error("系统错误:" + e.getMessage(), e);
            return null;
        }
    }

    /**
     * 添加指定元素到有序集合中
     *
     * @param key
     * @param score
     * @param value
     * @return
     */
    public boolean sortSetAdd(String key, double score, String value) {
        try {
            return stringRedisTemplate.opsForZSet().add(key, value, score);
        } catch (Exception e) {
            log.error("系统错误:" + e.getMessage(), e);
            return false;
        }
    }

    /**
     * 有序集合中对指定成员的分数加上增量 increment
     *
     * @param key
     * @param value
     * @param i
     * @return
     */
    public double sortSetZincrby(String key, String value, double i) {
        try {
            //返回新增元素后的分数
            return stringRedisTemplate.opsForZSet().incrementScore(key, value, i);
        } catch (Exception e) {
            log.error("系统错误:" + e.getMessage(), e);
            return -1;
        }
    }

    /**
     * 有序集合中对指定成员的分数加上增量 increment
     *
     * @param key
     * @param value
     * @return
     */
    public double delMember(String key, String value) {
        try {
            return stringRedisTemplate.opsForZSet().remove(key, value);
        } catch (Exception e) {
            log.error("系统错误:" + e.getMessage(), e);
            return -1;
        }
    }

    /**
     * 获得有序集合指定范围元素 (从大到小)
     *
     * @param key
     * @param start
     * @param end
     * @return
     */
    public Set sortSetRange(String key, int start, int end) {
        try {
            return stringRedisTemplate.opsForZSet().reverseRange(key, start, end);
        } catch (Exception e) {
            log.error("系统错误:" + e.getMessage(), e);
            return null;
        }
    }

    /**
     * 获得有序集合大小
     *
     * @param key
     * @return
     */
    public Long count(String key) {
        try {
            return stringRedisTemplate.opsForZSet().size(key);
        } catch (Exception e) {
            log.error("系统错误:" + e.getMessage(), e);
            return null;
        }
    }

    /**
     * 获得指定元素的分数
     *
     * @param key
     * @param value
     * @param key
     * @return
     */
    public Double getScope(String key, String value) {
        try {
            return stringRedisTemplate.opsForZSet().score(key, value);
        } catch (Exception e) {
            log.error("系统错误:" + e.getMessage(), e);
            return null;
        }
    }

    /******************************** set操作 **************/

    /**
     * 是否为Set成员
     *
     * @param key
     * @param value
     * @return
     */
    public Boolean isMember(String key, String value) {
        try {
            return stringRedisTemplate.opsForSet().isMember(key, value);
        } catch (Exception e) {
            log.error("系统错误:" + e.getMessage(), e);
            return null;
        }
    }

    /**
     * 新增成员
     *
     * @param key
     * @param value
     * @return
     */
    public void addMember(String key, String value) {
        try {
            stringRedisTemplate.opsForSet().add(key, value);
        } catch (Exception e) {
            log.error("系统错误:" + e.getMessage(), e);
        }
    }

    /**
     * 删除成员
     *
     * @param key
     * @param value
     * @return
     */
    public Long removeMember(String key, String value) {
        try {
            return stringRedisTemplate.opsForSet().remove(key, value);
        } catch (Exception e) {
            log.error("系统错误:" + e.getMessage(), e);
            return null;
        }
    }

    /**
     * 获取所有成员
     *
     * @param key
     * @return
     */
    public Set getMembers(String key) {
        try {
            //获取成员
            return stringRedisTemplate.opsForSet().members(key);
        } catch (Exception e) {
            log.error("系统错误:" + e.getMessage(), e);
            return null;
        }
    }

    /**
     * 获取所有成员数
     *
     * @param key
     * @return
     */
    public Long getMemberSize(String key) {
        try {
            //获取成员
            return stringRedisTemplate.opsForSet().size(key);
        } catch (Exception e) {
            log.error("系统错误:" + e.getMessage(), e);
            return null;
        }
    }

    @SuppressWarnings("unchecked")
    private <T> T stringToBean(String value, Class<T> clazz) {
        if (value == null || value.length() <= 0 || clazz == null || "null".equals(value)) {
            return null;
        }

        if (clazz == int.class || clazz == Integer.class) {
            return (T) Integer.valueOf(value);
        } else if (clazz == long.class || clazz == Long.class) {
            return (T) Long.valueOf(value);
        } else if (clazz == String.class) {
            return (T) value;
        } else {
            return JSON.toJavaObject(JSON.parseObject(value), clazz);
        }
    }

    private <T> List<T> stringToList(String value, Class<T> clazz) {
        if (value == null || value.length() <= 0 || clazz == null || "null".equals(value)) {
            return null;
        }
        return JSON.parseArray(value, clazz);

    }

    /**
     * @param value
     * @return String
     */
    private <T> String beanToString(T value) {

        if (value == null) {
            return null;
        }
        Class<?> clazz = value.getClass();
        if (clazz == int.class || clazz == Integer.class) {
            return "" + value;
        } else if (clazz == long.class || clazz == Long.class) {
            return "" + value;
        } else if (clazz == String.class) {
            return (String) value;
        } else {
            return JSON.toJSONString(value);
        }
    }

    /**
     * 获得指定 key的所有key
     * 可以是 key* ,*key ,*key* 进行模糊匹配
     *
     * @param key
     * @return
     */
    public Set<String> getKeys(String key) {
        return stringRedisTemplate.keys(key);
    }

    /**
     * 删除指定key的所有 key的值
     * 可以是 key*  , *key,*key* 进行模糊匹配
     *
     * @param key
     */
    public void deleteKeys(String key) {
        Set<String> keys = stringRedisTemplate.keys(key);
        stringRedisTemplate.delete(keys);
    }

    public synchronized void setContIncrement(String key){
        setContIncrement(key,1);
    }

    /**
     * 获取计数器数值
     * @param key key
     * @return int
     */
    public int getContIncrement(String key){
        try {
            Boolean redisKey = stringRedisTemplate.hasKey(key);
            if (redisKey) {
//                log.info("获取计数器："+key);
                return Integer.parseInt((String) stringRedisTemplate.opsForValue().get(key));
            }else{
                return 0;
            }
        }catch (Exception e){
            log.error("获取计数器系统错误:" + e.getMessage(), e);
            return 0;
        }
    }
    /**
     * 设置计数器
     * @param key key
     * @param step step
     * @return void
     */
    public synchronized void setContIncrement(String key,int step){
        try{
            Boolean redisKey = stringRedisTemplate.hasKey(key);
            if (redisKey) {
//                log.info("设置计数器"+key);
                // 对value进行加1操作
                stringRedisTemplate.opsForValue().increment(key,step);
            } else{
//                log.info("创建计数器"+key);
                // 如果没有key值，对他进行添加到redis中
                stringRedisTemplate.opsForValue().set(key,step+"");
            }
        }catch (Exception e){
            log.error("自增计数器系统错误:" + e.getMessage(), e);
        }
    }

    public <T> boolean setPage(String key, PageDto<T> page,int time,TimeUnit timeUnit){
        try {
            JSONObject jsonObject = new JSONObject();
            jsonObject.put("totalPage", page.getTotalPage());
            jsonObject.put("currentPage", page.getCurrentPage());
            jsonObject.put("total", page.getTotal());
            jsonObject.put("list", JSONObject.toJSONString(page.getList()));

            stringRedisTemplate.opsForValue().set(key, jsonObject.toJSONString(), time, timeUnit);
            return true;
        }catch (Exception e){
            log.error("设置PageDto 缓存异常："+e.getMessage(),e);
            return false;
        }
    }

    public <T> PageDto<T> getPage(String key,Class<T> clazz){
        String json = stringRedisTemplate.opsForValue().get(key);
        if(json == null || json.isEmpty()){
            return null;
        }
        JSONObject jsonObject = JSONObject.parseObject(json);
        PageDto<T> pageDto = PageDto.<T>builder()
                .currentPage(jsonObject.getLongValue("currentPage"))
                .totalPage(jsonObject.getLongValue("totalPage"))
                .total(jsonObject.getLongValue("total"))
                .list(stringToList(jsonObject.getString("list"),clazz)).build();
        return pageDto;
    }
}




// 应用代码


 /**
     * 忘记密码验证邮件
     *
     * @return
     */
    @PostMapping("/website/search/sendEmail")
    @Operation(summary = "忘记密码验证邮件")
    @Log("发送邮件")
    public ResultDto<String> sendEmail(String receiveAdress,String imgCode ,String uuid ) throws NoSuchAlgorithmException {
        //判断用户是否存在
        if (StringUtils.isEmpty(receiveAdress) || userService.getByEmail(receiveAdress) == null) {
            return ResultDtoUtil.toError("邮箱不合法", "");
        }
        // 图形验证码校验
        String codeRedis = redisClient.get("base_code_" + uuid, String.class);
        if (!imgCode.equals(codeRedis)) {
            return ResultDtoUtil.toError("图形验证码错误", "");
        }

        //防攻击
        if (redisClient.get("pwdCode_" + receiveAdress, String.class) != null) {
            return ResultDtoUtil.toError("验证码发送失败,请60s后再试！", "");
        } else {
            redisClient.set("pwdCode_" + receiveAdress, "1", 59, TimeUnit.SECONDS);
        }

        //生成随机6位验证码
        SecureRandom random = SecureRandom.getInstance("SHA1PRNG");

        String code = (int) ((random.nextDouble() * 9 + 1) * 100000) + "";
        //发送
        emailCilent.sentCode(sendAdress, receiveAdress, code);
        //存到redis中
        redisClient.set("pwdCode_email_" + receiveAdress, code, 600000, TimeUnit.MILLISECONDS);
        return ResultDtoUtil.toSuccess("验证码发送成功", "");
    }

qq_991495641
关注
redis-windows-7.2.5.zip
05-20
- Redis可与多种编程语言（如Python、Java、C#等）的客户端库配合使用。 - 在Web应用中，作为缓存加速数据访问；在分布式系统中，用作消息队列或分布式锁。 综上所述，Redis是一个强大且灵活的键值数据库，广泛...
tomcat-redis-session-manager
06-06
值得注意的是，使用`tomcat-redis-session-manager`可能会带来额外的网络延迟，因为每次session操作都需要与Redis通信。因此，在大型分布式系统中，推荐将Redis部署在靠近应用服务器的网络位置，以减少延迟影响。 ...
Java-Redis基本使用大全
weixin_45203607的博客
10-07 8897
Java-Redis基本使用大全 概念 redis是一款高性能的NOSQL系列的非关系型数据库 NoSQL(NoSQL = Not Only SQL)，意即“不仅仅是SQL”，是一项全新的数据库理念，泛指非关系型的数据库。 NOSQL和关系型数据库比较 优点： 成本：nosql数据库相比关系型数据库价格便宜。 2）查询速度：nosql数据库将数据存储于缓存之中，速度快 3）存储数据的格式：nosql的存储格式是key,value形式、文档形式、图片形式等等 4）扩展性：关系型数据库有类似join这样的多
redis使用redis-cli登录
m0_67402774的博客
03-23 1872
redis-cli -h 192.168.1.21 -p 6379 -a 123456 h：ip地址 p：端口号 a：密码 或者使用redis-cli进入之后，使用auth [password]
Redis-stack 初体验
c_zyer的博客
03-31 7718
Redis-stack Docker部署
idea 导出第三方 jar 包 （基于 tomcat8.5-redis-session-manager 编译打包成 jar）
weixin_42132143的博客
03-30 1949
文章目录前言一、准备工作二、操作过程1. 编译 class 文件2. 移动 class 文件3. 编译打包 jar总结 前言 相信搞 java 的都用过第三方的 jar 包，例如 log4j、jedis 等等。 但大家都有自己动手编译打包过一个 jar 吗？ 过程中是否有遇到过这样一个问题：打包的 class 文件里面引入了另一个第三方的包，而并没有引入将要打包的 jar，这时候编译时报错的。 一、准备工作 这篇文章我将用 tomcat8.5-redis-session-manager 来编译打包成 j
redis及redis-desktop-manager的下载及安装
weixin_52724250的博客
11-24 3549
一、下载安装 redis链接：https://pan.baidu.com/s/1ax2mMEfT5JPpqPv1YV5XNA 提取码：zfu0 官网地址：Releases · tporadowski/redis · GitHub redis-desktop-manager链接：https://pan.baidu.com/s/1BxfcOdTCUXvJTycp_ET6Qw 提取码：cvbk 二、启动 redis解压后双击redis-server.exe启动 出现如下图小黑板表示启动成功了
Redis(三)-redis-cli命令使用指南
一点博客
12-08 2501
redis-cli命令使用手册
redis运维(六)redis-cli命令
wzj_110的博客
11-16 5437
运行外部文件lua脚本。
使用开源插件tomcat-redis-session-manager实现session共享
积跬步，至千里。
07-21 2339
使用开源插件tomcat-redis-session-manager实现Tomcat的session共享。
java 链接Redis集群 redis-cluster
u013308504的博客
02-13 8249
redis-cluster 部署的redis集群 1、命令连接redis集群./src/redis-cli -h 192.168.33.159 -c -p 70012、通过java代码 连接redis集群添加依赖包                &lt;dependency&gt; &lt;groupId&gt;redis.clients&lt;/groupId&gt; &lt;artif...
redis ---- java 操作redis 及 redisClient可视化工具的安装使用
热门推荐
ws - 兮的博客空间
02-17 1万+
一、redis 的启动停止连接命令 ifconfig 查询ip ---------- redis-4.0.11（本机 linux7系统）------------ cd wslxm/redis/redis-4.0.11 切到redis目录 ./src/redis-server redis.conf ...
tomcat-redis-session-manager-1.2-tomcat-7-java-7
05-07
tomcat-redis-session-manager-1.2-tomcat-7-java-7tomcat-redis-session-manager-1.2-tomcat-7-java-7tomcat-redis-session-manager-1.2-tomcat-7-java-7tomcat-redis-session-manager-1.2-tomcat-7-java-7tomcat-...
tomcat-cluster-redis-session-manager:Tomcat集群Redis会话管理器Java客户端
05-11
请求会话将立即存储到Redis中（会话属性必须是可序列化的），以供其他服务器使用。 当tomcat从客户端收到请求时，将直接从Redis加载会话。 支持Redis默认，哨兵和集群模式（基于配置）。 展望未来，我们无需在...
【学习笔记】手写 Tomcat 三
LearnTech_123的博客
09-12 1106
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
Gradle
xiaocaij_icai的博客
09-15 150
");
计算机毕业设计 基于SpringBoot的课程教学平台的设计与实现 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
weixin_19164791635
09-12 912
本文介绍了一款基于Java、SpringBoot和Vue.js技术的课程教学平台。该平台服务于管理员、学生和教师，提供教学资源管理、课程信息浏览、作业提交与批改等功能，旨在优化教学流程，提升教育质量，促进教育资源的数字化共享，推动教育信息化发展。
spring security中几大组件的作用和执行顺序
阿信今天的代码没bug的博客
09-11 340
spirng security中的几大组件的差异和执行顺序
计算机毕业设计 网上书店系统 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
最新发布
weixin_19164791635
09-16 585
本文介绍了一款基于Java、SpringBoot和Vue.js技术的网上书店系统。该系统为管理员、用户和卖家提供了图书信息浏览、订单管理、个人中心管理等功能，旨在打造一个便捷、高效的在线购书平台。系统通过优化图书销售流程，提升用户体验，推动出版行业的数字化转型，促进知识传播和文化交流。
redis-cluster-operator java
04-30
Redis Cluster Operator是一种用于Kubernetes集群的开源软件，它可以自动化部署、管理和运维Redis Cluster。这个项目采用Java编写，使用了Kubernetes Client API和Redisson Client库，可以方便地与Kubernetes集成，并支持自定义扩展和配置。 该项目的主要功能包括： - 自动化部署和管理Redis Cluster集群 - 支持自定义Redis配置和扩展 - 自动进行备份和恢复 - 提供监控和告警功能 使用Redis Cluster Operator可以大大简化Redis集群的部署和管理，提高生产环境的稳定性和可靠性。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值