幂等性注解，以及适配成启动类注解

最新推荐文章于 2024-05-03 17:05:11 发布
最新推荐文章于 2024-05-03 17:05:11 发布
阅读量685 收藏 1
点赞数
分类专栏： 学习笔记 工具类 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41133233/article/details/107863368
版权

一. 前言：

在后端提供给前端接口之后，在某性场景下，如支付等。如果一个请求多次消费同一个接口，显然是错误的。这里显然就需要实现，多次消费和一次消费，是一样的结果了，这就和幂等性有关了。

二. 前后端未分离编写：

这由于架构的特殊性，小熙采用的是后端跳转页面并签发幂等性token，访问时再次校验。当然也有唯一索引、加锁、状态机等方法，看个人习惯吧。

  1. 创建幂等性注解

    package com.chengxi.datalom.idempotent;

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

/**
 * @author chengxi
 * @date 2020/8/7 10:00
 */
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface ApiIdempotent {
}

  2. 添加对应处理拦截器（这里是实现的主要地方，采用拦截器在进入方法之前做校验）

    package com.chengxi.datalom.idempotent;

import lombok.AllArgsConstructor;
import lombok.NoArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired;
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;

/**
 * @author chengxi
 * @date 2020/8/7 10:02
 */
@AllArgsConstructor
@NoArgsConstructor
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 {
    }

}

  3. 编写签发和校验幂等token的逻辑
    （1） 接口

    package com.chengxi.datalom.idempotent;

import javax.servlet.http.HttpServletRequest;

/**
 * @author chengxi
 * @date 2020/8/7 10:21
 */
public interface TokenService {

    /**
     * 签发token
     * @return
     */
    String createToken();

    /**
     * 校验幂等性的token
     * @param request
     */
    void checkToken(HttpServletRequest request);
}

    （2）实现类

    package com.chengxi.datalom.idempotent;

import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

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

/**
 * @author chengxi
 * @date 2020-08-07
 */
@Service
public class TokenServiceImpl implements TokenService {

    @Autowired
    private RedisTemplate redisTemplate;

    @Override
    public String createToken() {
        String str = UUID.randomUUID().toString().replaceAll("-","");
        StringBuffer token = new StringBuffer();
        token.append(Constant.IDEMPOTENCE_TOKEN_PREFIX).append("_").append(str);

        // 签发的IDEMPOTENCE_TOKEN默认有效期为1分钟
    	redisTemplate.opsForValue().set(token.toString(), token.toString(), 1, TimeUnit.MINUTES);
        return token.toString();
    }

    @Override
    public void checkToken(HttpServletRequest request) {
        String token = request.getHeader(Constant.IDEMPOTENT_TOKEN.getName());
        // header中不存在token
        if (StringUtils.isBlank(token)) {
            token = request.getParameter(Constant.IDEMPOTENT_TOKEN.getName());
            // parameter中也不存在token
            if (StringUtils.isBlank(token)) {
                throw new ServiceException(ResponseCode.ILLEGAL_ARGUMENT.getMsg());
            }
        }

        if (StringUtils.isBlank((String)redisTemplate.opsForValue().get(token))) {
            throw new ServiceException(ResponseCode.REPETITIVE_OPERATION.getMsg());
        }

        Boolean deleteTokenBoolean = redisTemplate.delete(token);
        if (!deleteTokenBoolean) {
            throw new ServiceException(ResponseCode.REPETITIVE_OPERATION.getMsg());
        }
    }

}

  4. 提供相应辅助工具类
    （1） 服务层收集异常类

    package com.chengxi.datalom.idempotent;

/**
 * @author chengxi
 * @date 2020/8/7 11:00
 */
public class BaseException extends RuntimeException {

    private static final long serialVersionUID = 8415686531516484839L;

    public BaseException(String message) {
        super(message);
    }

    public BaseException(Exception e){
        this(e.getMessage());
    }
}


    package com.chengxi.datalom.idempotent;

/**
 * @author chengxi
 * @date 2020/8/7 11:02
 */
public class ServiceException extends BaseException {

    public ServiceException(String message) {
        super(message);
    }

    public ServiceException(Exception e) {
        super(e);
    }
}

    （2）常量枚举

    package com.chengxi.datalom.idempotent;

