使用数据结构和算法实现一个短网址系统

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

public class Base62Encoder {
    private static final String ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
    private static final int BASE = ALPHABET.length();

    // 将数字编码为Base62字符串
    public static String encode(long number) {
        if (number == 0) {
            return String.valueOf(ALPHABET.charAt(0));
        }

        StringBuilder result = new StringBuilder();
        while (number > 0) {
            result.append(ALPHABET.charAt((int) (number % BASE)));
            number /= BASE;
        }

        return result.reverse().toString();
    }

    // 将Base62字符串解码为数字
    public static long decode(String encoded) {
        long result = 0;
        long power = 1;

        for (int i = encoded.length() - 1; i >= 0; i--) {
            char c = encoded.charAt(i);
            int index = ALPHABET.indexOf(c);
            if (index == -1) {
                throw new IllegalArgumentException("Invalid character in encoded string: " + c);
            }
            result += index * power;
            power *= BASE;
        }

        return result;
    }

    // 生成指定长度的随机Base62字符串
    public static String generateRandom(int length) {
        StringBuilder result = new StringBuilder();
        Random random = new SecureRandom();

        for (int i = 0; i < length; i++) {
            result.append(ALPHABET.charAt(random.nextInt(BASE)));
        }

        return result.toString();
    }

    // 计算指定长度可以表示的最大数字
    public static long getMaxValue(int length) {
        return (long) Math.pow(BASE, length) - 1;
    }

    // 计算表示指定数字需要的最小长度
    public static int getMinLength(long number) {
        if (number == 0) {
            return 1;
        }
        return (int) Math.ceil(Math.log(number + 1) / Math.log(BASE));
    }
}

// Base62编码器的测试和基准测试
public class Base62EncoderTest {
    public static void main(String[] args) {
        // 基本测试
        testBasicEncodeDecode();

        // 性能测试
        performanceBenchmark();

        // 容量计算
        calculateCapacity();
    }

    private static void testBasicEncodeDecode() {
        System.out.println("=== Base62 编码解码测试 ===");

        long[] testNumbers = {0, 1, 61, 62, 3843, 238327, 14776335};

        for (long number : testNumbers) {
            String encoded = Base62Encoder.encode(number);
            long decoded = Base62Encoder.decode(encoded);

            System.out.printf("数字: %d, 编码: %s, 解码: %d, 正确: %b%n",
                            number, encoded, decoded, number == decoded);
        }
    }

    private static void performanceBenchmark() {
        System.out.println("\n=== 性能基准测试 ===");

        int iterations = 1000000;
        long[] numbers = new long[iterations];
        Random random = new Random();

        // 生成测试数据
        for (int i = 0; i < iterations; i++) {
            numbers[i] = Math.abs(random.nextLong() % 1000000000L);
        }

        // 编码性能测试
        long startTime = System.nanoTime();
        for (long number : numbers) {
            Base62Encoder.encode(number);
        }
        long encodingTime = System.nanoTime() - startTime;

        // 编码并解码性能测试
        String[] encoded = new String[iterations];
        startTime = System.nanoTime();
        for (int i = 0; i < iterations; i++) {
            encoded[i] = Base62Encoder.encode(numbers[i]);
        }
        long bothTime = System.nanoTime() - startTime;

        startTime = System.nanoTime();
        for (String enc : encoded) {
            Base62Encoder.decode(enc);
        }
        long decodingTime = System.nanoTime() - startTime;

        System.out.printf("编码 %d 次耗时: %.2f ms (%.2f ns/op)%n",
                         iterations, encodingTime / 1e6, (double) encodingTime / iterations);
        System.out.printf("解码 %d 次耗时: %.2f ms (%.2f ns/op)%n",
                         iterations, decodingTime / 1e6, (double) decodingTime / iterations);
    }

    private static void calculateCapacity() {
        System.out.println("\n=== 容量计算 ===");

        for (int length = 1; length <= 10; length++) {
            long maxValue = Base62Encoder.getMaxValue(length);
            System.out.printf("长度 %d: 最大值 %,d (%s)%n",
                            length, maxValue, formatNumber(maxValue));
        }
    }

    private static String formatNumber(long number) {
        if (number < 1_000L) return String.valueOf(number);
        if (number < 1_000_000L) return String.format("%.1fK", number / 1_000.0);
        if (number < 1_000_000_000L) return String.format("%.1fM", number / 1_000_000.0);
        if (number < 1_000_000_000_000L) return String.format("%.1fB", number / 1_000_000_000.0);
        return String.format("%.1fT", number / 1_000_000_000_000.0);
    }
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

public class URLHashGenerator {
    private final MessageDigest md5Digest;
    private final MessageDigest sha256Digest;

    public URLHashGenerator() {
        try {
            this.md5Digest = MessageDigest.getInstance("MD5");
            this.sha256Digest = MessageDigest.getInstance("SHA-256");
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException("Hash algorithm not available", e);
        }
    }

    // 使用MD5生成短链
    public String generateShortUrlByMD5(String longUrl, int length) {
        byte[] hash = md5Digest.digest(longUrl.getBytes(StandardCharsets.UTF_8));
        long hashValue = 0;

        // 取hash的前8个字节转换为long
        for (int i = 0; i < Math.min(8, hash.length); i++) {
            hashValue = (hashValue << 8) + (hash[i] & 0xff);
        }

        // 确保为正数
        hashValue = Math.abs(hashValue);

        String shortUrl = Base62Encoder.encode(hashValue);

        // 截取指定长度
        if (shortUrl.length() > length) {
            shortUrl = shortUrl.substring(0, length);
        } else if (shortUrl.length() < length) {
            // 不足长度时用随机字符填充
            shortUrl = shortUrl + Base62Encoder.generateRandom(length - shortUrl.length());
        }

        return shortUrl;
    }

    // 使用SHA-256生成短链（多个候选）
    public List<String> generateShortUrlCandidates(String longUrl, int count, int length) {
        Set<String> candidates = new HashSet<>();

        // 原始URL
        candidates.add(generateShortUrlBySHA256(longUrl, length));

        // 添加盐值生成更多候选
        for (int i = 1; candidates.size() < count && i <= count * 2; i++) {
            String saltedUrl = longUrl + "#salt" + i;
            candidates.add(generateShortUrlBySHA256(saltedUrl, length));
        }

        return new ArrayList<>(candidates);
    }

    private String generateShortUrlBySHA256(String input, int length) {
        byte[] hash = sha256Digest.digest(input.getBytes(StandardCharsets.UTF_8));

        // 使用hash的不同部分生成多个可能的短链
        long hashValue = 0;
        for (int i = 0; i < Math.min(8, hash.length); i++) {
            hashValue = (hashValue << 8) + (hash[i] & 0xff);
        }

        hashValue = Math.abs(hashValue);
        String shortUrl = Base62Encoder.encode(hashValue);

        return adjustLength(shortUrl, length);
    }

    private String adjustLength(String shortUrl, int targetLength) {
        if (shortUrl.length() > targetLength) {
            return shortUrl.substring(0, targetLength);
        } else if (shortUrl.length() < targetLength) {
            return shortUrl + Base62Encoder.generateRandom(targetLength - shortUrl.length());
        }
        return shortUrl;
    }

    // 一致性哈希生成器（用于分布式场景）
    public static class ConsistentHashGenerator {
        private final TreeMap<Long, String> ring;
        private final int virtualNodes;
        private final MessageDigest md5;

        public ConsistentHashGenerator(List<String> nodes, int virtualNodes) {
            this.ring = new TreeMap<>();
            this.virtualNodes = virtualNodes;
            try {
                this.md5 = MessageDigest.getInstance("MD5");
            } catch (NoSuchAlgorithmException e) {
                throw new RuntimeException(e);
            }

            // 初始化一致性哈希环
            for (String node : nodes) {
                addNode(node);
            }
        }

        public void addNode(String node) {
            for (int i = 0; i < virtualNodes; i++) {
                String virtualNode = node + "#" + i;
                long hash = hash(virtualNode);
                ring.put(hash, node);
            }
        }

