Java实现：校验指定URL是否被robots.txt允许访问

嘿，这个问题我刚好有实操经验，咱们一步步拆解怎么用Java实现robots.txt的访问权限校验。其实核心逻辑就是解析robots.txt的规则，再结合目标URL和User-Agent来判断是否允许访问，下面是两种靠谱的实现方案：

不管用哪种方案，都绕不开这三个关键步骤：

• 解析robots.txt内容，筛选出与目标User-Agent匹配的规则组
• 将目标URL转换为站点根目录下的相对路径（比如https://example.com/admin/page会提取出/admin/page）
• 按规则顺序匹配路径，判断最终是否允许访问

自己手写解析器很容易踩规则的坑（比如通配符优先级、精确匹配符号$、规则顺序等），所以优先用经过验证的库，比如Apache Commons Robotstxt。

第一步：引入依赖 #

如果用Maven，在pom.xml里添加：

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-robotstxt</artifactId>
    <version>1.0.0</version> <!-- 建议使用最新稳定版本 -->
</dependency>

第二步：编写校验代码 #

import org.apache.commons.robotstxt.RobotstxtParser;
import java.io.StringReader;
import java.net.URL;

public class RobotsPermissionChecker {
    /**
     * 校验URL是否被robots.txt允许访问
     * @param robotsTxtContent robots.txt的文本内容
     * @param targetUrl 要校验的目标URL
     * @param userAgent 访问使用的User-Agent字符串
     * @return true=允许访问，false=禁止访问
     */
    public static boolean isUrlAllowed(String robotsTxtContent, String targetUrl, String userAgent) {
        try {
            RobotstxtParser parser = new RobotstxtParser();
            // 解析robots.txt内容
            parser.parse(new StringReader(robotsTxtContent));
            
            URL url = new URL(targetUrl);
            // 构造站点根URL（用于确定相对路径的基准）
            URL siteRootUrl = new URL(url.getProtocol(), url.getHost(), url.getPort(), "/");
            
            // 核心校验方法：库会自动处理规则优先级、路径匹配等逻辑
            return parser.isAllowed(userAgent, url, siteRootUrl);
        } catch (Exception e) {
            // 解析失败时（比如robots.txt格式错误），行业通常默认允许访问，可根据需求调整
            e.printStackTrace();
            return true;
        }
    }

    // 测试示例
    public static void main(String[] args) {
        String sampleRobotsTxt = """
                User-Agent: *
                Disallow: /admin/
                Allow: /admin/public/
                
                User-Agent: MyCustomCrawler/1.0
                Disallow: /private/
                """;
        String targetUrl = "https://example.com/admin/public/dashboard";
        String userAgent = "MyCustomCrawler/1.0";
        
        boolean result = isUrlAllowed(sampleRobotsTxt, targetUrl, userAgent);
        System.out.println("该URL是否允许访问：" + result); // 输出true
    }
}

代码说明 #

• RobotstxtParser会自动处理robots.txt的所有规则细节：比如特定User-Agent规则覆盖*规则、Allow优先级高于Disallow、通配符和$精确匹配等
• 异常处理逻辑：当解析出错时默认允许访问，这是爬虫领域的常见容错策略，你也可以根据业务需求改为拒绝

如果不想引入第三方依赖，也可以自己实现一个基础版本的解析器，适合简单场景：

import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Pattern;

public class SimpleRobotsChecker {
    // 封装规则：标记是Allow还是Disallow，以及对应的正则匹配模式
    static class AccessRule {
        boolean isAllow;
        Pattern matchPattern;

        AccessRule(boolean isAllow, String rulePath) {
            this.isAllow = isAllow;
            // 将robots.txt的通配符转换为正则表达式
            String regex = rulePath.replace("*", ".*").replace("$", "\\$");
            // 确保匹配从路径开头开始
            if (!regex.startsWith("^")) {
                regex = "^" + regex;
            }
            this.matchPattern = Pattern.compile(regex);
        }
    }

    public static boolean isUrlAllowed(String robotsTxtContent, String targetUrl, String userAgent) {
        try {
            URL url = new URL(targetUrl);
            String targetPath = url.getPath();
            // 处理根路径的特殊情况
            if (targetPath.isEmpty()) {
                targetPath = "/";
            }

            // 解析出当前User-Agent对应的规则组
            List<AccessRule> rules = getMatchingRules(robotsTxtContent, userAgent);

            // 按规则顺序匹配，第一个命中的规则生效
            for (AccessRule rule : rules) {
                if (rule.matchPattern.matcher(targetPath).find()) {
                    return rule.isAllow;
                }
            }

            // 无匹配规则时默认允许访问
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return true;
        }
    }

    // 从robots.txt中提取与目标User-Agent匹配的规则
    private static List<AccessRule> getMatchingRules(String robotsTxtContent, String userAgent) {
        List<AccessRule> rules = new ArrayList<>();
        boolean isCurrentAgentMatch = false;

        String[] lines = robotsTxtContent.split("\\r?\\n");
        for (String line : lines) {
            line = line.trim();
            // 跳过注释和空行
            if (line.isEmpty() || line.startsWith("#")) {
                continue;
            }

            // 匹配User-Agent行
            if (line.startsWith("User-Agent:")) {
                String agentPattern = line.substring("User-Agent:".length()).trim();
                // 判断是否匹配：要么是通配符*，要么User-Agent包含指定模式
                isCurrentAgentMatch = agentPattern.equals("*") || userAgent.contains(agentPattern);
            } 
            // 仅当当前User-Agent匹配时，才解析Allow/Disallow规则
            else if (isCurrentAgentMatch) {
                if (line.startsWith("Allow:")) {
                    String path = line.substring("Allow:".length()).trim();
                    rules.add(new AccessRule(true, path.isEmpty() ? "/" : path));
                } else if (line.startsWith("Disallow:")) {
                    String path = line.substring("Disallow:".length()).trim();
                    rules.add(new AccessRule(false, path.isEmpty() ? "/" : path));
                }
            }
        }

        // 如果没有找到匹配的User-Agent规则，回退到*的规则
        if (rules.isEmpty()) {
            return getMatchingRules(robotsTxtContent, "*");
        }

        return rules;
    }

    // 测试示例
    public static void main(String[] args) {
        String sampleRobotsTxt = """
                User-Agent: *
                Disallow: /admin/
                Allow: /admin/public/
                
                User-Agent: MyCustomCrawler/1.0
                Disallow: /private/
                """;
        String targetUrl = "https://example.com/admin/secret";
        String userAgent = "MyCustomCrawler/1.0";
        
        boolean result = isUrlAllowed(sampleRobotsTxt, targetUrl, userAgent);
        System.out.println("该URL是否允许访问：" + result); // 输出false
    }
}

注意事项 #

• 手动实现的版本只覆盖了基础规则，对于复杂场景（比如带参数的URL、多段通配符）可能会有遗漏
• 规则的顺序非常重要，必须严格按照robots.txt中的顺序匹配，第一个命中的规则决定结果

内容的提问来源于stack exchange，提问作者Denis Kulagin