/**
 * @author chengxi
 * @date 2020/8/7 10:27
 */
public enum Constant {

    IDEMPOTENCE_TOKEN_PREFIX("IDEMPOTENCE_TOKEN_PREFIX"),
    IDEMPOTENT_TOKEN("IdempotentToken");

    private String name;

    Constant(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

    （3）响应枚举

    package com.chengxi.datalom.idempotent;

/**
 * @author chengxi
 * @date 2020/8/7 11:20
 */
public enum ResponseCode {

    ILLEGAL_ARGUMENT(4001, "非法请求，缺少IdempotentToken"),
    REPETITIVE_OPERATION(4002, "请勿重复请求");

    private Integer code;
    private String msg;

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

    public Integer getCode() {
        return code;
    }

    public String getMsg() {
        return msg;
    }
}

    （4）简易的响应封装类（这是小熙临时写的，大家可以替换成自己的）

    package com.chengxi.demo02;

import lombok.Data;
import lombok.experimental.Accessors;

/**
 * @author chengxi
 * @date 2020/8/10 10:16
 */
@Data
@Accessors(chain = true)
public class ResponseDTO {

    private Integer resultCode;

    private Object resultInfo;

}

  5. 将幂等处理拦截器注册到bean中（这里有两种方式，小熙倾向于自定义启动类注解的装配）

    （1） 直接在模块的启动类中添加注册（虽然简单方便，但是拓展性等不太友好）

    package com.chengxi.datalom;

import com.chengxi.datalom.idempotent.ApiIdempotentInterceptor;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

@SpringBootApplication
//@MapperScan(value = "com.chengxi.datalom.mapper")
public class DataLomApplication extends WebMvcConfigurerAdapter {

    public static void main(String[] args) {
        SpringApplication.run(DataLomApplication.class, args);
    }

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 注册幂等性拦截器
        registry.addInterceptor(apiIdempotentInterceptor());
        super.addInterceptors(registry);
    }

    @Bean
    public ApiIdempotentInterceptor apiIdempotentInterceptor() {
        return new ApiIdempotentInterceptor();
    }

}

    （2） 添加自定义幂等启动类注解（小熙比较倾向于这类实现）
    1. 在启动类中添加注解

    package com.chengxi.datalom;

import com.chengxi.datalom.idempotent.enable.EnableApiIdempotent;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@EnableApiIdempotent
@SpringBootApplication
//@MapperScan(value = "com.chengxi.datalom.mapper")
public class DataLomApplication {

    public static void main(String[] args) {
        SpringApplication.run(DataLomApplication.class, args);
    }
    
}

    2.编写自定义幂等启动类

    package com.chengxi.datalom.idempotent.enable;

import org.springframework.context.annotation.Import;

import java.lang.annotation.*;

/**
 * @author chengxi
 * @date 2020/8/7 14:43
 */
@Documented
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Import(ApiIdempotentImportSelector.class)
public @interface EnableApiIdempotent {
}

    3.编写对应的选择器（这里有疑问的可以参考springBootApplication注解的实现）

    package com.chengxi.datalom.idempotent.enable;

import org.springframework.context.annotation.ImportSelector;
import org.springframework.core.type.AnnotationMetadata;

/**
 * @author chengxi
 * @date 2020/8/7 14:45
 */
public class ApiIdempotentImportSelector implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        return new String[]{
                "com.chengxi.datalom.idempotent.enable.ApiIdempotentConfig"
        };
    }
}
    1. 编写幂等配置文件类
    package com.chengxi.datalom.idempotent.enable;

import com.chengxi.datalom.idempotent.ApiIdempotentInterceptor;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

/**
 * @author chengxi
 * @date 2020/8/7 14:47
 */
@Configuration
@ConditionalOnClass(WebMvcConfigurer.class)
public class ApiIdempotentConfig implements WebMvcConfigurer {

    /**
     * 拦截器中加载比bean的注入优先，所以在其中加载不到，所以在这里加载从拦截器的构造中传递过去
     */
	@Autowired
    private TokenService tokenService;

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


}

  6. 签发token注解（有想法的可忽略，自定义）
    这里的签发token可以自己根据自己的喜好封装响应给前端，小熙这里提供一种思路，生成签发token注解，可以加在跳转方法上
    （1） 签发幂等token的注解

    package com.chengxi.datalom.idempotent.token;

