Java版網絡爬蟲基礎

時間 2019-11-22

標籤 java 網絡爬蟲基礎欄目 Java 简体版

原文原文鏈接

　　網絡爬蟲不單單能夠爬取網站的網頁，圖片，甚至能夠實現搶票功能，網上搶購，機票查詢等。這幾天看了點基礎，記錄下來。html

網頁的關係能夠看作是一張很大的圖，圖的遍歷能夠分爲深度優先和廣度優先。網絡爬蟲採起的廣度優先，歸納的說來以下:node

2個數組，一個記錄已訪問的網頁(Al)，一個記錄未訪問的網頁(Un)。假設網頁A爲爬取的起始點，分析A中的全部的超連接B,C,D，將B,C,D加入到Un，分析B中的全部的超連接E,F，將E,F加入到Un末尾，將B從Un除去並加入到AL。依次分析Un中的超連接並加入到Un中就能完成廣度優先的遍歷。web

從上面能夠看出，本身寫爬蟲有幾個主要部分，分析網頁中的連接，將使用htmlparser來完成，網頁的下載功能，將使用httpcliient來完成。apache

現有的爬蟲工具備webharvest等，能夠直接使用。Lucene是一個全文檢索系統的框架，它只是用來創建索引並搜索的，它不可以實現網絡爬蟲功能。可以實現網絡搜索的系統叫Nutch，它是基於Lucene開發的。數組

相關中間件的下載地址；網絡

　　HTMLParser : http://downloads.sourceforge.net/project/htmlparser/Integration-Builds/2.0-20060923/HTMLParser-2.0-SNAPSHOT-bin.zipapp

　　httpcliient : http://hc.apache.org/downloads.cgi框架

httpclient分爲3.x版本和4.x版本，使用3.x版本的在抓取HTTP V1.1時總出現cache設置的問題，使用4.x版本則是正常的。使用了代理時對httpclient和htmlparser都須要作代理設置。ide

LinkQueue定義已訪問隊列，待訪問隊列和爬取得URL的哈希表，包括出隊列，入隊列，判斷隊列是否空等操做。函數

public class LinkQueue {
    // 已訪問的 url 集合
    private static Set<String> visitedUrl = new HashSet<String>();
    // 待訪問的 url 集合
    private static Queue<String> unVisitedUrl = new PriorityQueue<String>();
    // 得到URL隊列
    public static Queue<String> getUnVisitedUrl() {
        return unVisitedUrl;
    }

    // 添加到訪問過的URL隊列中
    public static void addVisitedUrl(String url) {
        visitedUrl.add(url);
    }

    // 移除訪問過的URL
    public static void removeVisitedUrl(String url) {
        visitedUrl.remove(url);
    }

    // 未訪問的URL出隊列
    public static Object unVisitedUrlDeQueue() {
        return unVisitedUrl.poll();
    }

    // 保證每一個 url 只被訪問一次
    public static void addUnvisitedUrl(String url) {
        if (url != null && !url.trim().equals("") && !visitedUrl.contains(url) && !unVisitedUrl.contains(url))
            unVisitedUrl.add(url);
    }

    // 得到已經訪問的URL數目
    public static int getVisitedUrlNum() {
        return visitedUrl.size();
    }

    // 判斷未訪問的URL隊列中是否爲空
    public static boolean unVisitedUrlsEmpty() {
        return unVisitedUrl.isEmpty();
    }
}

實現抓取內容過濾的接口LinkFilter

public interface LinkFilter {    
    public boolean accept(String url);
}

DownLoadFile類，根據獲得的url，爬取網頁內容，下載到本地保存。 F盤下面須要有名爲spider的文件夾，存儲爬取的網頁。

public class DownLoadFileV4 {

    /* 下載 url 指向的網頁 */
    public String downloadFile(String url) throws Exception {
        String filePath = null;
        // 初始化，此處構造函數就與3.1中不一樣
        HttpClient httpclient = new DefaultHttpClient();
        //設置代理和超時，沒有使用代理時注掉
        HttpHost proxy = new HttpHost("172.16.91.109", 808);   
        httpclient.getParams().setParameter(ConnRoutePNames.DEFAULT_PROXY, proxy);   
        httpclient.getParams().setIntParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, 3000);


        HttpHost targetHost = new HttpHost(url.replace("http://", ""));
        HttpGet httpget = new HttpGet("/");
        // 查看默認request頭部信息
        System.out.println("Accept-Charset:" + httpget.getFirstHeader("Accept-Charset"));
        // 如下這條若是不加會發現不管你設置Accept-Charset爲gbk仍是utf-8，他都會默認返回gb2312（本例針對google.cn來講）
        httpget.setHeader("User-Agent", "Mozilla/5.0 (Windows; U; Windows NT 5.1; zh-CN; rv:1.9.1.2)");
        // 用逗號分隔顯示能夠同時接受多種編碼
        httpget.setHeader("Accept-Language", "zh-cn,zh;q=0.5");
        httpget.setHeader("Accept-Charset", "GB2312,utf-8;q=0.7,*;q=0.7");
        // 驗證頭部信息設置生效
        System.out.println("Accept-Charset:" + httpget.getFirstHeader("Accept-Charset").getValue());

