springboot使用注解实现60秒间隔发送短信

在日常中我们经常会看到有短信登录的功能，这种功能里面提供的根据手机号码发送短信的功能。

但是由于发送短信我们不能无节制的发送，如果允许无节制的发送短信，那么就会被恶人利用，形成短信轰炸，给用户造成困扰的同时，我们也会有很大的经济损失。目前各大云厂商短信审核的时候，也要求核验产品的防刷功能，因此今天我们就来演示下springboot如何实现相同手机号码60秒内只能发送一次短信。

这里整体的思路就是使用注解进行自动判断，如果在时间上一条短信发送后60秒不能再进行短信的发送。同时这里的60秒间隔时间我们使用redis的缓存过期策略来实现。下面具体开始演示下。

一、新建一个springboot的项目，引入maven依赖

<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<version>${lombok.version}</version>
			<scope>provided</scope>
		</dependency>
		<dependency>
			<groupId>org.bgee.log4jdbc-log4j2</groupId>
			<artifactId>log4jdbc-log4j2-jdbc4.1</artifactId>
			<version>${log4jdbc.log4j2.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-aop</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>



		<!-- 新增redis start -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-redis</artifactId>
		</dependency>
		<dependency>
			<groupId>redis.clients</groupId>
			<artifactId>jedis</artifactId>
			<version>${jedis.version}</version>
		</dependency>
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>fastjson</artifactId>
			<version>${fastjson.version}</version>
		</dependency>

二、编写一个注解，标记短信发送限制

package com.sms.demo.aop;

import java.lang.annotation.*;

/**
 * 接口防刷注解 使用： 在相应需要防刷的方法上加上 该注解，即可
 *
 * @author: zetting
 * @date:2018/12/29
 */
@Documented
@Target({ ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
public @interface SmsLimit {

	/**
	 * 限制的时间值（默认是60秒）
	 *
	 * @return
	 */
	String value() default "60";

	/**
	 * 如果出现拦截，则需要进行提示，这里默认的提示语是：需等待60秒后才能再次发送短信
	 */
	String message() default "需等待60秒后才能再次发送短信";

	/**
	 * 策略
	 *
	 * @return
	 */
	SmsLimitStrategy strategy() default SmsLimitStrategy.DEFAULT;
}

三、编写短信拦截切面，同时处理相关的逻辑

package com.sms.demo.aop;

import java.lang.reflect.Method;
import java.util.Base64;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

import com.sms.demo.exception.SmsException;
import com.sms.demo.redis.RedisUtil;

import lombok.extern.slf4j.Slf4j;

/**
 * 短信重复发送请求限制切面
 */
@Aspect
@Component
@Slf4j
public class SmsLimitAop {

	@Autowired
	private RedisUtil redisUtil;

	@Pointcut("@annotation(com.sms.demo.aop.SmsLimit)")
	public void pointcut() {
	}

	@Before("pointcut()")
	public void joinPoint(JoinPoint joinPoint) throws Exception {

		String phone = (String) joinPoint.getArgs()[0];
		log.info("当前拦截的手机号码是：{}，准备发送短信",phone);
		if (StringUtils.isEmpty(phone)) {
			return;
		}

		MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
		Method method = joinPoint.getTarget().getClass().getMethod(methodSignature.getName(),
				methodSignature.getParameterTypes());

		SmsLimit annotation = method.getAnnotation(SmsLimit.class);
		String methodFullName = method.getDeclaringClass().getName() + method.getName();

		entrance(annotation, phone, methodFullName);
		return;
	}

	private void entrance(SmsLimit limit, String phone, String methodFullName) throws Exception {
		SmsLimitStrategy strategy = limit.strategy();
		switch (strategy) {
		case DEFAULT:
			defaultHandle(phone, limit, methodFullName);
			break;
		default:
			throw new SmsException("无匹配的策略");
		}
	}

	private void defaultHandle(String phone, SmsLimit limit, String methodFullName) throws Exception {
		String base64Str = toBase64String(phone);
		long expire = Long.parseLong(limit.value());
		String resp = redisUtil.get(methodFullName + base64Str);
		if (StringUtils.isEmpty(resp)) {
			redisUtil.set(methodFullName + base64Str, phone, expire);
		} else {
			String message = !StringUtils.isEmpty(limit.message()) ? limit.message() : "短信发送频繁，请稍后重试";
			throw new SmsException(message);
		}
	}

	private String toBase64String(String obj) throws Exception {
		if (StringUtils.isEmpty(obj)) {
			return null;
		}
		Base64.Encoder encoder = Base64.getEncoder();
		byte[] bytes = obj.getBytes("UTF-8");
		return encoder.encodeToString(bytes);
	}

}

四、编写一个Controller，添加上注解

package com.sms.demo.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import com.sms.demo.aop.SmsLimit;
import com.sms.demo.model.BaseResponse;

import lombok.extern.slf4j.Slf4j;

@RestController
@Slf4j
public class SmsController {

	@RequestMapping("/sendSms")
	@SmsLimit(message = "60秒内不允许再次发送短信", value = "60")
	public BaseResponse sendSms(@RequestParam(required = true) String phone) {
		log.info("准备向手机号码：{} 发送短信", phone);
		return BaseResponse.success();
	}

}

备注：这里的注解我们可以直接使用默认的配置，也可以使用自定义的配置，这里我们自定义为60秒时间，并且给出60秒的提示：60秒内不允许再次发送短信

五、附上配置文件配置

server.port=9090

spring.redis.host=192.168.31.30
spring.redis.port=6379
spring.redis.password=3c0bef8420ca0961a74ff1fbe8c66ef4
spring.redis.timeout=1000
spring.redis.database=0
spring.redis.pool.max-active=10
spring.redis.pool.max-idle=8
spring.redis.pool.min-idle=2
spring.redis.pool.max-wait=100

六、运行测试下

1、请求地址：http://127.0.0.1:9090/sendSms?phone=1388888888