Springboot + redis + 注解 + 拦截器来实现接口幂等性校验

最新推荐文章于 2024-09-27 00:45:01 发布
最新推荐文章于 2024-09-27 00:45:01 发布
阅读量202 收藏
点赞数
分类专栏： java 文章标签： java redis spring
原文链接：jianshu.com/p/6189275403ed
版权

来源：jianshu.com/p/6189275403ed

一，概念

幂等性，通俗得说就是一个接口，多次发起同一个请求，必须保证操作只能执行一次
比如：

  • 订单接口，不能多次创建订单
  • 支付接口，重复支付同一笔订单只能扣一次钱
  • 支付宝回调接口，可能会多次回调，必须处理重复回调
  • 普通表单提交接口，因为网络超时等原因多次点击提交，只能成功一次等等

二，常见解决方案

  • 唯一索引 – 防止新增脏数据
  • token机制 – 防止页面重复提交
  • 悲观锁 – 获取数据的时候加锁（锁表或锁行）
  • 乐观锁 – 基于版本号version实现，在更新数据那一刻校验数据
  • 分布式锁 – redis（jedis，redisson）或zookeeper实现
  • 状态机 – 状态变更，更新数据时判断状态

三，本文实现

本文采用第二种实现方式，即通过 redis + token机制实现接口幂等性校验

四，实现思路

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

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

五，项目简介

  • spring boot
  • redis
  • @Apildempotent注解 + 拦截器对请求进行拦截
  • @ControllerAdvice全局异常处理
  • 压测工具：jmeter

说明：
本文重点介绍幂等性核心实现，关于spring boot如何集成redis，ServerResponse，ResponseCode等细枝末节不在本文讨论范围之内。

六，代码实现

pom

<!-- Redis-Jedis -->
		<dependency>
			<groupId>redis.clients</groupId>
			<artifactId>jedis</artifactId>
			<version>2.9.0</version>
		</dependency>

		<!--lombok 本文用到@Slf4j注解, 也可不引用, 自定义log即可-->
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<version>1.16.10</version>
		</dependency>

JedisUtil

package com.hrh.interfacecheck.util;

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


/**
 * @创建人 hrh
 * @创建时间 2020/2/13 0013
 * @描述
 */
@Component
public class JedisUtil {
    @Autowired
    private JedisPool jedisPool;

    private Jedis getJedis(){
        return this.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){
            //logger.error("set key:{} value:{} error",key,value,e);
            System.out.println("set key:{"+key+"} value:{"+value+"} error");
            return null;
        } finally {
            close(jedis);
        }
    }

    /**
     * 设值
     * @param key
     * @param value
     * @param expireTime
     * @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){
            //logger.error("set key:{} value:{} expireTime:{} error",key,value,expireTime,e);
            System.out.println("set key:{"+key+"} value:{"+value+"} expireTime:{"+expireTime+" error ");
            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){
            //logger.error("get key:{} error",key,e);
            System.out.println("get key:{"+key+"} ");
            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){
            //logger.error("del key:{} error",key,e);
            System.out.println("del key:{"+key+"} ");
            return null;
        } finally {
            close(jedis);
        }
    }

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

    /**
     * 设置key过期时间
     * @param key
     * @param expireTime
     * @return
     */
    public Long expire(String key,int expireTime){
        Jedis jedis = null;
        try {
            jedis = getJedis();
            return jedis.expire(key.getBytes(),expireTime);
        } catch (Exception e){
            //logger.error("expire key:{} error",key,e);
            System.out.println("expire key:{"+key+"} ");
            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){
            //logger.error("ttl key:{} error",key,e);
            System.out.println("ttl key:{"+key+"} ");
            return null;
        } finally {
            close(jedis);
        }
    }

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

}

自定义注解@ApiIdempotent

package com.hrh.interfacecheck.annotation;

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

/**
 * @创建人 hrh
 * @创建时间 2020/2/13 0013
 * @描述 在需要保证 接口幂等性 的Controller的方法上使用此注解
 */
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface ApiIdempotent {
}

ApiIdempotentInterceptor拦截器

package com.hrh.interfacecheck.Interceptor;

import com.hrh.interfacecheck.annotation.ApiIdempotent;
import com.hrh.interfacecheck.service.TokenService;
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;

/**
 * @创建人 hrh
 * @创建时间 2020/2/13 0013
 * @描述 接口幂等性拦截器
 */
public class ApiIdempotentInterceptor implements HandlerInterceptor{

    @Autowired
    private TokenService tokenService;

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

        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 request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

    }
}

TokenService

package com.hrh.interfacecheck.service;


import com.hrh.interfacecheck.common.ServerResponse;

import javax.servlet.http.HttpServletRequest;

/**
 * @创建人 hrh
 * @创建时间 2020/2/13 0013
 * @描述
 */
public interface TokenService {

    ServerResponse createToken();

    void checkToken(HttpServletRequest request);
}

TokenServiceImpl

package com.hrh.interfacecheck.service.impl;

import com.hrh.interfacecheck.common.Constant;
import com.hrh.interfacecheck.common.ServerResponse;
import com.hrh.interfacecheck.service.TokenService;
import com.hrh.interfacecheck.util.JedisUtil;
import com.hrh.interfacecheck.util.KeyUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import javax.servlet.http.HttpServletRequest;

/**
 * @创建人 hrh
 * @创建时间 2020/2/13 0013
 * @描述
 */
@Service
public class TokenServiceImpl  implements TokenService {

    private static final String TOKEN_NAME = "token";

    @Autowired
    private JedisUtil jedisUtil;

    @Override
    public ServerResponse createToken() {
        String str = KeyUtils.genUniqueKey();
        StringBuilder token = new StringBuilder();
        token.append(Constant.Redis.TOKEN_PREFIX).append(str);
        jedisUtil.set(token.toString(),token.toString(),Constant.Redis.EXPIRE_TIME_MINUTE);

        return ServerResponse.success(token.toString());
    }

