springboot搭配redis使用自定义注解和拦截器实现接口方法幂等性

﹏ヽ暗。殇╰゛Y 2022-12-29 12:56 141阅读 0赞

### springboot搭配redis使用自定义注解和拦截器实现接口方法幂等性 ###

*  springboot搭配redis使用自定义注解和拦截器实现接口方法幂等性
 *   *  什么是幂等
     *  幂等的实现方法
     *  程序的实现
     *   *  pom.xml
         *  自定义注解--AutoIdempotent.java
         *  Redis工具类
         *  Service--TokenService
         *  自定义拦截器
         *  自定义异常
         *  测试Controller
         *  测试结果

# springboot搭配redis使用自定义注解和拦截器实现接口方法幂等性 #

## 什么是幂等 ##

**任意执行多次所产生的影响均与一次执行的影响相同**

## 幂等的实现方法 ##

*  数据库建立唯一索引
 *  悲观锁
 *  token机制

我们今天要讲的是第三种–**token机制**，token机制的实现方法也有很多种，我们今天要说的是token机制的实现方法是使用springboot搭配redis利用自定义注解和拦截器实现的，流程如下

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JieHlscWYxMjZjb20_size_16_color_FFFFFF_t_70_pic_center]

`该图来源于网络，如果侵权请联系本人即刻删除`

## 程序的实现 ##

### pom.xml ###

新一个项目，修改pom.xml如下(这里只列出了主要的jar包依赖，实际开发中按自己的需求添加)

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
        <exclusions>
            <exclusion>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-logging</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
    
    
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    
    
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.50</version>
    </dependency>

### 自定义注解–AutoIdempotent.java ###

package com.chinachg.tbsp.config.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 AutoIdempotent { 
    
    }

### Redis工具类 ###

package com.chinachg.tbsp.utils.redis;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.core.ValueOperations;
    import org.springframework.stereotype.Component;
    
    import java.io.Serializable;
    import java.util.concurrent.TimeUnit;
    
    @Component
    public class RedisTemplateUtil { 
        @Autowired
        private RedisTemplate redisTemplate;
    
        /** * 写入缓存 * @param key * @param value * @return */
        public boolean set(final String key, Object value) { 
            boolean result = false;
            try { 
                ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
                operations.set(key, value);
                result = true;
            } catch (Exception e) { 
                e.printStackTrace();
            }
            return result;
        }
    
        /** * 写入缓存设置时效时间 * @param key * @param value * @return */
        public boolean setEx(final String key, Object value, Long expireTime) { 
            boolean result = false;
            try { 
                ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
                operations.set(key, value);
                redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
                result = true;
            } catch (Exception e) { 
                e.printStackTrace();
            }
            return result;
        }
    
        /** * 判断缓存中是否有对应的value * @param key * @return */
        public boolean exists(final String key) { 
            return redisTemplate.hasKey(key);
        }
    
        /** * 读取缓存 * @param key * @return */
        public Object get(final String key) { 
            Object result = null;
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            result = operations.get(key);
            return result;
        }
    
        /** * 删除对应的value * @param key */
        public boolean remove(final String key) { 
            if (exists(key)) { 
                Boolean delete = redisTemplate.delete(key);
                return delete;
            }
            return false;
        }
    }

### Service–TokenService ###

package com.chinachg.tbsp.service;
    
    import javax.servlet.http.HttpServletRequest;
    
    public interface TokenService { 
        /** * 创建token * @return */
        public  String createToken();
    
        /** * 检验token * @param request * @return */
        public boolean checkToken(HttpServletRequest request);
    }

package com.chinachg.tbsp.service.impl;
    
    import com.chinachg.tbsp.service.TokenService;
    import com.chinachg.tbsp.utils.GenerateUtil;
    import com.chinachg.tbsp.utils.exception.TokenException;
    import com.chinachg.tbsp.utils.redis.RedisTemplateUtil;
    import com.chinachg.tbsp.utils.values.Constants;
    import com.chinachg.tbsp.utils.values.ResultType;
    import com.github.xiaoymin.knife4j.core.util.StrUtil;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import org.springframework.util.StringUtils;
    
    import javax.servlet.http.HttpServletRequest;
    
    @Service
    public class TokenServiceImpl implements TokenService { 
        @Autowired
        private RedisTemplateUtil redisTemplateUtil;
    
        /** * 创建token * * @return */
        @Override
        public String createToken() { 
            // 精确到毫秒数的日期字符串+六位随机数确保不唯一
            String str = GenerateUtil.generateReqSerialNo();
            StringBuilder token = new StringBuilder();
            try { 
                token.append(Constants.TOKEN.TOKEN_PREFIX).append(str);
                redisTemplateUtil.setEx(token.toString(), token.toString(),10000L);
                boolean notEmpty = StringUtils.isEmpty(token.toString());
                if (!notEmpty) { 
                    return token.toString();
                }
            }catch (Exception ex){ 
                ex.printStackTrace();
            }
            return null;
        }
    
        /** * 检验token * * @param request * @return */
        @Override
        public boolean checkToken(HttpServletRequest request){ 
            String token = request.getHeader(Constants.TOKEN.TOKEN_NAME);
            if (StrUtil.isBlank(token)) { // header中不存在token
                token = request.getParameter(Constants.TOKEN.TOKEN_NAME);
                if (StrUtil.isBlank(token)) { // parameter中也不存在token
                    throw new TokenException(ResultType.TOKEN_INVALID.getCode(), ResultType.TOKEN_INVALID.getMsg());
                }
            }
    
            if (!redisTemplateUtil.exists(token)) { 
                throw new TokenException(ResultType.REQUEST_REPEAT.getCode(),ResultType.REQUEST_REPEAT.getMsg());
            }
    
            boolean remove = redisTemplateUtil.remove(token);
            if (!remove) { 
                throw new TokenException(ResultType.REQUEST_REPEAT.getCode(),ResultType.REQUEST_REPEAT.getMsg());
            }
            return true;
        }
    }

