redis进行幂等性

已于 2022-01-29 19:55:51 修改
阅读量1.2k 收藏 1
点赞数
分类专栏： idea 文章标签： java
于 2022-01-28 15:35:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49390750/article/details/122732214
版权

redis基于注解方式实现

package com.zhk.study.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * ElementType.METHOD：该注解作用于方法上
 * RetentionPolicy.RUNTIME：表示它在运行时
 */
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface ApiIdempotent {

}

package com.zhk.study.annotation;
 

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
 
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.lang.reflect.Method;
 
/**
 * 接口幂等性拦截器
 */
@Component
public class ApiIdempotentInterceptor implements HandlerInterceptor {
 
    @Autowired
    private TokenService tokenService;
 
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        if (!(handler instanceof HandlerMethod)) {
            return true;
        }
 
        HandlerMethod handlerMethod = (HandlerMethod) handler;
        Method method = handlerMethod.getMethod();
 
        ApiIdempotent methodAnnotation = method.getAnnotation(ApiIdempotent.class);
        if (methodAnnotation != null) {
            check(request);// 幂等性校验, 校验通过则放行, 校验失败则抛出异常, 并通过统一异常处理返回友好提示
        }
        return true;
    }
 
    private void check(HttpServletRequest request) {
        tokenService.checkToken(request);
    }
 
    @Override
    public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {
    }
 
    @Override
    public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {
    }
}


package com.zhk.study.annotation;

import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestControllerAdvice;

@RestControllerAdvice
public class ExceptionAdvice {

    @ExceptionHandler(Exception.class)
    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
    public ServerResponse responseCode(Exception e) {
        return ServerResponse.error(e.getMessage());
    }
}



package com.zhk.study.annotation;

import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

@Configuration
public class JedisConfig {

    @Bean(name = "jedisPoolConfig")
    public JedisPoolConfig jedisPoolConfig(){
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        jedisPoolConfig.setMaxTotal(500);
        jedisPoolConfig.setMaxIdle(200);
        jedisPoolConfig.setNumTestsPerEvictionRun(1024);
        jedisPoolConfig.setTimeBetweenEvictionRunsMillis(30000);
        jedisPoolConfig.setMinEvictableIdleTimeMillis(-1);
        jedisPoolConfig.setSoftMinEvictableIdleTimeMillis(10000);
        jedisPoolConfig.setMaxWaitMillis(1500);
        jedisPoolConfig.setTestOnBorrow(true);
        jedisPoolConfig.setTestWhileIdle(true);
        jedisPoolConfig.setTestOnReturn(false);
        jedisPoolConfig.setJmxEnabled(true);
        jedisPoolConfig.setBlockWhenExhausted(false);
        return jedisPoolConfig;
    }

    @Bean
    public JedisPool redisPool() {
        String host = "127.0.0.1";
        int port = 6379;
        return new JedisPool( jedisPoolConfig(),host,port,
        150000,"qv8sqntqmmv5");
    }

}


package com.zhk.study.annotation;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;


@Component
@Slf4j
public class JedisUtil {

    @Autowired
    private JedisPool jedisPool;

    private Jedis getJedis() {
	  return jedisPool.getResource();
    }

    /**
     * 设值
     *
     * @param key
     * @param value
     * @return
     */
    public String set(String key, String value) {
	  Jedis jedis = null;
	  try {
		jedis = getJedis();
		return jedis.set(key, value);
	  } catch (Exception e) {
		log.error("set key:{} value:{} error", key, value, e);
		return null;
	  } finally {
		close(jedis);
	  }
    }

    /**
     * 设值
     *
     * @param key
     * @param value
     * @param expireTime 过期时间, 单位: s
     * @return
     */
    public String set(String key, String value, int expireTime) {
	  Jedis jedis = null;
	  try {
		jedis = getJedis();
		return jedis.setex(key, expireTime, value);
	  } catch (Exception e) {
		log.error("set key:{} value:{} expireTime:{} error", key, value, expireTime, e);
		return null;
	  } finally {
		close(jedis);
	  }
    }

    /**
     * 取值
     *
     * @param key
     * @return
     */
    public String get(String key) {
	  Jedis jedis = null;
	  try {
		jedis = getJedis();
		return jedis.get(key);
	  } catch (Exception e) {
		log.error("get key:{} error", key, e);
		return null;
	  } finally {
		close(jedis);
	  }
    }

