利用Java实现网站聚合工具

 更新时间:2022年01月27日 15:14:43   作者:炒鸡辣鸡123  
互联网上有数以万亿计的网站,每个网站大都具有一定的功能。搜索引擎虽然对互联网上的部分网站建立了索引,但是其作为一个大而全的搜索系统,无法很好的定位到一些特殊的需求。因此本文将介绍一个用java实现的网站数据聚合工具,需要的可以参考一下

互联网上有数以万亿计的网站,每个网站大都具有一定的功能。搜索引擎虽然对互联网上的部分网站建立了索引,但是其作为一个大而全的搜索系统,无法很好的定位到一些特殊的需求,基于这样的背景,我尝试了写了一个网站数据聚合的程序。现在将原理和实现代码分享给大家。

原理

可以把互联网上的网站看做一张巨大的连通图,不同的网站处于不同的连通块中,然后以广度优先算法遍历这个连通块,就能找到所有的网站域名,利用广度优先算法遍历该连通块的结构可以抽象为:

然后,我们对该网站的返回内容进行分词,剔除无意义的词语和标点符号,就得出该网站首页的关键词排序,我们可以取词频在(10,50)区间范围内的为关键词,然后将这些关键词作为网站主题,把网站的信息放到以该词为名字的markdown文件中备用。

同理,我们也对该网站返回内容的title部分进行分词,因为title是网站开发者对网站功能的浓缩,也比较重要,同理,也将这些关键词作为网站主题,把网站的信息放到以该词为名字的markdown文件中备用。

最后,我们只需要从这些文件中人工做筛选,或者以这些数据放到elasticsearch中,做关键词搜索引擎即可。以达到想用的时候随时去拿的目的。​

不过,当你遍历连通块没有收敛时,得到的数据还是很少的,某些分类往往只有一两个网站。

实现代码

页面下载

页面下载我使用的是httpClient,前期考虑用playwrite来做,但是两者性能差距太大,后者效率太低了,所以舍弃了部分准确性(即web2.0技术的网站,前者无法拿到数据),所以准确的说我实现的仅仅是web1.0的网站分类搜索引擎的页面下载功能。

public SendReq.ResBody doRequest(String url, String method, Map<String, Object> params) {
    String urlTrue = url;
    SendReq.ResBody resBody = SendReq.sendReq(urlTrue, method, params, defaultHeaders());
    return resBody;
}

其中,SendReq是我封装的一个httpClient的类,只是实现了一个页面下载的功能,你可以替换为RestTemplate或者别的发起http(s)请求的方法。​

解析返回值中的所有链接

因为是连通块遍历,那么定义的连通网站就是该网站首页里面所有的外链的域名所在的站,所以我们需要提取链接,直接使用正则表达式提取即可。

public static List<String> getUrls(String htmlText) {
    Pattern pattern = Pattern.compile("(http|https):\\/\\/[A-Za-z0-9_\\-\\+.:?&@=\\/%#,;]*");
    Matcher matcher = pattern.matcher(htmlText);
    Set<String> ans = new HashSet<>();
    while (matcher.find()){
        ans.add(DomainUtils.getDomainWithCompleteDomain(matcher.group()));
    }
    return new ArrayList<>(ans);
}

解析返回值中的title

title是网站开发者对网站功能的浓缩,所以很有必要将title解析出来做进一步处理

public static String getTitle(String htmlText){
    Pattern pattern = Pattern.compile("(?<=title\\>).*(?=</title)");
    Matcher matcher = pattern.matcher(htmlText);
    Set<String> ans = new HashSet<>();
    while (matcher.find()){
        return matcher.group();
    }
    return "";
}

去除返回值中的标签

因为后续步骤需要对网站返回值进行分词,所以需要对页面中的标签和代码进行去除。

public static String getContent(String html) {
    String ans = "";
    try {
        html = StringEscapeUtils.unescapeHtml4(html);
        html = delHTMLTag(html);
        html = htmlTextFormat(html);
        return html;
    } catch (Exception e) {
        e.printStackTrace();
    }
    return ans;
}

