基于Java和Redis實(shí)現(xiàn)排行榜功能實(shí)例代碼

更新時(shí)間：2026年02月25日 09:51:06 作者：Zhu_S?W

Redis是我們Java開發(fā)中,使用頻次非常高的一個(gè)nosql數(shù)據(jù)庫(kù),數(shù)據(jù)以key-value鍵值對(duì)的形式存儲(chǔ)在內(nèi)存中,這篇文章主要介紹了基于Java和Redis實(shí)現(xiàn)排行榜功能的相關(guān)資料,需要的朋友可以參考下

引言

排行榜是現(xiàn)代應(yīng)用程序中常見的功能，無(wú)論是游戲積分榜、銷售排行還是用戶活躍度統(tǒng)計(jì)，都需要高效的排序和查詢機(jī)制。Redis的有序集合（Sorted Set）數(shù)據(jù)結(jié)構(gòu)為實(shí)現(xiàn)排行榜提供了完美的解決方案，它能夠自動(dòng)維護(hù)元素的排序，并支持高效的范圍查詢和排名操作。

Redis Sorted Set簡(jiǎn)介

Redis的有序集合（Sorted Set）是一種特殊的數(shù)據(jù)結(jié)構(gòu)，它具有以下特點(diǎn)：

唯一性：集合中的每個(gè)元素都是唯一的
有序性：每個(gè)元素都關(guān)聯(lián)一個(gè)分?jǐn)?shù)（score），Redis根據(jù)分?jǐn)?shù)自動(dòng)排序
高效性：插入、刪除、查找操作的時(shí)間復(fù)雜度都是O(log N)
范圍查詢：支持按分?jǐn)?shù)范圍或排名范圍查詢?cè)?/p>

環(huán)境準(zhǔn)備

Maven依賴

首先，在項(xiàng)目的pom.xml中添加必要的依賴：

<dependencies>
    <!-- Jedis Redis客戶端 -->
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>4.3.1</version>
    </dependency>
    
    <!-- Spring Boot Redis Starter (可選) -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
        <version>2.7.0</version>
    </dependency>
    
    <!-- JSON處理 -->
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.14.2</version>
    </dependency>
</dependencies>

Redis配置

創(chuàng)建Redis連接配置類：

@Configuration
public class RedisConfig {
    
    @Bean
    public JedisConnectionFactory jedisConnectionFactory() {
        JedisConnectionFactory factory = new JedisConnectionFactory();
        factory.setHostName("localhost");
        factory.setPort(6379);
        factory.setDatabase(0);
        return factory;
    }
    
    @Bean
    public RedisTemplate<String, Object> redisTemplate() {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(jedisConnectionFactory());
        template.setDefaultSerializer(new GenericJackson2JsonRedisSerializer());
        template.setKeySerializer(new StringRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());
        return template;
    }
}

核心實(shí)現(xiàn)

1. 排行榜服務(wù)類

@Service
public class LeaderboardService {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    private static final String LEADERBOARD_KEY = "game:leaderboard";
    
    /**
     * 更新用戶分?jǐn)?shù)
     * @param userId 用戶ID
     * @param score 分?jǐn)?shù)
     */
    public void updateScore(String userId, double score) {
        redisTemplate.opsForZSet().add(LEADERBOARD_KEY, userId, score);
    }
    
    /**
     * 增加用戶分?jǐn)?shù)
     * @param userId 用戶ID
     * @param increment 增加的分?jǐn)?shù)
     * @return 更新后的總分?jǐn)?shù)
     */
    public Double incrementScore(String userId, double increment) {
        return redisTemplate.opsForZSet().incrementScore(LEADERBOARD_KEY, userId, increment);
    }
    
    /**
     * 獲取用戶當(dāng)前分?jǐn)?shù)
     * @param userId 用戶ID
     * @return 用戶分?jǐn)?shù)
     */
    public Double getUserScore(String userId) {
        return redisTemplate.opsForZSet().score(LEADERBOARD_KEY, userId);
    }
    
    /**
     * 獲取用戶排名（從1開始）
     * @param userId 用戶ID
     * @return 用戶排名，如果用戶不存在返回null
     */
    public Long getUserRank(String userId) {
        Long rank = redisTemplate.opsForZSet().reverseRank(LEADERBOARD_KEY, userId);
        return rank != null ? rank + 1 : null;
    }
    
    /**
     * 獲取前N名排行榜
     * @param topN 獲取前幾名
     * @return 排行榜列表
     */
    public List<LeaderboardEntry> getTopN(int topN) {
        Set<ZSetOperations.TypedTuple<Object>> tuples = 
            redisTemplate.opsForZSet().reverseRangeWithScores(LEADERBOARD_KEY, 0, topN - 1);
        
        List<LeaderboardEntry> leaderboard = new ArrayList<>();
        int rank = 1;
        for (ZSetOperations.TypedTuple<Object> tuple : tuples) {
            LeaderboardEntry entry = new LeaderboardEntry();
            entry.setUserId((String) tuple.getValue());
            entry.setScore(tuple.getScore());
            entry.setRank(rank++);
            leaderboard.add(entry);
        }
        return leaderboard;
    }
    
