如何在java中添加异常以不使用jsoup解析某些类型的文件？

我正在使用Jsoup库编写一个web爬虫程序。（很抱歉，我不能发布我的代码，因为它太长了，无法发布到这里）。我只需要抓取可以让我找到新链接的URL，而不需要抓取以http或https开头，以图像文件、pdf、rar或zip文件结尾的URL。我只需要抓取以.html、.htm、.jsp、.php和.asp等结尾的URL

关于这个问题，我有两个问题：

1-如何防止程序不读取其他不需要的URL（如：图像、PDF或RAR）

2-如何改进这个类，使其不浪费时间将整个URL内容加载到内存中，然后从中解析URL

下面是我的代码：

import org.jsoup.Connection;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Writer;
import java.math.BigInteger;
import java.util.Formatter;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.security.*;
import java.nio.file.Path;
import java.nio.file.Paths;


public class HTMLParser {

private static final int READ_TIMEOUT_IN_MILLISSECS = (int) TimeUnit.MILLISECONDS.convert(30, TimeUnit.SECONDS);
private static HashMap <String, Integer> filecounter = new HashMap<> ();


public static List<LinkNodeLight> parse(LinkNode inputLink){
    List<LinkNodeLight> outputLinks = new LinkedList<>();
    try {
        inputLink.setIpAdress(IpFromUrl.getIp(inputLink.getUrl()));
        String url = inputLink.getUrl();
        if (inputLink.getIpAdress() != null) {
            url.replace(URLWeight.getHostName(url), inputLink.getIpAdress());
        }
        Document parsedResults =  Jsoup
                .connect(url)
                .timeout(READ_TIMEOUT_IN_MILLISSECS)
                .userAgent("Mozilla/5.0 (Windows; U; WindowsNT 5.1; en-US; rv1.8.1.6) Gecko/20070725 Firefox/2.0.0.6")

                .get();
        inputLink.setSize(parsedResults.html().length());
        /* IP address moved here in order to speed up the process */
        inputLink.setStatus(LinkNodeStatus.OK);
        inputLink.setDomain(URLWeight.getDomainName(inputLink.getUrl()));
        if (true) {
            /* save the file to the html */
            String filename = parsedResults.title();//digestBig.toString(16) + ".html";
            if (filename.length() > 24) {
                filename = filename.substring(0, 24);
            }
            filename = filename.replaceAll("[^\\w\\d\\s]", "").trim();
            filename = filename.replaceAll("\\s+",  " ");

            if (!filecounter.containsKey(filename)) {
                filecounter.put(filename, 1);
            } else {
                Integer tmp = filecounter.remove(filename);
                filecounter.put(filename, tmp + 1);
            }
            filename = filename + "-" + (filecounter.get(filename)).toString() + ".html";
            filename = Paths.get("downloads", filename).toString();
            inputLink.setFileName(filename);
            /* use md5 of url as file name */
            try (PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(filename)))) {
                out.println("<!--" + inputLink.getUrl() + "-->");
                out.print(parsedResults.html());
                out.flush();
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        String tag;
        Elements tagElements;
        List<LinkNode> result;


        tag = "a[href";
        tagElements = parsedResults.select(tag);
        result = toLinkNodeObject(inputLink, tagElements, tag);
        outputLinks.addAll(result);


        tag = "area[href";
        tagElements = parsedResults.select(tag);
        result = toLinkNodeObject(inputLink, tagElements, tag);
        outputLinks.addAll(result);
    } catch (IOException e) {
        inputLink.setParseException(e);
        inputLink.setStatus(LinkNodeStatus.ERROR);
    }

    return outputLinks;
}


static List<LinkNode> toLinkNodeObject(LinkNode parentLink, Elements tagElements, String tag) {
    List<LinkNode> links = new LinkedList<>();
    for (Element element : tagElements) {

        if(isFragmentRef(element)){
            continue;
        }

        String absoluteRef = String.format("abs:%s", tag.contains("[") ? tag.substring(tag.indexOf("[") + 1, tag.length()) : "href");
        String url = element.attr(absoluteRef);

        if(url!=null && url.trim().length()>0) {
            LinkNode link = new LinkNode(url);
            link.setTag(element.tagName());
            link.setParentLink(parentLink);
            links.add(link);
        }
    }
    return links;
}

static boolean isFragmentRef(Element element){
    String href = element.attr("href");
    return href!=null && (href.trim().startsWith("#") || href.startsWith("mailto:"));
}
}

