基于浏览器的 Java 网络爬虫方法

Engine engine = Engine.newInstance(OFF_SCREEN);
Browser browser = engine.newBrowser();

browser.navigation().loadUrlAndWait(url, Duration.ofSeconds(30));

browser.mainFrame().flatMap(Frame::document).ifPresent(document ->
        // 通过分析锚点 HTML 元素的 HREF 属性来收集链接。
        document.findElementsByTagName("a").forEach(element -> {
            try {
                String href = element.attributeValue("href");
                toUrl(href, browser.url()).ifPresent(
                        url -> result.add(Link.of(url)));
            } catch (IllegalStateException ignore) {
                // 网页的 DOM 可能会被 JavaScript 动态更改。
                // 我们分析的 DOM HTML 元素可能在我们的分析过程中被移除。
                // 我们不分析已移除 DOM 元素的属性。
            }
        }));

/**
 * 返回表示当前已加载网页 HTML 的字符串。
 */
private String html(Browser browser) {
    AtomicReference<String> htmlRef = new AtomicReference<>("");
    browser.mainFrame().ifPresent(frame -> 
            htmlRef.set(frame.html()));
    return htmlRef.get();
}

package com.teamdev.jxbrowser.examples.webcrawler;

import static com.google.common.base.Preconditions.checkNotNull;
import static com.teamdev.jxbrowser.engine.RenderingMode.OFF_SCREEN;

import com.google.common.collect.ImmutableSet;
import com.teamdev.jxbrowser.browser.Browser;
import com.teamdev.jxbrowser.engine.Engine;
import com.teamdev.jxbrowser.engine.EngineOptions;
import java.io.Closeable;
import java.util.HashSet;
import java.util.Optional;
import java.util.Set;

/**
 * 基于 JxBrowser 的网页爬虫实现，
 * 可以发现和分析网页，
 * 访问它们的 DOM 和 HTML 内容，
 * 查找网页上的损坏链接等。
 */
public final class WebCrawler implements Closeable {

    /**
     *
     * 为给定的目标 {@code url} 创建一个新的 {@code WebCrawler} 实例。
     *
     * @param url     爬虫将开始分析的目标网页的 URL
     * @param factory 用于为内部和外部 URL 创建 {@link
     *                WebPage} 实例的工厂
     */
    public static WebCrawler newInstance(String url,
            WebPageFactory factory) {
        return new WebCrawler(url, factory);
    }

    private final Engine engine;
    private final Browser browser;
    private final String targetUrl;
    private final Set<WebPage> pages;
    private final WebPageFactory pageFactory;

    private WebCrawler(String url, WebPageFactory factory) {
        checkNotNull(url);
        checkNotNull(factory);

        targetUrl = url;
        pageFactory = factory;
        pages = new HashSet<>();

        engine = Engine.newInstance(
                EngineOptions.newBuilder(OFF_SCREEN)
                        // 在 Chromium 的隐身模式下访问网页。
                        .enableIncognito()
                        .build());
        browser = engine.newBrowser();
    }

    /**
     * 启动网络爬虫，并通过给定的 {@code listener} 报告进度。
     * 分析网站所需的时间取决于发现的网页数量。
     *
     * <p>此操作会阻塞当前线程的执行，
     * 直到爬虫停止分析已发现的网页。
     *
     * @param listener 一个监听器，将被调用来报告进度。
     */
    public void start(WebCrawlerListener listener) {
        checkNotNull(listener);
        analyze(targetUrl, pageFactory, listener);
    }

    private void analyze(String url, WebPageFactory factory,
            WebCrawlerListener listener) {
        if (!isVisited(url)) {
            WebPage webPage = factory.create(browser, url);
            pages.add(webPage);

            // 通知监听器已访问了一个网页。
            listener.webPageVisited(webPage);

            // 如果是外部网页，则不遍历其链接。
            if (url.startsWith(targetUrl)) {
                webPage.links().forEach(
                        link -> analyze(link.url(), factory,
                                listener));
            }
        }
    }