    /**
     * 獲取指定排名范圍的排行榜
     * @param startRank 起始排名（從1開始）
     * @param endRank 結(jié)束排名（包含）
     * @return 排行榜列表
     */
    public List<LeaderboardEntry> getRangeByRank(int startRank, int endRank) {
        Set<ZSetOperations.TypedTuple<Object>> tuples = 
            redisTemplate.opsForZSet().reverseRangeWithScores(
                LEADERBOARD_KEY, startRank - 1, endRank - 1);
        
        List<LeaderboardEntry> leaderboard = new ArrayList<>();
        int rank = startRank;
        for (ZSetOperations.TypedTuple<Object> tuple : tuples) {
            LeaderboardEntry entry = new LeaderboardEntry();
            entry.setUserId((String) tuple.getValue());
            entry.setScore(tuple.getScore());
            entry.setRank(rank++);
            leaderboard.add(entry);
        }
        return leaderboard;
    }
    
    /**
     * 獲取指定分?jǐn)?shù)范圍的用戶
     * @param minScore 最小分?jǐn)?shù)
     * @param maxScore 最大分?jǐn)?shù)
     * @return 用戶列表
     */
    public List<LeaderboardEntry> getRangeByScore(double minScore, double maxScore) {
        Set<ZSetOperations.TypedTuple<Object>> tuples = 
            redisTemplate.opsForZSet().reverseRangeByScoreWithScores(
                LEADERBOARD_KEY, minScore, maxScore);
        
        List<LeaderboardEntry> result = new ArrayList<>();
        for (ZSetOperations.TypedTuple<Object> tuple : tuples) {
            LeaderboardEntry entry = new LeaderboardEntry();
            entry.setUserId((String) tuple.getValue());
            entry.setScore(tuple.getScore());
            // 獲取具體排名
            Long rank = redisTemplate.opsForZSet().reverseRank(LEADERBOARD_KEY, tuple.getValue());
            entry.setRank(rank != null ? rank.intValue() + 1 : 0);
            result.add(entry);
        }
        return result;
    }
    
    /**
     * 獲取排行榜總?cè)藬?shù)
     * @return 總?cè)藬?shù)
     */
    public Long getTotalCount() {
        return redisTemplate.opsForZSet().zCard(LEADERBOARD_KEY);
    }
    
    /**
     * 刪除用戶
     * @param userId 用戶ID
     * @return 是否刪除成功
     */
    public Boolean removeUser(String userId) {
        Long removed = redisTemplate.opsForZSet().remove(LEADERBOARD_KEY, userId);
        return removed != null && removed > 0;
    }
}

2. 排行榜條目實(shí)體類

public class LeaderboardEntry {
    private String userId;
    private Double score;
    private Integer rank;
    
    // 構(gòu)造函數(shù)
    public LeaderboardEntry() {}
    
    public LeaderboardEntry(String userId, Double score, Integer rank) {
        this.userId = userId;
        this.score = score;
        this.rank = rank;
    }
    
    // Getter和Setter方法
    public String getUserId() { return userId; }
    public void setUserId(String userId) { this.userId = userId; }
    
    public Double getScore() { return score; }
    public void setScore(Double score) { this.score = score; }
    
    public Integer getRank() { return rank; }
    public void setRank(Integer rank) { this.rank = rank; }
    
    @Override
    public String toString() {
        return String.format("LeaderboardEntry{userId='%s', score=%.2f, rank=%d}", 
                           userId, score, rank);
    }
}

3. REST API控制器

@RestController
@RequestMapping("/api/leaderboard")
public class LeaderboardController {
    
    @Autowired
    private LeaderboardService leaderboardService;
    
    /**
     * 更新用戶分?jǐn)?shù)
     */
    @PostMapping("/score")
    public ResponseEntity<String> updateScore(@RequestBody ScoreUpdateRequest request) {
        leaderboardService.updateScore(request.getUserId(), request.getScore());
        return ResponseEntity.ok("Score updated successfully");
    }
    
    /**
     * 增加用戶分?jǐn)?shù)
     */
    @PostMapping("/increment")
    public ResponseEntity<Double> incrementScore(@RequestBody ScoreIncrementRequest request) {
        Double newScore = leaderboardService.incrementScore(request.getUserId(), request.getIncrement());
        return ResponseEntity.ok(newScore);
    }
    