        public void removeNode(String node) {
            for (int i = 0; i < virtualNodes; i++) {
                String virtualNode = node + "#" + i;
                long hash = hash(virtualNode);
                ring.remove(hash);
            }
        }

        public String getNode(String key) {
            if (ring.isEmpty()) {
                return null;
            }

            long hash = hash(key);
            Map.Entry<Long, String> entry = ring.ceilingEntry(hash);

            if (entry == null) {
                // 超过最大值，返回第一个节点
                entry = ring.firstEntry();
            }

            return entry.getValue();
        }

        private long hash(String key) {
            md5.reset();
            byte[] digest = md5.digest(key.getBytes(StandardCharsets.UTF_8));

            long hash = 0;
            for (int i = 0; i < 4; i++) {
                hash <<= 8;
                hash |= ((int) digest[i]) & 0xFF;
            }

            return hash;
        }
    }
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211

public class URLBloomFilter {
    private final BitSet bitSet;
    private final int size;
    private final int hashFunctionCount;
    private final MessageDigest[] digestFunctions;

    public URLBloomFilter(int expectedElements, double falsePositiveRate) {
        this.size = calculateOptimalSize(expectedElements, falsePositiveRate);
        this.hashFunctionCount = calculateOptimalHashFunctions(expectedElements, size);
        this.bitSet = new BitSet(size);

        // 初始化多个哈希函数
        this.digestFunctions = new MessageDigest[hashFunctionCount];
        try {
            for (int i = 0; i < hashFunctionCount; i++) {
                digestFunctions[i] = MessageDigest.getInstance("SHA-256");
            }
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException("SHA-256 not available", e);
        }
    }

    // 计算最优位数组大小
    private int calculateOptimalSize(int expectedElements, double falsePositiveRate) {
        return (int) (-expectedElements * Math.log(falsePositiveRate) / (Math.log(2) * Math.log(2)));
    }

    // 计算最优哈希函数数量
    private int calculateOptimalHashFunctions(int expectedElements, int size) {
        return Math.max(1, (int) Math.round((double) size / expectedElements * Math.log(2)));
    }

    // 添加URL到布隆过滤器
    public void add(String url) {
        for (int i = 0; i < hashFunctionCount; i++) {
            int hash = hash(url, i);
            bitSet.set(Math.abs(hash % size));
        }
    }

    // 检查URL是否可能存在
    public boolean mightContain(String url) {
        for (int i = 0; i < hashFunctionCount; i++) {
            int hash = hash(url, i);
            if (!bitSet.get(Math.abs(hash % size))) {
                return false;
            }
        }
        return true;
    }

    // 生成多个哈希值
    private int hash(String url, int seed) {
        MessageDigest digest = digestFunctions[seed % digestFunctions.length];
        digest.reset();
        digest.update(url.getBytes(StandardCharsets.UTF_8));
        digest.update(String.valueOf(seed).getBytes(StandardCharsets.UTF_8));

        byte[] hashBytes = digest.digest();
        int hash = 0;

        // 将字节数组转换为int
        for (int i = 0; i < Math.min(4, hashBytes.length); i++) {
            hash = (hash << 8) | (hashBytes[i] & 0xFF);
        }

        return hash;
    }

    // 获取当前误判率估计
    public double getCurrentFalsePositiveRate() {
        int setBits = bitSet.cardinality();
        return Math.pow((double) setBits / size, hashFunctionCount);
    }

    // 重置布隆过滤器
    public void clear() {
        bitSet.clear();
    }

    // 获取统计信息
    public BloomFilterStats getStats() {
        BloomFilterStats stats = new BloomFilterStats();
        stats.setSize(size);
        stats.setHashFunctionCount(hashFunctionCount);
        stats.setBitsSet(bitSet.cardinality());
        stats.setCurrentFalsePositiveRate(getCurrentFalsePositiveRate());
        return stats;
    }

    public static class BloomFilterStats {
        private int size;
        private int hashFunctionCount;
        private int bitsSet;
        private double currentFalsePositiveRate;

        // getter和setter方法
        public int getSize() { return size; }
        public void setSize(int size) { this.size = size; }

