lucene.Net--学习笔记（3）---C#'网络爬虫' 源码详解

我们知道，要想对数据进行检索，最基本也是最重要的东西就是数据本身了。

本章介绍如何获取大量的网页信息。

相信大家都听说过‘网络爬虫’，我们正是通过这种方式搜集网页的。

一、下面首先简单的介绍一下网络爬虫的基本结构：

简单的讲就是：

1、从一个url开始搜索，将这个页面上的所有链接保存，放入一个queue中。

2、接着从这个queue中取出一个url，重复第1步

这个过程类似于BFS(广度优先搜索)。（为了防止url被重复使用，这里可以用两个集合分别存放已下载与未下载的url）。

由于下载网页的速度与网速有关，cpu的时间大部分时间都消耗到了等待上面，因此，这里的网络爬虫采用的是多线程的方式。

二、分析网络爬虫的源码：

首先对程序各个类进行简要的讲解：

Cyh_HttpServer类：

该类中只有一个方法public string GetResponse(string url)功能是对指定的url获取该页面的html，实现该功能必须解决以下几个问题：

1.如何获取指定url的html？

其实实现该功能很简单，在C#中通过HttpWebResponse类的调用就能实现,具体方法是:

HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);

HttpWebResponse response = (HttpWebResponse)request.GetResponse();

Stream reader = response.GetResponseStream();

然后从reader流中读取内容就行了

2.编码问题，网页通常使用utf-8或gb2312进行编码，如果程序在读取流时使用了错误的编码会导致中文字符的错误

3.对于有些页面的html可能会非常大所以我们要限制大小，在程序中最在读取不会超过100k。

代码如下：

/// <summary>
    /// <para>HTTP服务类</para>
    /// 由于在程序外该类是不可见的，所以声明时用了internal.
    /// </summary>
    internal class Cyh_HttpServer
    {
        public string GetResponse(string url)
        {

            string html = string.Empty;         //文本内容
            string encoding = string.Empty;     //文本格式

            #region MyRegion
            try
            {
                //创建一个hettpReq请求对象，包含要传递的值name
                HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
                request.Method = "get";     //发送方式
                request.ContentType = "text/html";  //Http标头的值
                request.Timeout = 30 * 1000;        //请求超时时间

                byte[] buffer = new byte[1024];

                //使用using的作用，可以在using结束时，回收所有using段内的内存

                //创建一个响应对象，并重请求对象中得到响应对象的事例。
                using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
                {
                    using (Stream reader = response.GetResponseStream())    //得到回应过来的流
                    {
                        reader.ReadTimeout = 30 * 1000;

                        #region 处理流
                        //MemoryStream是一个支持存储区为内存的流。
                        using (MemoryStream memory = new MemoryStream())
                        {
                            int index = 1;
                            int sum = 0;

                            //限制的读取的大小不超过100k
                            while (index > 0 && sum < 100 * 1024)
                            {
                                index = reader.Read(buffer, 0, 1024);
                                if (index > 0)
                                {
                                    memory.Write(buffer, 0, index); //将缓存写入memory
                                    sum += index;
                                }
                            }
                            //网页通常使用utf-8或gb2312进行编码                           
                            html = Encoding.GetEncoding("gb2312").GetString(memory.ToArray());  //返回与指定代码页名称关联的编码。 
                            if (string.IsNullOrEmpty(html))
                            {
                                return html;
                            }
                            else
                            {
                                Regex re = new Regex(@"charset=(?<charset>[\s\S]*?)[""|']");
                                Match m = re.Match(html.ToLower());
                                encoding = m.Groups["charset"].ToString();
                            }

                            if (string.IsNullOrEmpty(encoding) || string.Equals(encoding.ToLower(), "gb2312"))
                            {
                                return html;
                            }
                            else
                            {
                                //不是gb2312编码则按charset值的编码进行读取
                                return Encoding.GetEncoding(encoding).GetString(memory.ToArray());
                            }
                        }
                        #endregion
                    }
                }
            }
            #endregion
            catch
            {
                return "";  
            }
        }
    }

Cyh_AbsChain类：

/// <summary>
    /// <para>职责链抽象类</para>
    /// 对于AbsChain采用的是职责链设计模式,
    /// 目的是抽象出网络爬虫处理html的过程,
    /// 因为在spider程序集中并不真正处理如何解析html,
    /// 用户只需重载AbsChain类中的process方法，完成自定义的处理过程
     /// </summary>
    public abstract class Cyh_AbsChain 
    {
        /// <summary>
        /// 责任链中的一个 hander
        /// </summary>
        private Cyh_AbsChain _handler = null;
        internal Cyh_AbsChain Handler
        {
            get
            { return _handler; }
        }

        /// <summary>
        /// 待处理的url
        /// </summary>
        private string _url = string.Empty;
        public string Url
        {
            get { return _url; }
            set { _url = value; }
        }


        /// <summary>
        /// 文本处理过程(Protected abstract)
        /// </summary>
        /// <param name="htmlStream">html文本</param>
        protected abstract void Process(string html);

        /// <summary>
        /// 设置下一个处理节点
         /// </summary>
        /// <param name="handler">下一个处理节点</param>
        public void SetProcessHandler(Cyh_AbsChain handler)
        {
            _handler = handler;
        }

        /// <summary>
        /// Cyh_AbsChain 开始处理
         /// </summary>
        /// <param name="htmlStream">html文本流</param>
        public void Start_AbsChain(string html)
        {
            Process(html); //处理  用户重载方法
            if (Handler != null)
            {
                Handler.Url = Url;
                Handler.Start_AbsChain(html);   
            }
        }
    }

Cyh_ChainMain类：

/// <summary><para>ChainMain类是对AbsChain类的具体实现</para>
    /// 它的Process方法是个空方法，
    /// 所以你可以把它理解成它就是具体处理职责链上的头节点，
    /// 通过ChainMain类的_handler将处理任务往下传递，
    /// 用户通过调用ChainMain的SetProcessHandler方法设置下一个处理节点，
    /// 这个节点必须由用户继承AbsChain并实现抽象方法Process
    /// </summary>
    internal class Cyh_ChainMain : Cyh_AbsChain
    {
        /// <summary> 需要用户重置的处理函数 </summary>
        protected override void Process(string html)
        {
            
        }
    }

Cyh_WordThread类：

/// <summary>
    /// <para>工作线程</para>
    /// <para>WorkThread类是工作线程类，
    /// 每个工作线程类都包括</para>
    /// <para>一个职责链的头节点ChainMain、一个HttpServer类和一个UrlStack，</para>
    /// 其中UrlStack类采用了单构件设计模式，
    /// 所以对于整个应该用程序都是使用一个UrlStack对象。
    /// </summary>
    internal class Cyh_WordThread
    {
        #region 定义头节点ChainMain、HttpServer类和UrlStack
        private Cyh_ChainMain _chainHeader = new Cyh_ChainMain();
        internal Cyh_ChainMain ChainMain
        { get { return _chainHeader; } }

        private Cyh_HttpServer _httpServer = new Cyh_HttpServer();
        internal Cyh_HttpServer HttpServer
        { get { return _httpServer; } }

        public Cyh_UrlStack UrlStack
        { get { return Cyh_UrlStack.Instance; } } 

        private bool _isRun = false;
        public bool IsRun
        { get { return _isRun; } } 
        #endregion

        /// <summary>
        /// <para>工作线程入口函数</para>
        /// Start_WordThread()从UrlStack中取出url，
        /// 并调用Cyh_HttpServer的GetResponse方法取出Url对应网页的HTML代码，
        /// 并将HTML代码传递给职责链的头节点Cyh_ChainMain，
        /// 由它的Start_AbsChain()方法开始处理。
        /// 
        /// 它是先调用自身类的Process方法，
        /// 然后再调用_handler.Start_AbsChain（）方法，
        /// 就这样把处理过程传递下去。
        /// </summary>
        public void Start_WordThread()
        {
            #region Try
            try
            {
                this._isRun = true;
                while (_isRun)
                {
                    string url = this.UrlStack.Pop();
                    if (!string.IsNullOrEmpty(url))
                    {
                        string html = _httpServer.GetResponse(url);
                        if (!string.IsNullOrEmpty(html))
                        {
                            this.ChainMain.Url = url;
                            //处理得到的html
                            this.ChainMain.Start_AbsChain(html);  
                        }
                    }
                }
            } 
            #endregion  
            catch
            {  
   
            } 
        }

        /// <summary>
        /// 停止工作线程
        /// </summary>
        public void Stop_WorkThread()
        {
            this._isRun = false;    
        }

    }

Start_WordThread方法是工作线程的入口方法，它从Cyh_UrlStack中取出url，并调用Cyh_HttpServer的GetResponse方法取出Url对应 网页的HTML代码，并将HTML代码传递给职责链的头节点Cyh_ChainMain，由它的Start_WordThread方法开始处理。回忆一下Cyh_AbsChain的 Start_AbsChain()方法，它是先调用自身类的Process方法，然后再调用_handler.Start_AbsChain（方法，就这样把处理过程传递下去。

Cyh_UrlStack类：

/// <summary>
    /// UrlStack类非常的简单，
    /// 它采用单构件设计模式，
    /// 整个程序只用到一个UrlStack对象
    /// 并维护了一个数据结构，
    /// 该数据结构用来存储需要爬虫抓取的Url
    /// </summary>
    public class Cyh_UrlStack
    {
        private static Cyh_UrlStack _urlstack = new Cyh_UrlStack();

        /// <summary> stack、用来存放url </summary>
        private Queue<string> _stack = new Queue<string>();

        /// <summary> stack的最大存放数量 </summary>
        private readonly int _maxLength = Convert.ToInt32(System.Configuration.ConfigurationManager.AppSettings["MaxLength"]);

        /// <summary> 构造函数 </summary>
        private Cyh_UrlStack() { }

        /// <summary> UrlStack的实例 </summary>
        public static Cyh_UrlStack Instance
        {
            get { return _urlstack; }
        }

        public void Push(string url)
        {
            lock (this)
            {
                if (!_stack.Contains(url))
                {
                    if (_stack.Count >= _maxLength)
                    {
                        _stack.Dequeue();   //移除并返回位于 Queue 开始处的对象。
                    }

                    _stack.Enqueue(url);    //将url添加到 Queue 的结尾处。
                }
            }
        }

        public string Pop()
        {
            lock (this)
            {
                if (_stack.Count > 0)
                {
                    return _stack.Dequeue();
                }
                else
                {
                    return "";  
                }
            }
        }

        public int Count
        {
            get { return _stack.Count; }
        }

    }

Cyh_AbsThreadManager类：

