spring.redis.host=localhost
spring.redis.port=6379

public class Article {
    private String id;
    private String title;
    private int likeCount;
    // 省略構(gòu)造函數(shù)、getter和setter方法
}

@Service
public class ArticleService {

    @Autowired
    private StringRedisTemplate redisTemplate;

    public void likeArticle(String articleId) {
        // 增加文章的點(diǎn)贊數(shù)
        redisTemplate.opsForValue().increment(articleId, 1);
    }

    public List<Article> getTopLikedArticles(int topN) {
        // 獲取topN個(gè)點(diǎn)贊數(shù)最多的文章
        Set<String> articleIds = redisTemplate.keys("article:*:likeCount");
        List<Article> topArticles = new ArrayList<>();
        for (String id : articleIds) {
            int likeCount = (Integer) redisTemplate.opsForValue().get(id);
            Article article = new Article();
            article.setId(id.replace("article:", "").replace(":likeCount", ""));
            article.setTitle("文章標(biāo)題待查詢");
            article.setLikeCount(likeCount);
            topArticles.add(article);
        }
        // 根據(jù)點(diǎn)贊數(shù)排序
        topArticles.sort((a1, a2) -> a2.getLikeCount() - a1.getLikeCount());
        return topArticles.subList(0, topN);
    }
}

@RestController
@RequestMapping("/articles")
public class ArticleController {

    @Autowired
    private ArticleService articleService;

    @PostMapping("/{id}/like")
    public ResponseEntity<String> likeArticle(@PathVariable String id) {
        articleService.likeArticle(id);
        return ResponseEntity.ok("點(diǎn)贊成功");
    }

    @GetMapping("/top/{topN}")
    public ResponseEntity<List<Article>> getTopLikedArticles(@PathVariable int topN) {
        List<Article> topArticles = articleService.getTopLikedArticles(topN);
        return ResponseEntity.ok(topArticles);
    }
}

spring.redis.host=localhost
spring.redis.port=6379

@Service
public class OnlineDurationService {

    @Autowired
    private StringRedisTemplate redisTemplate;

    public void updateUserOnlineDuration(String userId, long duration) {
        // 使用Sorted Set存儲(chǔ)用戶ID和在線時(shí)長(zhǎng)
        redisTemplate.opsForZSet().incrementScore("user:online:duration", userId, duration);
    }

    public Set<String> getTopUsersByOnlineDuration(int topN) {
        // 獲取在線時(shí)長(zhǎng)最長(zhǎng)的前N個(gè)用戶
        Set<String> topUsers = redisTemplate.opsForZSet().reverseRange("user:online:duration", 0, topN - 1);
        return topUsers;
    }
}

@Controller
public class UserController {

    @Autowired
    private OnlineDurationService onlineDurationService;

    @PostMapping("/user/{userId}/login")
    public ResponseEntity<String> userLogin(@PathVariable String userId) {
        // 用戶登錄邏輯，可以是任何觸發(fā)登錄的事件
        return ResponseEntity.ok("User " + userId + " logged in");
    }

    @PostMapping("/user/{userId}/logout")
    public ResponseEntity<String> userLogout(@PathVariable String userId) {
        // 用戶登出時(shí)記錄在線時(shí)長(zhǎng)
        long duration = // 計(jì)算用戶在線時(shí)長(zhǎng)的邏輯
        onlineDurationService.updateUserOnlineDuration(userId, duration);
        return ResponseEntity.ok("User " + userId + " logged out");
    }
}

@RestController
@RequestMapping("/users")
public class UserRankController {

    @Autowired
    private OnlineDurationService onlineDurationService;

    @GetMapping("/online-duration/top/{topN}")
    public ResponseEntity<Set<String>> getTopUsersByOnlineDuration(@PathVariable int topN) {
        Set<String> topUsers = onlineDurationService.getTopUsersByOnlineDuration(topN);
        return ResponseEntity.ok(topUsers);
    }
}

# application.properties
redisson.address=redis://localhost:6379

# application.yml
redisson:
  address: "redis://localhost:6379"

@Configuration
public class RedissonConfig {

    @Bean(destroyMethod = "shutdown")
    public RedissonClient redissonClient() {
        RedissonClientConfig config = new RedissonClientConfig();
        config.useSingleServer().setAddress(redisson.address);
        return Redisson.create(config);
    }

    @Value("${redisson.address}")
    private String redissonAddress;
}

@Service
public class ReportService {

    @Autowired
    private RedissonClient redissonClient;

    public void generateDailyReport() {
        RLock lock = redissonClient.getLock("dailyReportLock");
        try {
            // 嘗試獲取鎖，最多等待3秒，鎖的自動(dòng)過期時(shí)間設(shè)置為10秒
            if (lock.tryLock(3, 10, TimeUnit.SECONDS)) {
                // 執(zhí)行生成日?qǐng)?bào)表的操作
                System.out.println("Generating daily report...");
                // 模擬長(zhǎng)時(shí)間運(yùn)行的任務(wù)
                TimeUnit.SECONDS.sleep(5);
                System.out.println("Daily report generated.");
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            // 釋放鎖
            lock.unlock();
        }
    }
}

@RestController
@RequestMapping("/reports")
public class ReportController {

    @Autowired
    private ReportService reportService;

    @GetMapping("/daily")
    public ResponseEntity<String> generateDailyReport() {
        reportService.generateDailyReport();
        return ResponseEntity.ok("Daily report generation triggered.");
    }
}

spring.redis.host=localhost
spring.redis.port=6379

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RateLimit {
    int limit() default 10; // 默認(rèn)每分鐘請(qǐng)求次數(shù)限制
    long timeout() default 60; // 默認(rèn)時(shí)間窗口為60秒
}

public class RateLimiterInterceptor implements HandlerInterceptor {

    private final RedisTemplate<String, Integer> redisTemplate;
    private final String rateLimitKeyPrefix = "rate_limit:";

    public RateLimiterInterceptor(RedisTemplate<String, Integer> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String ip = request.getRemoteAddr();
        String methodName = ((MethodSignature) (handler)).getMethod().getName();
        String rateLimitKey = rateLimitKeyPrefix + methodName + ":" + ip;

        int currentCount = redisTemplate.opsForValue().increment(rateLimitKey);
        if (currentCount > 1) {
            // 如果當(dāng)前計(jì)數(shù)大于1，則說明請(qǐng)求已超過限制
            response.sendError(HttpServletResponse.SC_TOO_MANY_REQUESTS, "Too many requests, please try again later.");
            return false;
        }

        // 設(shè)置過期時(shí)間
        redisTemplate.expire(rateLimitKey, RateLimit.class.cast(((MethodSignature) handler).getMethod().getAnnotation(RateLimit.class)).timeout(), TimeUnit.SECONDS);
        return true;
    }
}

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Autowired
    private RateLimiterInterceptor rateLimiterInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(rateLimiterInterceptor);
    }
}

@RestController
public class ApiController {

    @RateLimit(limit = 5, timeout = 60) // 每分鐘最多5個(gè)請(qǐng)求
    @GetMapping("/api/resource")
    public ResponseEntity<String> getLimitedResource() {
        return ResponseEntity.ok("Access to limited resource");
    }
}

spring.redis.host=localhost
spring.redis.port=6379

@Service
public class NewsService {

    // 假設(shè)有一個(gè)方法來獲取新聞列表
    public List<Article> getNewsList() {
        // 這里是獲取新聞列表的邏輯
        return Collections.emptyList();
    }
}

@Configuration
@EnableCaching
public class CacheConfig {

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory connectionFactory) {
        RedisCacheManager cacheManager = new RedisCacheManager(connectionFactory);
        // 設(shè)置緩存過期時(shí)間（例如5分鐘）
        cacheManager.setDefaultExpiration(300);
        return cacheManager;
    }
}

@Controller
public class NewsController {

    @Autowired
    private NewsService newsService;

    @Autowired
    private CacheManager cacheManager;

    @GetMapping("/")
    @Cacheable(value = "homePage", condition = "#root.caches[0].name == 'homePage'")
    public String homePage(Model model) {
        // 嘗試從緩存中獲取頁(yè)面
        model.addAttribute("newsList", newsService.getNewsList());
        return "home";
    }
}

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>首頁(yè)</title>
</head>
<body>
    <h1>新聞首頁(yè)</h1>
    <div th:each="article : ${newsList}">
        <h2 th:text="${article.title}"></h2>
        <p th:text="${article.summary}"></p>
    </div>
</body>
</html>

spring.redis.host=localhost
spring.redis.port=6379

public class User {
    private String id;
    private String name;
    // 省略構(gòu)造函數(shù)、getter和setter方法
}

public class StatusUpdate {
    private String userId;
    private String content;
    private Instant timestamp;
    // 省略構(gòu)造函數(shù)、getter和setter方法
}

@Service
public class SocialService {

    @Autowired
    private StringRedisTemplate redisTemplate;

    public void addFriend(String userOneId, String userTwoId) {
        // 使用集合存儲(chǔ)用戶的好友列表
        redisTemplate.opsForSet().add("friends:" + userOneId, userTwoId);
        redisTemplate.opsForSet().add("friends:" + userTwoId, userOneId);
    }

    public Set<String> getFriends(String userId) {
        // 獲取用戶的好友列表
        return redisTemplate.opsForSet().members("friends:" + userId);
    }

    public void postStatusUpdate(String userId, String content) {
        // 使用列表存儲(chǔ)用戶的狀態(tài)更新時(shí)間線
        StatusUpdate statusUpdate = new StatusUpdate(userId, content, Instant.now());
        redisTemplate.opsForList().rightPush("timeline:" + userId, statusUpdate);
    }

    public List<StatusUpdate> getStatusUpdates(String userId) {
        // 獲取用戶的狀態(tài)更新時(shí)間線
        return redisTemplate.opsForList().range("timeline:" + userId, 0, -1);
    }
}

@RestController
@RequestMapping("/social")
public class SocialController {

    @Autowired
    private SocialService socialService;

    @PostMapping("/addFriend")
    public ResponseEntity<String> addFriend(@RequestParam String userOneId, @RequestParam String userTwoId) {
        socialService.addFriend(userOneId, userTwoId);
        return ResponseEntity.ok("Friends added successfully");
    }

    @GetMapping("/friends/{userId}")
    public ResponseEntity<Set<String>> getFriends(@PathVariable String userId) {
        Set<String> friends = socialService.getFriends(userId);
        return ResponseEntity.ok(friends);
    }

    @PostMapping("/status")
    public ResponseEntity<String> postStatusUpdate(@RequestParam String userId, @RequestParam String content) {
        socialService.postStatusUpdate(userId, content);
        return ResponseEntity.ok("Status updated successfully");
    }

    @GetMapping("/timeline/{userId}")
    public ResponseEntity<List<StatusUpdate>> getStatusUpdates(@PathVariable String userId) {
        List<StatusUpdate> updates = socialService.getStatusUpdates(userId);
        return ResponseEntity.ok(updates);
    }
}

spring.redis.host=localhost
spring.redis.port=6379

public class Product {
    private String id;
    private String name;
    // 省略構(gòu)造函數(shù)、getter和setter方法
}

public class User {
    private String id;
    private String username;
    // 省略構(gòu)造函數(shù)、getter和setter方法
}

@Service
public class RecommendationService {

    @Autowired
    private StringRedisTemplate redisTemplate;

    public void recordView(String userId, String productId) {
        // 記錄用戶查看的商品
        redisTemplate.opsForList().leftPush("user:" + userId + ":views", productId);
    }

    public List<String> recommendProducts(String userId) {
        // 簡(jiǎn)單推薦算法：返回用戶查看次數(shù)最多的商品
        Set<String> viewedProducts = redisTemplate.opsForSet().members("user:" + userId + ":views");
        Map<String, Long> productViewCounts = new HashMap<>();
        viewedProducts.forEach(productId -> {
            long count = redisTemplate.opsForValue().decrement("user:" + userId + ":views:" + productId);
            productViewCounts.put(productId, count);
        });

        return productViewCounts.entrySet().stream()
                .sorted(Map.Entry.<String, Long>comparingByValue().reversed())
                .map(Map.Entry::getKey)
                .collect(Collectors.toList());
    }
}

@RestController
@RequestMapping("/recommendations")
public class RecommendationController {

    @Autowired
    private RecommendationService recommendationService;

    @PostMapping("/view")
    public ResponseEntity<String> recordProductView(@RequestParam String userId, @RequestParam String productId) {
        recommendationService.recordView(userId, productId);
        return ResponseEntity.ok("View recorded");
    }

    @GetMapping("/products")
    public ResponseEntity<List<String>> getRecommendations(@RequestParam String userId) {
        List<String> recommendedProducts = recommendationService.recommendProducts(userId);
        return ResponseEntity.ok(recommendedProducts);
    }
}

spring.redis.host=localhost
spring.redis.port=6379

public class User {
    private String id;
    private String name;
    private double longitude;
    private double latitude;
    // 省略構(gòu)造函數(shù)、getter和setter方法
}

@Service
public class GeoLocationService {

    @Autowired
    private RedisTemplate<String, User> redisTemplate;