public static String delHTMLTag(String htmlStr) {
    String regEx_script = "<script[^>]*?>[\\s\\S]*?<\\/script>"; //定义script的正则表达式
    String regEx_style = "<style[^>]*?>[\\s\\S]*?<\\/style>"; //定义style的正则表达式
    String regEx_html = "<[^>]+>"; //定义HTML标签的正则表达式

    Pattern p_script = Pattern.compile(regEx_script, Pattern.CASE_INSENSITIVE);
    Matcher m_script = p_script.matcher(htmlStr);
    htmlStr = m_script.replaceAll(""); //过滤script标签

    Pattern p_style = Pattern.compile(regEx_style, Pattern.CASE_INSENSITIVE);
    Matcher m_style = p_style.matcher(htmlStr);
    htmlStr = m_style.replaceAll(""); //过滤style标签

    Pattern p_html = Pattern.compile(regEx_html, Pattern.CASE_INSENSITIVE);
    Matcher m_html = p_html.matcher(htmlStr);
    htmlStr = m_html.replaceAll(""); //过滤html标签

    return htmlStr.trim();
}

分词

分词算法使用之前讲NLP入门的文章里面提到的hanlp即可

private static Pattern ignoreWords = Pattern.compile("[,.0-9_\\- ,、:。;;\\]\\[\\/!()【】*?“”()+:|\"%~<>——]+");

public static Set<Word> separateWordAndReturnUnit(String text) {
    Segment segment = HanLP.newSegment().enableOffset(true);
    Set<Word> detectorUnits = new HashSet<>();
    Map<Integer, Word> detectorUnitMap = new HashMap<>();
    List<Term> terms = segment.seg(text);
    for (Term term : terms) {
        Matcher matcher = ignoreWords.matcher(term.word);
        if (!matcher.find() && term.word.length() > 1 && !term.word.contains("�")) {
            Integer hashCode = term.word.hashCode();
            Word detectorUnit = detectorUnitMap.get(hashCode);
            if (Objects.nonNull(detectorUnit)) {
                detectorUnit.setCount(detectorUnit.getCount() + 1);
            } else {
                detectorUnit = new Word();
                detectorUnit.setWord(term.word.trim());
                detectorUnit.setCount(1);
                detectorUnitMap.put(hashCode, detectorUnit);
                detectorUnits.add(detectorUnit);
            }
        }
    }
    return detectorUnits;
}

获取分词结果的数量前十个

这里为了去掉词频过多的词的干扰,所以只取词频小于50的词的前十

public static List<String> print2List(List<Word> tmp,int cnt){
    PriorityQueue<Word> words = new PriorityQueue<>();
    List<String> ans = new ArrayList<>();
    for (Word word : tmp) {
        words.add(word);
    }
    int count = 0;
    while (!words.isEmpty()) {
        Word word = words.poll();
        if (word.getCount()<50){
            ans.add(word.getWord() + " " + word.getCount());
            count ++;
            if (count >= cnt){
                break;
            }
        }
    }
    return ans;
}

方法就是放到优先队列中一个一个取出来,优先队列是使用大顶堆实现的,所以取出来一定是有序的。如果想了解大顶堆的朋友,可以看我前面的文章。
值得注意的是,优先队列中放入的类必须是可排序的,所以,这里的Word也是可排序的,简化的代码如下:

public class Word implements Comparable{
    private String word;
    private Integer count = 0;

    ... ...

    @Override
    public int compareTo(Object o) {
        if (this.count >= ((Word)o).count){
            return -1;
        }else {
            return 1;
        }
    }
}

好了,现在准备工作已经做好了。下面开始实现程序逻辑部分。

遍历网站连通块

利用广度优先遍历网站连通块,之前的文章有专门讲利用队列写广度优先遍历。现在就使用该方法。

