系统设计实战：短链接服务架构

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

    public static String encode(long num) {
        if (num == 0) return String.valueOf(ALPHABET.charAt(0));

        StringBuilder sb = new StringBuilder();
        while (num > 0) {
            sb.append(ALPHABET.charAt((int) (num % BASE)));
            num /= BASE;
        }
        return sb.reverse().toString();
    }

    public static long decode(String str) {
        long num = 0;
        for (char c : str.toCharArray()) {
            num = num * BASE + ALPHABET.indexOf(c);
        }
        return num;
    }
}

// 号段模式 ID 生成器
@Service
public class SegmentIdGenerator {
    private final AtomicLong currentId = new AtomicLong(0);
    private volatile long maxId = 0;
    private final int segmentSize = 1000;
    private final Object lock = new Object();

    @Autowired
    private JdbcTemplate jdbc;

    public long nextId() {
        long id = currentId.incrementAndGet();
        if (id > maxId) {
            synchronized (lock) {
                if (currentId.get() > maxId) {
                    loadNextSegment();
                }
                id = currentId.incrementAndGet();
            }
        }
        return id;
    }

    private void loadNextSegment() {
        // 原子性地获取一个号段
        jdbc.update(
            "UPDATE id_generator SET max_id = max_id + ? WHERE biz_type = 'short_url'",
            segmentSize);

        Long newMaxId = jdbc.queryForObject(
            "SELECT max_id FROM id_generator WHERE biz_type = 'short_url'",
            Long.class);

        maxId = newMaxId;
        currentId.set(newMaxId - segmentSize);
    }
}

@RestController
@RequestMapping("/api/v1")
public class ShortUrlController {
    @Autowired
    private ShortUrlService shortUrlService;

    @PostMapping("/shorten")
    public ResponseEntity<ShortenResponse> shorten(@Valid @RequestBody ShortenRequest request) {
        String shortCode = shortUrlService.createShortUrl(
            request.getLongUrl(),
            request.getExpiresAt(),
            request.getCustomAlias()
        );

        return ResponseEntity.ok(new ShortenResponse(
            "https://s.io/" + shortCode,
            shortCode
        ));
    }
}

@Service
public class ShortUrlService {
    @Autowired
    private SegmentIdGenerator idGenerator;
    @Autowired
    private ShortUrlMapper urlMapper;
    @Autowired
    private RedisTemplate<String, String> redis;

    @Transactional
    public String createShortUrl(String longUrl, LocalDateTime expiresAt, String customAlias) {
        // 1. URL 格式校验
        validateUrl(longUrl);

        // 2. 自定义别名
        if (customAlias != null && !customAlias.isEmpty()) {
            if (urlMapper.existsByShortCode(customAlias)) {
                throw new AliasAlreadyExistsException(customAlias);
            }
            saveShortUrl(customAlias, longUrl, expiresAt);
            return customAlias;
        }

        // 3. 检查是否已有映射（去重）
        String urlHash = DigestUtils.sha256Hex(longUrl);
        String existingCode = urlMapper.findShortCodeByUrlHash(urlHash);
        if (existingCode != null) {
            return existingCode;
        }

        // 4. 生成短码
        long id = idGenerator.nextId();
        String shortCode = Base62Encoder.encode(id);

        // 5. 持久化
        saveShortUrl(shortCode, longUrl, expiresAt);
        urlMapper.insertUrlMapping(urlHash, shortCode, longUrl);

        // 6. 写入缓存
        redis.opsForValue().set("short:" + shortCode, longUrl,
            Duration.ofHours(24));

        return shortCode;
    }

    private void saveShortUrl(String shortCode, String longUrl, LocalDateTime expiresAt) {
        ShortUrl entity = new ShortUrl();
        entity.setShortCode(shortCode);
        entity.setLongUrl(longUrl);
        entity.setExpiresAt(expiresAt);
        urlMapper.insert(entity);
    }
}

