一、tienchin健身系统技术点复现–注解重复提交
对于开发系统中,我们很多时候,会有很多方法
-
Token机制
- 首先客户端请求服务端,获取一个 token,每一次请求都获取到一个全新的token,将token存入到redis中,然后将token返回给客户端。
- 客户端将来携带刚刚返回的token去请求一个接口。
- 服务端收到请求后,分为两种情况:
- 如果 token 在 redis 中,直接删除该 token,然后继续处理业务请求。
- 如果 token 不在 redis 中,说明 token 过期或者当前业务已经执行过了,那么此时就不执行业务逻辑。
- 优势:实现简单
- 劣势:多一个获取 token 的过程。
-
用 Redis 的 setnx
- 客户端请求服务端,服务端将能代表请求唯一性的业务字段,通过 setnx 的方式存入 redis,并设置超时时间。
- 判断 setnx 是否成功:
- 成功:继续处理业务
- 失败:表示业务已经执行过了
-
设置状态字段
- 要处理的数据,有一个状态字段
-
锁机制
-
乐观锁:数据库中增加版本号字段,每次更新都根据版本号来判断。更新之前先去查询要更新记录的版本号,第二步更新的时候,将版本号也作为查询条件
- select versionCode from xxx where id = xxx;
- update xxx set xxx = xxx where xxx = xxx and versionCode = xxx;
-
悲观锁
-
假设每一次拿数据都会被修改,所以直接上排他锁就行了
-
start; select * from xxx where xxx for update update xxx commit;
-
-
Gitee代码路径
1、装饰者模式-HttpServletRequest获取Json字节流
首先继承 HttpServletRequestWrapper
重写构造方法、getInputStream()、getReader()
public class RepeatableReadRequestWrapper extends HttpServletRequestWrapper {
private final byte[] body;
public RepeatableReadRequestWrapper(HttpServletRequest request, HttpServletResponse response)
throws IOException {
super(request);
request.setCharacterEncoding("UTF-8");
response.setCharacterEncoding("UTF-8");
body = request.getReader().readLine().getBytes();
}
@Override
public BufferedReader getReader() throws IOException {
return new BufferedReader(new InputStreamReader(getInputStream()));
}
@Override
public ServletInputStream getInputStream() throws IOException {
ByteArrayInputStream inputStream = new ByteArrayInputStream(body);
return new ServletInputStream() {
@Override
public boolean isFinished() {
return false;
}
@Override
public boolean isReady() {
return false;
}
@Override
public void setReadListener(ReadListener readListener) {
}
@Override
public int read() throws IOException {
return inputStream.read();
}
@Override
public int available() throws IOException {
return body.length;
}
};
}
然后创建一个过滤器,若是 application/json
格式的则进入装饰者,否则用原来的。
2、创建过滤器
由于过滤器 > servlet,所以在这里我们设置一下,在后面的拦截器中获取字节流就没有问题。
public class RepeatSubmitFilter implements Filter {
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse,
FilterChain filterChain) throws IOException, ServletException {
HttpServletRequest request = (HttpServletRequest) servletRequest;
// 若是json进入装饰者的request
if (StringUtils.startsWithIgnoreCase(request.getContentType(), "application/json")) {
RepeatableReadRequestWrapper wrapper = new RepeatableReadRequestWrapper(
request, ((HttpServletResponse) servletResponse));
filterChain.doFilter(wrapper, servletResponse);
return;
}
filterChain.doFilter(servletRequest, servletResponse);
}
}
对于下面的 重服提交拦截器,我们使用抽象类的方式,可以重写判断方式
@Component
public abstract class RepeatSubmitInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response,
Object handler) throws Exception {
// 获取前端传得入参、拦截有 RepeatSubmit 注解得方法,判断是否重复提交
if (handler instanceof HandlerMethod) {
// HandlerMethod 就是我们写的请求接口
HandlerMethod handlerMethod = (HandlerMethod) handler;
Method method = handlerMethod.getMethod();
RepeatSubmit annotation = method.getAnnotation(RepeatSubmit.class);
if (annotation != null) {
// 对这个加注解得方法进行判断
if (validateRepeatableSubmit(request, annotation)) {
// 若是重复提交
MapString, Object> map = new HashMap>();
map.put("status", 500);
map.put("message", annotation.message());
response.setContentType("application/json;charset=utf-8");
response.getWriter().write(new ObjectMapper().writeValueAsString(map));
return false;
}
}
}
return true;
}
/**
* 抽象方法,后面继承此类,可以重写生成 key 的方式
*
* @param request 请求
* @param repeatSubmit 注解
* @author [山沉]
* @date 2023/6/8
* @return {@link boolean}
*/
public abstract boolean validateRepeatableSubmit(HttpServletRequest request,
RepeatSubmit repeatSubmit);
}
这里的 HandlerMethod
就是我们定义的 请求接口类 controller
这个类可以获得 注解,然后判断是否为空,然后去作重复提交判断。
3、定义判断重复提交方法
/**
* 功能描述 基础可重复提交拦截器,是可以指定是存入 redis 中得 key 组成,比如 加入 url、header 等等
*
* @author [山沉]
* @个人博客 [https://choleen95.github.io/]
* @博客 [https://www.cnblogs.com/Choleen/]
* @since [2023/6/7 7:45]
*/
@Component
public class RepeatableSubmitUrlInterceptorImpl extends RepeatSubmitInterceptor {
private static final String REPEAT_PARAMS = "repeat_params";
private static final String REPEAT_TIME = "repeat_time";
private static final String REPEAT_SUBMIT_KEY = "repeat_submit_key";
private static final String HEADER = "Authorization";
@Autowired
RedisCache redisCache;
@Override
public boolean validateRepeatableSubmit(HttpServletRequest request, RepeatSubmit repeatSubmit) {
// 获取入参
String newParams = "";
// request 是 RepeatableReadRequestWrapper
if (request instanceof RepeatableReadRequestWrapper) {
try {
newParams = request.getReader().readLine();
} catch (IOException e) {
e.printStackTrace();
}
}
if (StringUtils.isEmpty(newParams)) {
try {
newParams = new ObjectMapper().writeValueAsString(request.getParameterMap());
} catch (JsonProcessingException e) {
e.printStackTrace();
}
}
// 构建新的newMap存入redis 且和redis中得redisMap比较
MapString, Object> newMap = new HashMap>();
newMap.put(REPEAT_PARAMS, newParams);
newMap.put(REPEAT_TIME, System.currentTimeMillis());
// 获取 repeat_sumbit_key
String header = request.getHeader(HEADER);
StringBuffer requestURL = request.getRequestURL();
String cacheKey = REPEAT_SUBMIT_KEY + requestURL + header.replace("Beare", "");
Object cacheValue = redisCache.getCacheValue(cacheKey);
if (cacheValue != null) {
// 转换成 Map
MapString, Object> oldMap = (MapString, Object>) cacheValue;
if (compareParams(newMap, oldMap) && compareTime(newMap, oldMap,
repeatSubmit.interval())) {
return true;
}
}
// 这里对没有存入redis 的请求,设置值
redisCache.setCacheValue(cacheKey, newMap, repeatSubmit.interval(), TimeUnit.MILLISECONDS);
return false;
}
private boolean compareTime(MapString, Object> newMap, MapString, Object> oldMap,
int interval) {
long newTime = (Long) newMap.get(REPEAT_TIME);
long oldTime = (Long) oldMap.get(REPEAT_TIME);
// 若时间间隔小于注解时间间隔 则属于重复提交
return (newTime - oldTime) interval;
}
private boolean compareParams(MapString, Object> newMap, MapString, Object> oldMap) {
String newParams = (String) newMap.get(REPEAT_PARAMS);
String oldParams = (String) oldMap.get(REPEAT_PARAMS);
return newParams.equals(oldParams);
}
}
这里判断 request
是否是自定义的 HttpServeltRequestWrapper
若是,可以获取 BufferReader
,然后获取字符串。否则可以获取 key-value 形式的入参。
对于 String header request.getHeader(HEADER)
此行代码非常关键,因为是请求头中带着用户信息,这样每个请求进来都可以生成不一样的 key 存入redis,作有效的重复提交判断。
4、注入过滤器的Bean
@Configuration
public class WebConfig implements WebMvcConfigurer {
@Autowired
RepeatSubmitInterceptor submitInterceptor;
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(submitInterceptor).addPathPatterns("/**");
}
@Bean
FilterRegistrationBeanRepeatSubmitFilter> filterFilterRegistrationBean() {
FilterRegistrationBeanRepeatSubmitFilter> bean = new FilterRegistrationBean>();
bean.setFilter(new RepeatSubmitFilter());
bean.addUrlPatterns("/*");
return bean;
}
}
若是 FilterRegistrationBean
不生成Bean,注入自定义的filer,不能生效,在实现 WebMvcConfigurer
接口,实现 addInterCeptors
注入拦截器,且拦截请求规则。
5、重复提交注解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RepeatSubmit {
/**
* 两个时间得间隔,毫秒
*/
int interval() default 5000;
/**
* 重复提交时得文本
*/
String message() default "单位时间内,不可重复提交";
}
在 RepeatSubmitInterceptor
中对于是否属于重复提交,就是 redis 中存储的系统时间,和当前时间作对比,若小于 RepeatSubmit 注解中的 interval 时间间隔,获取入参相同,就是重复提交。
服务器托管,北京服务器托管,服务器租用 http://www.fwqtg.net
什么是 BFC BFC 全称是 Block Formatting Context,即块格式化上下文。 除了 BFC,还有: IFC(行级格式化上下文)- inline 内联 GFC(网格布局格式化上下文)- display: grid FFC(自适应格式化上下…