        public int getHashFunctionCount() { return hashFunctionCount; }
        public void setHashFunctionCount(int hashFunctionCount) { this.hashFunctionCount = hashFunctionCount; }

        public int getBitsSet() { return bitsSet; }
        public void setBitsSet(int bitsSet) { this.bitsSet = bitsSet; }

        public double getCurrentFalsePositiveRate() { return currentFalsePositiveRate; }
        public void setCurrentFalsePositiveRate(double currentFalsePositiveRate) {
            this.currentFalsePositiveRate = currentFalsePositiveRate;
        }
    }

    // 分布式布隆过滤器
    public static class DistributedBloomFilter {
        private final RedisTemplate<String, String> redisTemplate;
        private final String keyPrefix;
        private final int size;
        private final int hashFunctionCount;

        private static final String LUA_SCRIPT_ADD = """
            local key = KEYS[1]
            local positions = cjson.decode(ARGV[1])

            for i, pos in ipairs(positions) do
                redis.call('setbit', key, pos, 1)
            end

            redis.call('expire', key, 86400)
            return 1
            """;

        private static final String LUA_SCRIPT_CHECK = """
            local key = KEYS[1]
            local positions = cjson.decode(ARGV[1])

            for i, pos in ipairs(positions) do
                if redis.call('getbit', key, pos) == 0 then
                    return 0
                end
            end

            return 1
            """;

        private final RedisScript<Long> addScript;
        private final RedisScript<Long> checkScript;

        public DistributedBloomFilter(RedisTemplate<String, String> redisTemplate,
                                    String keyPrefix,
                                    int expectedElements,
                                    double falsePositiveRate) {
            this.redisTemplate = redisTemplate;
            this.keyPrefix = keyPrefix;
            this.size = calculateOptimalSize(expectedElements, falsePositiveRate);
            this.hashFunctionCount = calculateOptimalHashFunctions(expectedElements, size);
            this.addScript = new DefaultRedisScript<>(LUA_SCRIPT_ADD, Long.class);
            this.checkScript = new DefaultRedisScript<>(LUA_SCRIPT_CHECK, Long.class);
        }

        public void add(String url) {
            String key = keyPrefix + ":bloom";
            List<Integer> positions = calculatePositions(url);

            List<String> keys = Collections.singletonList(key);
            String positionsJson = JsonUtils.toJson(positions);

            redisTemplate.execute(addScript, keys, positionsJson);
        }

        public boolean mightContain(String url) {
            String key = keyPrefix + ":bloom";
            List<Integer> positions = calculatePositions(url);

            List<String> keys = Collections.singletonList(key);
            String positionsJson = JsonUtils.toJson(positions);

            Long result = redisTemplate.execute(checkScript, keys, positionsJson);
            return result != null && result == 1;
        }

        private List<Integer> calculatePositions(String url) {
            List<Integer> positions = new ArrayList<>();

            try {
                MessageDigest digest = MessageDigest.getInstance("SHA-256");

                for (int i = 0; i < hashFunctionCount; i++) {
                    digest.reset();
                    digest.update(url.getBytes(StandardCharsets.UTF_8));
                    digest.update(String.valueOf(i).getBytes(StandardCharsets.UTF_8));

                    byte[] hash = digest.digest();
                    int hashInt = Math.abs(ByteBuffer.wrap(hash).getInt());
                    positions.add(hashInt % size);
                }
            } catch (NoSuchAlgorithmException e) {
                throw new RuntimeException("SHA-256 not available", e);
            }

            return positions;
        }

        private int calculateOptimalSize(int expectedElements, double falsePositiveRate) {
            return (int) (-expectedElements * Math.log(falsePositiveRate) / (Math.log(2) * Math.log(2)));
        }

        private int calculateOptimalHashFunctions(int expectedElements, int size) {
            return Math.max(1, (int) Math.round((double) size / expectedElements * Math.log(2)));
        }
    }
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242

public class URLMappingStore {
    // URL映射实体
    public static class URLMapping {
        private String shortUrl;
        private String longUrl;
        private String userId;
        private LocalDateTime createdAt;
        private LocalDateTime expiresAt;
        private long clickCount;
        private String customAlias;
        private Map<String, String> metadata;