    public void addLocation(String userId, double longitude, double latitude) {
        User user = new User(userId, "username", longitude, latitude);
        // 使用Geospatial索引存儲(chǔ)用戶位置
        redisTemplate.opsForGeo().add("userLocations", new GeoLocation(user.getLongitude(), user.getLatitude()), userId);
    }

    public List<User> getUsersNearby(double longitude, double latitude, double radius) {
        // 查詢給定位置附近的用戶
        List<GeoWithin> nearbyUsersGeo = redisTemplate.opsForGeo().radius("userLocations",
                new Circle(new GeoCoordinate(latitude, longitude), radius),
                RedisGeoCommands.GeoRadiusCommandArgs.newGeoRadiusArgs());
        
        List<User> nearbyUsers = new ArrayList<>();
        for (GeoWithin geoWithin : nearbyUsersGeo) {
            nearbyUsers.add(redisTemplate.opsForValue().get(geoWithin.getMember()));
        }
        return nearbyUsers;
    }
}

@RestController
@RequestMapping("/users")
public class UserController {

    @Autowired
    private GeoLocationService geoLocationService;

    @PostMapping("/addLocation")
    public ResponseEntity<String> addLocation(@RequestParam String userId,
                                               @RequestParam double longitude,
                                               @RequestParam double latitude) {
        geoLocationService.addLocation(userId, longitude, latitude);
        return ResponseEntity.ok("User location added");
    }

    @GetMapping("/nearby")
    public ResponseEntity<List<User>> getUsersNearby(@RequestParam double longitude,
                                                      @RequestParam double latitude,
                                                      @RequestParam double radius) {
        List<User> nearbyUsers = geoLocationService.getUsersNearby(longitude, latitude, radius);
        return ResponseEntity.ok(nearbyUsers);
    }
}

spring.redis.host=localhost
spring.redis.port=6379

public class CpuUsageData {
    private Instant timestamp;
    private double cpuUsage;

    // 省略構(gòu)造函數(shù)、getter和 setter 方法
}

@Service
public class MonitoringService {

    @Autowired
    private LettuceConnectionFactory connectionFactory;

    public void logCpuUsage(String serverId, double cpuUsage) {
        // 記錄CPU使用率數(shù)據(jù)
        CpuUsageData data = new CpuUsageData(Instant.now(), cpuUsage);
        // 使用Lettuce客戶端的命令執(zhí)行器來與RedisTimeSeries模塊交互
        StatefulRedisConnection<String, CpuUsageData> connection = connectionFactory.connect();
        try {
            RedisTimeSeriesCommands<String, CpuUsageData> ts = connection.sync();
            ts.add(serverId, data.getTimestamp().toEpochMilli() / 1000, data);
        } finally {
            connection.close();
        }
    }

    public List<CpuUsageData> getCpuUsageHistory(String serverId, Instant start, Instant end) {
        // 查詢指定時(shí)間范圍內(nèi)的CPU使用率歷史數(shù)據(jù)
        List<CpuUsageData> history = new ArrayList<>();
        StatefulRedisConnection<String, CpuUsageData> connection = connectionFactory.connect();
        try {
            RedisTimeSeriesCommands<String, CpuUsageData> ts = connection.sync();
            Range range = Range.create(start.toEpochMilli() / 1000, end.toEpochMilli() / 1000);
            Cursor<CpuUsageData> cursor = ts.rangeRead(serverId, range);
            while (cursor.hasNext()) {
                history.add(cursor.next().getValue());
            }
        } finally {
            connection.close();
        }
        return history;
    }
}

@RestController
@RequestMapping("/monitoring")
public class MonitoringController {

    @Autowired
    private MonitoringService monitoringService;

    @PostMapping("/logCpuUsage")
    public ResponseEntity<String> logCpuUsage(@RequestParam String serverId, @RequestParam double cpuUsage) {
        monitoringService.logCpuUsage(serverId, cpuUsage);
        return ResponseEntity.ok("CPU usage logged");
    }

    @GetMapping("/cpuUsageHistory")
    public ResponseEntity<List<CpuUsageData>> getCpuUsageHistory(@RequestParam String serverId,
                                                                 @RequestParam Instant start,
                                                                 @RequestParam Instant end) {
        List<CpuUsageData> history = monitoringService.getCpuUsageHistory(serverId, start, end);
        return ResponseEntity.ok(history);
    }
}

spring.redis.host=localhost
spring.redis.port=6379

