SpringBoot vs Nginx：5种实现 vs 1个指令，谁才是防盗链的“真·王者”？

location ~* \.(gif|jpg|png|jpeg)$ {
    root /web;  # 这是资源存放的根目录，你得替换成你的实际路径
    valid_referers none blocked *.ttlsa.com server_names ~\.google\. ~\.baidu\.;  # 允许的域名白名单
    if ($invalid_referer) {  


    
# 如果请求来源不在白名单里
        # return 403;  # 暴力拒绝，直接返回403错误
        rewrite ^/ https://img-blog.csdnimg.cn/20200429152123372.png;  # 重定向到防盗链提示图
    }
}

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.env.Environment;
import org.springframework.stereotype.Component;

import javax.servlet.*;
import


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

@Component
@Slf4j
publicclass AntiHotlinkFilter implements Filter {

    @Value("${anti-hotlink.enabled}")
    


    
privateboolean enabled;  // 是否启用防盗链

    @Value("${anti-hotlink.allowed-domains}")
    private List allowedDomains;  // 允许的域名列表

    @Value("${anti-hotlink.protected-formats}")
    private List protectedFormats;  // 需要保护的资源格式

    @Value(


    
"${anti-hotlink.allow-direct-access}")
    privateboolean allowDirectAccess;  // 是否允许直接访问（无Referer）

    @Value("${anti-hotlink.deny-action}")
    private String denyAction;  // 拒绝访问时的动作

    @Value("${anti-hotlink.default-image}")
    private String defaultImage;  // 默认图片路径

    


    
@Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        HttpServletRequest req = (HttpServletRequest) request;
        HttpServletResponse res = (HttpServletResponse) response;
        
        // 如果防盗链未启用，直接放行
        if (!enabled) {
            chain.doFilter(request, response);
            return;
        }



    

        // 获取Referer
        String referer = req.getHeader("referer");
        log.debug("Referer: {}", referer);

        // 检查是否为白名单路径
        if (isWhitelistPath(req.getRequestURI())) {
            chain.doFilter(request, response);
            return;
        }

        // 检查是否允许直接访问
        if (allowDirectAccess && (referer == null || referer.isEmpty())) {


    

            chain.doFilter(request, response);
            return;
        }

        // 检查Referer是否在白名单中
        boolean isAllowed = false;
        for (String domain : allowedDomains) {
            if (domain.equals("none") && referer == null) {
                isAllowed = true;
                


    
break;
            }
            if (domain.equals("blocked") && (referer == null || referer.isEmpty())) {
                isAllowed = true;
                break;
            }
            if (domain.startsWith("*.") && referer != null && referer.contains(domain.substring(2))) {
                isAllowed = true


    
;
                break;
            }
            if (domain.matches("^~\\..*\\..*$") && referer != null && referer.matches(domain.substring(1))) {
                isAllowed = true;
                break;
            }
            if (referer != null && referer.contains(domain)) {
                isAllowed = true


    
;
                break;
            }
        }

        // 如果不在白名单，处理拒绝
        if (!isAllowed) {
            handleDenyAction(res, defaultImage);
            return;
        }

        chain.doFilter(request, response);
    }

    private boolean isWhitelistPath


    
(String uri) {
        // 白名单路径配置，如/api/public/**
        returnfalse; // 实际实现中需要根据配置判断
    }

    private void handleDenyAction(HttpServletResponse res, String defaultImage) {
        // 根据deny-action配置决定处理方式
        if ("REDIRECT"


    
.equals(denyAction)) {
            try {
                res.sendRedirect(defaultImage);
            } catch (IOException e) {
                log.error("Redirect failed", e);
            }
        } elseif ("FORBIDDEN".equals(denyAction)) {
            res.setStatus(HttpServletResponse.SC_FORBIDDEN);
        } elseif ("DEFAULT_IMAGE".equals(denyAction)) {
            


    
try {
                res.setContentType("image/png");
                res.getOutputStream().write(getImageBytes(defaultImage));
            } catch (IOException e) {
                log.error("Failed to send default image", e);
            }
        }
    }

    privatebyte[] getImageBytes(String path) {
        // 读取默认图片的字节数据
        returnnewbyte[


    
0]; // 实际实现中需要读取文件
    }
}

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

publicclass AntiHotlinkInterceptor implements


    
 HandlerInterceptor {

    private List allowedDomains;
    private List protectedFormats;
    privateboolean allowDirectAccess;
    private String denyAction;
    private String defaultImage;

    // 从配置中注入
    public 


    
AntiHotlinkInterceptor(List allowedDomains, List protectedFormats, 
                                 boolean allowDirectAccess, String denyAction, String defaultImage) {
        this.allowedDomains = allowedDomains;
        this.protectedFormats = protectedFormats;
        this.allowDirectAccess = allowDirectAccess;
        this.denyAction = denyAction;
        this.defaultImage = defaultImage;
    }

    @Override
    


    
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 与Filter类似，检查Referer
        String referer = request.getHeader("referer");
        String uri = request.getRequestURI();

        // 检查是否为保护资源
        if (!isProtectedResource(uri)) {
            returntrue;
        }



    

        // 检查Referer
        if (isRefererAllowed(referer)) {
            returntrue;
        }

        // 处理拒绝
        handleDenyAction(response);
        returnfalse;
    }

    private boolean isProtectedResource


    
(String uri) {
        // 检查文件扩展名是否在protectedFormats中
        returnfalse; // 实际实现中需要判断
    }

    private boolean isRefererAllowed(String referer) {
        // 与Filter中的逻辑类似
        returnfalse;


    

    }

    private void handleDenyAction(HttpServletResponse response) throws IOException {
        // 与Filter中的逻辑类似
    }
}

location ~* \.(gif|jpg|png|jpeg)$ {
    root /web;
    valid_referers none blocked *.yourdomain.com server_names ~\.google\. ~\.baidu\.;  # 允许的域名
    


    
if ($invalid_referer) {
        return 403;  # 直接返回403错误
        # 或者重定向到防盗链图片：rewrite ^/ https://yourdomain.com/images/no-hotlinking.png;
    }
}

import org.springframework.util.DigestUtils;

publicclass SignatureUtil {
    


    
privatestaticfinal String SECRET_KEY = "your_secret_key";  // 秘钥，需要保密

    public static String generateSignature(String url) {
        // 生成签名：时间戳 + 秘钥 + URL
        long timestamp = System.currentTimeMillis() / 1000;
        String signature = DigestUtils.md5DigestAsHex((url + SECRET_KEY + timestamp).getBytes());
        return


    
 url + "?timestamp=" + timestamp + "&signature=" + signature;
    }

    public static boolean validateSignature(String url, String signature) {
        // 验证签名：检查时间戳和签名
        String[] parts = url.split("\\?");
        if (parts.length 2) 


    
returnfalse;
        String params = parts[1];
        String[] paramPairs = params.split("&");
        Map paramMap = new HashMap<>();
        for (String pair : paramPairs) {
            String[] kv = pair.split("=");
            if (kv.length == 2) {
                paramMap.put(kv[0], kv[1]);



    
            }
        }

        if (!paramMap.containsKey("timestamp") || !paramMap.containsKey("signature")) {
            returnfalse;
        }

        long timestamp = Long.parseLong(paramMap.get("timestamp"));
        String expectedSignature = DigestUtils.md5DigestAsHex((url + SECRET_KEY + timestamp).getBytes());
        return expectedSignature.equals(signature);
    }
}

# application.yml
anti-hotlink:
enabled:true
allowed-domains:
    -localhost
    -127.0.0.1
    -"*.example.com"
    -"^test\\d+\\.domain\\.com$"


    

protected-formats:
    -.jpg
    -.jpeg
    -.png
    -.gif
allow-direct-access:true
deny-action:DEFAULT_IMAGE
default-image:/images/no-hotlinking.png
whitelist-paths:



    
    -/api/public/**
    -/images/public/**