        public URLMapping() {
            this.createdAt = LocalDateTime.now();
            this.clickCount = 0;
            this.metadata = new HashMap<>();
        }

        public URLMapping(String shortUrl, String longUrl, String userId) {
            this();
            this.shortUrl = shortUrl;
            this.longUrl = longUrl;
            this.userId = userId;
        }

        // getter和setter方法
        public String getShortUrl() { return shortUrl; }
        public void setShortUrl(String shortUrl) { this.shortUrl = shortUrl; }

        public String getLongUrl() { return longUrl; }
        public void setLongUrl(String longUrl) { this.longUrl = longUrl; }

        public String getUserId() { return userId; }
        public void setUserId(String userId) { this.userId = userId; }

        public LocalDateTime getCreatedAt() { return createdAt; }
        public void setCreatedAt(LocalDateTime createdAt) { this.createdAt = createdAt; }

        public LocalDateTime getExpiresAt() { return expiresAt; }
        public void setExpiresAt(LocalDateTime expiresAt) { this.expiresAt = expiresAt; }

        public long getClickCount() { return clickCount; }
        public void setClickCount(long clickCount) { this.clickCount = clickCount; }

        public void incrementClickCount() { this.clickCount++; }

        public String getCustomAlias() { return customAlias; }
        public void setCustomAlias(String customAlias) { this.customAlias = customAlias; }

        public Map<String, String> getMetadata() { return metadata; }
        public void setMetadata(Map<String, String> metadata) { this.metadata = metadata; }

        public boolean isExpired() {
            return expiresAt != null && LocalDateTime.now().isAfter(expiresAt);
        }
    }

    // 内存存储实现
    public static class InMemoryURLMappingStore {
        private final ConcurrentHashMap<String, URLMapping> shortToLongMap;
        private final ConcurrentHashMap<String, String> longToShortMap;
        private final ConcurrentHashMap<String, Set<String>> userUrlsMap;

        public InMemoryURLMappingStore() {
            this.shortToLongMap = new ConcurrentHashMap<>();
            this.longToShortMap = new ConcurrentHashMap<>();
            this.userUrlsMap = new ConcurrentHashMap<>();
        }

        public void save(URLMapping mapping) {
            shortToLongMap.put(mapping.getShortUrl(), mapping);
            longToShortMap.put(mapping.getLongUrl(), mapping.getShortUrl());

            if (mapping.getUserId() != null) {
                userUrlsMap.computeIfAbsent(mapping.getUserId(), k -> ConcurrentHashMap.newKeySet())
                          .add(mapping.getShortUrl());
            }
        }

        public URLMapping findByShortUrl(String shortUrl) {
            URLMapping mapping = shortToLongMap.get(shortUrl);
            if (mapping != null && mapping.isExpired()) {
                delete(shortUrl);
                return null;
            }
            return mapping;
        }

        public String findShortUrlByLongUrl(String longUrl) {
            return longToShortMap.get(longUrl);
        }

        public Set<String> findUrlsByUserId(String userId) {
            return userUrlsMap.getOrDefault(userId, Collections.emptySet());
        }

        public boolean exists(String shortUrl) {
            URLMapping mapping = shortToLongMap.get(shortUrl);
            return mapping != null && !mapping.isExpired();
        }

        public void delete(String shortUrl) {
            URLMapping mapping = shortToLongMap.remove(shortUrl);
            if (mapping != null) {
                longToShortMap.remove(mapping.getLongUrl());
                if (mapping.getUserId() != null) {
                    Set<String> userUrls = userUrlsMap.get(mapping.getUserId());
                    if (userUrls != null) {
                        userUrls.remove(shortUrl);
                    }
                }
            }
        }

        public void incrementClickCount(String shortUrl) {
            URLMapping mapping = shortToLongMap.get(shortUrl);
            if (mapping != null && !mapping.isExpired()) {
                mapping.incrementClickCount();
            }
        }

        public int size() {
            return shortToLongMap.size();
        }