    /**
     * 删除key
     *
     * @param key
     * @return
     */
    public Long del(String key) {
	  Jedis jedis = null;
	  try {
		jedis = getJedis();
		return jedis.del(key.getBytes());
	  } catch (Exception e) {
		log.error("del key:{} error", key, e);
		return null;
	  } finally {
		close(jedis);
	  }
    }

    /**
     * 判断key是否存在
     *
     * @param key
     * @return
     */
    public Boolean exists(String key) {
	  System.out.println(key);
	  Jedis jedis = null;
	  try {
		jedis = getJedis();
		return jedis.exists(key.getBytes());
	  } catch (Exception e) {
		log.error("exists key:{} error", key, e);
		return null;
	  } finally {
		close(jedis);
	  }
    }

    /**
     * 设值key过期时间
     *
     * @param key
     * @param expireTime 过期时间, 单位: s
     * @return
     */
    public Long expire(String key, int expireTime) {
	  Jedis jedis = null;
	  try {
		jedis = getJedis();
		return jedis.expire(key.getBytes(), expireTime);
	  } catch (Exception e) {
		log.error("expire key:{} error", key, e);
		return null;
	  } finally {
		close(jedis);
	  }
    }

    /**
     * 获取剩余时间
     *
     * @param key
     * @return
     */
    public Long ttl(String key) {
	  Jedis jedis = null;
	  try {
		jedis = getJedis();
		return jedis.ttl(key);
	  } catch (Exception e) {
		log.error("ttl key:{} error", key, e);
		return null;
	  } finally {
		close(jedis);
	  }
    }

    private void close(Jedis jedis) {
	  if (null != jedis) {
		jedis.close();
	  }
    }

}



package com.zhk.study.annotation;


public enum ResponseCode {

    // 系统模块
    SUCCESS(0, "操作成功"),
    ERROR(1, "操作失败"),
    SERVER_ERROR(500, "服务器异常"),

    // 通用模块 1xxxx
    ILLEGAL_ARGUMENT(10000, "参数不合法"),
    REPETITIVE_OPERATION(10001, "请勿重复操作");

    ResponseCode(Integer code, String msg) {
	  this.code = code;
	  this.msg = msg;
    }

    private Integer code;

    private String msg;

    public Integer getCode() {
	  return code;
    }

    public void setCode(Integer code) {
	  this.code = code;
    }

    public String getMsg() {
	  return msg;
    }

    public void setMsg(String msg) {
	  this.msg = msg;
    }
}




package com.zhk.study.annotation;

import com.fasterxml.jackson.annotation.JsonIgnore;

import java.io.Serializable;

public class ServerResponse implements Serializable{

    private static final long serialVersionUID = 7498483649536881777L;

    private Integer status;

    private String msg;

    private Object data;

    public ServerResponse() {
    }

    public ServerResponse(Integer status, String msg, Object data) {
	  this.status = status;
	  this.msg = msg;
	  this.data = data;
    }

    @JsonIgnore
    public boolean isSuccess() {
	  return this.status == ResponseCode.SUCCESS.getCode();
    }

    public static ServerResponse success() {
	  return new ServerResponse(ResponseCode.SUCCESS.getCode(), null, null);
    }

    public static ServerResponse success(String msg) {
	  return new ServerResponse(ResponseCode.SUCCESS.getCode(), msg, null);
    }

    public static ServerResponse success(Object data) {
	  return new ServerResponse(ResponseCode.SUCCESS.getCode(), null, data);
    }

    public static ServerResponse success(String msg, Object data) {
	  return new ServerResponse(ResponseCode.SUCCESS.getCode(), msg, data);
    }

    public static ServerResponse error(String msg) {
	  return new ServerResponse(ResponseCode.ERROR.getCode(), msg, null);
    }

    public static ServerResponse error(Object data) {
	  return new ServerResponse(ResponseCode.ERROR.getCode(), null, data);
    }

    public static ServerResponse error(String msg, Object data) {
	  return new ServerResponse(ResponseCode.ERROR.getCode(), msg, data);
    }

    public Integer getStatus() {
	  return status;
    }

