Hạn chế Request nhận được từ một IP trong khoảng thời gian nhất định

@Data
@AllArgsConstructor
@NoArgsConstructor
public class BlockSpam implements Serializable{
	Long time;          // thòi gian gần nhất gọi Request
	Integer requests;   // Số Request đã gọi trong 1s
	
}

package com.davis.config;

public class RedisConfig {
	@Bean
	public JedisConnectionFactory connectionfactory() {
		RedisStandaloneConfiguration config = new RedisStandaloneConfiguration();
		config.setHostName("localhost");
		config.setPort(6379);
		return new JedisConnectionFactory(config);
	}

	@Bean
	public RedisTemplate<String, Long> redisTemplate() {
		RedisTemplate<String, Long> templ = new RedisTemplate<>();
		templ.setConnectionFactory(connectionfactory());
		templ.setKeySerializer(new StringRedisSerializer());
		templ.setHashKeySerializer(new StringRedisSerializer());
		templ.setHashKeySerializer(new JdkSerializationRedisSerializer());
		templ.setValueSerializer(new JdkSerializationRedisSerializer());
		templ.setEnableTransactionSupport(true);
		templ.afterPropertiesSet();
		return templ;
	}
}

package com.davis.model;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class BlockSpam implements Serializable{
	Long currenTime;
	Integer countrequest;
	
	
}

package com.davis.service;

@Service
public class RateLimiterService {
	@Autowired
	private RedisTemplate redisTemplate;

	@Autowired
	public RateLimiterService(StringRedisTemplate redisTemplate) {
		this.redisTemplate = redisTemplate;
	}

	public boolean allowRequest(String ipAddress, long maxRequests, long timeIntervalInSeconds) {
		String key = "ip:" + ipAddress;
		Long currentTime = System.currentTimeMillis() / 1000;
		//Long previousRequestTime = (Long) redisTemplate.opsForValue().get(key);
		BlockSpam b = (BlockSpam) redisTemplate.opsForValue().get(key);
		// nếu chưa request trong 10p
		if (b == null) {
			BlockSpam bs = new BlockSpam(currentTime, 1);
			redisTemplate.opsForValue().set(key, bs, timeIntervalInSeconds, TimeUnit.SECONDS);
			return true;
		}
		b.setCountrequest(b.getCountrequest()+1);
		if((b.getCountrequest()) < maxRequests) {
			redisTemplate.opsForValue().set(key, b, timeIntervalInSeconds, TimeUnit.SECONDS);
			return true;
		}
		// ngượpc lại
		System.out.println("Bi chan trong "+ (currentTime - b.getCurrenTime()));
		return false;
	}
}

package com.davis.service;

@Service
public class RateLimitService {
    private final StringRedisTemplate redisTemplate;

    
    @Autowired
    public RateLimitService(StringRedisTemplate redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    public boolean isAllowed(String userId) {
        String key = "rate_limit:" + userId;
        System.out.println(userId);
        Instant now = Instant.now();

        Instant lastRequestTime = Instant.parse(redisTemplate.opsForValue().get(key) != null ?
                redisTemplate.opsForValue().get(key) : now.toString());

        // Kiểm tra xem đã đủ thời gian giữa các yêu cầu chưa
        Duration timeElapsed = Duration.between(lastRequestTime, now);
        if (timeElapsed.getSeconds() >= 60) {
            // Reset thời gian cho yêu cầu tiếp theo và cập nhật vào Redis
            redisTemplate.opsForValue().set(key, now.toString());
            return true;
        } else {
            // Chưa đủ thời gian giữa các yêu cầu
            return false;
        }
    }
}

package com.davis.service;

@Aspect
@Component
public class RedisCheckAspect {
	

	@Value("${davis.redis.ttl}")	// thời gian tồn tại của một khiên (60s)
    private Long ttl;
	
	@Value("${davis.redis.requests}")	// số reuqest được chạy trong 1 phiên khiên (10)
    private Long requests;

    @Autowired
    private RedisService redisService;
    
    // lấy ra IP của Client
    private String getClientIp(HttpServletRequest request) {
		String ipAddress = request.getHeader("X-Forwarded-For");
		if (ipAddress == null || ipAddress.isEmpty() || "unknown".equalsIgnoreCase(ipAddress)) {
			ipAddress = request.getHeader("Proxy-Client-IP");
		}
		if (ipAddress == null || ipAddress.isEmpty() || "unknown".equalsIgnoreCase(ipAddress)) {
			ipAddress = request.getHeader("WL-Proxy-Client-IP");
		}
		if (ipAddress == null || ipAddress.isEmpty() || "unknown".equalsIgnoreCase(ipAddress)) {
			ipAddress = request.getHeader("HTTP_CLIENT_IP");
		}
		if (ipAddress == null || ipAddress.isEmpty() || "unknown".equalsIgnoreCase(ipAddress)) {
			ipAddress = request.getHeader("HTTP_X_FORWARDED_FOR");
		}
		if (ipAddress == null || ipAddress.isEmpty() || "unknown".equalsIgnoreCase(ipAddress)) {
			ipAddress = request.getRemoteAddr();
			if (ipAddress.equals("0:0:0:0:0:0:0:1")) {
				// Lấy địa chỉ IPv4 cho localhost
				try {
					InetAddress inetAddress = InetAddress.getLocalHost();
					ipAddress = inetAddress.getHostAddress();
				} catch (UnknownHostException e) {
					// Xử lý lỗi nếu cần
				}
			}
		}
		return ipAddress;
	}

    @Around("@annotation(com.davis.RedisCheck)")
    public Object checkRedis(ProceedingJoinPoint joinPoint) throws Throwable {
    	
    	 // Lấy request hiện tại
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.currentRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        
        // Thực hiện kiểm tra và xử lý Redis ở đây
        // Ví dụ: Kiểm tra một key trong Redis và xử lý dựa trên kết quả
        boolean isValid = redisService.allowRequest(getClientIp(request), requests, ttl); // Thay thế bằng phương thức kiểm tra thực tế

        if (isValid) {
            // Nếu request hợp lệ, tiếp tục thực hiện method bằng cách gọi joinPoint.proceed()
            return joinPoint.proceed();
        } else {
            // Nếu không hợp lệ, có thể trả về lỗi hoặc xử lý khác
        	return ResponseEntity.status(HttpStatus.TOO_MANY_REQUESTS).body("Too many requests");
        }
    }
}

package com.davis.controller;

@RestController
public class Controller {
    @Autowired
    private RateLimiterService rateLimiterService;

    @RedisCheck // Áp dụng kiểm tra Redis trước khi xử lý method này
    @GetMapping("/my-endpoint")
    public ResponseEntity<String> myEndpoint(HttpServletRequest request) {
        String ipAddress = request.getRemoteAddr();
        // Cho phép tối đa 10 request trong 1 phút từ cùng một IP
        if (rateLimiterService.allowRequest(ipAddress, 10, 60)) {             
            // Xử lý request ở đây
            return ResponseEntity.ok("Request allowed");
        } else {
            return ResponseEntity.status(HttpStatus.TOO_MANY_REQUESTS).body("Too many requests");
        }
    }
}