springboot + redis + 注解 + 拦截器用Token 实现接口幂等性

实现思路

为需要保证幂等性的每一次请求创建一个唯一标识token, 先获取token, 并将此token存入redis, 请求接口时, 将此token放到header或者作为请求参数请求接口, 后端接口判断redis中是否存在此token:

如果存在, 正常处理业务逻辑, 并从redis中删除此token, 那么, 如果是重复请求, 由于token已被删除, 则不能通过校验, 返回请勿重复操作提示
如果不存在, 说明参数不合法或者是重复请求, 返回提示即可

pom依赖


<!-- 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>
<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>5.8.7</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

yaml

配置Redis

spring:
  redis:
    host: 192.168.111.101
    port: 6379
    lettuce:
      pool:
        max-active: 8 # 最大连接
        max-idle: 8 # 最大空闲连接
        min-idle: 0 # 最小空闲连接
        max-wait: 100 # 连接等待时间


ResultVo

返回的结果!!!

public class ResultVo {
    private int code;
    private String message;
    private String data;
    private boolean success;

    public ResultVo() {
    }

    public int getCode() {
        return code;
    }

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

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public String getData() {
        return data;
    }

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

    public boolean isSuccess() {
        return success;
    }

    public void setSuccess(boolean success) {
        this.success = success;
    }
    public static ResultVo ok(String data){
        ResultVo resultVo = new ResultVo();
        resultVo.setCode(200);
        resultVo.setMessage("Success");
        resultVo.setSuccess(true);
        resultVo.setData(data);
        return  resultVo;
    }
    public static ResultVo fail(String message){
        ResultVo resultVo = new ResultVo();
        resultVo.setCode(110);
        resultVo.setMessage(message);
        resultVo.setSuccess(false);
        return  resultVo;
    }
}

ApiIdempotent

接口幂等性注解

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

/**
 * 防重复提交的注解
 *          放在Controller类:表示当前类的所有接口都是幂等性
 *          放在方法上:表示当前方法是幂等性
 */
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface ApiIdempotent {
}

TokenService

定义生成token和检查token

import javax.servlet.http.HttpServletRequest;


public interface TokenService {


    /**
     * 创建token
     * @return
     */
    public String createToken();


   /*
   *检验token
   * */

    public void checkToken(HttpServletRequest request);
}

TokenServiceImpl

Redis的UUID、token的创建与检查

import cn.hutool.core.util.StrUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;

import javax.servlet.http.HttpServletRequest;

import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.util.concurrent.TimeUnit;

@Service
public class TokenServiceImpl implements TokenService {
    /**
     * 开始时间戳2022-10-1
     */
    private final long BEGIN_TIMESTAMP = 1664553600L;
    /**
     * 序列号的位数
     */
    private final int COUNT_BITS = 32;
    private final String TOKEN_NAME = "IdempotentToken";
    private final String TOKEN_PREFIX = TOKEN_NAME + ":";
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    /**
     * 创建token
     *
     * @return
     */

    @Override
    public String createToken() {
        //使用Redis生成token
        String token = nextId();

        StringBuilder sb = new StringBuilder();

        try {
            //token的生成规则
            sb.append(TOKEN_PREFIX).append(token);
            //token三分钟过期
            stringRedisTemplate.opsForValue().set(sb.toString(), "1", 180L, TimeUnit.SECONDS);
            boolean isNotEmpty = !sb.toString().isEmpty();
            if (isNotEmpty) {
                return sb.toString();
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }

        return null;
    }


    //删除Token,true表示第一次提交,false表示重复提交

    public Boolean deleteToken(String token) {
        return stringRedisTemplate.delete(TOKEN_PREFIX + token);
    }

    public void checkToken(HttpServletRequest request) {
        //获取请求头携带的token
        String token = request.getHeader(TOKEN_NAME);
        //System.out.println(TOKEN_PREFIX+token);
        //如果没有携带token,返回
        if (StrUtil.isEmpty(token)) {
            ThreadLocalMaps.setVo(ResultVo.fail("重复提交"));
            return;
        }
        //幂等性校验, 校验通过则放行, 校验失败,flag=false,即 没有该token!
        Boolean flag = deleteToken(token);
        if (Boolean.FALSE.equals(flag)) {
            //重复提交
            ThreadLocalMaps.setVo(ResultVo.fail("重复提交"));
            return;
        }
        ThreadLocalMaps.setVo(ResultVo.ok(token));

    }

    public String nextId() {
        String key = "UUID:count";
        // 1.生成时间戳
        LocalDateTime now = LocalDateTime.now();
        long nowSecond = now.toEpochSecond(ZoneOffset.UTC);
        long timestamp = nowSecond - BEGIN_TIMESTAMP;
        // 2.自增长
        long count = stringRedisTemplate.opsForValue().increment(key);
        // 3.可以设置过期时间
        stringRedisTemplate.expire(key, 60, TimeUnit.DAYS);
        // 4.拼接并返回
        return (timestamp << COUNT_BITS | count) + "";
    }


}

ApiIdempotentInterceptor

拦截器,加了注解的方法都拦截住!!!

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 javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.lang.reflect.Method;

/**
 * 拦截器
 */

@Component
public class ApiIdempotentInterceptor 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();


        //被ApiIdempotment标记的扫描

        ApiIdempotent methodAnnotation = method.getAnnotation(ApiIdempotent.class);