    /**
     * 獲取用戶排名和分?jǐn)?shù)
     */
    @GetMapping("/user/{userId}")
    public ResponseEntity<UserRankInfo> getUserInfo(@PathVariable String userId) {
        Double score = leaderboardService.getUserScore(userId);
        Long rank = leaderboardService.getUserRank(userId);
        
        if (score == null) {
            return ResponseEntity.notFound().build();
        }
        
        UserRankInfo info = new UserRankInfo(userId, score, rank);
        return ResponseEntity.ok(info);
    }
    
    /**
     * 獲取前N名排行榜
     */
    @GetMapping("/top/{n}")
    public ResponseEntity<List<LeaderboardEntry>> getTopN(@PathVariable int n) {
        List<LeaderboardEntry> leaderboard = leaderboardService.getTopN(n);
        return ResponseEntity.ok(leaderboard);
    }
    
    /**
     * 獲取指定排名范圍的排行榜
     */
    @GetMapping("/range")
    public ResponseEntity<List<LeaderboardEntry>> getRangeByRank(
            @RequestParam int startRank, 
            @RequestParam int endRank) {
        List<LeaderboardEntry> leaderboard = leaderboardService.getRangeByRank(startRank, endRank);
        return ResponseEntity.ok(leaderboard);
    }
    
    /**
     * 獲取排行榜統(tǒng)計(jì)信息
     */
    @GetMapping("/stats")
    public ResponseEntity<LeaderboardStats> getStats() {
        Long totalCount = leaderboardService.getTotalCount();
        List<LeaderboardEntry> topUsers = leaderboardService.getTopN(1);
        
        LeaderboardStats stats = new LeaderboardStats();
        stats.setTotalUsers(totalCount);
        if (!topUsers.isEmpty()) {
            stats.setTopUser(topUsers.get(0));
        }
        
        return ResponseEntity.ok(stats);
    }
}

高級(jí)功能

1. 多個(gè)排行榜管理

@Service
public class MultiLeaderboardService {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    private static final String LEADERBOARD_PREFIX = "leaderboard:";
    
    /**
     * 獲取排行榜鍵名
     */
    private String getLeaderboardKey(String leaderboardType) {
        return LEADERBOARD_PREFIX + leaderboardType;
    }
    
    /**
     * 更新指定排行榜中用戶分?jǐn)?shù)
     */
    public void updateScore(String leaderboardType, String userId, double score) {
        String key = getLeaderboardKey(leaderboardType);
        redisTemplate.opsForZSet().add(key, userId, score);
    }
    
    /**
     * 獲取用戶在多個(gè)排行榜中的排名
     */
    public Map<String, UserRankInfo> getUserRanksInMultipleBoards(String userId, List<String> leaderboardTypes) {
        Map<String, UserRankInfo> results = new HashMap<>();
        
        for (String type : leaderboardTypes) {
            String key = getLeaderboardKey(type);
            Double score = redisTemplate.opsForZSet().score(key, userId);
            Long rank = redisTemplate.opsForZSet().reverseRank(key, userId);
            
            if (score != null && rank != null) {
                results.put(type, new UserRankInfo(userId, score, rank + 1));
            }
        }
        
        return results;
    }
}

2. 時(shí)間窗口排行榜

@Service
public class TimeWindowLeaderboardService {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    /**
     * 獲取日排行榜鍵名
     */
    private String getDailyLeaderboardKey() {
        String today = LocalDate.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
        return "leaderboard:daily:" + today;
    }
    
    /**
     * 獲取周排行榜鍵名
     */
    private String getWeeklyLeaderboardKey() {
        LocalDate now = LocalDate.now();
        int weekOfYear = now.get(WeekFields.ISO.weekOfYear());
        return String.format("leaderboard:weekly:%d-%02d", now.getYear(), weekOfYear);
    }
    
    /**
     * 更新日排行榜和總排行榜
     */
    public void updateDailyScore(String userId, double score) {
        String dailyKey = getDailyLeaderboardKey();
        String totalKey = "leaderboard:total";
        
        // 使用Redis事務(wù)確保一致性
        redisTemplate.execute(new SessionCallback<Object>() {
            @Override
            public Object execute(RedisOperations operations) throws DataAccessException {
                operations.multi();
                operations.opsForZSet().add(dailyKey, userId, score);
                operations.opsForZSet().incrementScore(totalKey, userId, score);
                return operations.exec();
            }
        });
        
        // 設(shè)置日排行榜過(guò)期時(shí)間（7天）
        redisTemplate.expire(dailyKey, 7, TimeUnit.DAYS);
    }
}

3. 排行榜緩存優(yōu)化

@Service
public class CachedLeaderboardService {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    private static final String CACHE_KEY_PREFIX = "cache:leaderboard:";
    private static final int CACHE_EXPIRE_SECONDS = 300; // 5分鐘緩存
    
