最近是不是經常發現自己網站的圖片資源莫名其妙地出現在別人的網站上？而這些圖片卻是存儲在你自己的服務器，消耗着你的帶寬資源！更糟的是，當別人網站加載緩慢時，用户可能會誤以為是你的網站出了問題。作為開發者，我們需要一種有效的方式來保護自己的圖片資源，這就是圖片防盜鏈技術的意義所在。

什麼是圖片防盜鏈？

圖片防盜鏈是一種保護網站圖片資源不被其他網站直接引用的技術手段。當用户訪問網頁時，瀏覽器會發送包含 Referer 信息的 HTTP 請求，這個 Referer 記錄了請求來源頁面的 URL。

sequenceDiagram
    participant 用户瀏覽器
    participant 正常網站A
    participant 盜鏈網站B
    participant 圖片服務器

    用户瀏覽器->>正常網站A: 訪問網站A
    正常網站A->>用户瀏覽器: 返回HTML(包含圖片鏈接)
    用户瀏覽器->>圖片服務器: 請求圖片(Referer:網站A)
    圖片服務器->>用户瀏覽器: 返回圖片資源

    用户瀏覽器->>盜鏈網站B: 訪問網站B
    盜鏈網站B->>用户瀏覽器: 返回HTML(包含網站A的圖片鏈接)
    用户瀏覽器->>圖片服務器: 請求圖片(Referer:網站B)
    圖片服務器-->>用户瀏覽器: 拒絕請求(檢測到非法Referer)

防盜鏈的原理就是通過檢查 HTTP 請求頭中的 Referer 字段，判斷請求是否來自允許的域名。如果不是，則拒絕提供服務。

為什麼需要實現圖片防盜鏈？

1. 節省帶寬資源：圖片被他人網站引用時，消耗的是你自己服務器的帶寬資源
2. 保護版權：避免原創圖片被隨意使用
3. 控制訪問來源：確保資源只被允許的網站使用
4. 防止資源濫用：避免惡意網站大量引用導致服務器負載過高

SpringBoot 實現圖片防盜鏈方案

在 SpringBoot 中實現圖片防盜鏈，我選擇使用過濾器（Filter）方式，因為它能在請求到達控制器前攔截並處理，適合處理跨域請求和防盜鏈需求。

實現思路

flowchart TD
    A[HTTP請求] --> B{過濾器}
    B -->|Referer合法| C[放行請求]
    B -->|Referer不合法| D[拒絕請求]
    B -->|無Referer但允許| C
    B -->|請求非圖片資源| C
    B -->|資源在白名單中| C
    C --> E[Controller處理]
    D --> F[返回錯誤信息或默認圖片]

更詳細的組件協作流程：

sequenceDiagram
    participant 瀏覽器
    participant 過濾器
    participant RefererChecker
    participant 緩存
    participant 策略工廠

    瀏覽器->>過濾器: HTTP GET /image.jpg
    過濾器->>ResourceTypeChecker: 檢查是否為圖片資源
    ResourceTypeChecker-->>過濾器: 是（.jpg）
    過濾器->>RefererChecker: 獲取Referer
    RefererChecker->>緩存: 檢查緩存
    緩存-->>RefererChecker: 未命中，檢查域名
    RefererChecker-->>過濾器: 非法Referer
    過濾器->>策略工廠: 獲取拒絕策略
    策略工廠-->>過濾器: DefaultImageStrategy
    過濾器->>瀏覽器: 返回默認圖片（200 OK）

項目實現步驟

1. 創建 SpringBoot 項目

首先創建一個基礎的 SpringBoot 項目，添加必要的依賴：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-configuration-processor</artifactId>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <!-- 添加緩存支持 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-cache</artifactId>
    </dependency>
    <dependency>
        <groupId>com.github.ben-manes.caffeine</groupId>
        <artifactId>caffeine</artifactId>
    </dependency>
</dependencies>

2. 添加配置參數

在application.yml中添加防盜鏈配置：

# 防盜鏈配置
anti-hotlink:
  # 是否啓用防盜鏈
  enabled: true
  # 允許的域名列表(支持精確匹配、子域名匹配和正則表達式)
  allowed-domains:
    - localhost
    - 127.0.0.1
    - example.com
    - "*.example.com"
    - "^test\\d+\\.domain\\.com$"  # 正則表達式，匹配test1.domain.com等
    - "^sub\\.example\\.com$"      # 匹配sub.example.com（YAML中反斜槓需雙重轉義）
  # 需要保護的資源格式
  protected-formats:
    - .jpg
    - .jpeg
    - .png
    - .gif
    - .bmp
    - .webp
  # 是否允許直接訪問(無Referer)
  allow-direct-access: true
  # 拒絕訪問時的動作：REDIRECT, FORBIDDEN, DEFAULT_IMAGE
  deny-action: DEFAULT_IMAGE
  # 默認圖片路徑(當deny-action為DEFAULT_IMAGE時使用)
  default-image: /images/no-hotlinking.png
  # 白名單路徑(不需要防盜鏈檢查的路徑)
  whitelist-paths:
    - /api/public/**
    - /images/public/**
  # 緩存配置
  cache:
    expire-after-write: 300  # 緩存有效期(秒)
    maximum-size: 1000       # 最大緩存條目數
  # 簽名URL配置
  signer:
    secret-key: ${SECURE_SIGNER_KEY}  # 從環境變量或配置中心獲取
    tolerance-seconds: 60  # 時間容差(秒)

3. 定義拒絕動作枚舉

使用枚舉替代字符串類型，提高代碼類型安全性：

package com.example.antihotlink.config;

import lombok.Getter;
import lombok.RequiredArgsConstructor;

@Getter
@RequiredArgsConstructor
public enum DenyAction {
    REDIRECT("redirect"),
    FORBIDDEN("forbidden"),
    DEFAULT_IMAGE("default");

    private final String value;

    public static DenyAction fromValue(String value) {
        for (DenyAction action : values()) {
            if (action.getValue().equals(value)) {
                return action;
            }
        }
        return DEFAULT_IMAGE; // 默認值
    }
}

4. 創建配置類讀取配置

package com.example.antihotlink.config;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.List;

@Data
@Component
@ConfigurationProperties(prefix = "anti-hotlink")
public class AntiHotlinkProperties {
    /**
     * 是否啓用防盜鏈
     */
    private boolean enabled = true;

    /**
     * 允許的域名列表
     */
    private List<String> allowedDomains = new ArrayList<>();

    /**
     * 需要保護的資源格式
     */
    private List<String> protectedFormats = new ArrayList<>();

    /**
     * 是否允許直接訪問(無Referer)
     */
    private boolean allowDirectAccess = true;

    /**
     * 拒絕訪問時的動作
     */
    private DenyAction denyAction = DenyAction.DEFAULT_IMAGE;

    /**
     * 默認圖片路徑
     */
    private String defaultImage = "/images/no-hotlinking.png";

    /**
     * 白名單路徑
     */
    private List<String> whitelistPaths = new ArrayList<>();

    /**
     * 緩存配置
     */
    @Data
    public static class CacheConfig {
        /**
         * 緩存過期時間(秒)
         */
        private int expireAfterWrite = 300;

        /**
         * 最大緩存條目數
         */
        private int maximumSize = 1000;
    }

    private CacheConfig cache = new CacheConfig();

    /**
     * 簽名URL配置
     */
    @Data
    public static class SignerConfig {
        /**
         * 簽名密鑰
         */
        private String secretKey;

        /**
         * 時間容差(秒)
         */
        private int toleranceSeconds = 60;
    }

    private SignerConfig signer = new SignerConfig();
}

5. 配置緩存管理器

package com.example.antihotlink.config;

import com.github.benmanes.caffeine.cache.Caffeine;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.caffeine.CaffeineCacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.concurrent.TimeUnit;

@Configuration
@EnableCaching
public class CacheConfig {

    private final AntiHotlinkProperties properties;

    public CacheConfig(AntiHotlinkProperties properties) {
        this.properties = properties;
    }

    @Bean
    public CacheManager antiHotlinkCacheManager() {
        CaffeineCacheManager cacheManager = new CaffeineCacheManager("allowedReferers");
        cacheManager.setCaffeine(Caffeine.newBuilder()
                .expireAfterWrite(properties.getCache().getExpireAfterWrite(), TimeUnit.SECONDS)
                .maximumSize(properties.getCache().getMaximumSize())
                .recordStats()); // 啓用統計信息收集，用於監控
        return cacheManager;
    }
}