/// <summary>
    /// <para>AbsThreadManager的主要功能是管理开启WorkThread工作线程，</para>
    /// 与监控线线程的,WorkThread对象与Thread对象一一对应，
    /// 这两个对象都被封在ObjThread对象里
    /// 
    /// 在AbsThreadManagers中用List<ObjThread>来维护一系列的线程对象与WorkThread对象，
    /// 同时在 AbsThreadManagers中增加了一个监控线程，
    /// 用来查看工作线程的工作线程，
    /// 若工作线程死去，由监控线程重新启动。
    /// </summary>
    public abstract class Cyh_AbsThreadManager
    {
        public int _maxThread = Convert.ToInt32(System.Configuration.ConfigurationManager.AppSettings["MaxCount"]);

        /// <summary>  用List<ObjThread>来维护一系列的线程对象与WorkThread对象， </summary>
        internal List<Cyh_ObjThread> list = new List<Cyh_ObjThread>();

        private bool _isRun = false;

        /// <summary> 用来监控线程存活死亡的主线程 </summary>
        private System.Threading.Thread _watchThread = null;

        /// <summary> 当前深度 </summary>
        public int Current { get { return Cyh_UrlStack.Instance.Count; } }

        /// <summary>
        /// 开启服务
        /// </summary>
        /// <param name="url">种子URL</param>
        public void Start_AbsThreadManager(string url)
        {
            Cyh_UrlStack.Instance.Push(url);

            _isRun = true;
            //初始化线程list
            for (int i = 0; i < _maxThread; i++)
            {
                this.AddObjThread();    
            }
            _watchThread = new System.Threading.Thread(Watch);
            _watchThread.Start();   
        }

        /// <summary> 停止服务 </summary>
        public void Stop_AbsThreadManager()
        {
            _isRun = false;
            _watchThread.Join();       //阻塞调用线程，直到线程终止为止。
            foreach (Cyh_ObjThread obj in list)
            {
                obj.WorkThread.Stop_WorkThread();
                obj.Thread.Abort();
                obj.Thread.Join();
            }
            list.RemoveRange(0, list.Count);

        }

        /// <summary> 增加一个线程 </summary>
        private void AddObjThread()
        {
            Cyh_ObjThread thread = new Cyh_ObjThread(); 
            //初始化一个新的Thread
            thread.WorkThread = new Cyh_WordThread();
            //设置该线程用于处理职责链中的下一个节点
            thread.WorkThread.ChainMain.SetProcessHandler(GetChainHeader());
            thread.Thread = new System.Threading.Thread(thread.WorkThread.Start_WordThread);

            list.Add(thread);   //线程list中加入新的thread

            thread.Thread.Start();  //开启该线程
        }

        /// <summary>
        /// <para>设置职责链头节点，该方法由用户设定</para>
        /// 返回一个继承了Cyh_AbsChain类的对象，
        /// 这个对象将会被设置到 Cyh_ChainMain的_handler中
        /// </summary>
        /// <returns>返回用户定义的Chain</returns>
        protected abstract Cyh_AbsChain GetChainHeader();

        /// <summary>
        /// 监测存活的或正在运行的线程，
        /// 将运行结束或死亡的进程去除，
        /// 并新增线程 
        /// </summary>
        internal void Watch()
        {
            List<Cyh_ObjThread> newList = new List<Cyh_ObjThread>();
            while (this._isRun)
            {
                try
                {   //检测存活的线程并保存下来，
                    foreach (Cyh_ObjThread temp in this.list)
                    {
                        if (temp.WorkThread.IsRun && temp.Thread.IsAlive)
                        {
                            newList.Add(temp);
                        }
                    }
                    //更新list中的线程
                    this.list.RemoveRange(0, list.Count);
                    list.AddRange(newList);

                    int newCount = this._maxThread - this.list.Count;

                    //加入其它新的线程，使list中的线程数达到_maxThread
                    for (int i = 0; i < newCount; i++)
                    {
                        this.AddObjThread();
                    }
                    newList.RemoveRange(0, newList.Count);
                    //System.Threading.Thread.Sleep(5 * 1000);
                }
                catch
                { }
                finally
                { 
                    
                }
            }
        }
    }

在Cyh_AbsThreadManager中用到了一个类Cyh_ObjThread，它是一种线程的类型，看定义：

Cyh_ObjThread类：

internal class Cyh_ObjThread
    {
        private Cyh_WordThread _workThread;
        internal Cyh_WordThread WorkThread
        {
            get { return _workThread; }
            set { _workThread = value; }
        }

        private System.Threading.Thread _thread;
        public System.Threading.Thread Thread
        {
            get { return _thread; }
            set { _thread = value; }
        }    
    }

以上为网络爬虫中的重要的几个类，还有几个用于客户端的类没有各处，如果需要源代码的可以在评论中提出，人员较多的话，我可以上传。

---------------------------------------------------2012年9月17日23:49:28