java 爬虫策略---广度优先遍历改进办法

亦凉 2022-04-13 07:47 178阅读 0赞

爬虫在后端开发中一直是一个很优秀的话题，不仅可以让我们不劳而获，还可以逐步出户就知道天下大事儿，可以利用爬虫技术，写出很多好玩的应用软件。可是，在现实生活中，爬虫比较消耗计算机资源，如果采取单线程模式，去爬取某一个页面，可能不会出现什么问题，一旦页面上千个，估计得跑一天，所以我们对标准的广度优先遍历进行了改进。广度优先遍历的时候，先按照标准的广度优先遍历的方法写，每层之间维护一个nextFloorUrls的集合，用于确定下一层的元素，然后在第一个元素这里对该层的所有页面进行爬取，此时就可以采取多线程去爬取。然后从队列中取出该层所有已经爬取过的页面url，同时维护下一层的nextFloorUrls集合。

此办法可以使得整体的性能得到提升，但是由于多线程是逐层开展的，如果某一页面访问很慢，就会使得该层的速度降低从而影响整体效率，目前采取的是多次尝试，尝试五次即宣告失败，即超时机制。这一点上，还有改进的需要。  
demo

import com.gargoylesoftware.htmlunit.html.HtmlPage;
    import cqcdi.spider.util.UrlNode;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import org.slf4j.Logger;
    
    import java.util.*;
    import java.util.concurrent.*;
    
    /** * ClassName * Description TODO 广度优先搜索实现爬虫 * Auther * Date * Version 1.0 **/
    @Service
    public class CrawlServiceImpl implements CrawlService { 
        private static final Logger LOGGER = LoggerFactory.getLogger(CrawlServiceImpl.class);
    
        @Autowired
        private CrawlParseService crawlParseService;
    
        /** * @description TODO * @author chaoj * @date * @Param * @return void * @version 1.0 **/
        @Override
        public void parse(WebProcessInfo webProcessInfo) { 
            UrlNode urlnode = new UrlNode();
            urlnode.setDepth(1);
            String url = webProcessInfo.getBaseUrl();
            urlnode.setUrl(url);
            WebEntity webEntity = new WebEntity(webProcessInfo.getProjectId(),url,webProcessInfo.getBatchId());
            //爬取主页信息
            HtmlPage page = crawlParseService.parsePage(webEntity);
            int currentDepth = 1;
            if (null != page){ 
                webProcessInfo.addUrl(url);
                Queue queue = new LinkedList<UrlNode>();
                // TODO: 2018/11/27 广度优先算法实现,子节点按层来进行爬取，从而可采用多线程模式
                //如果取出来的是当前层的第一个，那么就开始进行爬取该层的即可，上一层的执行结果中保存了该层待爬取页面的url，爬取完毕之后将url加入到已爬取页面中
                //而在找到合法的且在有效范围内的url就在寻找到的时候就加入到queue中，从而保证算法的有效性，需要维护一个变量，即当前执行到哪一深度
                Set<String>uncheckedUrlsinit = crawlParseService.childUrlfilter(
                        crawlParseService.extractLink(page, url), webProcessInfo);
                //如果当前深度等于最大深度，就直接返回
                if (currentDepth == webProcessInfo.getLevel())return;
                Set<String>nextfloorset = new HashSet<>();
                for (String urltmp: uncheckedUrlsinit){ 
                    //避免自己页面有自己的链接 && 总的页面应该小于等于最大页面
                    if (!webProcessInfo.getAccessedUrls().contains(urltmp) && ((1+nextfloorset.size()) < webProcessInfo.getMaxSize())){ 
                        UrlNode urlNodetmp = new UrlNode();
                        urlNodetmp.setUrl(urltmp);
                        urlNodetmp.setDepth(2);
                        ((LinkedList) queue).offer(urlNodetmp);
                        nextfloorset.add(urltmp);
                    }
                }
                String projectId = webProcessInfo.getProjectId();
                String baseUrl = webProcessInfo.getBaseUrl();
                Long batchId = webProcessInfo.getBatchId();
                //nextfloorset中保存了当前层的下一层需要爬取的url，并全部添加到队列里面
                while (!queue.isEmpty()){ 
                    Object object = queue.element();
                    if (object instanceof UrlNode){ 
                        UrlNode urlNodex = (UrlNode) object;
                        if (webProcessInfo.getAccessedUrls().contains(urlNodex.getUrl())){ 
                            ((LinkedList) queue).pop();
                            continue;
                        }
                        if (urlNodex.getDepth()>webProcessInfo.getLevel()){ 
                            queue.clear();
                            break;
                        }
                        if (webProcessInfo.getAccessedUrls().size()>=webProcessInfo.getMaxSize())break;
                        if (currentDepth < urlNodex.getDepth()){ 
                            //说明是下一层的url节点了，开始执行该层的节点爬取即可
    
                            //并发获取页面并获取页面的子链接
                            Set<String> uncheckedUrlSet = new HashSet<>();
                            ExecutorService pool = Executors.newFixedThreadPool(webProcessInfo.getMaxThread());
                            List<Callable<Integer>> callers = new ArrayList<>();
                            for (String linkurl: nextfloorset){ 
                                callers.add(()->{ 
                                    crawlParseService.getChildUrls(linkurl, projectId, batchId, baseUrl, webProcessInfo, uncheckedUrlSet);
                                    return null;
                                });
                            }
                            try { 
                                pool.invokeAll(callers);
                                pool.shutdown();
                            }catch (InterruptedException e){ 
                                e.printStackTrace();
                            }
                            //将爬取后的url放到已访问的url集合中
                            webProcessInfo.addAllUrl(nextfloorset);
                            if (webProcessInfo.getAccessedUrls().size()>=webProcessInfo.getMaxSize()){ 
                                queue.clear();//主动回收内存空间
                                break;
                            }
                            //维护每层之间的变量
                            nextfloorset.clear();
                            currentDepth += 1;
                            //如果当前深度等于最大深度，直接退出遍历
                            if (currentDepth == webProcessInfo.getLevel()){ 
                                queue.clear();//主动回收内存空间
                                break;
                            }
                            for (String uncheckedUrl: uncheckedUrlSet){ 
                                int accessSize = webProcessInfo.getAccessedUrls().size();
                                if(webProcessInfo.getAccessedUrls().contains(uncheckedUrl))continue;//多加一个判断：因为找子节点在加入父节点前面
                                if ((accessSize+nextfloorset.size()) >= webProcessInfo.getMaxSize()){ 
                                    break;
                                }
                                //维护下一层待执行的url 的set nextfloorset，并把它们都加入到队列中
                                nextfloorset.add(uncheckedUrl);
                                UrlNode urlNode1 = new UrlNode();
                                urlNode1.setDepth(currentDepth+1);
                                urlNode1.setUrl(uncheckedUrl);
                                ((LinkedList) queue).offer(urlNode1);
                            }
                            uncheckedUrlSet.clear();
                            ((LinkedList) queue).pop();//从队列中去掉当前这个
                        }
                    }
                }
    // System.err.println("currentDepth: "+currentDepth);
    // System.err.println("size: "+webProcessInfo.getAccessedUrls().size());
                nextfloorset.clear();
            }
        }
    }
    //UrlNode.java
    public class UrlNode { 
        private int depth;
        private String url;
        private String fatherUrl;
        public int getDepth() { 
            return depth;
        }
    
        public String getUrl() { 
            return url;
        }
    
        public String getFatherUrl() { 
            return fatherUrl;
        }
    
        public void setDepth(int depth) { 
            this.depth = depth;
        }
    
        public void setUrl(String url) { 
            this.url = url;
        }
    
        public void setFatherUrl(String fatherUrl) { 
            this.fatherUrl = fatherUrl;
        }
    }