    public void setStatus(Integer status) {
	  this.status = status;
    }

    public String getMsg() {
	  return msg;
    }

    public void setMsg(String msg) {
	  this.msg = msg;
    }

    public Object getData() {
	  return data;
    }

    public void setData(Object data) {
	  this.data = data;
    }
}



package com.zhk.study.annotation;

/**
 * 业务逻辑异常
 */
public class ServiceException extends RuntimeException{

    private String code;
    private String msg;

    public ServiceException() {
    }

    public ServiceException(String msg) {
        this.msg = msg;
    }

    public ServiceException(String code, String msg) {
        this.code = code;
        this.msg = msg;
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }
}




package com.zhk.study.annotation;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/token")
public class TokenController {
 
    @Autowired
    private TokenService tokenService;
    
    @GetMapping("/create")
    public ServerResponse token() {
        return tokenService.createToken();
    }

    @ApiIdempotent
    @PostMapping("/testIdempotence")
    public ServerResponse testIdempotence() {
        return tokenService.testIdempotence();
    }
}


package com.zhk.study.annotation;

import javax.servlet.http.HttpServletRequest;

public interface TokenService {

    ServerResponse createToken();

    void checkToken(HttpServletRequest request);

    ServerResponse testIdempotence();
}




package com.zhk.study.annotation;

import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.servlet.http.HttpServletRequest;
import java.util.UUID;

@Service
public class TokenServiceImpl implements TokenService {
 
    private static final String TOKEN_NAME = "token";

    private static final String TOKEN_PREFIX = "token:";

    // 过期时间, 60s, 一分钟
    private static final Integer EXPIRE_TIME_MINUTE = 60 * 5;
 
    @Autowired
    private JedisUtil jedisUtil;
 
    @Override
    public ServerResponse createToken() {
        String str = UUID.randomUUID().toString().replaceAll("-", "");
        StringBuilder token = new StringBuilder();
        token.append(TOKEN_PREFIX).append(str);

        System.out.println(token.toString()+":::::"+ token.toString());
        jedisUtil.set(token.toString(), token.toString(), EXPIRE_TIME_MINUTE);
 
        return ServerResponse.success(token.toString());
    }
 
    @Override
    public void checkToken(HttpServletRequest request) {
        String token = request.getHeader(TOKEN_NAME);
        if (StringUtils.isBlank(token)) {// header中不存在token
            token = request.getParameter(TOKEN_NAME);
            if (StringUtils.isBlank(token)) {// parameter中也不存在token
                throw new ServiceException(ResponseCode.ILLEGAL_ARGUMENT.getMsg());
            }
        }
 
        if (!jedisUtil.exists(token)) {
            throw new ServiceException(ResponseCode.REPETITIVE_OPERATION.getMsg());
        }
 
        Long del = jedisUtil.del(token);
        if (del <= 0) {
            throw new ServiceException(ResponseCode.REPETITIVE_OPERATION.getMsg());
        }
    }
    
    @Override
    public ServerResponse testIdempotence() {
        return ServerResponse.success("testIdempotence: success");
    }
 
}


package com.zhk.study.annotation;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import org.springframework.web.filter.CorsFilter;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

/**
 * Web配置文件
 */
@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
    @Autowired
    private ApiIdempotentInterceptor apiIdempotentInterceptor;

    /**
     * 跨域
     * @return
     */
    @Bean
    public CorsFilter corsFilter() {
        final UrlBasedCorsConfigurationSource urlBasedCorsConfigurationSource = new UrlBasedCorsConfigurationSource();
        final CorsConfiguration corsConfiguration = new CorsConfiguration();
        corsConfiguration.setAllowCredentials(true);
        corsConfiguration.addAllowedOrigin("*");
        corsConfiguration.addAllowedHeader("*");
        corsConfiguration.addAllowedMethod("*");
        urlBasedCorsConfigurationSource.registerCorsConfiguration("/**", corsConfiguration);
        return new CorsFilter(urlBasedCorsConfigurationSource);
    }



    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(apiIdempotentInterceptor).addPathPatterns("/**");
    }
}

用法切记 创建token的时候 传token这个token有点恶心 是这种 自己可以改一下 本人懒
在这里插入图片描述