    /**
     * 獲取緩存的前N名排行榜
     */
    @Cacheable(value = "leaderboard", key = "'top:' + #topN")
    public List<LeaderboardEntry> getCachedTopN(int topN) {
        String cacheKey = CACHE_KEY_PREFIX + "top:" + topN;
        
        // 嘗試從緩存獲取
        List<LeaderboardEntry> cached = (List<LeaderboardEntry>) 
            redisTemplate.opsForValue().get(cacheKey);
        
        if (cached != null) {
            return cached;
        }
        
        // 緩存未命中，從排行榜獲取
        List<LeaderboardEntry> leaderboard = getTopN(topN);
        
        // 存入緩存
        redisTemplate.opsForValue().set(cacheKey, leaderboard, 
                                       CACHE_EXPIRE_SECONDS, TimeUnit.SECONDS);
        
        return leaderboard;
    }
    
    /**
     * 清除相關(guān)緩存
     */
    public void clearLeaderboardCache() {
        Set<String> keys = redisTemplate.keys(CACHE_KEY_PREFIX + "*");
        if (keys != null && !keys.isEmpty()) {
            redisTemplate.delete(keys);
        }
    }
}

性能優(yōu)化建議

1. 批量操作

對(duì)于大量的分?jǐn)?shù)更新操作，建議使用批量處理：

public void batchUpdateScores(Map<String, Double> userScores) {
    redisTemplate.executePipelined(new SessionCallback<Object>() {
        @Override
        public Object execute(RedisOperations operations) throws DataAccessException {
            ZSetOperations<String, Object> zSetOps = operations.opsForZSet();
            userScores.forEach((userId, score) -> {
                zSetOps.add(LEADERBOARD_KEY, userId, score);
            });
            return null;
        }
    });
}

2. 連接池配置

優(yōu)化Redis連接池配置以提升性能：

@Configuration
public class RedisPoolConfig {
    
    @Bean
    public JedisConnectionFactory jedisConnectionFactory() {
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        poolConfig.setMaxTotal(50);
        poolConfig.setMaxIdle(20);
        poolConfig.setMinIdle(10);
        poolConfig.setTestOnBorrow(true);
        poolConfig.setTestOnReturn(true);
        
        JedisConnectionFactory factory = new JedisConnectionFactory(poolConfig);
        factory.setHostName("localhost");
        factory.setPort(6379);
        factory.setTimeout(3000);
        
        return factory;
    }
}

測(cè)試示例

@SpringBootTest
public class LeaderboardServiceTest {
    
    @Autowired
    private LeaderboardService leaderboardService;
    
    @Test
    public void testLeaderboard() {
        // 添加測(cè)試數(shù)據(jù)
        leaderboardService.updateScore("user1", 1000);
        leaderboardService.updateScore("user2", 1500);
        leaderboardService.updateScore("user3", 800);
        leaderboardService.updateScore("user4", 1200);
        
        // 測(cè)試獲取前3名
        List<LeaderboardEntry> top3 = leaderboardService.getTopN(3);
        assertEquals(3, top3.size());
        assertEquals("user2", top3.get(0).getUserId());
        assertEquals(1500.0, top3.get(0).getScore(), 0.01);
        
        // 測(cè)試用戶排名
        Long rank = leaderboardService.getUserRank("user2");
        assertEquals(Long.valueOf(1), rank);
        
        // 測(cè)試分?jǐn)?shù)增加
        Double newScore = leaderboardService.incrementScore("user1", 600);
        assertEquals(1600.0, newScore, 0.01);
        
        // 驗(yàn)證排名變化
        Long newRank = leaderboardService.getUserRank("user1");
        assertEquals(Long.valueOf(1), newRank);
    }
}

總結(jié)

使用Redis實(shí)現(xiàn)排行榜功能具有以下優(yōu)勢(shì)：

高性能：Redis的內(nèi)存數(shù)據(jù)庫(kù)特性保證了快速的讀寫操作
自動(dòng)排序：Sorted Set自動(dòng)維護(hù)元素排序，無(wú)需額外的排序操作
豐富的操作：支持范圍查詢、排名查詢、分?jǐn)?shù)更新等多種操作
擴(kuò)展性強(qiáng)：可以輕松實(shí)現(xiàn)多種類型的排行榜和時(shí)間窗口排行榜

通過(guò)合理的緩存策略和批量操作優(yōu)化，Redis排行榜系統(tǒng)可以輕松應(yīng)對(duì)高并發(fā)場(chǎng)景，為用戶提供實(shí)時(shí)、準(zhǔn)確的排名服務(wù)。在實(shí)際項(xiàng)目中，還可以根據(jù)具體需求添加更多功能，如排行榜歷史記錄、用戶分組排行等。

到此這篇關(guān)于基于Java和Redis實(shí)現(xiàn)排行榜功能的文章就介紹到這了,更多相關(guān)Java和Redis排行榜功能內(nèi)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: