对于比较复杂的验证码，比如DZ论坛最新的验证码，处理起来相对麻烦一些，但是原理还是和普通的识别一样的，无非多了个背景处理的方案，看如下对DZ论坛的验证码的识别的思路

//power by www.crazycoder.cn

首先我们要去除它的背景，对于这样稍微复杂的背景，用过去的方法很难做到，上图的例子还不是很明显，我发现很多图片背景色和字母色近似，而且字母颜色是不断变化的，背景也是不断变化的

那我初始的想法是找到图片中使用颜色最多的方法，于是我们用HSL表示各点颜色，接着进行统计，得到最大的几个峰值，这里便是图片中几个最丰富的颜色的L值得累加值

其余的都可以认为是噪音，我们对每个峰值进行分割，得到如下图片

你看这样就把单个颜色图片分割出来了，接下来就是找到图片中除去黑色和白色后的图片

然后进行灰化处理，阀值处理，降噪，得到

接着根据边界检测出来的最左侧x位置，来排序字母顺序

接下来的事情就轻车熟路了，把图片转成标准模板，通过少量学习就达到了95%以上的识别率

c:15 j:8 8:7 t:9 9:4 x:7 4:6 2:4 h:7 f:8 e:18 b:5 y:3 k:4 w:3 g:5 3:5 7:6 r:2 m:3 q:4 v:2 p:3 6:2
以上数据表示 c学习15次 j学习8次…

只要字符不粘连，大部分验证码干扰技术都是可以有办法，所以为什么google验证码看起来很简单，但是没有人能够很好的破解它得原因。

补充，
rise在留言中发现有一些字符加入杂点的问题，由于这种验证码不是很普遍，稍微做了研究

CY3E 这个图片3字中有杂点，其他没有，按照文章中介绍的办法，怎么知道这个3不是像其他颜色杂点一样的图片呢？

我觉得需要加入一个步骤，就是对每次过滤颜色生成出来的图片，进行填充
找到3的杂点原图：

然后我们进行算法填充

这个图片与其他全部是杂点的图片之间的差别进行过滤，我考虑可以通过以下方法：
1、连贯点的宽度
2、连贯点的个数
这样剩下的就只剩下CY3E的过滤后的图片

至于字符倾斜的问题，我觉得完全可以在机器学习过程中，我们自己旋转正在学习的图片一定角度，例如从-10到+10度，只不过这样的学习库会大一些，但是就10个数字的验证码来说，这点性能损失应该可以忽略不计。

注：非crazycoder原装，文章是转载的，原文出处不祥了，很多地方都有，找不到原出处了

验证码(captcha)是伴随自动提交程序(spam)的出现而出现的。现在各种论坛、博客、投票等程序都带有验证码功能。大部分验证码都比较容 易识别，只需要简单对照一下特征码就可以得到百分之百准确的结果。也有稍微复杂一点的，比如phpwind和discuz的验证码。

前段时间做了phpwind和discuz的验证码识别，phpwind6.0以前的验证码和discuz最新的验证码如果在不改变后台验证码配置的情况下，识别正确率几乎可以达到100%，现在跟大家分享一下识别方法。

验证码识别一般分为以下几个步骤：

1. 取出字模
2. 二值化
3. 计算特征
4. 对照样本

各种验证码在具体的步骤上操作会有所不同。

我的程序是用VC++写的，这里不贴详细代码了，只讲识别方法。

先说phpwind验证码的识别方法：

具体分为这几步：

1. 把图片横向等宽分为4块
2. 找出每块图片中分布最多的一种颜色
3. 与已有样本比较得出结果

因为这个验证码的字符分布几乎是等宽的，所以我们首先把图片切为4份，这样方便取出每一个字符。分成4块后，通过每一块中的颜色值对比可以很快得到 字符的特征。因为每一块中字符的颜色值比杂点颜色值要多很多，而且字符是纯色的，所以只要统计出最多的一种颜色，然后去除其它颜色就可以得到只有字符的干 净图片。然后对图片二值化（即构造一个二维数组对应图片上有颜色的点，把有颜色的点的数组值置为1，无颜色的置为0），与样本比对即可得到字符。当然首先 要得到样本。样本的制作与上面分析的步骤一致。经过测试，上面这种方法的识别率是100%的，不会有差错。

discuz的验证码识别较之phpwind要稍难一点。因为图片带有不太容易去掉的背景。字符也不是单纯的字符，有阴影边框，而且不等宽，位置不确定。我们具体分为以下几步：

1. 去除背景色
2. 分出每一个字符区域
3. 用轮廓法（berg）得到特征码
4. 与样本比较得出结果

这个背景色是渐变的而字符的颜色是不变的。首先去除对角线上找不到相同颜色的点，然后统计出每一种颜色占用的区域的宽度和高度。去除占用区域高度小 于图片总高度1/5或大于图片总高度2/3的点，因为一个字符不可能达到这种尺寸。再去除密度（即颜色点数/颜色所占的区域宽高的积）小于15%的点。剩 下的就只有干净的字符的颜色点了。

把这些点分为4份。（分割的办法为从左到右用一条竖直的线扫描，扫描线经过的连续区域就是字符区域。）分成4个字符块后，我们就可以对每一个字符块进行轮廓特征取值。

什么是轮廓法？我是由berg（berg是网易社区的牛人，对我帮助不少）那里获知验证码识别中的轮廓法。即将一个字模点阵，以四条直线由上下左右 4个方向向字符中心扫描，遇到点即停下，把每一条线通过的路径长度记下。然后以比路径长度和其它一些相关的参数得到正确的字符。

我稍微变换了一下轮廓法。即把4个方向上的路径长度变为波的形式。波峰记为1，波谷记为0，最后得到一个由1和0组成的特征串，与样本串比较即可得 到匹配结果。有几个字符，如V和Y、H和M、4和6等，得到的特征串可能是一样的，这样需要通过其它的一些参数来辅助得到结果。

下面是我计算的特征串和字符的对照样本：
10-10-10-10- X
1-1010-1-10101- W
-1010--- W
1--1-101- T
-1-1010-10- R
--10-10- R
101-101-1010-1010- Q
-1-101-1- P
--1-1- P
-10--1010- M
-10-10-10- K
10-10-1-1- J
10-10--- J
101-101-1010-10- G
--101-1- F
--1010-- E
101-101-10101-101- C
101-10-10-10- C
-1-10101-1- B
---- B
10101-101-101-101- 9
1---10- 9
-101--- 8
10--1-101- 7
-1-10-- 6
1-101-10-101- 4
1010---- 3
1010-101-1010-- 2
10--10-- 2
//below is equivocal
1-10-1-101- V //Y
10-10-10-- G //Q
-10--10- H //M
10101-101-10101-101- 3 //8
101-101-101-101- 4 //6

上面这种方法，对discuz的默认验证码，即如图所示的验证码识别正确率为100%

上面对phpwind和discuz的验证码识别方法均没有用到高级的算法，更加没有用到人工智能的知识，不免有点遗憾，不过准确率相当高，也容易看懂。

在实际应用中可能遇到一些问题，比如discuz验证码可以在后台设为gif图片格式。如何把gif动画中那一个字符帧转为bmp图片呢？下面是VC里面的方法：

BOOL CCaptchaBreak::Gif2Bmp(CString &sPath)
{
ULONG_PTR   GdippToken;  
GdiplusStartupInput   GdippStart;  
GdiplusStartup(&GdippToken,&GdippStart,0);
BSTR bsTemp = sPath.AllocSysString();
Bitmap   bmp(bsTemp);
::SysFreeString(bsTemp);

int   FrameCount,FramePos,size,pause;  
PropertyItem*   pPropItem;  
GUID   pageGuid;  
GUID*   pDimID;  
UINT   count;  

count=bmp.GetFrameDimensionsCount();  

pDimID=new GUID[count];  

bmp.GetFrameDimensionsList(pDimID,count);  
FrameCount=bmp.GetFrameCount(&pDimID[0]);

if (1==FrameCount) //if is bmp then exit
{
   delete[]pDimID;  
   return FALSE;
}

size=bmp.GetPropertyItemSize(PropertyTagFrameDelay);  
pPropItem=(PropertyItem*)malloc(size);  

bmp.GetPropertyItem(PropertyTagFrameDelay,size,pPropItem);  
delete[]pDimID;  

pageGuid=FrameDimensionTime;  
FramePos=0;

int iFontFramePos = 0;
int iMaxPause = 0;
while (FramePos

return TRUE;
}

BOOL CCaptchaBreak::GetEncoderClsid(const WCHAR* format, CLSID* pClsid)
{
UINT num = 0;          // number of image encoders
UINT size = 0;         // size of the image encoder array in bytes

ImageCodecInfo* pImageCodecInfo = NULL;

GetImageEncodersSize(&num, &size);
if(size == 0)
   return FALSE;

pImageCodecInfo = (ImageCodecInfo*)(malloc(size));
if(pImageCodecInfo == NULL)
   return FALSE;

GetImageEncoders(num, size, pImageCodecInfo);

for(UINT j = 0; j < num; ++j)
{
   if( wcscmp(pImageCodecInfo[j].MimeType, format) == 0 )
   {
    *pClsid = pImageCodecInfo[j].Clsid;
    free(pImageCodecInfo);
    return TRUE; // Success
   }   
}

free(pImageCodecInfo);
return FALSE;
}

<%@ Page Language="C#" AutoEventWireup="true" CodeFile="LoginValidate.aspx.cs" Inherits="Admin_LoginValidate" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title>验证用户名是否存在</title>

    <script type="text/javascript">
var xmlHttp;
function createXMLHttpRequest()
{
       if(window.ActiveXObject)
       {
         xmlHttp = new ActiveXObject("Microsoft.XMLHTTP");
       }
       else if(window.XMLHttpRequest)
       {
         xmlHttp = new XMLHttpRequest();
       }
}
//处理方法
function CheckUserName()
{
       createXMLHttpRequest();
       var url= "../ashx/LoginValidate.ashx?username="+document.getElementById("username").value;
       xmlHttp.open("GET",url,true);
       xmlHttp.onreadystatechange=ShowResult;
       xmlHttp.send(null);
     // document.getElementById("Msg").innerHTML='';
     
}
//回调方法
function ShowResult()
{
       if(xmlHttp.readyState==4)
       {
         if (xmlHttp.status == 200)
         {
            alert("Server is done!");
           alert(xmlHttp.responseText);
           document.getElementById("Msg").innerHTML=xmlHttp.responseText;
         }
         else if (xmlHttp.status == 404)
        {
         alert("Request URL does not exist");
        }
         else if (xmlHttp.status == 403)
         {
         alert("Access   or sql   denied.");
         }
         else
         {
         alert("Error: status code is " + xmlHttp.status);
         }
        
        
       }
   
}
    </script>

</head>
<body>
    <form id="form1" runat="server">
        <div>
            <h1 align="center">
                验证用户名是否存在</h1>
            <table align="center" style="width: 487px">
                <tr>
                    <td style="width: 70px">
                        用户名：</td>
                    <td style="width: 231px">
                        <input id="username" onchange="CheckUserName();" type="text" />
                        <input id="Button1" type="button" value="button" onclick="CheckUserName();" /></td>
                    <td id="Msg1">
                        <asp:Label ID="Msg" runat="server" ForeColor="Blue"></asp:Label>
                    </td>
                </tr>
                <tr>
                    <td style="width: 70px">
                    </td>
                    <td style="width: 231px">
                    </td>
                    <td>
                    </td>
                </tr>
            </table>
        </div>
    </form>
</body>
</html>

LoginValidate.ashx

<%@ WebHandler Language="C#" Class="LoginValidate" %>

using System;
using System.Web;
using System.Data;
using System.Data.SqlClient;
using System.Configuration;

public class LoginValidate : IHttpHandler {
   
    public void ProcessRequest (HttpContext context) {
        //context.Response.ContentType = "text/plain";
        //context.Response.Write("Hello World");
        context.Response.ContentType = "text/plain";
        string username = context.Request.QueryString["username"].ToString();
        string strSQL = "select username from users where username='" + username + "'";
        if (ReDataSet(strSQL).Tables[0].Rows.Count > 0)
        {
            context.Response.Write("该用户已经有人使用！");
        }
        else
        {
          if (username.Trim().Length>int.Parse("0"))
            {
            context.Response.Write("恭喜你！" + username + "可以使用！");
            }
            else
            {
                context.Response.Write("请您输入用户名！");  
            }

        }
        System.Threading.Thread.Sleep(1000);

    }

    //数据库连接字符串
    public static string strCon = "Data Source=.;database=test;uid=sa;pwd=;";

    /// <summary>
    /// 执行SQL语句，返回DataSet
    /// </summary>
    /// <param name="strSQL"></param>
    /// <returns></returns>
    public DataSet ReDataSet(string strSQL)
    {
      // SqlConnection con = new SqlConnection(strCon);
        using (SqlConnection con = new SqlConnection(ConfigurationManager.AppSettings["ConnectionString"]))
        try
        {
            con.Open();
            SqlDataAdapter da = new SqlDataAdapter(strSQL, con);
            DataSet ds = new DataSet();
            da.Fill(ds);
            return ds;
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message);
        }
        finally
        {
            con.Close();
        }
    }

    /// <summary>
    /// 不重复调用
    /// </summary>

    public bool IsReusable {
        get {
            return false;
        }
    }

}

/**//// <summary>
///SQL注入过滤
/// </summary>
/// <param name="InText">要过滤的字符串</param>
/// <returns>如果参数存在不安全字符，则返回true</returns>
public static bool SqlFilter2(string InText)
{
   string word="and|exec|insert|select|delete|update|chr|mid|master|or|truncate|char|declare|join";
   if(InText==null)
    return false;
   foreach(string i in word.Split('|'))
   {
    if((InText.ToLower().IndexOf(i+" ")>-1)||(InText.ToLower().IndexOf(" "+i)>-1))
    {
     return true;
    }
   }
   return false;
}

二，Global.asax 事件

/**//// <summary>
/// 当有数据时交时，触发事件
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void Application_BeginRequest(Object sender, EventArgs e)
{
   //遍历Post参数，隐藏域除外
   foreach(string i in this.Request.Form)
   {
    if(i=="__VIEWSTATE")continue;
    this.goErr(this.Request.Form[i].ToString());   
   }
   //遍历Get参数。
   foreach(string i in this.Request.QueryString)
   {
    this.goErr(this.Request.QueryString[i].ToString());   
   }
}

三，Global中的一个方法

/**//// <summary>
/// 校验参数是否存在SQL字符
/// </summary>
/// <param name="tm"></param>
private void goErr(string tm)
{
   if(WLCW.Extend.CValidity.SqlFilter2(tm))
    this.Response.Redirect("/error.html");
}

此软件需要微软的net framework 2.0运行库支持
framework 2.0可以从以下地址下载：
(微软官方)http://www.microsoft.com/downloads/details.aspx?familyid=0856EACB-4362-4B0D-8EDD-AAB15C5E04F5&displaylang=zh-cn
(天空软件)http://www.skycn.com/soft/39946.html
(华军软件)http://www.newhua.com/soft/38669.htm

群发器下载地址：http://huliduo.com/download/WangWangSend_v1.03.rar

使用帮助：http://bbs.huliduo.com/showtopic-19.aspx

ihttpHandler拦截httpRequest.
ihttpModule是事件侦听器（其作用跟glob.aspx有些相同）

捕获asp.net下的未处理异常
对软件开发，有个基本的要求，就是要屏蔽掉未处理的异常，在系统出错的时候显示一个友好的界面给用户，同时，保存错误信息到日志中。在asp.net下，未处理的异常会引发HttpApplication.Error 事件，因此，我们可以很简单地实现这个feature。
1、写一个类实现IHttpModule接口，挂接该事件，在事件处理中执行log的功能；
2、在web.config中的customErrors配置节，指定defaultRedirect，并置mode的值为On。

       <customErrors mode="RemoteOnly" defaultRedirect="GenericErrorPage.htm">
             <error statusCode="403" redirect="NoAccess.htm" />
             <error statusCode="404" redirect="FileNotFound.htm" />
         </customErrors>

asp.net中当服务器出错时显示指定的错误页面同时把错误信息写入系统日志文件的探讨

一，在Web.config中填写出错时显示的页面，可以根据不同的statusCode显示不同的出错页面。
    <customErrors mode="On"   //如果设置为Off则出错只返回错误信息，不会跳到自己的指定页面defaultRedirect="/error/customerrorpage.aspx">
     <error statusCode="404" redirect="/error/404Page.aspx"/>
     <error statusCode="403" redirect="/error/403page.aspx"/>
   </customErrors>

二,在Global.asax文件中添加应用出错代码，写入系统日志文件
protected void Application_Error(Object sender, EventArgs e)
         {
             Exception LastError = Server.GetLastError();
             String ErrMessage = LastError.ToString();

             String LogName   = "MyLog";
             String Message = "Url " + Request.Path + " Error: " + ErrMessage;

             // Create Event Log if It Doesn't Exist
        
             if (!EventLog.SourceExists(LogName))
             {
                 EventLog.CreateEventSource(LogName, LogName);
             }
             EventLog Log = new EventLog();
             Log.Source   = LogName;
             //These are the five options that will display a different icon.
             Log.WriteEntry(Message, EventLogEntryType.Information, 1);
             Log.WriteEntry(Message, EventLogEntryType.Error, 2);
             Log.WriteEntry(Message, EventLogEntryType.Warning, 3);
             Log.WriteEntry(Message, EventLogEntryType.SuccessAudit, 4);
             Log.WriteEntry(Message, EventLogEntryType.FailureAudit, 5);

         }
三，现在你可以进行测试了。
我在Default.aspx.cs中产生一个错误，果然跳到默认的错误页面！
private void Page_Load(object sender, System.EventArgs e)
         {
             // Put user code to initialize the page here
             try
             {
                 int y=0;
                 int x=1/y;
             }
             catch (Exception Err)
             {
                 throw new Exception("404");//我想产生不同的错误，对应web.config中的statusCode,该如何实现？
                 //Err.
             }

9.获取错误信息并到指定页面

　　不要使用Response.Redirect,而应该使用Server.Transfer

　　e.g

// in global.asax
protected void Application_Error(Object sender, EventArgs e) {
if (Server.GetLastError() is HttpUnhandledException)
Server.Transfer("MyErrorPage.aspx");

//其余的非HttpUnhandledException异常交给ASP.NET自己处理就okay了 :)
}
　　Redirect会导致post－back的产生从而丢失了错误信息，所以页面导向应该直接在服务器端执行，这样就可以在错误处理页面得到出错信息并进行相应的处理

11.自定义异常处理

//自定义异常处理类
using System;
using System.Diagnostics;

namespace MyAppException
{
　/// ＜summary＞
　/// 从系统异常类ApplicationException继承的应用程序异常处理类。
　/// 自动将异常内容记录到Windows NT/2000的应用程序日志
　/// ＜/summary＞
　public class AppException:System.ApplicationException
　{
　　public AppException()
　　{
　　　if (ApplicationConfiguration.EventLogEnabled)LogEvent("出现一个未知错误。");
　　}

　public AppException(string message)
　{
　　LogEvent(message);
　}

　public AppException(string message,Exception innerException)
　{
　　LogEvent(message);
　　if (innerException != null)
　　{
　　　LogEvent(innerException.Message);
　　}
　}

　//日志记录类
　using System;
　using System.Configuration;
　using System.Diagnostics;
　using System.IO;
　using System.Text;
　using System.Threading;

　namespace MyEventLog
　{
　　/// ＜summary＞
　　/// 事件日志记录类，提供事件日志记录支持
　　/// ＜remarks＞
　　/// 定义了4个日志记录方法 (error, warning, info, trace)
　　/// ＜/remarks＞
　　/// ＜/summary＞
　　public class ApplicationLog
　　{
　　　/// ＜summary＞
　　　/// 将错误信息记录到Win2000/NT事件日志中
　　　/// ＜param name="message"＞需要记录的文本信息＜/param＞
　　　/// ＜/summary＞
　　　public static void WriteError(String message)
　　　{
　　　　WriteLog(TraceLevel.Error, message);
　　　}

　　　/// ＜summary＞
　　　/// 将警告信息记录到Win2000/NT事件日志中
　　　/// ＜param name="message"＞需要记录的文本信息＜/param＞
　　　/// ＜/summary＞
　　　public static void WriteWarning(String message)
　　　{
　　　　WriteLog(TraceLevel.Warning, message);　　
　　　}

　　　/// ＜summary＞
　　　/// 将提示信息记录到Win2000/NT事件日志中
　　　/// ＜param name="message"＞需要记录的文本信息＜/param＞
　　　/// ＜/summary＞
　　　public static void WriteInfo(String message)
　　　{
　　　　WriteLog(TraceLevel.Info, message);
　　　}
　　　/// ＜summary＞
　　　/// 将跟踪信息记录到Win2000/NT事件日志中
　　　/// ＜param name="message"＞需要记录的文本信息＜/param＞
　　　/// ＜/summary＞
　　　public static void WriteTrace(String message)
　　　{
　　　　WriteLog(TraceLevel.Verbose, message);
　　　}

　　　/// ＜summary＞
　　　/// 格式化记录到事件日志的文本信息格式
　　　/// ＜param name="ex"＞需要格式化的异常对象＜/param＞
　　　/// ＜param name="catchInfo"＞异常信息标题字符串.＜/param＞
　　　/// ＜retvalue＞
　　　/// ＜para＞格式后的异常信息字符串，包括异常内容和跟踪堆栈.＜/para＞
　　　/// ＜/retvalue＞
　　　/// ＜/summary＞
　　　public static String FormatException(Exception ex, String catchInfo)
　　　{
　　　　StringBuilder strBuilder = new StringBuilder();
　　　　if (catchInfo != String.Empty)
　　　　{
　　　　　strBuilder.Append(catchInfo).Append("\r\n");
　　　　}
　　　　strBuilder.Append(ex.Message).Append("\r\n").Append(ex.StackTrace);
　　　　return strBuilder.ToString();
　　　}

　　　/// ＜summary＞
　　　/// 实际事件日志写入方法
　　　/// ＜param name="level"＞要记录信息的级别（error,warning,info,trace).＜/param＞
　　　/// ＜param name="messageText"＞要记录的文本.＜/param＞
　　　/// ＜/summary＞
　　　private static void WriteLog(TraceLevel level, String messageText)
　　　{
　　　　try
　　　　{
　　　　　EventLogEntryType LogEntryType;
　　　　　switch (level)
　　　　　{
　　　　　　case TraceLevel.Error:
　　　　　　　LogEntryType = EventLogEntryType.Error;
　　　　　　　break;
　　　　　　case TraceLevel.Warning:
　　　　　　　LogEntryType = EventLogEntryType.Warning;
　　　　　　　break;
　　　　　　case TraceLevel.Info:
　　　　　　　LogEntryType = EventLogEntryType.Information;
　　　　　　　break;
　　　　　　case TraceLevel.Verbose:
　　　　　　　LogEntryType = EventLogEntryType.SuccessAudit;
　　　　　　　break;
　　　　　　default:
　　　　　　　LogEntryType = EventLogEntryType.SuccessAudit;
　　　　　　　break;
　　　　　}

　　　　　EventLog eventLog = new EventLog("Application", ApplicationConfiguration.EventLogMachineName, ApplicationConfiguration.EventLogSourceName );
　　　　　//写入事件日志
　　　　　eventLog.WriteEntry(messageText, LogEntryType);

　　　　}
　　　catch {} //忽略任何异常
　　}
　} //class ApplicationLog
}

现在用一个用线程控制的进程条来说明，大致的步骤如下：

1． 创建Invoke函数，大致如下：

        /// <summary>

        /// Delegate function to be invoked by main thread

        /// </summary>

        private void InvokeFun()

        {

            if( prgBar.Value < 100 )

                prgBar.Value = prgBar.Value + 1;

        }

2． 子线程入口函数：

        /// <summary>

        /// Thread function interface

        /// </summary>

        private void ThreadFun()

        {

            //Create invoke method by specific function

            MethodInvoker mi = new MethodInvoker( this.InvokeFun );

            for( int i = 0; i < 100; i++ )

            {

                this.BeginInvoke( mi );

                Thread.Sleep( 100 );

            }

        }

3． 创建子线程：

            Thread thdProcess = new Thread( new ThreadStart( ThreadFun ) );

            thdProcess.Start();

       备注：

              using System.Threading;

              private System.Windows.Forms.ProgressBar prgBar;

一、引言

    在最近几年，以Google为首的搜索引擎越来越引起人们的关注。由于在Google出现之前，很多提供搜索服务的公司都是使用人工从网络上搜集信息，并将这些信息分类汇总后作为搜索引擎的数据源。如yahoo公司一开始就是通过数千人不停地从网上搜集供查询的信息。这样做虽然信息的分类会很人性化，也比较准确，但是随着互联网信息爆炸式地增长，通过人工的方式来搜集信息已经不可能满足网民对信息的需求了。然而，这一切随着Google的出现而得到了彻底改变。Google一反常规的做法，通过程序7*24地从网上不停地获取网络资源，然后通过一些智能算法分析这些被下载到本地的网络资源，最后将这些分析后的数据进行索引后就形成了一套完整的基本上不需要人工干预的搜索引擎。使用这种模式的搜索引擎甚至可以在几天之内就可获取Internet中的所有信息，同时也节省了大量的资金和时间成本。而这种搜索引擎最重要的组成部分之一就是为搜索引擎提供数据源的网络蜘蛛。也就是说，实现网络蜘蛛是实现搜索引擎的第一步，也是最重要的一步。

二、网络蜘蛛的基本实现思想和实现步骤

    网络蜘蛛的主要作用是从Internet上不停地下载网络资源。它的基本实现思想就是通过一个或多个入口网址来获取更多的URL，然后通过对这些URL所指向的网络资源下载并分析后，再获得这些网络资源中包含的URL，以此类推，直到再没有可下的URL为止。下面是用程序实现网络蜘蛛的具体步骤。

    1. 指定一个（或多个）入口网址(如http://www.comprg.com.cn），并将这个网址加入到下载队列中（这时下载队列中只有一个或多个入口网址）。
    2. 负责下载网络资源的线程从下载队列中取得一个或多个URL，并将这些URL所指向的网络资源下载到本地（在下载之前，一般应该判断一下这个URL是否已经被下载过，如果被下载过，则忽略这个URL）。如果下载队列中没有URL，并且所有的下载线程都处于休眠状态，说明已经下载完了由入口网址所引出的所有网络资源。这时网络蜘蛛会提示下载完成，并停止下载。
    3. 分析这些下载到本地的未分析过的网络资源（一般为html代码），并获得其中的URL（如标签<a>中href属性的值）。
    4. 将第3步获得的URL加入到下载队列中。并重新执行第2步。

三、实现数据的输入输出

    从实现网络蜘蛛的步骤中我们可以看出，下载队列的读、写URL的操作一直贯穿于整个系统中。虽然这个下载队列可以用.Queue类实现，但是各位读者要清楚地知道，在互联网上的URL可不是几十个、几百个这么少。而是以千万计的。这么多的URL显然不能保存在内存中的Queue对象中。因此，我们需要将它保存在容量更大的存储空间中，这就是硬盘。
    本文采用了一个普通的文本文件来保存需要下载和分析的URL（这个文本文件也就是下载队列）。存储格式是每一行为一个URL。既然将URL都保存在了文本文件中，就需要对这个文本文件进行读写。因此，在本节实现了一个用于操作这个文本文件的FileIO类。
    在实现FileIO类之前，先来说一下要如何操作这个文本文件。既然要将这个文件作为队列使用，那么就需要对这个文件进行追加行和从文件开始部分读取数据操作。让我们首先来实现向文件中追加行操作。实现代码如下：

    向文件中追加行的实现代码
// 这两个变量为类全局变量
private FileStream fsw;
private StreamWriter sw;

// 创建用于向文件中追加行的文件流和StreamWriter对象
public void OpenWriteFile(string file)
{
if (!File.Exists(file)) // 如果文件不存在，先创建这个文件
File.Create(file).Close();
// 以追加模式打开这个文件
fsw = new FileStream(file, FileMode.Append ,FileAccess.Write, FileShare.ReadWrite);
// 根据创建的FileStream对象来创建StreamWriter对象
sw = new StreamWriter(fsw);
}
// 关闭写文件流
public void CloseWriteFile()
{
if (fsr != null)
fsw.Close();
}
// 向文件中追加一行字符串
public void WriteLine(string s)
{
sw.WriteLine(s);
sw.Flush(); // 刷新写入缓冲区，使这一行对于读文件流可见
}

    在实现上述的代码时要注意，在创建FileStream对象时，必须使用FileShare.ReadWrite，否则这个文件无法被两个或两个以上的Stream打开，也就是说下面要介绍的读文件流将无法操作这个被写文件流打开的文件。从文件中读取行的实现代码如下：

    从文件中读取行的实现代码
// 这两个变量为类全局变量
private FileStream fsr;
private StreamReader sr;

// 创建用于读取文件行的文件流和StreamWriter对象
public void OpenReadFile(string file)
{
if (!File.Exists(file)) // 如果文件不存在，首先创建这个文件
File.Create(file).Close();
fsr = new FileStream(file, FileMode.OpenOrCreate, FileAccess.Read,
FileShare.ReadWrite);
sr = new StreamReader(fsr);
}
// 关闭读文件流
public void CloseReadFile()
{
if(fsr != null)
fsr.Close();
}
// 从文件中读取一行
public string ReadLine()
{
if(sr.EndOfStream) // 如果文件流指针已经指向文件尾部，返回null
return null;
return sr.ReadLine();
}

    除了上述的读写文件的代码外，FileIO还提供了一个IsEof方法用来判断文件流指针是否位于文件尾部。IsEof方法的实现代码如下如下：

IsEof方法的实现代码
// 用于判断文件流指针是否位于文件尾部
public bool IsEof()
{
return sr.EndOfStream;
}

    FileIO类不仅仅用于对下载队列的读写。在后面我们还会讲到，网络蜘蛛通过多线程下载网络资源时，每一个线程将自己下载的网络资源保存在属于自己的一个目录中。每个这样的目录都有一个index.txt文件，这个文件保存了当前目录的网络资源的URL。向index.txt文件中追加URL也用到了FileIO（index.txt不需要读取，只需要不断地追加行）。


四、线程类的实现

    要想使网络蜘蛛在有限的硬件环境下尽可能地提高下载速度。最廉价和快捷的方法就是使用多线程。在.net framework2.0中提供了丰富的线程功能。其中的核心线程类是Thread。一般可使用如下的代码创建并运行一个线程：

    在C#中使用线程的演示代码
private void fun()
{
// 线程要执行的代码
}
public void testThread()
{
Thread thread;
thread = new Thread(fun); // 创建一个Thread对象，并将fun设为线程运行的方法
thread.Start(); // 运行一个线程
}

    虽然上面的代码比较简单地创建并运行了一个线程，但是这段代码看起来仍然不够透明，也就是客户端在调用线程时仍然需要显式地使用Thread类。下面我们来实现一个用于创建线程的MyThread类。C#中的任何类只需要继承这个类，就可以自动变成一个线程类。MyThread类的代码如下：

    MyThread类的实现代码
// 任何C#类继承MyThread后，就会自动变成一个线程类
class MyThread
{
private Thread thread;
public MyThread()
{
thread = new Thread(run); // 创建Thread对象
}
// 用于运行线程代码的方法，MyThread的子类必须覆盖这个方法
public virtual void run()
{
}
public void start()
{
thread.Start(); // 开始运行线程，也就是开始执行run方法
}
// 使当前线程休眠millisecondsTimeout毫秒
public void sleep(int millisecondsTimeout)
{
Thread.Sleep(millisecondsTimeout);
}
}


    我们可参照如下的代码使用MyThread类：

    测试的ThreadClass类的代码
class ThreadClass : MyThread
{
public override void run()
{
// 要执行的线程代码
}
}

// 测试ThreadClass类
public void testThreadClass()
{
ThreadClass tc = new ThreadClass();
tc.start(); // 开始运行线程，也就是执行run方法
}

    各位读者可以看看，上面的代码是不是要比直接使用Thread类更方便、直观、易用，还有些面向对象的感觉！

五、用多线程下载网络资源

    一般来说，网络蜘蛛都是使用多线程来下载网络资源的。至于如何使用多线程来下载，各个版本的网络蜘蛛不尽相同。为了方便和容易理解，本文所讨论的网络蜘蛛采用了每一个线程负责将网络资源下载到一个属于自己的目录中，也就是说，每一个线程对应一个目录。而在当前目录中下载的网络资源达到一定的数目后（如5000），这个线程就会再建立一个新目录，并从0开始计数继续下载网络资源。在本节中将介绍一个用于下载网络资源的线程类DownLoadThread。这个类的主要功能就是从下载队列中获得一定数量的URL，并进行下载和分析。在DownLoadThread类中涉及到很多其他重要的类，这些类将在后面的部分介绍。在这里我们先看一下DownLoadThread类的实现代码。

    DownLoadThread类的代码
class DownLoadThread : MyThread
{
// ParseResource类用于下载和分析网络资源
private ParseResource pr = new ParseResource();
private int currentCount = 0; // 当前下载目录中的网页数
// 用于向每个线程目录中的index.txt中写当前目录的URL
private FileIO fileIO = new FileIO();
private string path; // 当前的下载目录（后面带“\"）
private string[] patterns; // 线程不下载符合patterns中的正则表达式的URL
public bool stop = false; // stop为true，线程退出
public int threadID; // 当前线程的threadID，用于区分其他的线程

public DownLoadThread(string[] patterns)
{
pr.findUrl += findUrl; // 为findUrl事件赋一个方法
this.patterns = patterns;
}
// 这是一个事件方法，每获得一个URL时发生
private void findUrl(string url)
{
Common.addUrl(url); // 将获得的URL加到下载队列中
}
private void openFile() // 打开下载目录中的index.txt文件
{
fileIO.CloseWriteFile();
fileIO.OpenWriteFile(path + Common.indexFile);
}
public override void run() // 线程运行方法
{
LinkedList<string> urls = new LinkedList<string>();
path = Common.getDir(); // 获得下载目录
openFile();
while (!stop)
{
// 当下载队列中没有URL时，进行循环等待
while (!stop && urls.Count == 0)
{
Common.getUrls(urls, 20); // 从下载队列中获得20个url
if (urls.Count == 0) // 如果未获得url
{
// 通知系统当前线程已处于等待状态，
// 如果所有的线程都处于等待状态，
// 说明所有的网络资源都被下载完了
Common.threadWait(threadID);
sleep(5000); // 当前线程休眠5秒
}
}
StringBuilder sb = new StringBuilder();
foreach (string url in urls) // 循环对这20个url进行循环下载分析
{
if (stop) break;
// 如果当前下载目录的资源文件数大于等于最大文件数目时，
// 建立一个新目录，并继续下载
if (currentCount >= Common.maxCount)
{
path = Common.getDir();
openFile();
currentCount = 0; // 目录
}
// 每个下载资源文件名使用5位的顺序号保存（没有扩展名），
// 如00001、00002。下面的语句是格式化文件名
string s = string.Format("{0:D5}", currentCount + 1);
sb.Remove(0, sb.Length);
sb.Append(s);
sb.Append(":");
sb.Append(url);
try
{
// 下载和分析当前的url
pr.parse(url, path + s, patterns);
Common.Count++;
// 将当前的url写入index.txt
fileIO.WriteLine(sb.ToString());
currentCount++;
}
catch (Exception e)
{

}
}
urls.Clear();
}
}
}
}

六、分析网络资源

    对下载的网络资源进行分析是网络蜘蛛中最重要的功能之一。这里网络资源主要指的是html代码中<a>标签的href属性值。状态和状态之间会根据从html文件中读入的字符进行切换。下面是状态之间切换的描述。

状态0：读入'<'字符后切换到状态1，读入其他的字符，状态不变。
状态1：读入'a'或'A'，切换到状态2，读入其他的字符，切换到状态0。
状态2：读入空格或制表符(\t)，切换到状态3，读入其他的字符，切换到状态0。
状态3：读入'>'，成功获得一个<a>，读入其他的字符，状态不变。为了更容易说明问题。在本文给出的网络蜘蛛中只提取了html代码中<a>中的href属性中的url。本文中所采用的分析方法是分步进行提取href。首先将html代码中的<a>标签整个提出来。不包括</a>和前面的字符，如<a href="http://www.comprg.com.cn">comprg</a>中只提取<a href="http://www.comprg.com.cn">，而comprg</a>将被忽略，因为这里并没有url。
本文使用了一个状态机来的提取<a>，这个状态机分为五个状态（0 至 4）。第一个状态是初始态，最后一个状态为终止态，如果到达最后一个状态，说明已经成功获得了一个<a>

    状态机如图1所示。



图1

    最后一个双环的状态是最终态。下面让我们来看看获得<a>的实现代码。

getA方法的实现
// 获得html中的<a>
private void getA()
{
char[] buffer = new char[1024];
int state = 0;
String a = "";

while (!sr.EndOfStream)
{
int n = sr.Read(buffer, 0, buffer.Length);
for (int i = 0; i < n; i++)
{
switch (state)
{
case 0: // 状态0
if (buffer[i] == '<') // 读入的是'<'
{
a += buffer[i];
state = 1; // 切换到状态1
}
break;
case 1: // 状态1
if (buffer[i] == 'a' || buffer[i] == 'A') // 读入是'a'或'A'
{
a += buffer[i];
state = 2; // 切换到状态2
}
else
{
a = "";
state = 0; // 切换到状态0
}
break;
case 2: // 状态2
if (buffer[i] == ' ' || buffer[i] == '\t') // 读入的是空格或'\t'
{
a += buffer[i];
state = 3;
}
else
{
a = "";
state = 0; // 切换到状态0
}
break;
case 3: // 状态3
if (buffer[i] == '>') // 读入的是'>'，已经成功获得一个<a>
{
a += buffer[i];
try
{
string url = getUrl(getHref(a)); // 获得<a>中的href属性的值
if (url != null)
{
if (findUrl != null)
findUrl(url); // 引发发现url的事件

}
}
catch (Exception e)
{
}
state = 0; // 在获得一个<a>后，重新切换到状态0
}
else
a += buffer[i];
break;
}
}
}
}

    在getA方法中除了切换到状态0外，其他的状态切换都将已经读入的字符赋给String变量a，如果最后发现变量a中的字符串不可能是<a>后，就将a清空，并切换到状态0后重新读入字符。
在getA方法中使用了一个重要的方法getHref来从<a>中获得href部分。getHref方法的实现如下：

    getHref方法的实现
// 从<a>中获得Href
private String getHref(string a)
{
try
{
string p = @"href\s*=\s*('[^']*'|""[^""]*""|\S+\s+)"; // 获得Href的正则表达式
MatchCollection matches = Regex.Matches(a, p,
RegexOptions.IgnoreCase |
RegexOptions.ExplicitCapture);

foreach (Match nextMatch in matches)
{
return nextMatch.Value; // 返回href
}
return null;
}
catch (Exception e)
{
throw e;
}
}

    在getHref方法中使用了正则表达式从<a>中获得href。在<a>中正确的href属性格式有三种情况，这三种情况的主要区别是url两边的符号，如单引号、双引号或没有符号。这三种情况如下所示：
情况1： <a href = "http://www.comprg.com.cn" > comprg</a>
情况2： <a href = 'http://www.comprg.com.cn' > comprg</a>
情况3： <a href = http://www.comprg.com.cn > comprg</a>
    getHref方法中的p存储了用于过滤这三种情况的href，也就是说，使用正则表达式可以获得上述三种情况的href如下：

从情况1获得得的href：href = "http://www.comprg.com.cn"
从情况2获得得的href：href = 'http://www.comprg.com.cn'
从情况3获得得的href：href = http://www.comprg.com.cn

    在获得上述的href后，需要将url提出来。这个功能由getUrl完成，这个方法的实现代码如下：

getUrl方法的实现
// 从href中提取url
private String getUrl(string href)
{
try
{
if (href == null) return href;
int n = href.IndexOf('='); // 查找'='位置
String s = href.Substring(n + 1);
int begin = 0, end = 0;
string sign = "";
if (s.Contains("\"")) // 第一种情况
sign = "\"";
else if (s.Contains("'")) // 第二种情况
sign = "'";
else // 第三种情况
return getFullUrl(s.Trim());
begin = s.IndexOf(sign);
end = s.LastIndexOf(sign);

return getFullUrl(s.Substring(begin + 1, end - begin - 1).Trim());
}
catch (Exception e)
{
throw e;
}
}

    在获得url时有一点应该注意。有的url使用的是相对路径，也就是没有“http://host”部分，但将url保存时需要保存它们的完整路径。这就需要根据相对路径获得它们的完整路径。这个功能由getFullUrl方法完成。这个方法的实现代码如下：

getFullUrl方法的实现代码
// 将相对路径变为绝对路径
private String getFullUrl(string url)
{
try
{
if (url == null) return url;
if (processPattern(url)) return null; // 过滤不想下载的url
// 如果url前有http://或https://，为绝对路径，按原样返回
if (url.ToLower().StartsWith("http://") || url.ToLower().StartsWith("https://"))
return url;
Uri parentUri = new Uri(parentUrl);
string port = "";
if (!parentUri.IsDefaultPort)
port = ":" + parentUri.Port.ToString();
if (url.StartsWith("/")) // url以"/"开头，直接放在host后面
return parentUri.Scheme + "://" + parentUri.Host + port + url;
else // url不以"/"开头，放在url的路径后面
{
string s = "";
s = parentUri.LocalPath.Substring(0, parentUri.LocalPath.LastIndexOf("/"));
return parentUri.Scheme + "://" + parentUri.Host + port + s + "/" + url;
}
}
catch (Exception e)
{
throw e;
}
}

    在ParseResource中还提供了一个功能就是通过正则表达式过滤不想下载的url，这个功能将通过processPattern方法完成。实现代码如下：

    processPattern方法的实现代码
// 如果返回true，表示url符合pattern，否则，不符合模式
private bool processPattern(string url)
{
foreach (string p in patterns)
{

if (Regex.IsMatch(url, p, RegexOptions.IgnoreCase | RegexOptions.ExplicitCapture)
&& !p.Equals(""))
return true;
}
return false;
}
    ParseResource类在分析html代码之前，先将html下载到本地的线程目录中，再通过FileStream打开并读取待分析的数据。ParseResource类其他的实现代码请读者参阅本文提供的源代码。

七、键树的实现

    在获取Url的过程中，难免重复获得一些Url。这些重复的Url将大大增加网络蜘蛛的下载时间，以及会导致其他的分析工具重复分析同一个html。因此，就需要对过滤出重复的Url，也就是说，要使网络蜘蛛下载的Url都是唯一的。达到这个目的的最简单的方法就是将已经下载过的Url保存到一个集合中，然后在下载新的Url之前，在这个集合中查找这个新的Url是否被下载过，如果下载过，就忽略这个Url。
    这个功能从表面上看非常简单，但由于我们处理的是成千上万的Url，要是将这些Url简单地保存在类似List一样的集合中，不仅会占用大量的内存空间，而且当Url非常多时，如一百万。这时每下载一个Url，就要从这一百万的Url中查找这个待下载的Url是否存在。虽然可以使用某些查找算法（如折半查找）来处理，但当数据量非常大时，任何查找算法的效率都会大打折扣。因此，必须要设计一种新的存储结构来完成这个工作。这个新的数据存储结构需要具有两个特性:

    1. 尽可能地减少存储Url所使用的内存。
    2. 查找Url的速度尽可能地快（最好的可能是查找速度和Url的数量无关）。

    下面先来完成第一个特性。一般一个Url都比较长，如平均每个Url有50个字符。如果有很多Url，每个Url占50个字符，一百万个Url就是会占用50M的存储空间。而我们保存Url的目的只有一个，就是查找某一个Url是否存在。因此，只需要将Url的Hashcode保存起来即可。由于Hashcode为Int类型，因此，Hashcode要比一个Url字符串使用更少的存储空间。
    对于第二个特性，我们可以使用数据结构中的键树来解决。假设有一个数是4532。首先将其转换为字符串。然后每个键树节点有10个（0至9）。这样4532的存储结构如图2所示：



图2

    从上面的数据结构可以看出，查找一个整数只和这个整数的位数有关，和整数的数量无关。这个键树的实现代码如下：

    KeyTree的实现代码
class KeyTreeNode // 键树节点的结构
{
// 指向包含整数下一个的结点的指针
public KeyTreeNode[] pointers = new KeyTreeNode[10];
// 结束位标志，如果为true，表示当前结点为整数的最后一位
public bool[] endFlag = new bool[10];
}
class KeyTree
{
private KeyTreeNode rootNode = new KeyTreeNode(); // 根结点
// 向键树中添加一个无符号整数
public void add(uint n)
{
string s = n.ToString();
KeyTreeNode tempNode = rootNode;
int index = 0;
for (int i = 0; i < s.Length; i++)
{
index = int.Parse(s[i].ToString()); // 获得整数每一位的值
if (i == s.Length - 1) // 在整数的最后一位时，将结束位设为true
{
tempNode.endFlag[index] = true;
break;
}
if (tempNode.pointers[index] == null) // 当下一个结点的指针为空时，新建立一个结点对象
tempNode.pointers[index] = new KeyTreeNode();
tempNode = tempNode.pointers[index];
}
}
// 判断一个整数是否存在
public bool exists(uint n)
{
string s = n.ToString();
KeyTreeNode tempNode = rootNode;
int index = 0;
for (int i = 0; i < s.Length; i++)
{
if (tempNode != null)
{
index = int.Parse(s[i].ToString());
// 当整数的最后一位的结束标志为true时，表示n存在
if((i == s.Length - 1)&& (tempNode.endFlag[index] == true))
return true;
else
tempNode = tempNode.pointers[index];
}
else
return false;
}
return false;
}
}

    上面代码中的KeyTreeNode之所以要使用结束标志，而不根据指针是否为空判断某个整数的存在，是因为可能存在长度不相等的整数，如4321和432。如果只使用指针判断。保存4321后，432也会被认为存在。而如果用结束标志后，在值为2的节点的结束标志为false，因此，表明432并不存在。下面的UrlFilter使用了上面的键树来处理Url。

    UrlFilter类的实现代码
// 用于将url重新组合后再加到键树中
// 如http://www.comprg.com.cn和http://www.comprg.com.cn/是一样的
// 因此，它们的hashcode也要求一样
class UrlFilter
{
public static KeyTree urlHashCode = new KeyTree();
private static object syncUrlHashCode = new object();
private static string processUrl(string url) // 重新组合Url
{
try
{
Uri uri = new Uri(url);
string s = uri.PathAndQuery;
if(s.Equals("/"))
s = "";
return uri.Host + s;
}
catch(Exception e)
{
throw e;
}
}
private static bool exists(string url) // 判断url是否存在
{
try
{
lock (syncUrlHashCode)
{
url = processUrl(url);
return urlHashCode.exists((uint)url.GetHashCode());
}
}
catch (Exception e)
{
throw e;
}
}

public static bool isOK(string url)
{
return !exists(url);
}
// 加处理完的Url加到键树中
public static void addUrl(string url)
{
try
{
lock (syncUrlHashCode)
{
url = processUrl(url);
urlHashCode.add((uint)url.GetHashCode());
}
}
catch (Exception e)
{
throw e;
}
}

}

八、其他部分的实现

    到现在为止，网络蜘蛛所有核心代码都已经完成了。下面让我们做一个界面来使下载过程可视化。界面如图3所示。



图3

    这个界面主要通过一个定时器每2秒钟获得个一次网络蜘蛛的下载状态。包括获得的URL数和已经下载的网络资源数。其中这些状态信息都保存在一个Common类的静态变量中。Common类和主界面的代码请读者参阅本文提供的源代码。

九、结束语

    至此，网络蜘蛛程序已经全部完成了。但在实际应用中，光靠一台机器下载整个的网络资源是远远不够的。这就需要通过多台机器联合下载。然而这就会给我们带来一个难题。就是这些机器需要对已经下载的Url进行同步。读者可以根据本文提供的例子，将其改成分布式的可多机同时下载的网络蜘蛛。这样网络蜘蛛的下载速度将会有一个质的飞跃。