import java.lang.annotation.*;

/**
 * @author chengxi
 * @date 2020/8/7 14:43
 */
@Inherited
@Documented
@Target({ ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
public @interface IdempotentTokenIssuer {

}

    （2） 编写幂等签发token拦截器

    package com.chengxi.datalom.idempotent.token;

import com.chengxi.datalom.idempotent.Constant;
import com.chengxi.datalom.idempotent.TokenService;
import lombok.AllArgsConstructor;
import lombok.NoArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.lang.reflect.Method;

/**
 * @author chengxi
 * @date 2020/8/7 16:36
 */
@NoArgsConstructor
@AllArgsConstructor
public class IdempotentTokenIssuerInterceptor implements HandlerInterceptor {

    @Autowired
    private TokenService tokenService;

    /**
     *  handler ：处理器（控制器） = controller对象
     *      preHandle ：处理请求的（再调用controller对象方法之前执行）
     *                ：对请求进行放行（继续执行进入到方法）
     *                ：对请求过滤
     *      返回值：true = 放行
     *             false = 过滤
     *
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        return false;
    }

    /**
     *  postHandle  调用控制器方法之后执行的方法
     *            ：处理响应的
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

    }

    /**
     *  afterCompletion ：
     *      整个请求处理完毕，在视图渲染完毕时回调，一般用于资源的清理或性能的统计
     * 			在多个拦截器调用的过程中,
     * 				afterCompletion是否取决于preHandler是否=true
     *
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        if (handler instanceof HandlerMethod) {

            HandlerMethod handlerMethod = (HandlerMethod) handler;
            Method method = handlerMethod.getMethod();

            IdempotentTokenIssuer methodAnnotation = method.getAnnotation(IdempotentTokenIssuer.class);
            if (methodAnnotation != null) {
                createToken(response);
            }
        }
    }

    public void createToken(HttpServletResponse response){
        // 签发幂等token
        Cookie cookie = new Cookie(Constant.IDEMPOTENT_TOKEN.getName(), tokenService.createToken());
        cookie.setHttpOnly(true);
        response.addCookie(cookie);
    }
}

    （3）在上面的幂等配置文件类中，注册该处理拦截器
    注册签发幂等拦截器

三. 测试前后端未分离的幂等注解

  1. 编写测试controller

    /**
 * @author chengxi
 * @date 2020/5/25 11:54
 */
@Controller
@RequestMapping(value = "/userController")
public class UserController {

    @Autowired
    private TokenService tokenService;

    @RequestMapping(value = "/testRequest")
//    @PreAuthorize("hasAuthority('admin:list')")
    @ApiIdempotent
    @ResponseBody
    public void testRequest(HttpServletRequest request, HttpServletResponse response) throws IOException {
        System.out.println("开始进入");
        String requestURI = request.getRequestURI();
        System.out.println("requestURI: "+requestURI);
        ServletOutputStream outputStream = response.getOutputStream();
        outputStream.write("响应数据：访问成功".getBytes());
        outputStream.flush();
        outputStream.close();
        System.out.println("流程结束");
    }


    @RequestMapping(value = "/createToken")
    @ResponseBody
    public ResponseEntity<Map<String, Object>> createToken(){
        return new ResponseEntity<>(MapBuilder.<String,Object>create(Maps.newHashMap())
                .put(Constant.IDEMPOTENT_TOKEN.getName(),tokenService.createToken())
                .build(), HttpStatus.OK);
    }
 }

    /**
     * 测试签发幂等token注解
     */
    @RequestMapping(value = "/createToken2")
    @IdempotentTokenIssuer()
    public void createToken2(){
        System.out.println(123);
    }

  2. 通过方法获取签发的幂等token（这里可以自定义封装，小熙只是展示下返回结果）
    签发幂等token

  3. 通过签发幂等token注解获取（在cookies中查看）
    注解签发幂等token

  4. 多次请求统一接口（测试幂等性注解是否生效，截图结果为第二次请求以及以后的或token过期的预期结果）
    幂等token过多消费

  5. 没有携带幂等token
    未携带幂等token的非法访问

四. 前后端分离编写：

由于架构特性，小熙这里采用访问时生成唯一幂等token，存储到redis中，然后返回前端，下次访问如果已存在则判定为重复提交。当然这是在不是恶意访问的时候，成立的。
理解了上述编写，那实现就较为简单了，可自行实现。（不想实现的，可以看下小熙简单编写的）

  1. 处理拦截器添加处理

    package com.chengxi.demo02.idempotent;

import cn.hutool.json.JSONUtil;
import com.alibaba.druid.support.json.JSONUtils;
import com.chengxi.demo02.ResponseDTO;
import com.chengxi.demo02.service.TokenService;
import lombok.AllArgsConstructor;
import lombok.NoArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.lang.reflect.Method;

/**
 * @author chengxi
 * @date 2020/8/7 10:02
 */
@Slf4j
@AllArgsConstructor
@NoArgsConstructor
public class ApiIdempotentInterceptor implements HandlerInterceptor {

    @Autowired
    private TokenService tokenService;

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws IOException {
        if (!(handler instanceof HandlerMethod)) {
            return true;
        }

        HandlerMethod handlerMethod = (HandlerMethod) handler;
        Method method = handlerMethod.getMethod();

        ApiIdempotent methodAnnotation = method.getAnnotation(ApiIdempotent.class);
        if (methodAnnotation != null) {
            try {
                judgeIdempotentToken(request, response);
            } catch (Exception e) {
                e.printStackTrace();
                log.error(e.toString());
                // ResponseDTO 是小熙临时写的简易响应也可替换成自己的，或者jsonObject等都可以
                String errorInfoJson = JSONUtil.toJsonStr(new ResponseDTO().setResultCode(HttpStatus.INTERNAL_SERVER_ERROR.value())
                        .setResultInfo(e.getMessage()));
                returnErrorInfo(response, errorInfoJson);
                return false;
            }
        }

        return true;
    }

    /**
     * 前后端分离时的校验
     * @param request
     * @param response
     */
    private void judgeIdempotentToken(HttpServletRequest request, HttpServletResponse response) {
        String token = tokenService.judgeIdempotentToken(request);
        if (StringUtils.isNotBlank(token)) {
            // 签发幂等token
            Cookie cookie = new Cookie(Constant.IDEMPOTENT_TOKEN.getName(), token);
            cookie.setHttpOnly(true);
            response.addCookie(cookie);
        }
    }

    private void returnErrorInfo(HttpServletResponse response, String errorInfo) throws IOException {
        response.setCharacterEncoding("UTF-8");
        response.setContentType("text/html; charset=utf-8");
        PrintWriter writer = response.getWriter();
        writer.println(errorInfo);
        writer.flush();
        writer.close();
    }

    /**
     * 前后未分离时的校验
     * @param request
     */
    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 {
    }


}

  2. 业务逻辑中添加处理（tokeService中添加）

    @Override
    public String judgeIdempotentToken(HttpServletRequest request) {
        String token = request.getHeader(Constant.IDEMPOTENT_TOKEN.getName());
        // header中不存在token
        if (token == null) {
            token = request.getParameter(Constant.IDEMPOTENT_TOKEN.getName());
            // parameter中也不存在token
            if (token == null) {
                throw new ServiceException(ResponseCode.ILLEGAL_ARGUMENT.getMsg());
            }
        }
        // 校验redis中是否存有已访问的token
        if (redisTemplate.hasKey(token)) {
            throw new ServiceException(ResponseCode.REPETITIVE_OPERATION.getMsg());
        }

        String requestURI = request.getRequestURI();
        String str = UUID.randomUUID().toString().replaceAll("-","");
        StringBuffer tokenSt = new StringBuffer();
        tokenSt.append(Constant.IDEMPOTENCE_TOKEN_PREFIX).append("_").append(requestURI).append("_").append(str);
        // 签发的IDEMPOTENCE_TOKEN默认有效期为1天
        redisTemplate.opsForValue().set(tokenSt.toString(), tokenSt.toString(), 1, TimeUnit.DAYS);

        return tokenSt.toString();
    }

  3. 展示结果
    展示结果

五. 后语：

以上就是小熙对于幂等接口，提供的一些想法了，如果有好的想法可以提出来讨论下。

程熙cjp
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot + MybatisPlus 实现实体类转成数据库表结构，可直接运行
11-12
MybatisPlus是一个Mybatis的增强工具，它在Mybatis的基础上做了很多自动化的工作，比如插入、更新、删除等操作，无需编写SQL语句，只需通过注解或XML配置即可。MybatisPlus也提供了实体类和数据库表之间的映射功能，...
今提头条适配终极版
11-05
4. 处理特殊情况：对于一些不支持自动适配的组件或者需要特殊处理的情况，可以使用`@AutoDimen`注解或者`AutoAdaptUtil`工具类进行手动适配。 除了基本的适配功能，AndroidAutoSize还提供了丰富的扩展功能，如字体...
【实战教程】使用自定义注解实现幂等性
自律使我自由
03-13 3512
使用自定义注解实现幂等性
通过redis实现SpringBoot接口幂等性的自定义注解
weixin_45357745的博客
07-19 665
通过自定义注解实现接口的幂等性，亲测可用
2024年网安最新【安全】Java幂等性校验解决重复点击（6种实现方式）_幂等校验
最新发布
2401_84239625的博客
05-03 972
幂等是一个数学与计算机科学概念，英文 idempotent [aɪˈdempətənt]。。比如 求绝对值 的函数，就是幂等的，abs(x) = abs(abs(x))。计算机科学中，幂等表示一次和多次请求某一个资源应该具有同样的作用。满足幂等条件的性能叫做幂等性。
一个注解实现接口幂等性，真心优雅！
Java技术栈，分享最主流的Java技术
01-03 1050
简单来说，就是对一个接口执行重复的多次请求，与一次请求所产生的结果是相同的，听起来非常容易理解，但要真正的在系统中要始终保持这个目标，是需要很严谨的设计的，在实际的生产环境下，我们应该保证任何接口都是幂等的，而如何正确的实现幂等，就是本文要讨论的内容。/*** 参数名，表示将从哪个参数中获取属性值。* 获取到的属性值将作为KEY。* @return*//*** 属性，表示将获取哪个属性的值。* @return*//*** 参数类型* @return*/
如何使用注解实现接口的幂等性校验
天青色 等烟雨的博客
12-02 648
在数学领域中对于幂等性的解释是即幂等元素x在函数f的多次作用下，其效果和在f的一次作用下相同。在编程上可以理解为，如果某个函数（方法）或接口被调用多次其行为结果和被调用一次相同，则这种函数或接口就具有幂等性。简单举个例子，天然幂等性假设对象Person中有个name属性，有个的方法，那这个方法就是天然幂等的哦，你输入相同的“小明”参数，不论你重复调用多少次都是将名字设置为“小明”，其对对象Person的影响都是一样的。这就是天然幂等性。非幂等性。
041-若依pro(ruoyi-vue-pro)幂等性（防重复提交）
RichardHLee的博客
09-19 371
yudao-spring-boot-starter-protection 技术组件，由它的 idempotent 包，提供声明式的幂等特性，可防止重复请求。例如说，用户快速的双击了某个按钮，前端没有禁用该按钮，导致发送了两次重复的请求。
RxRetroHttp为多套API请求适配而生
08-26
【RxRetroHttp详解：为多套API请求适配打造高效解决方案】 RxRetroHttp是一个专为解决多套API请求适配问题而设计的库，它巧妙地整合了RxJava和Retrofit，使得在面对不同API规则、不同Host地址的需求时，能够灵活地...
dubbo启动生成的自适应类.rar
11-27
在运行时，Dubbo会根据接口和`@Adaptive`注解生成一个代理类，这个代理类会根据当前的配置信息（如协议、注册中心等）决定调用哪个实际的服务实现。 3. **元数据解析**: 自适应类的工作原理依赖于元数据解析。Dubbo...
scan:关于二维码识别 ，二维码图片生成 做了Android6.0权限适配 单例模式调用，链式编程，可用接口回调，也可用注解回调
05-01
本项目"scan"专注于二维码的处理，包括识别和生成，并且针对Android 6.0及以上版本进行了权限适配，采用了单例模式设计以及链式编程技术。同时，它提供了接口回调和注解回调两种方式来处理扫描结果，使得代码更加...
自定义注解解决API接口幂等设计防止表单重复提交（生成token存放到redis中）
07-28
自定义封装注解类，（生成token存放到redis中）通过注解的方式解决API接口幂等设计防止表单重复提交
自定义幂等注解
m0_37999219的博客
03-12 3513
*** 幂等拦截器*/@Component@Autowired/*** 预处理* @return*/@Overrideif (!//被ApiIdempotment标记的扫描= null) {try {// 幂等性校验, 校验通过则放行, 校验失败则抛出异常, 并通过统一异常处理返回友好提示throw ex;//必须返回true,否则会被拦截一切请求@Override@Override/*** 返回的json值*/
自定义spring-boot-starter 实现 幂等注解 防止重复提交
峡谷电光马仔的博客
01-04 1191
一般遇见这种需求，大体思路思路我想基本是这样的， 1.自定义一个spring-boot-starter 2.启动一个拦截器实现拦截自定义注解 3.根据注解的一些属性进行拼接一个key 4.判断key是否存在 4.1 不存在 存入redis，然后设置一个过期时间（一般过期时间也是注解的一个属性） 4.2 存在则抛出一个重复提交异常 闲话少说，先来一个使用端代码以及结果 使用方式 key = "T(cn.goswan.orient.common.security.util.Sec..
基于redis实现数据幂等性注解
weixin_36617122的博客
10-30 121
加锁成功后，再次从redis中获取修改标识的值，如果值仍然存在，则说明此次修改已经执行过，直接返回结果。否则，执行实际的数据修改操作，并将修改标识写入redis中，以便下一次判断。在分布式环境中，多个服务可能同时对同一个数据进行修改操作，这时候就需要考虑如何保证数据的幂等性，避免出现数据的重复修改或者数据修改的混乱情况。以上就是基于redis实现数据幂等性注解的具体步骤。4.在注解处理器中，还需要添加异常处理逻辑，当redis连接异常或者redis分布式锁加锁失败时，需要抛出异常，避免数据修改操作失败。
SpringBoot中接口幂等性实现方案-自定义注解+Redis+拦截器实现防止订单重复提交
BADAO_LIUMANG_QIZHI的博客
07-25 1633
以下接口幂等性的实现方式与上面博客类似，可参考。
幂等注解实现
qq1076472549的博客
05-18 893
业务需求： 有些前端，或者第三方的接口请求要实现幂等操作，考虑到节省开发时间，做了一个可配置的幂等注解 先说明基本的实现原理和优缺点，后面直接贴代码： 原理： 1.通过自定义注解配置幂等参数：唯一主键，过期时间； 2.通过HandleInterceptor拦截请求方法和注解参数，进行校验 3.根据唯一主键，主键的值，过期时间，请求url来生成唯一token存redis。后续重复请求判断redis是否已经存在key。如果redis存在则说明已经执行过了（不管执行失败还是成功都算） 优点： .
自定义注解解决接口幂等性问题
zxc_123_789的博客
09-03 985
一. 什么是幂等性 简单的说就是对于同一笔业务操作，不管调用多少次，得到的结果都是一样的。 例如：在一次用户的支付订单的操作中,第一次支付时因一些原因显示网络异常,但是后台实际已经扣款了,那么用户支付第二次时,就会给用户显示扣款成功. 实现接口幂等性的设计方案可以有很多种,今天我们就用自定义注解的方式来解决 二. 基于拦截器实现 2.1 实现思路 自定义注解,在每个需要控制幂等性的接口上加上此注解 后台提供生成token的接口供前台调用,并在生成时将之存入redis中 前台每次请求接口时,必须带有从后
SpringBoot自定义注解@Idempotent实现API幂等性（防止接口重复请求）
qq837993702的博客
02-05 6473
目的 一定时间内，同样的请求（业务参数相同）访问同一个接口，则只能成功一次，其余被拒绝。 自定义幂等性注解 import java.lang.annotation.*; /** * 幂等注解 */ @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface Idempotent { /** * 幂等名称，作为redis缓存Key的一部分。 */
如何开启@Autoware适配注入
07-09
可以通过在该对象的类上添加相应的注解，例如`@Component`、`@Service`、`@Repository`等。 5. 如果需要对注入进行更精确的控制，可以使用`@Qualifier`注解指定具体的实现类。例如： ```java @Autowired @...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值