        // Execute HTTP request
        System.out.println("executing request " + httpget.getURI());

        HttpResponse response = null;
        try {
            response = httpclient.execute(targetHost, httpget);
        
        // HttpResponse response = httpclient.execute(httpget);

        System.out.println("----------------------------------------");
        System.out.println("Location: " + response.getLastHeader("Location"));
        System.out.println(response.getStatusLine().getStatusCode());
        System.out.println(response.getLastHeader("Content-Type"));
        System.out.println(response.getLastHeader("Content-Length"));
        System.out.println("----------------------------------------");

        // 判斷頁面返回狀態判斷是否進行轉向抓取新連接
        int statusCode = response.getStatusLine().getStatusCode();
        if ((statusCode == HttpStatus.SC_MOVED_PERMANENTLY) || (statusCode == HttpStatus.SC_MOVED_TEMPORARILY) || (statusCode == HttpStatus.SC_SEE_OTHER)
                || (statusCode == HttpStatus.SC_TEMPORARY_REDIRECT)) {
            // 此處重定向處理 此處還未驗證
            String newUri = response.getLastHeader("Location").getValue();
            httpclient = new DefaultHttpClient();
            httpget = new HttpGet(newUri);
            response = httpclient.execute(httpget);
        }

        // Get hold of the response entity
        HttpEntity entity = response.getEntity();

        // 查看全部返回頭部信息
        Header headers[] = response.getAllHeaders();
        int ii = 0;
        while (ii < headers.length) {
            System.out.println(headers[ii].getName() + ": " + headers[ii].getValue());
            ++ii;
        }

        // If the response does not enclose an entity, there is no need
        // to bother about connection release
        if (entity != null) {
            // 將源碼流保存在一個byte數組當中，由於可能須要兩次用到該流，
            byte[] bytes = EntityUtils.toByteArray(entity);
            if(response.getLastHeader("Content-Type") != null){
                filePath = "f:\\spider\\" + getFileNameByUrl(url, response.getLastHeader("Content-Type").getValue());
            }else{
                filePath = "f:\\spider\\" + url.substring(url.lastIndexOf("/"), url.length());
            }
            saveToLocal(bytes, filePath);
            
            String charSet = "";

            // 若是頭部Content-Type中包含了編碼信息，那麼咱們能夠直接在此處獲取
            charSet = EntityUtils.getContentCharSet(entity);

            System.out.println("In header: " + charSet);
            // 若是頭部中沒有，那麼咱們須要 查看頁面源碼，這個方法雖然不能說徹底正確，由於有些粗糙的網頁編碼者沒有在頁面中寫頭部編碼信息
            if (charSet == "") {
                String regEx = "(?=<meta).*?(?<=charset=[\\'|\\\"]?)([[a-z]|[A-Z]|[0-9]|-]*)";
                Pattern p = Pattern.compile(regEx, Pattern.CASE_INSENSITIVE);
                Matcher m = p.matcher(new String(bytes)); // 默認編碼轉成字符串，由於咱們的匹配中無中文，因此串中可能的亂碼對咱們沒有影響
                boolean result = m.find();
                if (m.groupCount() == 1) {
                    charSet = m.group(1);
                } else {
                    charSet = "";
                }
            }
            System.out.println("Last get: " + charSet);
            // 至此，咱們能夠將原byte數組按照正常編碼專成字符串輸出（若是找到了編碼的話）
            //System.out.println("Encoding string is: " + new String(bytes, charSet));
        }} catch (Exception e) {
            e.printStackTrace();
        }
        finally {
            httpclient.getConnectionManager().shutdown();
            httpget.abort();
        }
        
