Java版网络爬虫基础（转）

网络爬虫不仅仅可以爬取网站的网页，图片，甚至可以实现抢票功能，网上抢购，机票查询等。这几天看了点基础，记录下来。

网页的关系可以看做是一张很大的图，图的遍历可以分为深度优先和广度优先。网络爬虫采取的广度优先，概括的说来如下:

2个数组，一个记录已访问的网页(Al)，一个记录未访问的网页(Un)。假设网页A为爬取的起始点，分析A中的所有的超链接B,C,D，将B,C,D加入到Un，分析B中的所有的超链接E,F，将E,F加入到Un末尾，将B从Un除去并加入到AL。依次分析Un中的超链接并加入到Un中就能完成广度优先的遍历。

从上面可以看出，自己写爬虫有几个主要部分，分析网页中的链接，将使用htmlparser来完成，网页的下载功能，将使用httpcliient来完成。

现有的爬虫工具有webharvest等，可以直接使用。Lucene是一个全文检索系统的框架，它只是用来建立索引并搜索的，它不能够实现网络爬虫功能。能够实现网络搜索的系统叫Nutch，它是基于Lucene开发的。

相关中间件的下载地址；

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

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

httpclient分为3.x版本和4.x版本，使用3.x版本的在抓取HTTP V1.1时总出现cache设置的问题，使用4.x版本则是正常的。使用了代理时对httpclient和htmlparser都需要做代理设置。

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"});
    }
}

http://www.cnblogs.com/lnlvinso/p/3970865.html