@Service
public class TaskSchedulingService {

    @Autowired
    private RedisTemplate<String, Runnable> redisTemplate;

    public void scheduleTask(Runnable task, long delay, TimeUnit timeUnit) {
        // 將任務(wù)和延遲時(shí)間存儲(chǔ)到Redis中
        redisTemplate.opsForValue().set(
            "task:" + task.hashCode(), 
            task, 
            timeUnit.toSeconds(delay), 
            timeUnit
        );
        // 使用schedule命令安排任務(wù)在未來執(zhí)行
        String scheduleCommand = String.format(
            "SCHEDULE %d %s", 
            System.currentTimeMillis() + timeUnit.toMillis(delay), 
            "task:" + task.hashCode()
        );
        redisTemplate.execute((RedisConnection connection) -> {
            connection.schedule(scheduleCommand);
            return null;
        });
    }
}

public class SampleTask implements Runnable {
    @Override
    public void run() {
        System.out.println("Task is running: " + LocalDateTime.now());
        // 執(zhí)行任務(wù)邏輯
    }
}

@RestController
@RequestMapping("/tasks")
public class TaskController {

    @Autowired
    private TaskSchedulingService taskSchedulingService;

    @PostMapping("/schedule")
    public ResponseEntity<String> scheduleTask(@RequestParam long delay, @RequestParam TimeUnit timeUnit) {
        taskSchedulingService.scheduleTask(new SampleTask(), delay, timeUnit);
        return ResponseEntity.ok("Task scheduled for execution at " + LocalDateTime.now().plusNanos(timeUnit.toNanos(delay)));
    }
}

spring.redis.host=localhost
spring.redis.port=6379

public class CartItem {
    private String productId;
    private int quantity;
    // 省略構(gòu)造函數(shù)、getter和setter方法
}

@Service
public class CartService {

    @Autowired
    private StringRedisTemplate redisTemplate;

    public void addToCart(String cartId, String productId, int quantity) {
        // 將購(gòu)物車項(xiàng)存儲(chǔ)到Redis的Hash結(jié)構(gòu)中
        redisTemplate.opsForHash().put("cart:" + cartId, productId, quantity);
    }

    public Map<String, Integer> getCart(String cartId) {
        // 從Redis獲取購(gòu)物車內(nèi)容
        return redisTemplate.opsForHash().entries("cart:" + cartId);
    }
}

@RestController
@RequestMapping("/cart")
public class CartController {

    @Autowired
    private CartService cartService;

    @PostMapping("/{cartId}/items")
    public ResponseEntity<String> addToCart(@PathVariable String cartId,
                                             @RequestParam String productId,
                                             @RequestParam int quantity) {
        cartService.addToCart(cartId, productId, quantity);
        return ResponseEntity.ok("Item added to cart");
    }

    @GetMapping("/{cartId}")
    public ResponseEntity<Map<String, Integer>> getCart(@PathVariable String cartId) {
        Map<String, Integer> cart = cartService.getCart(cartId);
        return ResponseEntity.ok(cart);
    }
}

spring.redis.host=localhost
spring.redis.port=6379

@Service
public class ScheduledTaskService {

    public void executeTask() {
        // 執(zhí)行任務(wù)的邏輯，例如發(fā)送郵件
        System.out.println("Executing scheduled task: " + LocalDateTime.now());
    }
}

@Configuration
public class RedissonConfig {

    @Bean(destroyMethod = "shutdown")
    public RedissonClient redissonClient() {
        RedissonClientConfig config = new RedissonClientConfig();
        config.useSingleServer().setAddress("redis://" + spring.redis.host + ":" + spring.redis.port);
        return Redisson.create(config);
    }

    @Value("${spring.redis.host}")
    private String redisHost;

    @Value("${spring.redis.port}")
    private int redisPort;
}

@Configuration
public class ScheduledConfig {

    @Bean
    public RedissonScheduledExecutorService redissonScheduledExecutorService(RedissonClient redissonClient) {
        return redissonClient.getExecutorService("myScheduler");
    }
}

@Component
public class ScheduledTasks {

    @Autowired
    private ScheduledTaskService taskService;

    @Autowired
    private RedissonScheduledExecutorService scheduler;

    @Scheduled(cron = "0 0 1 * * ?") // 每天凌晨1點(diǎn)執(zhí)行
    public void scheduledTask() {
        scheduler.schedule(() -> taskService.executeTask(), 0, TimeUnit.SECONDS);
    }
}