        return filePath;
    }
    
    /**
     * 根據 url 和網頁類型生成須要保存的網頁的文件名 去除掉 url 中非文件名字符
     */
    public String getFileNameByUrl(String url, String contentType) {
        // remove http://
        url = url.substring(7);
        // text/html類型
        if (contentType.indexOf("html") != -1&& url.indexOf(".jpg")!=-1&& url.indexOf(".gif")!=-1) {
            url = url.replaceAll("[\\?/:*|<>\"]", "_") + ".html";
            return url;
        }
        
        else if(url.indexOf(".jpg")!=-1|| url.indexOf(".gif")!=-1){
            url =url;
            return url;
        }// 如application/pdf類型
        else {
            return url.replaceAll("[\\?/:*|<>\"]", "_") + "." + contentType.substring(contentType.lastIndexOf("/") + 1);
        }
    }

    /**
     * 保存網頁字節數組到本地文件 filePath 爲要保存的文件的相對地址
     */
    private void saveToLocal(byte[] data, String filePath) {
        try {
            DataOutputStream out = new DataOutputStream(new FileOutputStream(new File(filePath)));
            for (int i = 0; i < data.length; i++)
                out.write(data[i]);
            out.flush();
            out.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

HtmlParserTool類，用來得到網頁中的超連接（包括a標籤，frame中的src等等），即爲了獲得子節點的URL。須要引入htmlparser.jar。

public class HtmlParserTool {
    public static List<String>imageURLS = new ArrayList<String>();
    // 獲取一個網站上的連接,filter 用來過濾連接
    public static Set<String> extracLinks(String url, LinkFilter filter) {
        Set<String> links = new HashSet<String>();
        try {
            Parser parser = new Parser();
            // 設置代理，沒有代理時注掉
            System.getProperties().put("proxySet", "true");
            System.getProperties().put("proxyHost", "172.16.91.109");
            System.getProperties().put("proxyPort", "808");
            Parser.getConnectionManager().setProxyHost("123");

            parser.setURL(url);
            parser.setEncoding("utf-8");
            // 設置過濾圖片
            NodeFilter imgfil = new TagNameFilter("IMG");

            // 過濾 <frame >標籤的 filter，用來提取 frame 標籤裏的 src 屬性所表示的連接
            NodeFilter frameFilter = new NodeFilter() {
                private static final long serialVersionUID = -6464506837817768182L;

                public boolean accept(Node node) {
                    if (node.getText().startsWith("frame src=")) {
                        return true;
                    } else {
                        return false;
                    }
                }
            };
            // OrFilter 來設置過濾 <a> 標籤，和 <frame> 標籤
            OrFilter lf = new OrFilter(new NodeClassFilter(LinkTag.class), frameFilter);
            
            // 獲得全部通過過濾的標籤
            //NodeList list = parser.extractAllNodesThatMatch(lf);
            NodeList list = parser.extractAllNodesThatMatch(imgfil);
            for (int i = 0; i < list.size(); i++) {
                Node tag = list.elementAt(i);
                if (tag instanceof LinkTag)// <a> 標籤
                {
                    if (tag instanceof ImageTag) {
                        // 加入圖片信息
                        ImageTag link = (ImageTag) tag;
                        String imageUrl = link.getImageURL();// url
                        links.add(imageUrl);
                        imageURLS.add(imageUrl);
                        System.out.println(imageUrl);
                    }else{
                        LinkTag link = (LinkTag) tag;
                        String linkUrl = link.getLink();// url
                        if (filter.accept(linkUrl))
                        links.add(linkUrl);
                    }
                } else// <frame> 標籤
                {
                    if (tag instanceof ImageTag) {
                        // 加入圖片信息
                        ImageTag link = (ImageTag) tag;
                        String imageUrl = link.getImageURL();// url
                        links.add(imageUrl);
                        imageURLS.add(imageUrl);
                        System.out.println(imageUrl);
                    } else {
                        // 提取 frame 裏 src 屬性的連接如 <frame src="test.html"/>
                        String frame = tag.getText();
                        int start = frame.indexOf("src=");
                        frame = frame.substring(start);
                        int end = frame.indexOf(" ");
                        if (end == -1)
                            end = frame.indexOf(">");
                        String frameUrl = frame.substring(5, end - 1);
                        if (filter.accept(frameUrl))
                            links.add(frameUrl);
                    }
                }
            }
        } catch (ParserException e) {
            e.printStackTrace();
        }
        return links;
    }
}

測試類MyCrawler，用來測試爬取效果

public class MyCrawler {
    /**
     * 使用種子初始化 URL 隊列
     * 
     * @return
     * @param seeds
     *            種子URL
     */
    private void initCrawlerWithSeeds(String[] seeds) {
        for (int i = 0; i < seeds.length; i++)
            LinkQueue.addUnvisitedUrl(seeds[i]);
    }

    /**
     * 抓取過程
     * 
     * @return
     * @param seeds
     * @throws Exception 
     */
    public void crawling(String[] seeds) throws Exception { 
        LinkFilter filter = new LinkFilter() {
            public boolean accept(String url) {
                if (url.contains("csdn"))
                    return true;
                else
                    return false;
            }
        };
        // 初始化 URL 隊列
        initCrawlerWithSeeds(seeds);
        // 循環條件：待抓取的連接不空且抓取的網頁很少於1000
        while (!LinkQueue.unVisitedUrlsEmpty() && LinkQueue.getVisitedUrlNum() <= 1000) {
            // 隊頭URL出隊列
            String visitUrl = (String) LinkQueue.unVisitedUrlDeQueue();
            if (visitUrl == null)
                continue;
            DownLoadFileV4 downLoader = new DownLoadFileV4();
            // 下載網頁
            try {
                downLoader.downloadFile(visitUrl);
                // 只下載圖片，不下載網頁
                //if(HtmlParserTool.imageURLS.contains(visitUrl)){
                //    downLoader.downloadFile(visitUrl);
                //}
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println();            
            // 該 url 放入到已訪問的 URL 中
            LinkQueue.addVisitedUrl(visitUrl);
            // 提取出下載網頁中的 URL
            Set<String> links = HtmlParserTool.extracLinks(visitUrl, filter);
            // 新的未訪問的 URL 入隊
            for (String link : links) {
                LinkQueue.addUnvisitedUrl(link);
            }
        }
    }

    // main 方法入口
    public static void main(String[] args) throws Exception {
        MyCrawler crawler = new MyCrawler();
        crawler.crawling(new String[] {"http://www.csdn.com"});
    }
}