以下是Spring Boot
整合Spring Cloud Alibaba Gateway并
使用Redis进行
缓存的步骤：
1. 创建Spring Boot工程，添加依赖
在pom.xml文件中添加以下依赖：
```
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-gateway</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-
redis</artifactId>
</dependency>
```
2. 配置
Redis
在application.properties文件中添加以下配置：
```
spring.
redis.host=127.0.0.1
spring.
redis.port=6379
```
3. 配置Gateway
在application.yml文件中添加以下配置：
```
spring:
cloud:
gateway:
routes:
- id: test_route
uri: http://localhost:8080
predicates:
- Path=/test/**
filters:
- name: RequestRateLimiter
args:
key-resolver: "#{@userKeyResolver}"
redis-rate-limiter.replenishRate: 1
redis-rate-limiter.burstCapacity: 2
user:
rate-limiter:
redis:
prefix: "rate-limiter"
remaining-key: "remaining"
reset-key: "reset"
```
其中：
- id：路由ID
- uri：目标服务的URL
- predicates：路由断言，此处表示只有访问/test/**的请求才会被路由到目标服务
- filters：路由过滤器，此处
使用了RequestRateLimiter过滤器，用于限流
4. 编写
Redis限流过滤器
在工程中创建一个
RedisRatelimiterFilter类，实现GatewayFilter和Ordered接口，并重写filter方法。
```
@Component
public class
RedisRatelimiterFilter implements GatewayFilter, Ordered {
private final
RedisTemplate<String, String>
redisTemplate;
private final String
RedisTemplate string
RedisTemplate;
private final ObjectMapper objectMapper;
public
RedisRatelimiterFilter(
RedisTemplate<String, String>
redisTemplate,
String
RedisTemplate string
RedisTemplate,
ObjectMapper objectMapper) {
this.
redisTemplate =
redisTemplate;
this.string
RedisTemplate = string
RedisTemplate;
this.objectMapper = objectMapper;
}
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
String key = "rate-limiter:" + exchange.getRequest().getPath().value();
String remainingKey = key + ":remaining";
String resetKey = key + ":reset";
return
redisTemplate.execute(script, Collections.singletonList(remainingKey), "1", "2")
.flatMap(result -> {
String json = objectMapper.writeValueAsString(result);
Map<String, Object> map = objectMapper.readValue(json, Map.class);
int remaining = (int) map.get("remaining");
long reset = (long) map.get("reset");
exchange.getResponse().getHeaders().add("X-RateLimit-Remaining", String.valueOf(remaining));
exchange.getResponse().getHeaders().add("X-RateLimit-Reset", String.valueOf(reset));
if (remaining < 0) {
exchange.getResponse().setStatusCode(HttpStatus.TOO_MANY_REQUESTS);
return exchange.getResponse().setComplete();
}
return string
RedisTemplate.opsForValue().increment(remainingKey)
.flatMap(result2 -> {
if (result2.equals(1L)) {
string
RedisTemplate.expire(resetKey, Duration.ofMinutes(1));
}
return chain.filter(exchange);
});
});
}
private static final
RedisScript<List<Long>> script =
RedisScript.of(
"local key = KEYS[1]\n" +
"local now = tonumber(ARGV[1])\n" +
"local rate = tonumber(ARGV[2])\n" +
"local capacity = tonumber(ARGV[3])\n" +
"local remaining =
redis.call('get', key)\n" +
"if remaining then\n" +
" remaining = tonumber(remaining)\n" +
"else\n" +
" remaining = capacity\n" +
"end\n" +
"if remaining == 0 then\n" +
" return {0, 0}\n" +
"else\n" +
" local reset\n" +
" if remaining == capacity then\n" +
" reset = now + 60\n" +
"
redis.call('set', key..\":reset\", reset)\n" +
" else\n" +
" reset = tonumber(
redis.call('get', key..\":reset\"))\n" +
" end\n" +
" local ttl = reset - now\n" +
" local ratePerMillis = rate / 1000\n" +
" local permits = math.min(remaining, ratePerMillis * ttl)\n" +
"
redis.call('set', key, remaining - permits)\n" +
" return {permits, reset}\n" +
"end\n",
ReturnType.MULTI,
Collections.singletonList("remaining")
);
@Override
public int getOrder() {
return -1;
}
}
```
5. 编写KeyResolver
在工程中创建一个UserKeyResolver类，实现KeyResolver接口，并重写resolve方法。
```
@Component
public class UserKeyResolver implements KeyResolver {
@Override
public Mono<String> resolve(ServerWebExchange exchange) {
String userId = exchange.getRequest().getQueryParams().getFirst("userId");
return Mono.justOrEmpty(userId);
}
}
```
6. 测试
启动工程，访问http://localhost:8080/test，可以看到返回结果为“Hello, world!”；再次访问http://localhost:8080/test，可以看到返回结果为“Too Many Requests”。
以上就是Spring Boot
整合Spring Cloud Alibaba Gateway并
使用Redis进行
缓存的步骤。
本文介绍了SpringBoot中缓存的使用，包括接口、注解和key/value策略，详细解析了如何启用缓存、整合Redis以及缓存运行流程。通过引入Redis启动器、配置Redis信息，并自定义序列化器，实现数据以JSON格式存储。同时，文章探讨了缓存原理，如自动配置的CacheManager和默认的SimpleCacheConfiguration。
最低0.47元/天 解锁文章
1672
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