    @Override
    public void checkToken(HttpServletRequest request) {
        String token = request.getHeader(TOKEN_NAME);
        if(StringUtils.isEmpty(token)){//head中不存在token
            token = request.getParameter(TOKEN_NAME);
            if(StringUtils.isEmpty(token)){//parameter中也不存在token
                try {
                    throw new Exception("");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
        if(!jedisUtil.exists(token)){
            try {
                throw new Exception("");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        Long del = jedisUtil.del(token);
        if(del<=0){
            try {
                throw new Exception("");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

TestService

**package com.hrh.interfacecheck.service;

import com.hrh.interfacecheck.common.ServerResponse;

/**
 * @创建人 hrh
 * @创建时间 2020/2/13 0013
 * @描述
 */
public interface TestService {

    ServerResponse testIdempotence();

    ServerResponse accessLimit();

}
**

TestServiceImpl

package com.hrh.interfacecheck.service.impl;

import com.hrh.interfacecheck.common.ServerResponse;
import com.hrh.interfacecheck.service.TestService;
import org.springframework.stereotype.Service;

/**
 * @创建人 hrh
 * @创建时间 2020/2/13 0013
 * @描述
 */
@Service
public class TestServiceImpl implements TestService {
    @Override
    public ServerResponse testIdempotence() {
        return ServerResponse.success("testIdempotence: success");
    }

    @Override
    public ServerResponse accessLimit() {
        return ServerResponse.success("accessLimit: success");
    }
}

InterfacecheckApplication

package com.hrh.interfacecheck;

import com.hrh.interfacecheck.Interceptor.ApiIdempotentInterceptor;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
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.WebMvcConfigurerAdapter;

@SpringBootApplication
public class InterfacecheckApplication extends WebMvcConfigurerAdapter{

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

	/**
	 * 跨域
	 * @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());
		super.addInterceptors(registry);
	}
	@Bean
	public ApiIdempotentInterceptor apiIdempotentInterceptor(){
		return new ApiIdempotentInterceptor();
	}
}

KeyUtils

package com.hrh.interfacecheck.util;

import java.util.Random;

/**
 * @创建人 hrh
 * @创建时间 2020/1/4 0004
 * @描述
 */
public class KeyUtils {
    /**
     * 生成唯一主键
     * 格式：时间+随机数
     */

    public static synchronized  String genUniqueKey(){
        Random random = new Random();
        Integer number = random.nextInt(900000) + 100000;
        return System.currentTimeMillis() + String.valueOf(number);
    }
}

Constant

package com.hrh.interfacecheck.common;

/**
 * @创建人 hrh
 * @创建时间 2020/2/13 0013
 * @描述
 */
public class Constant {

    public interface Redis {
        String OK = "OK";
        Integer EXPIRE_TIME_MINUTE = 60;// 过期时间, 60s, 一分钟
        Integer EXPIRE_TIME_HOUR = 60 * 60;// 过期时间, 一小时
        Integer EXPIRE_TIME_DAY = 60 * 60 * 24;// 过期时间, 一天
        String TOKEN_PREFIX = "token:";
        String MSG_CONSUMER_PREFIX = "consumer:";
        String ACCESS_LIMIT_PREFIX = "accessLimit:";
    }

    public interface LogType {
        Integer LOGIN = 1;// 登录
        Integer LOGOUT = 2;// 登出
    }

    public interface MsgLogStatus {
        Integer DELIVERING = 0;// 消息投递中
        Integer DELIVER_SUCCESS = 1;// 投递成功
        Integer DELIVER_FAIL = 2;// 投递失败
        Integer CONSUMED_SUCCESS = 3;// 已消费
    }

}

ResponseCode

package com.hrh.interfacecheck.common;

/**
 * @创建人 hrh
 * @创建时间 2020/2/13 0013
 * @描述
 */
/**
 * 响应状态码
 */
public enum ResponseCode {

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

    // 通用模块 1xxxx
    ILLEGAL_ARGUMENT(10000, "参数不合法"),
    REPETITIVE_OPERATION(10001, "请勿重复操作"),
    ACCESS_LIMIT(10002, "请求太频繁, 请稍后再试"),
    MAIL_SEND_SUCCESS(10003, "邮件发送成功"),

    // 用户模块 2xxxx
    NEED_LOGIN(20001, "登录失效"),
    USERNAME_OR_PASSWORD_EMPTY(20002, "用户名或密码不能为空"),
    USERNAME_OR_PASSWORD_WRONG(20003, "用户名或密码错误"),
    USER_NOT_EXISTS(20004, "用户不存在"),
    WRONG_PASSWORD(20005, "密码错误"),

    // 订单模块 4xxxx

    ;

    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;
    }
}

ServerResponse

package com.hrh.interfacecheck.common;

import com.fasterxml.jackson.annotation.JsonIgnore;

import java.io.Serializable;

/**
 * @创建人 hrh
 * @创建时间 2020/2/13 0013
 * @描述
 */
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;
    }
}

JedisConfig

package com.hrh.interfacecheck.config;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

/**
 * @创建人 hrh
 * @创建时间 2020/2/14 0014
 * @描述
 */
@Configuration
public class JedisConfig {

    @Value("${spring.redis.host}")
    private String host;

    @Value("${spring.redis.port}")
    private int port;

    @Value("${spring.redis.password}")
    private String password;

    @Value("${spring.redis.jedis.pool.max-idle}")
    private int maxIdle;

    @Value("${spring.redis.jedis.pool.max-wait}")
    private long maxWait;

    @Value("${spring.redis.jedis.pool.min-idle}")
    private int minIdle;

    @Value("${spring.redis.timeout}")
    private int timeout;

    @Bean
    public JedisPool redisPoolFactory() {
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        jedisPoolConfig.setMaxIdle(maxIdle);
        jedisPoolConfig.setMaxWaitMillis(maxWait);
        jedisPoolConfig.setMinIdle(minIdle);

        JedisPool jedisPool = new JedisPool(jedisPoolConfig, host, port, timeout, password);

        return jedisPool;
    }

}

配置文件

server.port=8080

# redis
spring.redis.host=localhost
spring.redis.port=6379
spring.redis.password=
spring.redis.jedis.pool.max-idle=8
spring.redis.jedis.pool.max-wait=-1
spring.redis.jedis.pool.min-idle=0
spring.redis.timeout=0

OK，目前为止，校验代码准备完毕，接下来测试验证

七，测试验证

1.获取token的控制器TokenController

package com.hrh.interfacecheck.controller;

import com.hrh.interfacecheck.common.ServerResponse;
import com.hrh.interfacecheck.service.TokenService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @创建人 hrh
 * @创建时间 2020/2/13 0013
 * @描述
 */
@RestController
@RequestMapping("/token")
public class TokenController {

    @Autowired
    private TokenService tokenService;

    @GetMapping
    public ServerResponse token(){
        return tokenService.createToken();
    }
}

2、TestController, 注意@ApiIdempotent注解, 在需要幂等性校验的方法上声明此注解即可, 不需要校验的无影响

package com.hrh.interfacecheck.controller;

import com.hrh.interfacecheck.annotation.ApiIdempotent;
import com.hrh.interfacecheck.common.ServerResponse;
import com.hrh.interfacecheck.service.TestService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @创建人 hrh
 * @创建时间 2020/2/13 0013
 * @描述
 */
@RestController
@RequestMapping("/test")
public class TestController {

    @Autowired
    private TestService testService;
    @ApiIdempotent
    @PostMapping("testIdempotence")
    public ServerResponse testIdempotence(){
        return testService.testIdempotence();
    }
}

3、获取token
在这里插入图片描述
4、测试接口安全性: 利用jmeter测试工具模拟50个并发请求, 将上一步获取到的token作为参数

5、header或参数均不传token, 或者token值为空, 或者token值乱填, 均无法通过校验, 如token值为"abcd"

八、注意点(非常重要)

上图中, 不能单纯的直接删除token而不校验是否删除成功, 会出现并发安全性问题, 因为, 有可能多个线程同时走到第46行, 此时token还未被删除, 所以继续往下执行, 如果不校验jedisUtil.del(token)的删除结果而直接放行, 那么还是会出现重复提交问题, 即使实际上只有一次真正的删除操作, 下面重现一下

稍微修改一下代码:
在这里插入图片描述

再次请求

再看看控制台

虽然只有一个真正删除掉token, 但由于没有对删除结果进行校验, 所以还是有并发问题, 因此, 必须校验

九、总结

其实思路很简单, 就是每次请求保证唯一性, 从而保证幂等性, 通过拦截器+注解, 就不用每次请求都写重复代码, 其实也可以利用spring aop实现， 无所谓。

道生壹贰
关注
专栏目录
SpringBoot中接口幂等性实现方案-自定义注解+Redis+拦截器实现防止订单重复提交
BADAO_LIUMANG_QIZHI的博客
07-25 1821
以下接口幂等性的实现方式与上面博客类似，可参考。
java.lang.IllegalStateException: original request is required
weixin_43918355的博客
06-16 2096
最近一个项目使用了Feign, 并且配置了 feign.httpclient.enabled = true 但是在进行调用其他服务是报错了 java.lang.RuntimeException:com.netflix.client.ClientException ...... Caused by: com.netflix.client.ClientException: null ...... Caused by: java.lang.IllegalStateException: original requ
SpringMVC中的拦截器和全局异常处理
qq_50313418的博客
03-16 4057
4. SpringMVC中拦截器 # springmvc中拦截器 1. 拦截器 Interceptor 拦截 中断 类似于javaweb中Filter过滤器（具有拦截请求、放行请求、拦截响应、放行响应） 拦截器也是拦截请求的，而有一点不同的是过滤器可以拦截所有的请求，而拦截器只能拦截控制器相关的请求 2. 作用 通过将控制器中的公共代码放在拦截器中执行，减少控制器中代码的冗余 3. 拦截器特点 1). 请求到达会经过拦截器 响应回来同样会经过拦截器 2
Error creating bean with name ‘XXX‘: Injection of autowired dependencies failed解决办法
fanr639的博客
08-13 1339
springMVC 中的采坑呀 项目结构如图 增加了workFlow 这个文件夹，里面添加的东西都没有报错，但是启动报错，提示dao层不存在，不注意的话都会出现这个问题 请查看自己的配置文件，applicationContext.xml 中有没有配置扫描到那个文件夹下的dao包。。。。。 <!--mapper接口扫描--> <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer"> <property n
springBoot securiyt实现微信登录
okludawei的博客
04-23 1139
spring security 实现微信登录 上一章讲解了如何用QQ实现登录，这一回讲解的是用微信实现登录。 实现功能 实现微信登录。 开发步骤 引入jar包 jar包的引入和QQ引入的jar包一致。 微信实体信息 /** * @author lvhaibao * @description * @date 2019/1/4 0004 9:46 */ @Data public class WeixinUserInfo { /** * 普通用户的标识，对当前开发者帐号唯一 ...
Redis详解 - SpringBoot整合Redis，RedisTemplate和注解两种方式的使用
zhijun666
05-10 345
本文主要讲 Redis 的使用，如何与 SpringBoot 项目整合，如何使用注解方式和 RedisTemplate 方式实现缓存。最后会给一个用 Redis 实现分布式锁，用在秒杀系统中的案例。 更多 Redis 的实际运用场景请关注开源项目 coderiver 项目地址：h...
SpringBoot+Redis实现接口幂等性，就看这篇了
m0_55849656的博客
06-21 1038
幂等性的概念是，任意多次执行所产生的影响都与一次执行产生的影响相同，按照这个含义，最终的解释是对数据库的影响只能是一次性的，不能重复处理。
接口幂等性校验（使用拦截器+自定义注解+redis解决问题）
qq_42926855的博客
02-13 1676
使用 拦截器+自定义注解+redis解决接口幂等性问题
如何使用 SpringBoot + Redis 优雅的解决接口幂等性问题
十指波课堂的博客
08-27 477
# 前言在实际的开发项目中,一个对外暴露的接口往往会面临很多次请求，我们来解释一下幂等的概念：任意多次执行所产生的影响均与一次执行的影响相同。按照这个含义，最终的含义就是 对数据库的影响只能是一次性的，不能重复处理。如何保证其幂等性，通常有以下手段：数据库建立唯一性索引，可以保证最终插入数据库的只有一条数据token机制，每次接口请求前先获取一个token，然后再下次请求的时候在请求的header...
图文结合！用 SpringBoot+Redis 解决海量重复提交问题
lt_xiaodou的博客
09-27 349
自定义一个注解，定义此注解的主要目的是把它添加在需要实现幂等的方法上，凡是某个方法注解了它，都会实现自动幂等。搜索公纵号： MarkerHub ，关注回复[vue]获取 前后端入门教程！后台利用反射如果扫描到这个注解，就会处理这个方法实现自动幂等，使用元注解ElementType.METHOD表示它只能放在方法上，etentionPolicy.RUNTIME表示它在运行时。}
Error creating bean with name ‘XXX‘: Injection of autowired dependencies failed错误的解决方法
iLzn_的博客
07-29 8086
初学ssm架构项目的时候出现Error creating bean with name ‘XXX’: Injection of autowired dependencies failed。 错误代码 package com.ssxdsz.crm.settings.service.impl; import com.ssxdsz.crm.settings.dao.UserDao; import com.ssxdsz.crm.settings.service.UserService; import org.sp
spring-boot aop 访问权限
fengxing_2的专栏
12-28 1001
使用spring-boot aop处理访问权限 spring-boot 2.0.1 1、pom.xml 添加aop-starter &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-boot-starter-aop&lt;/a...
Jmeter接口响应Json格式校验：Json Schema
未来来
05-31 1880
1 介绍 Json Schema定义了一套词汇和规则，这套词汇和规则用来定义Json元数据，且元数据也是通过Json数据形式表达的。Json元数据定义了Json数据需要满足的规范，规范包括成员、结构、类型、约束等。 1.1 使用Json Schema做接口测试的步骤 将响应json转换成json schema格式，（在线转换工具：jsonschema.net） 优化修改生成的json schema，使其更符合该接口的各种场景； 校验修改后的json schema是否符合规范(在线校验工具：jsonsche
springMVC项目启动时出现bean注入失败的情况：Error creating bean with name ‘XXX‘: Injection of autowired dependencies
GCUDE的博客
12-20 9686
springMVC项目启动时出现bean注入失败的情况：Error creating bean with name ‘XXX’: Injection of autowired dependencies 如下图所示： 这是修改之前的代码： [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-A1ZWNCqM-1608448007916)(C:\Users\ASUS\AppData\Roaming\Typora\typora-user-images\1608281711231.png)
SpringBoot整合Redis（三 ) 将登录成功产生的token存入redis
热门推荐
qq_42547698的博客
05-10 2万+
通过SpringBoot整合Redis（二 ) springboot整合缓存redis对redis有了初步的理解。接下来探索一下如何运用Redis存取、识别当前登录用户信息。 本次实现: 1.用户登录，校验用户名密码后，登录成功产生token值，保存入Redis中，设置时效50分钟。 2.使用拦截器/ SpringAop技术，当用户调用其他接口时，必须传入token值，并且比较token值...
spring boot 使用 spring security + redis 进行登录 及 权限验证
AmbroseLe
07-03 4489
目录 filter 过滤器 相关的工具类 安全服务工具类 客户端工具类 字符串工具类 handle处理类 认证失败处理类 返回未授权 自定义退出处理类 返回成功 service LoginService 通用常量信息 自定义异常 基础异常 用户信息异常类 验证码错误异常类 验证码失效异常类 用户密码不正确或不符合规范异常类 异步任务管理器 异步工厂（产生任务用） 获取i18n资源文件 自定义权限实现 用户权限处理 token验证处理 用户验证处理 co.
GitHub标星1.3W！五分钟带你搞定Linux Bash脚本使用技巧
RToax
09-15 499
原文：https://mp.weixin.qq.com/s/NnpyTOAghr_MXXK5H9twAg 来自：开源最前线（ID：OpenSourceTop） 综合自：https://leanpub.com/u/dylanaraps、https://leanpub.com/u/dylanaraps Bash脚本比我们想象中的都要强大，通过Bash脚本，大多数任务都可以让你在无任何其它语...
工厂模式的介绍及实现
户伟伟的博客
09-25 101
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
基于Hive和Hadoop的哔哩哔哩网站分析系统
最新发布
图南的博客
09-27 232
本项目是一个基于大数据技术的哔哩哔哩平台分析系统，旨在为用户提供全面的哔哩哔哩视频数据和深入的用户行为分析。系统采用 Hadoop 平台进行大规模数据存储和处理，利用 MapReduce 进行数据分析和处理，通过 Sqoop 实现数据的导入导出，以 Spark 为核心进行高效的数据处理。整个系统结合了大数据处理技术，为用户提供精准的内容推荐和深入的用户兴趣分析，帮助平台更好地了解视频趋势和用户需求。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值