6. 創建拒絕策略接口和實現

按照單一職責原則，將拒絕處理邏輯分離為獨立策略：

package com.example.antihotlink.strategy;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public interface DenyActionStrategy {
    /**
     * 處理拒絕訪問請求
     */
    void handle(HttpServletRequest request, HttpServletResponse response) throws IOException;
}

實現幾種拒絕策略：

package com.example.antihotlink.strategy.impl;

import com.example.antihotlink.strategy.DenyActionStrategy;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@Slf4j
@Component("forbiddenStrategy")
public class ForbiddenStrategy implements DenyActionStrategy {
    @Override
    public void handle(HttpServletRequest request, HttpServletResponse response) throws IOException {
        response.setStatus(HttpStatus.FORBIDDEN.value());
        response.getWriter().write("Forbidden: Direct linking to this resource is not allowed");
    }
}

package com.example.antihotlink.strategy.impl;

import com.example.antihotlink.strategy.DenyActionStrategy;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@Slf4j
@Component("redirectStrategy")
public class RedirectStrategy implements DenyActionStrategy {
    @Override
    public void handle(HttpServletRequest request, HttpServletResponse response) throws IOException {
        response.sendRedirect("/");
    }
}

package com.example.antihotlink.strategy.impl;

import com.example.antihotlink.config.AntiHotlinkProperties;
import com.example.antihotlink.strategy.DenyActionStrategy;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.core.io.Resource;
import org.springframework.core.io.ResourceLoader;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.MediaTypeFactory;
import org.springframework.stereotype.Component;
import org.springframework.util.StreamUtils;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.InputStream;

@Slf4j
@Component("defaultImageStrategy")
@RequiredArgsConstructor
public class DefaultImageStrategy implements DenyActionStrategy {

    private final AntiHotlinkProperties properties;
    private final ResourceLoader resourceLoader;

    @Override
    public void handle(HttpServletRequest request, HttpServletResponse response) throws IOException {
        try {
            String defaultImagePath = properties.getDefaultImage();
            // 根據資源路徑確定加載位置，避免硬編碼路徑前綴
            String resourcePath;
            if (defaultImagePath.startsWith("/")) {
                resourcePath = "classpath:static" + defaultImagePath;
            } else {
                resourcePath = "classpath:" + defaultImagePath;
            }

            Resource resource = resourceLoader.getResource(resourcePath);
            if (!resource.exists()) {
                log.error("默認圖片資源不存在: {}", resourcePath);
                response.setStatus(HttpStatus.NOT_FOUND.value());
                return;
            }

            // 根據文件擴展名動態設置MIME類型，避免硬編碼
            MediaType mediaType = MediaTypeFactory.getMediaTypeForFileName(defaultImagePath)
                    .orElse(MediaType.IMAGE_JPEG); // 設置更精準的默認值
            response.setContentType(mediaType.toString());

            try (InputStream in = resource.getInputStream()) {
                StreamUtils.copy(in, response.getOutputStream());
            }
        } catch (Exception e) {
            log.error("發送默認圖片時出錯: {}", e.getMessage(), e);
            response.setStatus(HttpStatus.INTERNAL_SERVER_ERROR.value());
        }
    }
}

7. 創建策略工廠

package com.example.antihotlink.strategy;

import com.example.antihotlink.config.DenyAction;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.util.HashMap;
import java.util.Map;

@Component
@RequiredArgsConstructor
public class DenyActionStrategyFactory {

    private final DenyActionStrategy defaultImageStrategy;
    private final DenyActionStrategy forbiddenStrategy;
    private final DenyActionStrategy redirectStrategy;

    private final Map<DenyAction, DenyActionStrategy> strategies = new HashMap<>();

    @PostConstruct
    public void init() {
        strategies.put(DenyAction.DEFAULT_IMAGE, defaultImageStrategy);
        strategies.put(DenyAction.FORBIDDEN, forbiddenStrategy);
        strategies.put(DenyAction.REDIRECT, redirectStrategy);
    }

    public DenyActionStrategy getStrategy(DenyAction action) {
        return strategies.getOrDefault(action, defaultImageStrategy);
    }
}