张航柯
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【项目实战】Redis使用场景之防止重复提交 - 接口幂等性
本本本添哥
03-12 1514
接口幂等性是指无论调用多少次，结果都是一样的。
Redis分布式锁解决接口幂等的两种方案
12-21
利用Redis分布式锁解决接口幂等性，既保证了接口的正确性，又简化了开发流程。自定义注解结合AOP的方式，提高了代码的可复用性和可维护性。但需要注意，正确配置锁的过期时间和处理可能出现的死锁情况，以保证系统的...
生产问题一：redis锁处理幂等性失效
半路出家的码农小王
12-31 619
如果有两个线程a,b。如果a线程释放锁后，退出方法前，让出时间片，由于方法未执行完，此时事务没有提交，那么b线程在去数据库查询的时候仍然出来count为0，执行了insert操作，两个线程执行完该方法提交事务，此时数据库中会增加两条数据，幂等性失效。去掉@Transactional注解，这样在a线程在insert时候就会自动提交事务，a释放锁后，b在查询时候，count不等0，不执行插入操作。将锁放到到事务提交后。
通过redis存储来保证接口幂等性
最新发布
2401_84627575的博客
04-27 373
在上面的示例中，IdempotentServiceImpl类利用了Redis的SADD命令来往名为processed_requests的Set中添加请求标识。在Java中结合Redis实现接口的幂等性通常是利用Redis的数据结构和原子性操作来确保操作的幂等性。一种常见的做法是利用Redis的Set数据结构来存储已处理的请求标识，确保同一个请求不会被处理多次。// 如果setResult为0，表示请求已经被处理过了，直接返回true。// 利用Redis的Set数据结构来存储已处理的请求标识。
第10讲：Redis幂等性
分享日常工作技术
04-20 1419
幂等性：就是用户对于同一操作发起的一次请求或者多次请求的结果是一致的，不会因为多次点击而产生了了副作用。举个最简单的例子，那就是支付，用户购买商品后支付，支付扣款成功，但是返回结果的时候网络异常，此时钱已经扣了，用户再次点击按钮，此时会进行第二次扣款，返回结果成功，用户查询余额发现多扣了钱，流水记录也变成了两条，再或者新增用户表单注册时，用户反复提交表单.。按照这个含义，最终的含义就是产生『』（假定程序业务代码没问题），绝大部分就是发生了重复的请求，重复请求是指『接口的幂等性实际上就是『
Reids实现幂等性
qq_37705525的博客
03-18 3735
Reids实现幂等性
设计模式之幂等性
weixin_40413961的博客
09-07 429
什么是幂等性 HTTP/1.1中对幂等性的定义是：一次和多次请求某一个资源对于资源本身应该具有同样的结果（网络超时等问题除外）。也就是说，其任意多次执行对资源本身所产生的影响均与一次执行的影响相同。 Methods can also have the property of “idempotence” in that (aside from error or expiration issues) ...
Redis（四）——Redis 处理接口幂等性（代码实现、两种方式拦截令牌）、Redis 分布式锁（两种引入 lua 脚本、Redission实现分布式锁）、Redis做限流工具（简单限流，限流插件）
qq_41824825的博客
03-07 2090
Redis（四）——Redis 处理接口幂等性（代码实现、两种方式拦截令牌）、Redis 分布式锁（两种引入 lua 脚本、通过 Redission 实现分布式锁）、Redis做限流工具（简单限流，限流插件——Redis-Cell模块（使用了漏斗算法）、java 代码操作（使用 Lettuce 扩展））
Redis幂等性校验
qq_67548292的博客
03-06 128
简单的使用redis设置幂等性校验
Aop注解+Redis解决SpringBoot接口幂等性(源码自取)
03-08
本教程将通过Spring Boot结合AOP注解与Redis来实现接口幂等性，以确保系统的稳定性和数据的一致性。 首先，我们需要了解Spring Boot和AOP注解。Spring Boot是基于Spring框架的快速开发工具，它简化了配置并提供了开...
3.2）幂等性以及消息的幂等性1
08-04
通过巧妙地利用Redis等数据存储工具，我们可以有效地实现接口和消息处理的幂等性，从而提高系统的稳定性和数据一致性。在实际应用中，设计和实现幂等性策略对于防止数据错误和避免不必要的资源消耗至关重要。
02、接口幂等性1
08-03
在IT行业中，接口幂等性是一项重要的设计原则，特别是在分布式系统和微服务架构中。它确保了对同一接口的多次请求不会导致额外的副作用。在本文中，我们将深入探讨接口幂等性的概念、应用场景以及实现策略。 一、...
Springboot+redis+Interceptor+自定义annotation实现接口自动幂等
08-25
【接口幂等性概念】 接口幂等性是软件设计中的一个重要原则，它指的是一个接口被多...Spring Boot结合Redis和自定义Interceptor，能够有效地确保接口幂等性，防止重复处理和数据不一致，从而提高系统的稳定性和可靠性。
分布式常见问题丨高并发时重复提交，基于Redis的幂等性解决方案来啦
威哥爱编程，一个坚持研究技术的80后老鸟，擅长后端、AI 大模型、鸿蒙等技术体系，愿与你在技术路上一起成长！
06-24 2534
原创作者：千锋威尔逊一. 幂等性所谓的幂等性，是分布式环境下的一个常见问题，一般是指我们在进行多次操作时，所得到的结果是一样的，即多次运算结果是一致的。也就是说，用户对于同一操作，无论是发起一次请求还是多次请求，最终的执行结果是一致的，不会因为多次点击而产生副作用。二. 常见幂等性操作在我们进行代码实现时，常见的请求有如下几种，他们的幂等性如下：select查询天然幂等；delete删除也是幂等，删除同一个数据多次其效果一样;update直接更新某个值时，幂等；update更新累加操作的的结果，非幂等；in
SpringBoot 之使用 Redis 实现接口幂等性
const_
03-19 2604
瞬间几千次的重复提交，我用 SpringBoot+Redis 扛住了 Sprinig Boot + Redis 实现接口幂等性，写得太好了！
mq消费并发排队及幂等机制实现-redisson
C18298182575的博客
10-26 415
主要为了解决并发访问排队执行及重复下发保证幂等的问题实现技术方案如何实现并发访问时，请求排队执行方法。@Redssion如何实现MQ重复下发时，保证幂等。@redis。
redis如何实现幂等性校验？
zouyang920的博客
01-04 961
如何实现幂等性校验？
幂等性校验
学无止境
10-21 1619
幂等性校验：基于spring boot 的拦截器功能+ redis
基于Spring Boot + Redis实现接口幂等性
G0_hw
05-26 597
https://mp.weixin.qq.com/s/2vycQljbC-DZYZgUtAQiXQ https://mp.weixin.qq.com/s/v_iyZVd5ldixnhaxkdSArA https://mp.weixin.qq.com/s/xy4Jg3LrK0dpYy5q4rAAaw https://mp.weixin.qq.com/s/8t8eNRSMLBgjeQBfnfxZIQ
redis实现幂等性
08-12
在使用 Redis 实现幂等性时，可以通过以下步骤进行操作： 1. 生成一个唯一的标识符（例如 UUID），作为每个请求的幂等性标志。 2. 在处理请求之前，使用 Redis 的 SETNX 命令将该标识符作为键存储到 Redis 中。SETNX 命令只在键不存在时才会设置成功，因此可以保证只有第一次请求才会成功设置。 3. 设置一个适当的过期时间，以防止 Redis 键一直占用内存。可以使用 Redis 的 EXPIRE 命令为键设置过期时间。 4. 在处理请求完成后，使用 Redis 的 DEL 命令删除该键，释放占用的资源。 在处理请求时，可以通过判断 Redis 中是否存在该键来确定请求是否为重复请求。如果键存在，则表示请求已经被处理过了，可以直接返回之前的处理结果；如果键不存在，则表示是第一次处理该请求，需要执行相应的处理逻辑，并将处理结果存储到 Redis 中。 需要注意的是，在分布式环境下，可能存在多个服务同时操作 Redis，为了保证幂等性的正确性，可以使用分布式锁来确保只有一个服务能够成功设置键。常见的分布式锁实现方式有基于 Redis 的 RedLock、基于 ZooKeeper 的 Curator 等。 以上是使用 Redis 实现幂等性的一种简单方式，具体场景中还需要根据业务需求进行相应的调整和优化。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

张航柯

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值