        if (methodAnnotation != null) {
            tokenService.checkToken(request);
        }
        //全部返回 true,这个拦截器 不拦截任何请求!!

        return true;

    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        // 防止内存泄露
        // 在拦截的请求 渲染页面后进行,即拦截的方法return后进行!!
        ThreadLocalMaps.removeVo();
    }

}


WebConfiguration

配置拦截器以及跨域

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;

import javax.annotation.Resource;

@Configuration
public class WebConfiguration implements WebMvcConfigurer {

    @Resource
    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);

    }


}

TestController

进行测试的接口!!!

import cn.hutool.json.JSONUtil;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;

@RestController
public class TestController {

    @Resource
    private TokenService tokenService;


    @PostMapping("/get/token")
    public String getToken() {

        String token = tokenService.createToken();

        if (!token.isEmpty()) {


            return JSONUtil.toJsonStr(ResultVo.ok(token));

        }

        return StrUtil.EMPTY;

    }


    @PostMapping("/add")
    @ApiIdempotent
    public String add(HttpServletRequest request) {
        //userService.insertUser(user); //有字段唯一性,故注释
        ResultVo vo = ThreadLocalMaps.getVo();

        boolean isSuccess = vo.isSuccess();

        if (!isSuccess)
            return "请勿重复提交!";

        String str = JSONUtil.toJsonStr(vo);
           
        return str;
      
    }


}

测试

获取令牌

在这里插入图片描述

Redis中可以看到令牌!

在这里插入图片描述

不带请求头或请求头错误

在这里插入图片描述

在这里插入图片描述

带正确的请求头

在这里插入图片描述

完成!!!

  • 0
    点赞
  • 11
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
### 回答1: 可以通过实现 Filter 接口来创建一个过滤器,然后在 Spring Boot使用 @Bean 注解将其注册到应用程序中。在过滤器中,可以通过 HttpServletRequest 对象获取请求头中的 token,然后进行验证或者其他操作。具体实现可以参考 Spring Boot 官方文档或者相关教程。 ### 回答2: 在使用Spring Boot中,可以通过创建一个过滤器来拦截token。下面是一个简单的示例,说明如何实现。 首先,需要创建一个自定义的过滤器类,实现javax.servlet.Filter接口。在实现过滤器时,我们可以在doFilter方法中进行token验证的逻辑处理。以下是示例代码: ```java import javax.servlet.*; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import java.io.IOException; public class TokenFilter implements Filter { @Override public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException { // 将请求和响应对象转换成HttpServletRequest和HttpServletResponse对象 HttpServletRequest httpRequest = (HttpServletRequest) request; HttpServletResponse httpResponse = (HttpServletResponse) response; // 从请求头中获取token String token = httpRequest.getHeader("Authorization"); // 进行token验证的逻辑处理,例如验证token是否过期、是否有效等 // ... // 如果验证通过,将请求继续传递给下一个过滤器或目标资源处理 chain.doFilter(request, response); } // 其他方法,例如init和destroy方法,可以留空不处理 } ``` 接下来,需要将自定义的过滤器添加到Spring Boot应用程序中。可以使用@Configuration注解将过滤器添加为一个Bean,并使用@Order注解指定过滤器的执行顺序。例如: ```java import org.springframework.boot.web.servlet.FilterRegistrationBean; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.core.Ordered; @Configuration public class FilterConfig { @Bean public FilterRegistrationBean<TokenFilter> tokenFilter() { FilterRegistrationBean<TokenFilter> registrationBean = new FilterRegistrationBean<>(); registrationBean.setFilter(new TokenFilter()); // 设置过滤器的URL映射规则,例如/*表示拦截所有请求 registrationBean.addUrlPatterns("/*"); // 设置过滤器的执行顺序 registrationBean.setOrder(Ordered.HIGHEST_PRECEDENCE); return registrationBean; } } ``` 最后,重新启动Spring Boot应用程序,自定义的过滤器就会拦截所有请求,并对token进行验证处理。 请注意,上述示例只是一个简单的演示,实际应用中可能需要根据具体的需求进行修改和扩展。例如,可以从数据库或缓存中获取token,进行更加复杂的验证逻辑,并在验证失败时返回相应的错误信息。 ### 回答3: 使用Spring Boot实现过滤器拦截Token的步骤如下: 1. 创建一个自定义的过滤器类,实现javax.servlet.Filter接口,并重写doFilter方法。在doFilter方法中,可以通过HttpServletRequest对象获取请求头中的Token信息,并进行相应的验证或处理。 2. 在Spring Boot应用的启动类中,通过添加注解@EnableWebSecurity开启Web安全配置,并通过继承WebSecurityConfigurerAdapter类重写configure方法。 3. 在configure方法中,使用http对象的addFilterBefore方法将自定义的过滤器添加到过滤器链中,指定过滤器在哪个过滤器之前进行拦截。 4. 在过滤器中,可以进行Token的验证和处理逻辑。例如,可以使用JWT来生成和验证Token,或将Token存储在Redis中,根据请求的Token进行校验等。 5. 如果Token验证不通过,可以返回相应的错误信息或重定向到登录页面。如果验证通过,可以进行其他的业务逻辑处理。 总之,通过自定义过滤器并将其添加到Spring Boot的过滤器链中,可以在请求到达Controller之前进行Token的验证和拦截操作,以实现对请求的安全控制。

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值