@RestController
public class RedirectController {

    @GetMapping("/{shortCode:[a-zA-Z0-9]{4,10}}")
    public ResponseEntity<Void> redirect(
            @PathVariable String shortCode,
            HttpServletRequest request) {

        // 1. 查缓存
        String longUrl = redis.opsForValue().get("short:" + shortCode);

        if (longUrl == null) {
            // 2. 查数据库
            ShortUrl shortUrl = urlMapper.findByShortCode(shortCode);
            if (shortUrl == null) {
                throw new ShortUrlNotFoundException(shortCode);
            }

            // 3. 检查过期
            if (shortUrl.getExpiresAt() != null &&
                shortUrl.getExpiresAt().isBefore(LocalDateTime.now())) {
                throw new ShortUrlExpiredException(shortCode);
            }

            longUrl = shortUrl.getLongUrl();

            // 4. 回填缓存
            redis.opsForValue().set("short:" + shortCode, longUrl,
                Duration.ofHours(24));
        }

        // 5. 异步记录点击事件
        publishClickEvent(shortCode, request);

        // 6. 302 重定向
        return ResponseEntity.status(HttpStatus.FOUND)
            .location(URI.create(longUrl))
            .build();
    }

    private void publishClickEvent(String shortCode, HttpServletRequest request) {
        ClickEvent event = new ClickEvent();
        event.setShortCode(shortCode);
        event.setClientIp(getClientIp(request));
        event.setUserAgent(request.getHeader("User-Agent"));
        event.setReferer(request.getHeader("Referer"));
        event.setTimestamp(Instant.now());

        kafkaTemplate.send("click-events", shortCode, event);
    }
}

// Flink 实时统计处理
public class ClickAnalyticsJob {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();

        DataStream<ClickEvent> clicks = env
            .addSource(new FlinkKafkaConsumer<>("click-events",
                new ClickEventSchema(), kafkaProps));

        // 每分钟统计各短链接的点击量
        clicks
            .keyBy(ClickEvent::getShortCode)
            .window(TumblingProcessingTimeWindows.of(Time.minutes(1)))
            .aggregate(new ClickCountAggregator())
            .addSink(new ClickHouseSink());

        // 实时更新 Redis 计数器
        clicks
            .keyBy(ClickEvent::getShortCode)
            .process(new ProcessFunction<ClickEvent, Void>() {
                @Override
                public void processElement(ClickEvent event, Context ctx, Collector<Void> out) {
                    redisClient.incr("clicks:" + event.getShortCode());
                    redisClient.pfAdd("uv:" + event.getShortCode(), event.getClientIp());
                }
            });

        env.execute("Click Analytics");
    }
}

// 多级缓存
@Component
public class ShortUrlCache {
    // L1: 本地缓存 (热点数据)
    private final Cache<String, String> localCache = Caffeine.newBuilder()
        .maximumSize(100_000)
        .expireAfterAccess(10, TimeUnit.MINUTES)
        .build();

    @Autowired
    private RedisTemplate<String, String> redis;

    public String getLongUrl(String shortCode) {
        // L1
        String url = localCache.getIfPresent(shortCode);
        if (url != null) return url;

        // L2
        url = redis.opsForValue().get("short:" + shortCode);
        if (url != null) {
            localCache.put(shortCode, url);
            return url;
        }

        return null; // 需要查数据库
    }
}

// URL 安全检查
public class UrlSafetyChecker {
    private final Set<String> blacklistedDomains;

    public boolean isSafe(String url) {
        URI uri = URI.create(url);
        String host = uri.getHost().toLowerCase();

        // 黑名单检查
        if (blacklistedDomains.contains(host)) {
            return false;
        }

        // 防止内网地址
        InetAddress addr = InetAddress.getByName(host);
        if (addr.isLoopbackAddress() || addr.isSiteLocalAddress()) {
            return false;
        }

        return true;
    }
}