8. 創建 Referer 檢查器組件

package com.example.antihotlink.service;

import com.example.antihotlink.config.AntiHotlinkProperties;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;

@Slf4j
@Component
@RequiredArgsConstructor
public class RefererChecker {

    private final AntiHotlinkProperties properties;
    // 預編譯正則表達式，提高性能
    private final Map<String, Pattern> regexPatterns = new HashMap<>();

    @PostConstruct
    public void init() {
        // 初始化時預編譯所有正則表達式
        properties.getAllowedDomains().stream()
                .filter(domain -> domain.startsWith("^"))
                .forEach(domain -> {
                    try {
                        regexPatterns.put(domain, Pattern.compile(domain));
                    } catch (PatternSyntaxException e) {
                        log.error("跳過無效正則規則: {}，錯誤: {}", domain, e.getMessage());
                        // 可以在此添加監控指標或報警通知
                    }
                });
        log.info("預編譯正則表達式完成，共 {} 個模式", regexPatterns.size());
    }

    /**
     * 檢查Referer是否允許訪問
     * 使用緩存優化性能
     */
    @Cacheable(value = "allowedReferers", key = "#referer", cacheManager = "antiHotlinkCacheManager")
    public boolean isAllowedReferer(String referer) {
        if (referer == null || referer.isEmpty()) {
            return properties.isAllowDirectAccess();
        }

        try {
            URL refererUrl = new URL(referer);
            String refererHost = refererUrl.getHost();
            return isAllowedRefererHost(refererHost);
        } catch (MalformedURLException e) {
            log.warn("非法Referer格式: {}", referer, e);
            return false; // 非法格式拒絕訪問，而不是直接放行
        }
    }

    /**
     * 檢查Referer域名是否在允許列表中
     */
    private boolean isAllowedRefererHost(String refererHost) {
        for (String domain : properties.getAllowedDomains()) {
            // 精確匹配
            if (domain.equals(refererHost)) {
                return true;
            }

            // 通配符匹配(*.example.com)
            if (domain.startsWith("*.") && refererHost.endsWith(domain.substring(1))) {
                return true;
            }

            // 正則表達式匹配 - 使用預編譯的Pattern
            if (domain.startsWith("^") && regexPatterns.containsKey(domain)) {
                Pattern pattern = regexPatterns.get(domain);
                if (pattern.matcher(refererHost).matches()) {
                    return true;
                }
            }
        }
        return false;
    }
}

9. 創建資源類型檢查器

package com.example.antihotlink.service;

import com.example.antihotlink.config.AntiHotlinkProperties;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.springframework.util.AntPathMatcher;

@Slf4j
@Component
@RequiredArgsConstructor
public class ResourceTypeChecker {

    private final AntiHotlinkProperties properties;
    private final AntPathMatcher pathMatcher = new AntPathMatcher();

    /**
     * 檢查請求的資源是否受保護
     */
    public boolean isProtectedResource(String requestUri) {
        // 檢查是否在白名單路徑中
        if (isWhitelistedPath(requestUri)) {
            return false;
        }

        // 檢查是否是受保護的文件格式
        String lowerUri = requestUri.toLowerCase();
        return properties.getProtectedFormats().stream()
                .map(String::toLowerCase) // 確保格式比較忽略大小寫
                .anyMatch(lowerUri::endsWith);
    }

    /**
     * 檢查請求路徑是否在白名單中
     */
    private boolean isWhitelistedPath(String requestUri) {
        return properties.getWhitelistPaths().stream()
                .anyMatch(pattern -> pathMatcher.match(pattern, requestUri));
    }
}

10. 優化的防盜鏈過濾器

package com.example.antihotlink.filter;

import com.example.antihotlink.config.AntiHotlinkProperties;
import com.example.antihotlink.service.RefererChecker;
import com.example.antihotlink.service.ResourceTypeChecker;
import com.example.antihotlink.strategy.DenyActionStrategyFactory;
import io.micrometer.core.instrument.MeterRegistry;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.net.URL;

@Slf4j
@Component
@RequiredArgsConstructor
public class AntiHotlinkFilter extends OncePerRequestFilter {