public void doTask() {
    String root = "http://" + this.domain + "/";
    Queue<String> urls = new LinkedList<>();
    urls.add(root);
    Set<String> tmpDomains = new HashSet<>();
    tmpDomains.add(DomainUtils.getDomainWithCompleteDomain(root));
    while (!urls.isEmpty()) {
        String url = urls.poll();
        SendReq.ResBody html = doRequest(url, "GET", new HashMap<>());
        System.out.println("当前的请求为 " + url + " 队列的大小为 " + urls.size() + " 结果为" + html.getCode());
        if (html.getCode().equals(0)) {
            ignoreSet.add(DomainUtils.getDomainWithCompleteDomain(url));
            try {
                GenerateFile.createFile2("moneyframework/generate/ignore", "demo.txt", ignoreSet.toString());
            } catch (IOException e) {
                e.printStackTrace();
            }
            continue;
        }

        OnePage onePage = new OnePage();
        onePage.setUrl(url);
        onePage.setDomain(DomainUtils.getDomainWithCompleteDomain(url));
        onePage.setCode(html.getCode());
        String title = HtmlUtil.getTitle(html.getResponce()).trim();
        if (!StringUtils.hasText(title) || title.length() > 100 || title.contains("�")) continue;
        onePage.setTitle(title);
        String content = HtmlUtil.getContent(html.getResponce());
        Set<Word> words = Nlp.separateWordAndReturnUnit(content);
        List<String> wordStr = Nlp.print2List(new ArrayList<>(words), 10);
        handleWord(wordStr, DomainUtils.getDomainWithCompleteDomain(url), title);
        onePage.setContent(wordStr.toString());
        if (html.getCode().equals(200)) {
            List<String> domains = HtmlUtil.getUrls(html.getResponce());
            for (String domain : domains) {
                int flag = 0;
                for (String i : ignoreSet) {
                    if (domain.endsWith(i)) {
                        flag = 1;
                        break;
                    }
                }
                if (flag == 1) continue;
                if (StringUtils.hasText(domain.trim())) {
                    if (!tmpDomains.contains(domain)) {
                        tmpDomains.add(domain);
                        urls.add("http://" + domain + "/");
                    }
                }
            }
        }
    }
}

调用测试

@Service
public class Task {

    @PostConstruct
    public void init(){
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true){
                    try {
                        HttpClientCrawl clientCrawl = new HttpClientCrawl("http://www.mengwa.store/");
                        clientCrawl.doTask();
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                }
            }
        }).start();
    }
}

大家也可以用自己的个人博客作为起点试一下,看下自己在哪个连通块里面。

以上就是利用Java实现网站聚合工具的详细内容,更多关于Java网站聚合的资料请关注脚本之家其它相关文章!

相关文章

  • 如何在JAVA中使用Synchronized

    如何在JAVA中使用Synchronized

    这篇文章主要介绍了如何在JAVA中使用Synchronized,文中代码非常详细,对大家的学习有所帮助,感兴趣的朋友可以参考下
    2020-06-06
  • Java文件读取写入后 md5值不变的实现方法

    Java文件读取写入后 md5值不变的实现方法

    下面小编就为大家分享一篇Java文件读取写入后 md5值不变的实现方法,具有很好的参考价值,希望对大家有所帮助
    2017-11-11
  • 一文详解JAVA中InputStreamReader流

    一文详解JAVA中InputStreamReader流

    本文主要介绍了一文详解JAVA中InputStreamReader流,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
    2023-04-04
  • 详解java中接口与抽象类的区别

    详解java中接口与抽象类的区别

    这篇文章主要介绍了详解java中接口与抽象类的区别的相关资料,希望通过本文能帮助到大家,让大家轻松理解掌握接口与抽象类的区别,需要的朋友可以参考下
    2017-10-10
  • Java微信公众平台开发(12) 微信用户信息的获取

    Java微信公众平台开发(12) 微信用户信息的获取

    这篇文章主要为大家详细介绍了Java微信公众平台开发第十二步,微信用户信息的获取,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
    2017-04-04
  • java创建线程的两种方法区别

    java创建线程的两种方法区别

    这篇文章主要为大家区分了java创建线程的两种方法,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
    2017-06-06
  • java实现马踏棋盘游戏

    java实现马踏棋盘游戏

    这篇文章主要为大家详细介绍了java实现马踏棋盘游戏,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
    2022-02-02
  • maven项目后出现‘parent.relativePath’ of POM错误时的解决方法

    maven项目后出现‘parent.relativePath’ of POM错误时的解决方法

    在Springboot项目启动时,项目报错‘parent.relativePath’ of POM问题,项目无法正常启动,本文就来介绍一下解决方法,感兴趣的可以了解一下
    2023-10-10
  • java9版本特性资源自动关闭的语法增强

    java9版本特性资源自动关闭的语法增强

    这篇文章主要为大家介绍了java9版本特性资源自动关闭的语法增强的详细使用说明,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步
    2022-03-03
  • spring boot集成loback日志配置的示例代码

    spring boot集成loback日志配置的示例代码

    这篇文章主要介绍了spring boot集成loback日志配置的示例代码,本文通过示例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友参考下吧
    2024-01-01

最新评论