### 自定义拦截器 ###

package com.chinachg.tbsp.config.interceptor;
    
    import com.chinachg.tbsp.config.annotation.AutoIdempotent;
    import com.chinachg.tbsp.service.TokenService;
    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 AutoIdempotentInterceptor implements HandlerInterceptor { 
    
        @Autowired
        private TokenService tokenService;
    
        /** * 预处理 * * @param request * @param response * @param handler * @return * @throws Exception */
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { 
            if (!(handler instanceof HandlerMethod)) { 
                return true;
            }
    
            HandlerMethod handlerMethod = (HandlerMethod) handler;
            Method method = handlerMethod.getMethod();
            AutoIdempotent methodAnnotation = method.getAnnotation(AutoIdempotent.class);
            if (methodAnnotation != null) { 
                return tokenService.checkToken(request);
            }
            //必须返回true,否则会被拦截一切请求
            return true;
        }
    
    
        @Override
        public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception { 
        }
    
        @Override
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception { 
        }
    }

上面的自定义拦截器记得加入到自定义的**WebConfigurer**中，否则不起作用

registry.addInterceptor(autoIdempotentInterceptor).addPathPatterns("/token/**");

### 自定义异常 ###

package com.chinachg.tbsp.utils.exception;
    
    import com.chinachg.tbsp.utils.exception.base.BaseException;
    
    public class TokenException extends BaseException { 
        public TokenException() { 
        }
    
        public TokenException(String message) { 
            super(message);
        }
    
        public TokenException(int code, String message) { 
            super(code, message);
        }
    }

自定义异常记得加入到全局的异常处理中进行处理

package com.chinachg.tbsp.utils.exception.handler;
    
    import com.chinachg.tbsp.utils.ExceptionUtil;
    import com.chinachg.tbsp.utils.exception.*;
    import com.chinachg.tbsp.utils.values.ResultInfo;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.web.bind.annotation.ControllerAdvice;
    import org.springframework.web.bind.annotation.ExceptionHandler;
    import org.springframework.web.bind.annotation.ResponseBody;
    
    import javax.servlet.http.HttpServletRequest;
    import java.util.Map;
    
    @Slf4j
    @ControllerAdvice
    public class GlobalExceptionHandler { 
        /** * 处理TokenException 异常 */
        @ExceptionHandler(TokenException.class)
        @ResponseBody
        public Map<String, Object> handleException(HttpServletRequest request, TokenException e) { 
            log.error("开始捕获异常：");
            log.error("异常名称：" + e.toString());
            StringBuilder stringBuilder = new StringBuilder();
            stringBuilder.append("异常详情：");
            stringBuilder.append(System.getProperty("line.separator"));
            stringBuilder.append(ExceptionUtil.getStackTraceString(e));
            log.error(stringBuilder.toString());
            return ResultInfo.getDataMap(e.getCode(), e.getMessage(), null);
        }
    }

### 测试Controller ###

package com.chinachg.tbsp.controller;
    
    import com.chinachg.tbsp.config.annotation.AutoIdempotent;
    import com.chinachg.tbsp.service.TokenService;
    import com.chinachg.tbsp.utils.values.ResultInfo;
    import com.chinachg.tbsp.utils.values.ResultType;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.util.StringUtils;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.PostMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import javax.annotation.Resource;
    import java.util.Map;
    
    @Slf4j
    @RestController
    @RequestMapping("token")
    public class TokenController { 
        @Resource
        private TokenService tokenService;
    
        @PostMapping("/get")
        public Map<String,Object> getToken(){ 
            String token = tokenService.createToken();
            if (!StringUtils.isEmpty(token)) { 
                return ResultInfo.getDataMap(ResultType.SUCCESS.getCode(), ResultType.SUCCESS.getMsg(),token);
            }
            return ResultInfo.getDataMap(ResultType.FAIL.getCode(), "token获取失败",null);
        }
    
        @AutoIdempotent
        @PostMapping("/test/{token}")
        public Map<String,Object> test(@PathVariable(name = "token")String token) { 
            return ResultInfo.getDataMap(ResultType.SUCCESS.getCode(), ResultType.SUCCESS.getMsg(),token);
        }
    }

### 测试结果 ###

首先我们执行**get**方法，获取一个token

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JieHlscWYxMjZjb20_size_16_color_FFFFFF_t_70_pic_center 1]

然后我们执行**test**方法，传递刚才我们获取到的token

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JieHlscWYxMjZjb20_size_16_color_FFFFFF_t_70_pic_center 2]

可以看到第一次请求后台能顺利返回我们刚才传递过去的token，最后我们再次请求一次test方法

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JieHlscWYxMjZjb20_size_16_color_FFFFFF_t_70_pic_center 3]

这样就实现了我们开头所说的接口幂等性。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JieHlscWYxMjZjb20_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/59fd8e96dc154ce3b1904f15d030805e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JieHlscWYxMjZjb20_size_16_color_FFFFFF_t_70_pic_center 1]: https://img-blog.csdnimg.cn/20201222181133240.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JieHlscWYxMjZjb20=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JieHlscWYxMjZjb20_size_16_color_FFFFFF_t_70_pic_center 2]: https://img-blog.csdnimg.cn/20201222181144296.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JieHlscWYxMjZjb20=,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JieHlscWYxMjZjb20_size_16_color_FFFFFF_t_70_pic_center 3]: https://img-blog.csdnimg.cn/20201222181154849.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JieHlscWYxMjZjb20=,size_16,color_FFFFFF,t_70#pic_center