Springboot中使用Redisson+AOP+自定義注解實現(xiàn)訪問限流與黑名單攔截
更新時間：2024年02月29日 09:53:09 作者：牽著貓散步的鼠鼠
本文主要介紹了Springboot中使用Redisson+AOP+自定義注解實現(xiàn)訪問限流與黑名單攔截,包含針對用戶IP限流,整個接口的訪問限流,以及對某個參數(shù)字段的限流,并且支持請求限流后處理回調(diào),感興趣的可以了解一下
前言
在開發(fā)高并發(fā)系統(tǒng)時有三把利器用來保護系統(tǒng)：緩存、降級和限流。 限流的目的是通過對并發(fā)訪問請求進行限速或者一個時間窗口內(nèi)的的請求數(shù)量進行限速來保護系統(tǒng)，一旦達到限制速率則可以拒絕服務、排隊或等待
我們上次講解了如何使用Sentinel來實現(xiàn)服務限流，今天我們來講解下如何使用Redisson+AOP+自定義注解+反射優(yōu)雅的實現(xiàn)服務限流，本文講解的限流實現(xiàn)支持針對用戶IP限流，整個接口的訪問限流，以及對某個參數(shù)字段的限流，并且支持請求限流后處理回調(diào)
1.導入Redisson
引入依賴
我們首先導入Redisson所需要的依賴，我們這里的springboot版本為2.7.12
<dependency> <groupId>org.redisson</groupId> <artifactId>redisson-spring-boot-starter</artifactId> <version>3.23.4</version> </dependency>
編寫配置
# Redisson客戶端
redis:
sdk:
config:
host: redis服務IP
port: 6379
password: redis密碼，沒有可刪掉這行
pool-size: 10
min-idle-size: 5
idle-timeout: 30000
connect-timeout: 5000
retry-attempts: 3
retry-interval: 1000
ping-interval: 60000
keep-alive: true聲明Redisson客戶端Bean
配置映射類RedisCientConfigProperties
@Data
@ConfigurationProperties(prefix = "redis.sdk.config", ignoreInvalidFields = true)
public class RedisCientConfigProperties {
/** host:ip */
private String host;
/** 端口 */
private int port;
/** 賬密 */
private String password;
/** 設置連接池的大小，默認為64 */
private int poolSize = 64;
/** 設置連接池的最小空閑連接數(shù)，默認為10 */
private int minIdleSize = 10;
/** 設置連接的最大空閑時間（單位：毫秒），超過該時間的空閑連接將被關閉，默認為10000 */
private int idleTimeout = 10000;
/** 設置連接超時時間（單位：毫秒），默認為10000 */
private int connectTimeout = 10000;
/** 設置連接重試次數(shù)，默認為3 */
private int retryAttempts = 3;
/** 設置連接重試的間隔時間（單位：毫秒），默認為1000 */
private int retryInterval = 1000;
/** 設置定期檢查連接是否可用的時間間隔（單位：毫秒），默認為0，表示不進行定期檢查 */
private int pingInterval = 0;
/** 設置是否保持長連接，默認為true */
private boolean keepAlive = true;
}Configuration
@EnableConfigurationProperties(RedisCientConfigProperties.class)
public class RedisClientConfig {
@Bean("redissonClient")
public RedissonClient redissonClient(ConfigurableApplicationContext applicationContext, RedisCientConfigProperties properties) {
Config config = new Config();
// 根據(jù)需要可以設定編解碼器；https://github.com/redisson/redisson/wiki/4.-%E6%95%B0%E6%8D%AE%E5%BA%8F%E5%88%97%E5%8C%96
// config.setCodec(new RedisCodec());
config.useSingleServer()
.setAddress("redis://" + properties.getHost() + ":" + properties.getPort())
.setPassword(properties.getPassword())
.setConnectionPoolSize(properties.getPoolSize())
.setConnectionMinimumIdleSize(properties.getMinIdleSize())
.setIdleConnectionTimeout(properties.getIdleTimeout())
.setConnectTimeout(properties.getConnectTimeout())
.setRetryAttempts(properties.getRetryAttempts())
.setRetryInterval(properties.getRetryInterval())
.setPingConnectionInterval(properties.getPingInterval())
.setKeepAlive(properties.isKeepAlive())
;
RedissonClient redissonClient = Redisson.create(config);
// 注冊消息發(fā)布訂閱主題Topic
// 找到所有實現(xiàn)了Redisson中MessageListener接口的bean名字
String[] beanNamesForType = applicationContext.getBeanNamesForType(MessageListener.class);
for (String beanName : beanNamesForType) {
// 通過bean名字獲取到監(jiān)聽bean
MessageListener bean = applicationContext.getBean(beanName, MessageListener.class);
Class<? extends MessageListener> beanClass = bean.getClass();
// 如果bean的注解里包含我們的自定義注解RedisTopic.class，則以RedisTopic注解的值作為name將該bean注冊到bean工廠，方便在別處注入
if (beanClass.isAnnotationPresent(RedisTopic.class)) {
RedisTopic redisTopic = beanClass.getAnnotation(RedisTopic.class);
RTopic topic = redissonClient.getTopic(redisTopic.topic());
topic.addListener(String.class, bean);
ConfigurableListableBeanFactory beanFactory = applicationContext.getBeanFactory();
beanFactory.registerSingleton(redisTopic.topic(), topic);
}
}
return redissonClient;
}
static class RedisCodec extends BaseCodec {
private final Encoder encoder = in -> {
ByteBuf out = ByteBufAllocator.DEFAULT.buffer();
try {
ByteBufOutputStream os = new ByteBufOutputStream(out);
JSON.writeJSONString(os, in, SerializerFeature.WriteClassName);
return os.buffer();
} catch (IOException e) {
out.release();
throw e;
} catch (Exception e) {
out.release();
throw new IOException(e);
}
};
private final Decoder<Object> decoder = (buf, state) -> JSON.parseObject(new ByteBufInputStream(buf), Object.class);
@Override
public Decoder<Object> getValueDecoder() {
return decoder;
}
@Override
public Encoder getValueEncoder() {
return encoder;
}
}
}2.自定義注解
我們這里自定義一個注解來作為后續(xù)AOP切面編程的切點
根據(jù)注解Key屬性的值，我們會有如下情況
all：針對整個接口限流
request_ip：針對各個用戶的訪問IP限流
其他str：根據(jù)參數(shù)作為標識符限流，比如我這里key=userid，那么我會根據(jù)參數(shù)中的userid來限流
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})
public @interface AccessInterceptor {
/** 用哪個字段作為攔截標識符，配置all則是對整個接口限流，配置request_ip，
* 則是對訪問ip限流，配置其他str，則會到參數(shù)中尋找對應名稱的屬性值（包括對象內(nèi)部屬性） */
String key() default "all";
/** 限制頻次（每秒請求次數(shù)） */
long permitsPerSecond();
/** 黑名單攔截（多少次限制后加入黑名單）0 不限制 */
double blacklistCount() default 0;
/** 攔截后的執(zhí)行方法 */
String fallbackMethod();
}3.AOP切面編程
導入依賴
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency>
編寫AOP限流代碼
我們doRouter切面函數(shù)以AccessInterceptor注解為切點，根據(jù)注解的各類配置來執(zhí)行整個限流過程。
我們通過使用Redisson的RRateLimiter限流器，基于令牌桶實現(xiàn)訪問限流，并對已經(jīng)限流的訪問記錄黑名單次數(shù)，超過設置的黑名單閾值就會被加入黑名單中，較長時間無法訪問
代碼較長，為了縮短篇幅就一次性放上來了，各處已經(jīng)打上了詳細注解，若有疑問可評論區(qū)留言。
@Slf4j
@Aspect
public class RateLimiterAOP {
// 注入我們聲明的redisson客戶端
@Resource
private RedissonClient redissonClient;
// 限流RateLimiter緩存前綴
private static final String rateLimiterName = "test:RateLimiter:";
// 黑名單原子計數(shù)器緩存前綴
private static final String blacklistPrefix = "test:RateBlockList:";
@Around("@annotation(accessInterceptor)")
public Object doRouter(ProceedingJoinPoint jp, AccessInterceptor accessInterceptor) throws Throwable {
// 獲取注解配置的字段key
String key = accessInterceptor.key();
if (StringUtils.isBlank(key)) {
log.error("限流RateLimiter注解中的 Key 屬性為空！");
throw new RuntimeException("RateLimiter注解中的 Key 屬性為空！");
}
log.info("限流攔截關鍵字為 {}", key);
// 根據(jù)key獲取攔截標識符字段
String keyAttr = getAttrValue(key, jp.getArgs());
// 黑名單攔截，非法訪問次數(shù)超過黑名單閾值
if (!"all".equals(keyAttr) && accessInterceptor.blacklistCount() != 0 && redissonClient.getAtomicLong(blacklistPrefix + keyAttr).get() > accessInterceptor.blacklistCount()) {
log.info("限流-黑名單攔截：{}", keyAttr);
return fallbackMethodResult(jp, accessInterceptor.fallbackMethod());
}
// 獲取限流器 -> Redisson RRateLimiter
RRateLimiter rateLimiter = redissonClient.getRateLimiter(rateLimiterName + keyAttr);
if (!rateLimiter.isExists()) {
// 創(chuàng)建令牌桶數(shù)據(jù)模型，單位時間內(nèi)產(chǎn)生多少令牌
rateLimiter.trySetRate(RateType.PER_CLIENT,1, accessInterceptor.permitsPerSecond(), RateIntervalUnit.MINUTES);
}
// 限流判斷,沒有獲取到令牌，超出頻率
if (!rateLimiter.tryAcquire()) {
// 如果開啟了黑名單限制，那么就記錄當前的非法訪問次數(shù)
if (accessInterceptor.blacklistCount() != 0) {
RAtomicLong atomicLong = redissonClient.getAtomicLong(blacklistPrefix + keyAttr);
atomicLong.incrementAndGet(); // 原子自增
atomicLong.expire(24, TimeUnit.HOURS); // 刷新黑名單原子計數(shù)器器過期時間為24小時
}
log.info("限流-頻率過高攔截：{}", keyAttr);
return fallbackMethodResult(jp, accessInterceptor.fallbackMethod());
}
// 返回結果
return jp.proceed();
}
/**
* 調(diào)用用戶配置的回調(diào)方法，使用反射機制實現(xiàn)。
*/
private Object fallbackMethodResult(JoinPoint jp, String fallbackMethod) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
// 通過JoinPoint對象獲取方法的簽名（Signature）
Signature sig = jp.getSignature();
// 將方法簽名轉(zhuǎn)換為MethodSignature對象，以便獲取方法的詳細信息
MethodSignature methodSignature = (MethodSignature) sig;
// 獲取到具體的方法對象,通過方法名和參數(shù)（所以回調(diào)函數(shù)參數(shù)一定要和原方法一致）
Method method = jp.getTarget().getClass().getMethod(fallbackMethod, methodSignature.getParameterTypes());
// 調(diào)用目標對象的方法，并傳入當前對象（jp.getThis()）和方法的參數(shù)（jp.getArgs()）。
return method.invoke(jp.getThis(), jp.getArgs());
}
/**
* 根據(jù)JoinPoint對象獲取其所代表的方法對象
*/
private Method getMethod(JoinPoint jp) throws NoSuchMethodException {
Signature sig = jp.getSignature();
MethodSignature methodSignature = (MethodSignature) sig;
return jp.getTarget().getClass().getMethod(methodSignature.getName(), methodSignature.getParameterTypes());
}
/**
* 實際根據(jù)自身業(yè)務調(diào)整，主要是為了獲取通過某個值做攔截
*/
public String getAttrValue(String attr, Object[] args) {
String filedValue = null;
for (Object arg : args) {
try {
// 找到HttpServletRequest對象來獲取請求IP地址（如果是根據(jù)IP攔截的話）
if ("request_ip".equals(attr) && arg instanceof HttpServletRequest) {
HttpServletRequest request = (HttpServletRequest) arg;
filedValue = IPUtils.getIpAddr(request);
}
// 找到了值，返回
if (StringUtils.isNotBlank(filedValue)) {
break;
}
// fix: 使用lombok時，uId這種字段的get方法與idea生成的get方法不同，會導致獲取不到屬性值，改成反射獲取解決
filedValue = String.valueOf(this.getValueByName(arg, attr));
} catch (Exception e) {
log.error("獲取路由屬性值失敗 attr：{}", attr, e);
}
}
return filedValue;
}
/**
* 獲取對象的特定屬性值（反射）
*
* @param item 對象
* @param name 屬性名
* @return 屬性值
* @author tang
*/
private Object getValueByName(Object item, String name) {
try {
// 獲取指定對象中對應屬性名的Field對象
Field field = getFieldByName(item, name);
// 獲取到的Field對象為null，表示屬性不存在，直接返回null。
if (field == null) {
return null;
}
// 將Field對象設置為可訪問，以便獲取私有屬性的值。
field.setAccessible(true);
// 獲取屬性值，并將其賦值給變量o。
Object o = field.get(item);
// 將Field對象設置為不可訪問，以保持對象的封裝性。
field.setAccessible(false);
return o;
} catch (IllegalAccessException e) {
return null;
}
}
/**
* 根據(jù)名稱獲取方法，該方法同時兼顧繼承類獲取父類的屬性
*
* @param item 對象
* @param name 屬性名
* @return 該屬性對應方法
* @author tang
*/
private Field getFieldByName(Object item, String name) {
try {
Field field;
try {
// 獲取指定對象中對應屬性名的Field對象。
field = item.getClass().getDeclaredField(name);
} catch (NoSuchFieldException e) {
// 沒有找到，拋出NoSuchFieldException異常，嘗試獲取父類中對應屬性名的Field對象
field = item.getClass().getSuperclass().getDeclaredField(name);
}
return field;
} catch (NoSuchFieldException e) {
// 父類也沒找到對應屬性名的Field對象，寄，返回null
return null;
}
}
}以上代碼用到了自己寫的一個工具類IPUtils來獲取請求的IP地址，內(nèi)容如下
public class IPUtils {
private static Logger logger = LoggerFactory.getLogger(IPUtils.class);
private static final String IP_UTILS_FLAG = ",";
private static final String UNKNOWN = "unknown";
private static final String LOCALHOST_IP = "0:0:0:0:0:0:0:1";
private static final String LOCALHOST_IP1 = "127.0.0.1";
/**
* 獲取IP地址
* <p>
* 使用Nginx等反向代理軟件， 則不能通過request.getRemoteAddr()獲取IP地址
* 如果使用了多級反向代理的話，X-Forwarded-For的值并不止一個，而是一串IP地址，X-Forwarded-For中第一個非unknown的有效IP字符串，則為真實IP地址
*/
public static String getIpAddr(HttpServletRequest request) {
String ip = null;
try {
//以下兩個獲取在k8s中，將真實的客戶端IP，放到了x-Original-Forwarded-For。而將WAF的回源地址放到了 x-Forwarded-For了。
ip = request.getHeader("X-Original-Forwarded-For");
if (StringUtils.isEmpty(ip) || UNKNOWN.equalsIgnoreCase(ip)) {
ip = request.getHeader("X-Forwarded-For");
}
//獲取nginx等代理的ip
if (StringUtils.isEmpty(ip) || UNKNOWN.equalsIgnoreCase(ip)) {
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");
}
//兼容k8s集群獲取ip
if (StringUtils.isEmpty(ip) || UNKNOWN.equalsIgnoreCase(ip)) {
ip = request.getRemoteAddr();
if (LOCALHOST_IP1.equalsIgnoreCase(ip) || LOCALHOST_IP.equalsIgnoreCase(ip)) {
//根據(jù)網(wǎng)卡取本機配置的IP
InetAddress iNet = null;
try {
iNet = InetAddress.getLocalHost();
} catch (UnknownHostException e) {
logger.error("getClientIp error: {}", e);
}
ip = iNet.getHostAddress();
}
}
} catch (Exception e) {
logger.error("IPUtils ERROR ", e);
}
//使用代理，則獲取第一個IP地址
if (!StringUtils.isEmpty(ip) && ip.indexOf(IP_UTILS_FLAG) > 0) {
ip = ip.substring(0, ip.indexOf(IP_UTILS_FLAG));
}
return ip;
}
}4.接口使用自定義注解實現(xiàn)限流
使用自定義限流注解
比如我在用戶controller層的登錄接口上使用注解，key為request_ip，表示根據(jù)用戶IP限流，回調(diào)函數(shù)為fallbackMethod，每分鐘訪問限制10次
@PostMapping(value = "/login")
@AccessInterceptor(key = "request_ip", fallbackMethod = "loginErr", permitsPerSecond = 1L, blacklistCount = 10)
public Response<String> doLogin(@RequestParam String code, HttpServletRequest request){綁定限流回調(diào)函數(shù)
這里需要注意的是，回調(diào)函數(shù)的參數(shù)必須和你使用限流注解的方法參數(shù)一致，否則報對應方法找不到的錯誤（因為這里是通過反射機制找到回調(diào)函數(shù)執(zhí)行的）
public Response<String> loginErr(String code, HttpServletRequest request) {
System.out.println("限流觸發(fā)回調(diào)，參數(shù)信息:" + code);
return Response.<String>builder()
.code(Constants.ResponseCode.FREQUENCY_LIMITED.getCode())
.info(Constants.ResponseCode.FREQUENCY_LIMITED.getInfo())
.data(code)
.build();
}總結
以上通過Redission+自定義注解+AOP+反射實現(xiàn)了對不同標識符的限流和黑名單攔截，并且可以綁定限流回調(diào)函數(shù)來處理限流后的邏輯，代碼篇幅較長，各位小伙伴也可以嘗試繼續(xù)優(yōu)化一下這里的設計，減少request_ip這種魔法值(實在懶得改了)，更多相關Springboot 訪問限流與黑名單攔截內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！
相關文章
這篇文章主要為大家詳細介紹了java實現(xiàn)掃雷游戲，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2020-04-04
MyBatis解決Update動態(tài)SQL逗號的問題
這篇文章主要介紹了MyBatis解決Update動態(tài)SQL逗號的問題，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2022-01-01
Spring Boot 2.7.6整合redis與低版本的區(qū)別
這篇文章主要介紹了Spring Boot 2.7.6整合redis與低版本的區(qū)別,文中補充介紹了SpringBoot各個版本使用Redis之間的區(qū)別實例講解，需要的朋友可以參考下2023-02-02
dm.jdbc.driver.DMException網(wǎng)絡通信異常的解決過程
最近一個項目里面出現(xiàn)了一個比較詭異的問題,給大家分享下,這篇文章主要給大家介紹了關于dm.jdbc.driver.DMException網(wǎng)絡通信異常的解決過程,需要的朋友可以參考下2023-02-02
SpringBoot通過@Value實現(xiàn)給靜態(tài)變量注入值詳解
這篇文章主要介紹了springboot如何通過@Value給靜態(tài)變量注入值，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2022-07-07
Spring Boot實戰(zhàn)之靜態(tài)資源處理
這篇文章主要介紹了Spring Boot實戰(zhàn)之靜態(tài)資源處理，小編覺得挺不錯的，現(xiàn)在分享給大家，也給大家做個參考。一起跟隨小編過來看看吧2018-01-01
本文主要介紹了SpringCache緩存自定義配置的實現(xiàn)，文中通過示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2022-01-01
SpringCloudAlibaba是一款優(yōu)秀的微服務架構,在市面上有著廣泛的應用,這篇文章介紹了SpringCloudAlibaba的一些基本使用,適合初學者,希望能夠給大家?guī)韼椭?/div> 2024-08-08
圖像處理是各類應用程序的重要組成部分,Java作為一種多功能且強大的編程語言,提供了豐富的庫和框架來高效地處理圖像處理任務,本文將帶您了解Java圖像處理的基本概念、工具以及實踐示例,幫助您掌握Java圖像處理技術,需要的朋友可以參考下2024-09-09
解決java-jar報錯：xxx.jar 中沒有主清單屬性的方法
在使用 java -jar xxx.jar 命令運行 Java 應用程序時,遇到了以下錯誤：xxx.jar 中沒有主清單屬性,這個錯誤表示 JAR 文件缺少必要的啟動信息,本文將介紹該錯誤的原因以及如何通過修改 pom.xml 文件來解決,需要的朋友可以參考下2024-11-11最新評論