        public void cleanup() {
            Set<String> expiredUrls = shortToLongMap.entrySet().stream()
                    .filter(entry -> entry.getValue().isExpired())
                    .map(Map.Entry::getKey)
                    .collect(Collectors.toSet());

            expiredUrls.forEach(this::delete);
        }
    }

    // Redis存储实现
    public static class RedisURLMappingStore {
        private final RedisTemplate<String, String> redisTemplate;
        private final String keyPrefix;

        private static final String LUA_SCRIPT_INCREMENT_CLICK = """
            local shortUrlKey = KEYS[1]
            local mapping = redis.call('get', shortUrlKey)

            if mapping then
                local data = cjson.decode(mapping)
                data.clickCount = (data.clickCount or 0) + 1
                redis.call('set', shortUrlKey, cjson.encode(data))
                return data.clickCount
            else
                return 0
            end
            """;

        private final RedisScript<Long> incrementClickScript;

        public RedisURLMappingStore(RedisTemplate<String, String> redisTemplate, String keyPrefix) {
            this.redisTemplate = redisTemplate;
            this.keyPrefix = keyPrefix;
            this.incrementClickScript = new DefaultRedisScript<>(LUA_SCRIPT_INCREMENT_CLICK, Long.class);
        }

        public void save(URLMapping mapping) {
            String shortUrlKey = keyPrefix + ":short:" + mapping.getShortUrl();
            String longUrlKey = keyPrefix + ":long:" + DigestUtils.sha256Hex(mapping.getLongUrl());
            String userKey = keyPrefix + ":user:" + mapping.getUserId();

            String mappingJson = JsonUtils.toJson(mapping);

            // 保存短链到长链的映射
            if (mapping.getExpiresAt() != null) {
                Duration ttl = Duration.between(LocalDateTime.now(), mapping.getExpiresAt());
                redisTemplate.opsForValue().set(shortUrlKey, mappingJson, ttl);
            } else {
                redisTemplate.opsForValue().set(shortUrlKey, mappingJson);
            }

            // 保存长链到短链的映射
            redisTemplate.opsForValue().set(longUrlKey, mapping.getShortUrl());

            // 保存用户的URL列表
            if (mapping.getUserId() != null) {
                redisTemplate.opsForSet().add(userKey, mapping.getShortUrl());
            }
        }

        public URLMapping findByShortUrl(String shortUrl) {
            String key = keyPrefix + ":short:" + shortUrl;
            String mappingJson = redisTemplate.opsForValue().get(key);

            if (mappingJson != null) {
                URLMapping mapping = JsonUtils.fromJson(mappingJson, URLMapping.class);
                if (mapping.isExpired()) {
                    delete(shortUrl);
                    return null;
                }
                return mapping;
            }

            return null;
        }

        public String findShortUrlByLongUrl(String longUrl) {
            String key = keyPrefix + ":long:" + DigestUtils.sha256Hex(longUrl);
            return redisTemplate.opsForValue().get(key);
        }

        public Set<String> findUrlsByUserId(String userId) {
            String key = keyPrefix + ":user:" + userId;
            return redisTemplate.opsForSet().members(key);
        }

        public boolean exists(String shortUrl) {
            String key = keyPrefix + ":short:" + shortUrl;
            return redisTemplate.hasKey(key);
        }

        public void delete(String shortUrl) {
            URLMapping mapping = findByShortUrl(shortUrl);
            if (mapping != null) {
                String shortUrlKey = keyPrefix + ":short:" + shortUrl;
                String longUrlKey = keyPrefix + ":long:" + DigestUtils.sha256Hex(mapping.getLongUrl());
                String userKey = keyPrefix + ":user:" + mapping.getUserId();

                redisTemplate.delete(shortUrlKey);
                redisTemplate.delete(longUrlKey);

                if (mapping.getUserId() != null) {
                    redisTemplate.opsForSet().remove(userKey, shortUrl);
                }
            }
        }

        public long incrementClickCount(String shortUrl) {
            String key = keyPrefix + ":short:" + shortUrl;
            List<String> keys = Collections.singletonList(key);

            Long newCount = redisTemplate.execute(incrementClickScript, keys);
            return newCount != null ? newCount : 0;
        }
    }
}