    private final AntiHotlinkProperties properties;
    private final ResourceTypeChecker resourceTypeChecker;
    private final RefererChecker refererChecker;
    private final DenyActionStrategyFactory strategyFactory;
    private final MeterRegistry meterRegistry; // 用於性能監控

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
            throws ServletException, IOException {

        // 如果防盜鏈未啓用，直接放行
        if (!properties.isEnabled()) {
            filterChain.doFilter(request, response);
            return;
        }

        String requestUri = request.getRequestURI();

        // 檢查是否是受保護的資源格式
        boolean isProtectedResource = resourceTypeChecker.isProtectedResource(requestUri);
        if (!isProtectedResource) {
            filterChain.doFilter(request, response);
            return;
        }

        // 獲取Referer並檢查
        String referer = request.getHeader("Referer");
        boolean isAllowed = refererChecker.isAllowedReferer(referer);

        if (isAllowed) {
            // 記錄通過的請求指標
            meterRegistry.counter("anti.hotlink.allowed",
                "resource_type", getResourceType(requestUri)).increment();
            filterChain.doFilter(request, response);
        } else {
            // 記錄被攔截的請求指標
            meterRegistry.counter("anti.hotlink.blocked",
                "referer_domain", getDomain(referer),
                "resource_type", getResourceType(requestUri)).increment();

            log.info("檢測到圖片盜鏈: {} -> {}", referer, requestUri);
            // 使用策略模式處理拒絕訪問
            strategyFactory.getStrategy(properties.getDenyAction())
                    .handle(request, response);
        }
    }

    // 獲取資源類型，用於統計
    private String getResourceType(String uri) {
        int lastDotIndex = uri.lastIndexOf('.');
        if (lastDotIndex > 0 && lastDotIndex < uri.length() - 1) {
            return uri.substring(lastDotIndex).toLowerCase();
        }
        return "unknown";
    }

    // 從Referer中提取域名
    private String getDomain(String referer) {
        if (referer == null || referer.isEmpty()) {
            return "no-referer";
        }

        try {
            URL url = new URL(referer);
            return url.getHost();
        } catch (Exception e) {
            return "invalid-referer";
        }
    }
}

11. 添加簽名 URL 支持

package com.example.antihotlink.util;

import com.example.antihotlink.config.AntiHotlinkProperties;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.time.Instant;
import java.util.Base64;

@Slf4j
@Component
@RequiredArgsConstructor
public class UrlSigner {

    private static final String HMAC_ALGORITHM = "HmacSHA256";
    private final AntiHotlinkProperties properties;

    /**
     * 生成帶簽名的URL
     * @param path 圖片路徑
     * @param expireSeconds 有效期秒數
     * @return 帶簽名的URL
     */
    public String generateSignedUrl(String path, long expireSeconds) {
        Instant expireAt = Instant.now().plusSeconds(expireSeconds);
        long expireTimestamp = expireAt.getEpochSecond();

        String dataToSign = path + ":" + expireTimestamp;
        String signature = generateHmac(dataToSign);

        return path + "?expires=" + expireTimestamp + "&signature=" + signature;
    }

    /**
     * 驗證URL簽名
     * @param path 圖片路徑
     * @param expires 過期時間戳
     * @param signature 簽名
     * @return 是否有效
     */
    public boolean verifySignedUrl(String path, long expires, String signature) {
        return verifySignedUrl(path, expires, signature, properties.getSigner().getToleranceSeconds());
    }

    /**
     * 驗證URL簽名(帶時間容差)
     * @param path 圖片路徑
     * @param expires 過期時間戳
     * @param signature 簽名
     * @param toleranceSeconds
     * @return 是否有效
     */
    public boolean verifySignedUrl(String path, long expires, String signature, long toleranceSeconds) {
        // 檢查是否已過期，考慮時間容差
        if (Instant.now().plusSeconds(toleranceSeconds).getEpochSecond() > expires) {
            return false;
        }

        String dataToSign = path + ":" + expires;
        String expectedSignature = generateHmac(dataToSign);

        return expectedSignature.equals(signature);
    }