import org.jsoup.Connection；
导入org.jsoup.jsoup；
导入org.jsoup.nodes.Document；
导入org.jsoup.nodes.Element；
导入org.jsoup.select.Elements；
导入java.io.BufferedWriter；
导入java.io.File；
导入java.io.FileOutputStream；
导入java.io.FileWriter；
导入java.io.IOException；
导入java.io.OutputStreamWriter；
导入java.io.PrintWriter；
导入java.io.Writer；
导入java.math.biginger；
导入java.util.Formatter；
导入java.util.HashMap；
导入java.util.LinkedList；
导入java.util.List；
导入java.util.concurrent.TimeUnit；
导入java.security.*；
导入java.nio.file.Path；
导入java.nio.file.path；
公共类HTMLPasser{
私有静态最终整型读取超时，单位为（int）TimeUnit.millizes.convert（30，TimeUnit.SECONDS）；
私有静态HashMap filecounter=newhashmap（）；
公共静态列表解析（LinkNode inputLink）{
List outputLinks=新建LinkedList（）；
试一试{
inputLink.setIPAddress（IpFromUrl.getIp（inputLink.getUrl（））；
字符串url=inputLink.getUrl（）；
if（inputLink.GetiPAddress（）！=null）{
replace（URLWeight.getHostName（url），inputLink.getipAddress（））；
}
文档parsedResults=Jsoup
.connect（url）
.超时（以毫秒为单位读取超时）
.userAgent（“Mozilla/5.0（Windows；U；WindowsNT 5.1；en-US；rv1.8.1.6）Gecko/20070725 Firefox/2.0.0.6”）
.get（）；
setSize（parsedResults.html（）.length（））；
/*IP地址移到这里是为了加快进程*/
inputLink.setStatus（LinkNodeStatus.OK）；
setDomain（URLWeight.getDomainName（inputLink.getUrl（））；
如果（真）{
/*将文件保存到html*/
String filename=parsedResults.title（）；//digestBig.toString（16）+“.html”；
如果（filename.length（）>24）{
filename=filename.substring（0,24）；
}
filename=filename.replaceAll（“[^\\w\\d\\s]”，“）.trim（）；
filename=filename.replaceAll（\\s+，“”）；
如果（！filecounter.containsKey（文件名））{
filecounter.put（文件名，1）；
}否则{
整数tmp=filecounter.remove（文件名）；
filecounter.put（文件名，tmp+1）；
}
filename=filename+“-”+（filecounter.get（filename））.toString（）+“.html”；
filename=path.get（“下载”，filename）.toString（）；
inputLink.setFileName（文件名）；
/*使用url的md5作为文件名*/
try（PrintWriter out=new PrintWriter（new BufferedWriter（new FileWriter（filename）））{
out.println（“”）；
打印（parsedResults.html（））；
out.flush（）；
out.close（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
}
字符串标签；
元素标记元素；
列出结果；
tag=“a[href”；
tagElements=parsedResults.select（标记）；
结果=toLinkNodeObject（inputLink、tagElements、tag）；
outputLinks.addAll（结果）；
tag=“区域[href”；
tagElements=parsedResults.select（标记）；
结果=toLinkNodeObject（inputLink、tagElements、tag）；
outputLinks.addAll（结果）；
}捕获（IOE异常）{
inputLink.setParseException（e）；
inputLink.setStatus（LinkNodeStatus.ERROR）；
}
返回输出链接；
}
静态列表toLinkNodeObject（链接节点父链接、元素标记元素、字符串标记）{
列表链接=新建链接列表（）；
for（元素：标记元素）{
if（isFragmentRef（元素））{
继续；
}
String absoluteRef=String.format（“abs:%s”，tag.contains（“[”）tag.substring（tag.indexOf（“[”）+1，tag.length（））：“href”）；
字符串url=element.attr（绝对引用）；
if（url！=null&&url.trim（）.length（）>0）{
LinkNode链接=新的LinkNode（url）；
link.setTag（element.tagName（））；
link.setParentLink（parentLink）；
链接。添加（链接）；
}
}
返回链接；
}
静态布尔值isFragmentRef（元素）{
字符串href=element.attr（“href”）；
return href！=null&（href.trim（）.startsWith（“#”）href.startsWith（“mailto:”）；
}
}

为您的第一个问题向Pshemo添加另一个解决方案。您可能希望创建一个正则表达式进行比较，这样您甚至不需要将元素放入列表中 在方法中，“静态列表到链接节点对象”可能类似 “[http].+[^（pdf | rar | zip）]”并将您的url与正则表达式匹配。这也会加快程序的速度，因为您甚至不会添加这些链接来解析

    String url = element.attr(absoluteRef);

    if(url!=null && url.trim().length()>0 
                 && url.matches("[http].+[^(pdf|rar|zip)]")) {
        LinkNode link = new LinkNode(url);
        link.setTag(element.tagName());
        link.setParentLink(parentLink);
        links.add(link);
    }

---

为了提高整个类的速度，它将有助于多线程下载和解析，并允许多线程获取和验证信息。

您阅读了吗？基于示例

img[src~=（？i）\（png | jpe？g）]

您可以创建类似于

a[href~=（？i）\（htm | html | restofwhatouwanttopars）$的选择器

仅选择这些要爬网的链接。谢谢，我已经尝试过了，但是我的第二个问题呢？你能告诉我如何改进吗？我是n