AOP表单防止重复提交

1. 自定义注解

code：

import java.lang.annotation.ElementType;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.lang.annotation.Target;

/**

* 可以防止表单提交的注解

*/

@Retention(RetentionPolicy.RUNTIME)//指定该注解在运行时可以获取

@Target(ElementType.METHOD)//该注解执行当前注解可以作用的范围

public @interface AvoidRepeatableCommit {

/**

* 指定时间内不可重复提交,单位毫秒 default 3000默认为三秒

*/

long timeout() default 3000 ;

}

1. 切面

code：

import com.shkj.partsstock.common.Result;

import lombok.extern.slf4j.Slf4j;

import org.apache.commons.lang3.StringUtils;

import org.aspectj.lang.ProceedingJoinPoint;

import org.aspectj.lang.annotation.Around;

import org.aspectj.lang.annotation.Aspect;

import org.aspectj.lang.reflect.MethodSignature;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.data.redis.core.RedisTemplate;

import org.springframework.stereotype.Component;

import org.springframework.web.context.request.RequestContextHolder;

import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;

import java.lang.reflect.Method;

import java.util.concurrent.TimeUnit;

@Aspect

@Component

@Slf4j

public class AvoidRepeatableCommitAspect{

@Autowired

private RedisTemplate redisTemplate;

@Around("@annotation(com.shkj.partsstock.test.test1.AvoidRepeatableCommit)")

public Object around(ProceedingJoinPoint point) throws Throwable {

HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.currentRequestAttributes()).getRequest();

String ip = IPUtils.getIpAddr(request);//获取客户端请求的ip地址

log.debug("客户端ip地址：" + ip);

//获取到注解信息

MethodSignature signature = (MethodSignature) point.getSignature();

Method method = signature.getMethod();

//获取目标类，方法

String name = method.getName();//获取方法名

String className = method.getDeclaringClass().getName();//获取类名称

String ipKey = className + "#" +name;

log.debug("类名与方法名的hashCode值："+ipKey.hashCode());

int keyHashCode = Math.abs(ipKey.hashCode());

String key = "ECCOM:arc-" + ip +"-"+ keyHashCode;

log.info("ipKey={},keyHashCode={},key={}",ipKey,keyHashCode,key);

AvoidRepeatableCommit avoidRepeatableCommit = method.getAnnotation(AvoidRepeatableCommit.class);

long timeout = avoidRepeatableCommit.timeout();

if (timeout < 0 ){

timeout = 3 * 1000L;

}

String value = (String) redisTemplate.opsForValue().get(key);

if (StringUtils.isNotBlank(value)){

return Result.fail(303,"请勿重复提交！",null);

}

redisTemplate.opsForValue().set(key, UUIDUtils.getUUID(),timeout, TimeUnit.MILLISECONDS);

Object proceed = point.proceed();

return proceed;

}

}

1. 工具类

code:

package com.shkj.partsstock.test.test1;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.util.StringUtils;

import javax.servlet.http.HttpServletRequest;

public class IPUtils {

private static Logger logger = LoggerFactory.getLogger(IPUtils.class);

/**

* 获取IP地址

* 使用Nginx等反向代理软件， 则不能通过request.getRemoteAddr()获取IP地址

* 如果使用了多级反向代理的话，X-Forwarded-For的值并不止一个，而是一串IP地址，X-Forwarded-For中第一个非unknown的有效IP字符串，则为真实IP地址

*/

public static String getIpAddr(HttpServletRequest request) {

String ip = null;

try {

ip = request.getHeader("x-forwarded-for");

if (StringUtils.isEmpty(ip) || "unknown".equalsIgnoreCase(ip)) {

ip = request.getHeader("Proxy-Client-IP");

}

if (StringUtils.isEmpty(ip) || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {

ip = request.getHeader("WL-Proxy-Client-IP");

}

if (StringUtils.isEmpty(ip) || "unknown".equalsIgnoreCase(ip)) {

ip = request.getHeader("HTTP_CLIENT_IP");

}

if (StringUtils.isEmpty(ip) || "unknown".equalsIgnoreCase(ip)) {

ip = request.getHeader("HTTP_X_FORWARDED_FOR");

}

if (StringUtils.isEmpty(ip) || "unknown".equalsIgnoreCase(ip)) {

ip = request.getRemoteAddr();

}

} catch (Exception e) {

logger.error("IPUtils ERROR ", e);

}

// 使用代理，则获取第一个IP地址

if (StringUtils.isEmpty(ip) && ip.length() > 15) {

if (ip.indexOf(",") > 0) {

ip = ip.substring(0, ip.indexOf(","));

}

}

return ip;

}

}