    private String generateHmac(String data) {
        try {
            String secretKey = properties.getSigner().getSecretKey();
            if (secretKey == null || secretKey.isEmpty()) {
                throw new IllegalStateException("簽名密鑰未配置");
            }

            Mac hmac = Mac.getInstance(HMAC_ALGORITHM);
            SecretKeySpec secretKeySpec = new SecretKeySpec(
                    secretKey.getBytes(StandardCharsets.UTF_8), HMAC_ALGORITHM);
            hmac.init(secretKeySpec);
            byte[] hmacBytes = hmac.doFinal(data.getBytes(StandardCharsets.UTF_8));
            return Base64.getUrlEncoder().withoutPadding().encodeToString(hmacBytes);
        } catch (NoSuchAlgorithmException | InvalidKeyException e) {
            log.error("生成HMAC簽名失敗", e);
            throw new RuntimeException("簽名失敗", e);
        }
    }
}

使用示例：

@RestController
@RequiredArgsConstructor
public class ImageUrlController {

    private final UrlSigner urlSigner;

    @GetMapping("/generate-image-url")
    public Map<String, String> generateImageUrl(@RequestParam String imagePath) {
        // 生成24小時有效的簽名URL
        String signedUrl = urlSigner.generateSignedUrl(imagePath, 86400);
        return Map.of("url", signedUrl);
    }
}

域名匹配規則説明

在配置防盜鏈允許域名時，支持多種匹配方式：

注意：

• 正則表達式在 YAML 中需要雙重轉義（反斜槓自身需要轉義）
• 端口號不參與域名匹配判斷
• 匹配規則按配置順序檢查，命中任一規則即通過

生產環境部署注意事項

CDN 與反向代理兼容

使用 CDN 或反向代理時需要特別注意：

1. Nginx 配置轉發 Referer:

proxy_set_header Referer $http_referer;

2. HTTPS 與 HTTP 混合使用:
   若網站同時支持 HTTP 和 HTTPS，需要注意 Referer 的協議頭差異。來自 HTTPS 頁面的請求訪問 HTTP 資源時，瀏覽器可能不發送 Referer，或者只發送域名部分。
3. 多級代理場景:
   多級代理可能會丟失原始 Referer，此時可使用X-Forwarded-Host等自定義頭部。

CDN 與應用層防盜鏈配合

採用分層防護策略效果最佳：

1. CDN 邊緣層防盜鏈 - 第一道防線:

• 配置 Referer 白名單和 User-Agent 限制
• 靠近用户，減少無效流量傳輸，降低源站壓力
• 示例: 阿里雲 OSS 設置 Referer 白名單並禁止空 Referer

2. 雲存儲防盜鏈配置:

• 在雲存儲控制枱配置 Referer 白名單，作為第一層防護
• 應用層過濾器作為補充，處理未被雲存儲攔截的請求
• 敏感資源優先使用雲存儲的簽名 URL（如 AWS S3 的 Presigned URL）

3. 應用層防盜鏈 - 第二道防線:

• 處理複雜驗證邏輯和精細控制
• 與用户認證系統結合，限制資源訪問權限

防 Referer 欺騙

Referer 可以被偽造，建議多重保護：

1. 簽名 URL: 添加時間限制和唯一性驗證
2. 結合用户認證: 敏感資源檢查登錄狀態
3. 限流防護: 對可疑 IP 實施請求頻率限制

跨域與 CORS

若需要支持第三方合法調用，需配置 CORS：

@Bean
public WebMvcConfigurer corsConfigurer() {
    return new WebMvcConfigurer() {
        @Override
        public void addCorsMappings(CorsRegistry registry) {
            registry.addMapping("/images/**")
                .allowedOrigins("https://partner.example.com")
                .allowedMethods("GET")
                .maxAge(3600);
        }
    };
}

性能監控與緩存優化

高併發環境下的監控建議：

1. 緩存命中率監控:

@Autowired
private CaffeineCache allowedReferersCache;

// 每分鐘記錄緩存統計
@Scheduled(fixedRate = 60000)
public void reportCacheStats() {
    log.info("防盜鏈緩存統計: 命中率={}, 加載時間={}ms",
        allowedReferersCache.getNativeCache().stats().hitRate(),
        allowedReferersCache.getNativeCache().stats().averageLoadPenalty()/1000000);
}

2. Micrometer 指標收集:

// 監控緩存命中率
meterRegistry.gauge("anti.hotlink.cache.hitRate",
    allowedReferersCache.getNativeCache().stats(), stats -> stats.hitRate());