    /**
     * 检查给定的 {@code url} 是否属于已访问过的网页。
     */
    private boolean isVisited(String url) {
        checkNotNull(url);
        return page(url).orElse(null) != null;
    }

    /**
     * 返回此网络爬虫已分析过的网页的不可变集合。
     */
    public ImmutableSet<WebPage> pages() {
        return ImmutableSet.copyOf(pages);
    }

    /**
     * 返回一个包含与给定 {@code url} 关联的网页的 {@code Optional}，
     * 如果不存在这样的网页，
     * 则返回空的选项。
     */
    public Optional<WebPage> page(String url) {
        checkNotNull(url);
        for (WebPage page : pages) {
            if (page.url().equals(url)) {
                return Optional.of(page);
            }
        }
        return Optional.empty();
    }

    /**
     * 释放所有已分配的资源，
     * 并关闭用于发现和分析网页的网页浏览器。
     */
    @Override
    public void close() {
        engine.close();
    }
}

https://teamdev.com/jxbrowser [OK]
https://teamdev.com/about [OK]
https://teamdev.com/jxbrowser/docs/guides/dialogs.html [OK]
https://teamdev.com/jxcapture [OK]
https://api.jxbrowser.com/7.13/com/teamdev/jxbrowser/view/javafx/BrowserView.html [OK]
https://spine.io [OK]
https://jxbrowser.support.teamdev.com/support/tickets [OK]
https://sos-software.com [OK]
...
Dead or problematic links:
https://www.teamdev.com/jxbrowser
  https://www.shi.com CONNECTION_TIMED_OUT
  http://www.comparex-group.com ABORTED
  http://www.insight.com NAME_NOT_RESOLVED
  https://www.swnetwork.de/swnetwork ADDRESS_UNREACHABLE
...

Process finished with exit code 0

/**
 * 加载给定的 {@code url} 并等待网页完全加载。
 *
 * 如果网页已成功加载，则 @return {@code true}。
 * 如果给定的 URL 无效，或者我们未能在 45 秒内加载它，
 * 则返回 {@code false}。
 *
 * @implNote 在每次导航之前，我们等待 {@link 
 * #NAVIGATION_DELAY_MS}， 因为网络服务器可能会经常中断 URL 请求，
 * 以保护自己免受 DDoS 攻击。
 */
private NetError loadUrlAndWait(Browser browser, String url,
        int navigationAttempts) {
    // 我们尝试加载给定 URL 的所有尝试都被拒绝了，(
    // 我们放弃并继续处理其他网页。
    if (navigationAttempts == 0) {
        return NetError.ABORTED;
    }
    try {
        // Web 服务器可能经常中断 URL 请求，
        // 以保护自身免受 DDoS 攻击。
        // 在 URL 请求之间使用延迟。
        long timeout = (long) NAVIGATION_DELAY_MS
                * navigationAttempts;
        TimeUnit.MILLISECONDS.sleep(timeout);
        // 加载给定的 URL 并等待网页完全加载。
        browser.navigation()
                .loadUrlAndWait(url, Duration.ofSeconds(30));
    } catch (NavigationException e) {
        NetError netError = e.netError();
        if (netError == NetError.ABORTED) {
            // 如果 Web 服务器中断了我们的请求，请重试。
            return loadUrlAndWait(browser, url,
                    --navigationAttempts);
        }
        return netError;
    } catch (TimeoutException e) {
        // Web 服务器在 30 秒内未响应 (
        return NetError.CONNECTION_TIMED_OUT;
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
    return NetError.OK;
}

browser.mainFrame().flatMap(Frame::document).ifPresent(document ->
        // 通过分析锚点 HTML 元素的 HREF 属性来收集链接。
        document.findElementsByTagName("a").forEach(element -> {
            try {
                String href = element.attributeValue("href");
                toUrl(href, browser.url()).ifPresent(
                        url -> result.add(Link.of(url)));
            } catch (IllegalStateException ignore) {
                // 网页的 DOM 可能会被 JavaScript 动态地更改。
                // 我们分析的 DOM HTML 元素，
                // 可能会在分析过程中被移除。
                // 我们不分析已移除的 DOM 元素的属性。
            }
        }));