3. 異步日誌配置:

<appender name="ASYNC" class="ch.qos.logback.classic.AsyncAppender">
  <appender-ref ref="FILE" />
  <queueSize>512</queueSize>
  <discardingThreshold>0</discardingThreshold>
</appender>

常見問題

Q：為什麼配置了允許域名仍被攔截？

A：可能原因：

1. Referer URL 格式不正確（需包含協議頭）
2. 域名大小寫不匹配
3. 帶端口的域名配置問題
4. 反向代理修改/丟失了原始 Referer

Q：移動端 App 請求無 Referer 如何處理？

A：解決方案：

1. 開啓allow-direct-access配置
2. 要求 App 添加自定義認證頭（如X-App-Token）
3. 為 App 提供簽名 URL 訪問機制

Q：瀏覽器隱私模式適配問題？

A：部分瀏覽器（如 Chrome 隱身模式、Firefox 私密瀏覽）可能不發送 Referer，或發送no-referrer。處理方法：

1. 配置allow-direct-access=true
2. 結合 Cookie 驗證替代 Referer 檢查
3. 提供備用認證機制（如 URL 參數令牌）

Q：如何處理圖片在社交媒體分享？

A：社交平台抓取圖片預覽的處理：

1. 將社交平台域名添加到白名單
2. 創建專用預覽圖片路徑並加入白名單
3. 提供低分辨率預覽版本開放訪問

優化與擴展

1. 動態配置刷新

@RefreshScope // 結合Spring Cloud Config使用
@Component
@ConfigurationProperties(prefix = "anti-hotlink")
public class AntiHotlinkProperties {
    // 屬性配置...
}

或實現定時刷新：

@Scheduled(fixedRateString = "${anti-hotlink.config-refresh-interval:60000}")
public void refreshConfig() {
    // 從數據庫或配置中心重新加載配置
    allowedDomains = domainRepository.findAllAllowedDomains();
    // 刷新預編譯正則表達式
    refreshRegexPatterns();
}

2. 多策略組合防禦

flowchart TD
    A["HTTP請求"] --> B{"防盜鏈過濾器"}
    B --> C{"Referer檢查"} & D{"簽名驗證"} & E{"訪問頻率檢查"} & F{"用户認證"}
    C -- 通過 --> G["放行"]
    D -- 通過 --> G
    E -- 通過 --> G
    F -- 通過 --> G
    C -- 不通過 --> H["拒絕"]
    D -- 不通過 --> H
    E -- 不通過 --> H
    F -- 不通過 --> H

    linkStyle 5 stroke:#D50000,fill:none
    linkStyle 6 stroke:#FFD600,fill:none
    linkStyle 7 stroke:#00C853,fill:none
    linkStyle 8 stroke:#2962FF,fill:none
    linkStyle 9 stroke:#D50000,fill:none
    linkStyle 10 stroke:#FFD600,fill:none
    linkStyle 11 stroke:#00C853,fill:none
    linkStyle 12 stroke:#2962FF

實現組合策略鏈：

public class CompositeProtectionChain {
    private final List<ProtectionStrategy> strategies;

    // 按順序執行所有策略
    public boolean check(HttpServletRequest request) {
        return strategies.stream()
                .allMatch(strategy -> strategy.check(request));
    }
}

3. 水印與追蹤機制

對圖片添加動態水印，便於追蹤泄露源：

@GetMapping("/images/{filename:.+}")
public void getImageWithWatermark(
        @PathVariable String filename,
        HttpServletRequest request,
        HttpServletResponse response) throws IOException {

    // 讀取原始圖片
    Resource imageResource = resourceLoader.getResource("classpath:images/" + filename);
    BufferedImage originalImage = ImageIO.read(imageResource.getInputStream());

    // 添加水印(如用户ID或請求IP)
    String watermarkText = request.getRemoteAddr();
    BufferedImage watermarkedImage = addWatermark(originalImage, watermarkText);

    // 輸出圖片
    response.setContentType(MediaType.IMAGE_JPEG_VALUE);
    ImageIO.write(watermarkedImage, "jpg", response.getOutputStream());
}

性能對比

不同優化手段對防盜鏈系統性能的影響：

注：數據基於 4 核 8G 內存測試環境，實際性能因環境而異

總結