自从有了计算机以后，人类开始用计算机保存信息，有保存，就有查找，于是检索技术诞生了。文本检索技术的发展从最初的SMART文档检索系统[1]到Altavista搜索引擎，到现在的搜索巨头Google[2]，其发展可谓日新月异、与时具进，人们开始习惯互联网的搜索时代，站内检索的需求也逐渐显露出来。下面列举需要站内检索的五大理由：

一、所寻即所得。

信息量总在不断增长，而访问者的耐心却逐渐下降。据统计，每需要多点击一次鼠标，就有三分之一的用户选择放弃。这意味着100个访问者进入我们的网站，如果需要点击三次鼠标才能找到所需要的东西，那么就只剩下不到4个人了。根据第十一次中国互联网信息调查表明，53.1%的人上网是为了获取信息[3]，大部分网站的目的是让外界了解自己，了解的人越多，效果就越好。把访问者最想要的返回给用户，就可让更多的用户了解自己，这样站内检索成为必然选择。

二、了解访问者的意图。

管理大师彼得.德鲁克说：“一定要知道你的客户想要什么？”客户的需求永远都是最重要的，因此我们总在分析我们的客户在哪里及他们需要什么。所有访问我们网站的人都可能是我们的潜在客户，了解他们的意图对于我们做决策很重要。站内检索技术可以实现这个功能，站内检索的日志功能可以记录每个访问者的检索词和检索结果，这是访问者意图的最直接的表现。通过分析这些信息，我们还可以调整网站结构，把访问者最想要的放在明显的位置（了解我们的人就多啦）。这个理由经常被人忽视，我在这里放在第二位也是希望引起大家重视，特别是那些已经使用站内检索的网站所有者。

三、  符合网民习惯。

根据调查表明，68.3％的上网者经常使用搜索引擎[3]。大部分人已经习惯通过检索来找到他们想要的东西，而不是按照某个栏目一级一级往下找(我就很少用yahoo的分类目录）。在网站内访问者要是没看见那熟悉的按钮会多少有些不习惯（我们千万不要让上帝感到不习惯）。在心理学角度讲，人们如果对某个事物不习惯很容易产生厌烦情绪，这也就是为什么你第一次去某个地方会觉得特别远，要是路熟了这种感觉就消失了。看来，为了上帝我们也需要使用站内检索。

四、  提升网站信息价值。

我们经常会发生这样的事情：明明记得有一篇写关于吃香辣虾的文件，就是想不起存放在什么地方了。访问者也有类似困扰，只记得某个网站上说了关于张国荣跳楼的消息，但不知道具体的链接在哪里。另外，要是隐藏在目录很深的html文档可能自从网站建立到整个网站关闭也没有一个人看过，这些都不是我们所想要的。站内检索毫无疑问可以解决上述问题。同时，按照一个主题把所有相关文档提供给访问者，可以让访问者更全面的了解他所想要的东西，这增加了网站信息间的组织性和逻辑性，方便了访问者的使用，提升用户体验度（用户体验度：一个让我们忐忑不安的名词）。

五、 身份的象征。

有没有站内检索其实已经不只是用户体验度的问题了，还是一个网站专业身份的象征。浏览国外公司的网站，会发现几乎所有网站都在首页最明显的区域放置了一个搜索框，这传达的信息是：专业的网站都有站内检索（呵呵，我没说国外网站就是专业网站）。网民的心态是：我用不用，你管不着，你要是没有就说明你不够专业。为了树立形象，也需要使用站内检索。

最后还得解释一个问题：为什么有了搜索引擎还需要站内检索？用网际搜索引擎不是直接可以查到吗？这其中有两个问题：1 搜索羽毛球，你会搜索到235,000个网页[4]，也不知道我公司的排在第10,000页还是10,001页，搜索者可能永远也不会去看。2 搜索引擎通过网络Spider收集网页，对于网站内隐藏很深的网页很难索引到的。

     有很多网站都在网页上加个“站内搜索引擎”、“搜索引擎”、“全文检索”等等相关字样。
     用户一用，结果发现，既不能多关键组合查询，也不能支持国际语法，甚至不能支持全文检索，就更别谈不支持相关性排序等真正的搜索引擎具备的功能了。这些搜索和真正的站内搜索引擎有和区别呢？
     真正的全文检索应具备 相关性排序技术 和 分词索引功能。 如果需要进行互联网的信息抓取和采集那么还需要网络蜘蛛模块。 分词、索引、排序这是全文检索的基本和核心，缺一不可。全文检索至少需要具备中文分词、索引、相关性排序功能。
     所以简单考查一个站内搜索引擎的真伪只需要知道：能否实现相关性排序、国际标准的搜索语法、动态摘要、飘红、支持海量数据多并快速发查询、搜索耗时极短。
（当然这只是全文检索的基本内容，一个全文检索的搜索引擎的品质好坏还和相关的技术水平、各种技术的结合、产品的管理有很大关系。 评价全文检索的标准是用户体验度，今后我们会提供相关方面的内容）

常用的站内搜索技术比较：

  private String[] getExecString() {
    return new String[] {"df","-k", dirPath};
  }

把这个命令改掉后编译打包就OK了

@echo off
set JAVA_HEAP_MAX="-Xmx1000m"
set JAVA=$JAVA_HOME/bin/java

if not "%1"=="" goto INIT else goto echoMSG
:echoMSG 
  echo Title:欢迎使用北京线点科技 Hadoop 运行脚本
  echo Author:jaddy0302 mail:jaddy0302@126.com QQ:5622928
  echo Site:http://www.xd-tech.com.cn 线点科技 专业垂直搜索引擎产品
  echo Usage: hadoop [--config confdir] COMMAND
  echo where COMMAND is one of:
  echo   namenode -format     format the DFS filesystem
  echo   secondarynamenode    run the DFS secondary namenode
  echo   namenode             run the DFS namenode
  echo   datanode             run a DFS datanode
  echo   dfsadmin             run a DFS admin client
  echo   fsck                 run a DFS filesystem checking utility
  echo   fs                   run a generic filesystem user client
  echo   jobtracker           run the MapReduce job Tracker node
  echo   pipes                run a Pipes job
  echo   tasktracker          run a MapReduce task Tracker node
  echo   job                  manipulate MapReduce jobs
  echo   version              print the version
  echo   jar jar            run a jar file
  echo   distcp srcurl desturl copy file or directories recursively
  echo  or
  echo   CLASSNAME            run the class named CLASSNAME
  echo Most commands print help when invoked w/o parameters.
  goto end;
:INIT 
  set HADOOP_HOME=C:\work\hadoop
  if "%HADOOP_HOME%"=="" set HADOOP_HOME=.. 
  set CLASSPATH=%HADOOP_HOME%;%HADOOP_HOME%\conf;%JAVA_HOME%/lib/tools.jar;
  set HADOOP_LOG_DIR=%HADOOP_HOME%/logs
  set HADOOP_LOGFILE=hadoop.log
  @echo @echo off>setclasspath.bat
  for %%i in (%HADOOP_HOME%\hadoop-*.jar) do @echo set CLASSPATH=%%CLASSPATH%%%%i>>setclasspath.bat;
  for %%i in (%HADOOP_HOME%\lib\*.jar) do @echo set CLASSPATH=%%CLASSPATH%%%%i>>setclasspath.bat;
  for %%i in (%HADOOP_HOME%\lib\jetty-ext\*.jar) do @echo set CLASSPATH=%%CLASSPATH%%%%i>>setclasspath.bat;
  goto EXEC
:EXEC
  call setclasspath.bat
  if  "%1" == "namenode" set CLASS=org.apache.hadoop.dfs.NameNode
  if  "%1" == "secondarynamenode" set CLASS=org.apache.hadoop.dfs.SecondaryNameNode
  if  "%1" == "datanode" set  CLASS=org.apache.hadoop.dfs.DataNode
  if  "%1" == "fs" set  CLASS=org.apache.hadoop.fs.FsShell
  if  "%1" == "dfs" set  CLASS=org.apache.hadoop.fs.FsShell
  if  "%1" == "dfsadmin" set  CLASS=org.apache.hadoop.dfs.DFSAdmin
  if  "%1" == "fsck" set  CLASS=org.apache.hadoop.dfs.DFSck
  if  "%1" == "jobtracker" set  CLASS=org.apache.hadoop.mapred.JobTracker
  if  "%1" == "tasktracker" set  CLASS=org.apache.hadoop.mapred.TaskTracker
  if  "%1" == "job" set  CLASS=org.apache.hadoop.mapred.JobClient
  if  "%1" == "pipes" set  CLASS=org.apache.hadoop.mapred.pipes.Submitter
  if  "%1" == "version" set  CLASS=org.apache.hadoop.util.VersionInfo
  if  "%1" == "jar" set  CLASS=org.apache.hadoop.util.RunJar
  if  "%1" == "distcp" set  CLASS=org.apache.hadoop.util.CopyFiles
goto SPLI
:SPLI
  set HADOOP_OPTS=
  set HADOOP_OPTS=%HADOOP_OPTS% -Dhadoop.log.dir=%HADOOP_LOG_DIR%
  set HADOOP_OPTS=%HADOOP_OPTS% -Dhadoop.log.file=%HADOOP_LOGFILE%
  set HADOOP_OPTS=%HADOOP_OPTS% -Dhadoop.home.dir=%HADOOP_HOME%
  set HADOOP_OPTS=%HADOOP_OPTS% -Dhadoop.id.str=%HADOOP_IDENT_STRING%
  call "%JAVA_HOME%\bin\java" %JAVA_HEAP_MAX% %HADOOP_OPTS% -classpath "%CLASSPATH%" %CLASS% %2 %3 %4 %5 %6 %7 %8 %9
  rem if "%ERRORLEVEL%" == "1" goto SPLI else goto end 
:end

在各种网络文本中，最容易获得的，就是网络新闻之类。这类文章，甚至包括很多的非新闻类的网上文章，特点都是具有一个标题，这个标题一般会放在正文开头在<h1> </h1>标签中，有些网站也会放在<title> </title>标签中；另外，在一般的网上文章中，正文往往都是用<p> </p>来进行段落划分。同时，正文成分在网页源代码中，分布往往较为集中。因此，本文提出一种正文判定法则，即标签密度判定法，即，首先判断一个<p> </p>代码块中的标签密度，如果低于某一阈值，就认为其标签含量很低，是正文的可能性就比较大。下面举两个例子来论证标签密度是否能成为判定正文的标准：代码片段A是一篇新闻网页的源码中，正文部分的Fragment，而代码片段B，则是非正文部分的Fragment。这两段网页源代码，是随机地从某一搜索引擎结果集中抽取的，因而具有相当的代表性：

图3-1 代码片段A，从某HTML页面源文件中摘取的片断

图3-2 代码片段B，从同一HTML页面源文件中摘取的片断

这代码片段A指示的就是我们要提取的正文。如何把这样的代码，与代码段B这样的代码区分开呢？首先从语言内容角度是行不通的，目前电脑很难理解自然语言；也不能从是否是超级链接入手，前面已经说了，正文中有时也会出现不能随意整个去除的超级链接，必须判断出哪里是正文，才能对正文中的超级链接进行处理。笔者在这个问题上也曾徘徊很久，最后的突破在于寻找到了这样一个规律：正文部分的HTML标签密度，远远大于非正文部分。为了验证这个规律，我们统计分析一下上面的两个例子（HTML标签：这里指所有在HTML源代码中出现的，尖括号（<>）中的内容，每对尖括号，连同其内容，算作一个标签，每个类似于<html> </html>的两个标签，其中一个标示标签内容开始，另一个标志标签内容结束的，称为一个标签对。）：

代码片段A的统计分析：

正文字数：242字（正文字数： 指的是非标签的文本字数，标点符号计在内。）

标签数：7个（标签数：只计算标签的个数，忽略标签内文本的多少。）

标签密度：28.93个/千字（标签密度：指的是前面定义的标签数与正文数的商，单位规定为“个/千字”，计算公式为“标签密度=1000*标签数/字数”。）

代码片段B的统计分析：

正文字数（非标签文本）：221字

标签数：69个

标签密度：312.22个/千字

从上面的两组统计数据可以看出，网络文本源代码中，正文部分的HTML标签密度远远小于非正文部分，同时，对于更多的网络文本的统计数据分析可以知道，按照上文的方法所算出的标签密度，正文部分与非正文部分，存在着极大的差异。从而我们可以得出初步结论：可以依据对HTML标签密度的统计分析来指出在一份HTML源代码中，文章正文的位置。

于是，在对更多的文本进行类似的统计后，笔者得出一个正式的统计的结论，正文部分的HTML标签密度大于50个/千字的概率接近于零，而非正文部分的标签密度小于200个/千字的机率也几乎为零。所以，理论上，在50个/千字和200个/千字这个统计得出标签密度数据的“真空区”中选择任何一个数值作为正文与非正文部分的分界线都是可以的。但是，为了保证不遗漏正文（不遗漏正文：对于标注对象来说，正文的缺失是难以接受的，而少量的冗余资料则被认为是对工作无害的。所以，在提取正文时，宁可放行一些无用的资料，也不能把丝毫的正文过滤掉），笔者建议选择的分界值是150个/千字（150个/千字：这是针对网络新闻资料得出的建议分界值，可能并不适用于其他类型的资料）。当然，在其后的设计分析中，我们可以知道，对于不同网站的文本语料，存在不同的设计风格差异，体现在源码上，就是正文部分与非正文部分的标签密度存在一定的波动。我们可以通过对这个阈值进行调整，来达到最适合的抽取精度。当然，在软件中，会存在一个Scroll Bar，对这个阈值进行调整。

 @echo off
set JAVA_HEAP_MAX="-Xmx512M"
if not "%1"=="" goto INIT else goto echoMSG
:echoMSG
  echo Title:欢迎使用北京线点科技 Nutch 运行脚本
  echo Author:jaddy0302 mail:jaddy0302@126.com QQ:5622928
  echo Site:http://www.xd-tech.com.cn 线点科技 专业垂直搜索引擎产品
  echo Nutch Version: 0.7.2
  echo Usage: nutch COMMAND
  echo where COMMAND is one of:
  echo   crawl             one-step crawler for intranets
  echo   admin             database administration, including creation
  echo   inject            inject new urls into the database
  echo   generate          generate new segments to fetch
  echo   fetchlist         print the fetchlist of a segment
  echo   fetch             fetch a segment's pages
  echo   parse             parse a segment's pages
  echo   index             run the indexer on a segment's fetcher output
  echo   merge             merge several segment indexes
  echo   dedup             remove duplicates from a set of segment indexes
  echo   updatedb          update db from segments after fetching
  echo   updatesegs        update segments with link data from the db
  echo   mergesegs         merge multiple segments into a single segment
  echo   readdb            examine arbitrary fields of the database
  echo   analyze           adjust database link-analysis scoring
  echo   prune             prune segment index(es) of unwanted content
  echo   segread           read, fix and dump segment data
  echo   segslice          append, join and slice segment data
  echo   server            run a search server
  echo   namenode          run the NDFS namenode
  echo   datanode          run an NDFS datanode
  echo   ndfs              run an NDFS admin client
  echo   jobtracker        run the MapReduce job Tracker node
  echo   tasktracker       run a MapReduce task Tracker node
  echo  or
  echo   CLASSNAME         run the class named CLASSNAME
  echo Most commands print help when invoked w/o parameters.
  goto end;
:INIT 
  set NUTCH_HOME=C:\work\nutch-0.7.2
  if "%NUTCH_HOME%"=="" set NUTCH_HOME=.. 
  set CLASSPATH=%NUTCH_HOME%;%NUTCH_HOME%\conf;%NUTCH_HOME%\plugin
  @echo @echo off>setclasspath.bat
  for %%i in (%NUTCH_HOME%\nutch-*.jar) do @echo set CLASSPATH=%%CLASSPATH%%;%%i>>setclasspath.bat;& for %%i in (%NUTCH_HOME%\lib\*.jar) do @echo set CLASSPATH=%%CLASSPATH%%;%%i>>setclasspath.bat;
  goto EXEC
:EXEC
  call setclasspath
  if  "%1" == "crawl" set CLASS=org.apache.nutch.tools.CrawlTool
  if  "%1" == "admin" set CLASS=org.apache.nutch.tools.WebDBAdminTool
  if  "%1" == "inject" set CLASS=org.apache.nutch.db.WebDBInjector
  if  "%1" == "generate" set CLASS=org.apache.nutch.tools.FetchListTool
  if  "%1" == "fetchlist" set CLASS=org.apache.nutch.pagedb.FetchListEntry
  if  "%1" == "fetch" set CLASS=org.apache.nutch.fetcher.Fetcher
  if  "%1" == "parse" set CLASS=org.apache.nutch.tools.ParseSegment
  if  "%1" == "index" set CLASS=org.apache.nutch.indexer.IndexSegment
  if  "%1" == "merge" set CLASS=org.apache.nutch.indexer.IndexMerger
  if  "%1" == "dedup" set CLASS=org.apache.nutch.indexer.DeleteDuplicates
  if  "%1" == "updatedb" set CLASS=org.apache.nutch.tools.UpdateDatabaseTool
  if  "%1" == "updatesegs" set CLASS=org.apache.nutch.tools.UpdateSegmentsFromDb
  if  "%1" == "mergesegs" set CLASS=org.apache.nutch.tools.SegmentMergeTool
  if  "%1" == "readdb" set CLASS=org.apache.nutch.db.WebDBReader
  if  "%1" == "prune" set CLASS=org.apache.nutch.tools.PruneIndexTool
  if  "%1" == "segread" set CLASS=org.apache.nutch.segment.SegmentReader
  if  "%1" == "segslice" set CLASS=org.apache.nutch.segment.SegmentSlicer
  if  "%1" == "analyze" set CLASS=org.apache.nutch.tools.LinkAnalysisTool
  if  "%1" == "server" set CLASS=org.apache.nutch.searcher.DistributedSearch$Server
  if  "%1" == "namenode" set CLASS=org.apache.nutch.ndfs.NDFS$NameNode
  if  "%1" == "datanode" set CLASS=org.apache.nutch.ndfs.NDFS$DataNode
  if  "%1" == "ndfs" set CLASS=org.apache.nutch.fs.TestClient
  if  "%1" == "jobtracker" set CLASS=org.apache.nutch.mapReduce.JobTracker
  if  "%1" == "tasktracker" set CLASS=org.apache.nutch.mapReduce.TaskTracker
  call "%JAVA_HOME%\bin\java" %JAVA_HEAP_MAX% -classpath "%CLASSPATH%" %CLASS% %2 %3 %4 %5 %6 %7 %8 %9
:end

您输入一个关键字列表，点击 Search 按钮，马上将得到相关文档的列表。这非常容易，不是吗？是的，的确很容易。这是什么魔法吗？其实并不是。

信息检索或简称为“搜索”，目前是计算机科学中的一个非常重要的领域。从技术的角度来看，倒排索引用于存储文档中出现的关键字，并且支持搜索，它是一种广为熟悉并且精确描述的数据结构。

公正地说，查找包含关键字的文档列表是件很容易的事情，但是，排序技术却涉及到很多未知的技术和深奥的计算公式。事实上，对数以千计的、包含请求搜索的关键字的文档进行排序，以便将与用户最相关的文档列在最上方，这并不是一件容易的任务。尽管如此，用于排序结果的数学模型通常是常用的词频/倒排文档频率模型的变体，而对于这种模型，已有很好的研究基础。

每年，美国国家标准局都组织关于搜索引擎的“奥运比赛”：称为 TREC 挑战赛，这一赛事提供给参赛者海量的文档，而他们必须在这些文档中查找出满足要求的少部分内容。不幸的是，大多数商业搜索引擎都拒绝使用这类科学的方法进行评估。

除了使用关键字进行搜索之外，您还可以使用浏览的方法进行搜索，这种方法使用分层结构的、类似于目录的结构来定位文档。有些时候将这些分层结构称为分类，通常由专家来构建这些分类。例如曾经很受欢迎的 Open Directory 项目，这是一种用于 Web 站点的常规分类。

这个基本搜索方法的一种变体是高级搜索，其中使用预先选定的一组特定字段的值来执行搜索，如标题、作者，等等。通常认为这是“超级用户”的特性，超级用户希望查找特定的来源，而不是有关特定主题的任何来源。例如，如果您知道准确的标题、作者名、出版时间、或者关于您正在查找的文档的一些其他精确信息，那么您就可以使用高级搜索。

尽管这不是“高级”用户专用的，但是高级搜索也并非适用于所有的用户。如果您了解关于您正在搜索的对象的细节信息，那么什么因素可能阻止您使用高级搜索，并成为所谓的超级用户呢？高级搜索可能很麻烦。我的看法是，用于定义这些高级条件的用户接口和计算机语言通常令人费解或非常复杂，以至于普通人难以使用。

但是事情正在发生变化，并且现在有更多的方法用于获得相关的内容。要了解搜索技术所经历的发展趋势，并且要了解如何获得所需的搜索结果，很重要的一点是，必须弄清楚下面两种使用搜索引擎的方法之间的区别：发现和获得。

通常在需要发现 网络上可用的资源时，您需要搜索 Web；在您开始进行搜索之前，您并不清楚可能存在什么样的资源。另一方面，当您在搜索自己的硬盘时，通常试图获得 某项已经存在的信息，而您只是不知道该信息的具体位置而已。以下是两个基本的场景：发现与获得之间的比较。换句话说，寻找关于某个特定主题所存在的内容与寻找某项已经知道的特定信息，这两种搜索是不相同的。

回页首

后过滤（Post-filtering）和方面（facet）：这是高级搜索的终结吗？

很明显，高级搜索主要用于获得场景，而这些场景很少出现在搜索 Web 的情况下。这正是为什么大多数最新的 Web 搜索引擎放弃了所谓的高级搜索特性的原因。另一方面，当您在搜索个人数据（或者甚至公司内部网）时，您通常知道关于正在查找的信息的一些细节信息。

这就产生了称为面向方面的搜索的新的搜索范例。面向方面的搜索的价值是，它使用户能够研究结果并且更精确地细化他们的搜索，而无需使用复杂的高级搜索语法所提供的布尔条件。当您使用支持面向方面的搜索特性的搜索引擎时，除了您的搜索结果之外，您还将得到一组方面，每个方面都描述了某种属性，如作者、出版日期，等等。对于其中的每个方面，您可以看见与搜索相关的各种可能的值所组成的列表，并且还提供了一个数字，用于表现包含对应值的结果的数量。

例如，假设您正使用词汇“marketing chicken”对您的计算机进行搜索。搜索引擎可能为这些词汇返回一个结果列表，同时包括下面的这些方面：

Source:Lotus Notes (34), Disk (26)
Author:John H. (12), David K (23), Others (25)
Updated:Last Week (15), Last Month (45)

这意味着在搜索结果的范围中，其中 34 项存储于您的 Lotus® Notes 电子邮件中，而有 26 项存储在您的硬盘上。如果不考虑存储位置，那么 John H. 是其中 12 项结果的作者，David K. 是其中 23 项结果的作者，而由其他人所撰写的内容共计 25 项。另外，如果不考虑存储位置和作者，那么在上周进行更新的有 15 项，而在上个月进行更新的有 45 项。

如何使用这些方面呢？很容易。这些方面都是链接，所以当您认为某个方面对您是最重要的，只需单击它即可，这将显示来自对应来源的筛选结果，而且所显示的结果将使用剩下的方面进行组织。例如，单击 Lotus Notes 链接，可能出现下列的方面：

Author:John H. (3), David K (11), Others (20)
Updated:Last Week (11), Last Month (23)

当只考虑那些来自 Lotus Notes 的结果时，您可以通过深入研究最重要的方面并且更精确地定制搜索，直到找到所需的信息。您可以在任何时候撤消所做的选择，从而研究其他的路径。

这种方法的优点可能非常明显。当搜索结果中包含很多属性时，您可以采用简单而直观的方式对其进行研究，而无需求助于布尔逻辑。此外，因为通过数值表示了每个方面可用内容的潜在范围，所以您可以确保不会深入研究任何“空”的路径。

在 Internet 上的电子商务站点（如消费电子产品站点）中，当前最流行的是面向方面的搜索，这类产品信息有足够的特性和部分，以使得这种导航操作非常有意义。尽管对于标准的 Web 页面，面向方面的搜索目前看起来并不是很合适，但有足够的特性以使得面向方面的搜索适用于个人和内部网搜索引擎的环境，所以我相信在今后的几年中，随着我们越来越多地对电子邮件、个人文件和内部网信息进行搜索，我们将会更多地看到这种特性。

回页首

标记和社会化搜索：这是分类法的终结吗？

如前所述，您可以使用分类法对感兴趣的主题和相应的文档进行定位。尽管对于这些分类，很难进行维护。在创建一个新的文档时，必须将其与这种复杂数据结构中合适的类别关联。这引出了一种新的趋势，称为 大众分类法 ：您可以对您撰写的或者访问的文档进行分类，而无需依赖分类专家或者其他人根据实际情况对信息加以分类。通过将文档关联于单个单词或者标记，就可以完成这项操作。然后，任何用户都可以搜索并利用这个标记空间，查看其中最频繁使用的标记，查看使用这个单词标记了哪些文档，等等。从理论上讲，标记将帮助更多的人找到更多的文档。例如，可以使用“微电子学”这个单词来标记一篇关于微电子学的文章，即使“微电子学”这个术语根本没有出现在文档本身的内容中。因此，如果使用这个词作为标记搜索微电子学相关的内容，那么将在搜索结果中找到该文档，这正是由于那位有远见或判断力的人创建了这个标记，并且标记本身具有动态实用性。而使用关键字进行搜索，则不会出现这种情况。

当然，在实践中，标记的使用可能会使得一些事情变得复杂。因为任何人都可以随意地建立标记，所以经过一段时间后，在搜索集合中无法防止无关标记或错误标记的出现。在企业环境中，安全性也是一个问题。如果不允许某些用户访问某个文档，那么当他们使用标记空间时，是否应该允许他们看到与这个文档相关联的标记呢？这种方法可以简化和改进在个人控制的信息集合（您的团队文件、您的照片）中的搜索，但是，同时会使得对大型企业范围内的信息集合的搜索变得更加复杂。

回页首

来自多个来源的结果

当您进行搜索时，可能希望通过多个来源进行搜索。例如，在 Web 上，通常会限制您只能使用一个搜索引擎，这是因为，使用多个搜索引擎并对其进行比较是非常麻烦的。当搜索您的个人文件或者企业内部网时，这个问题甚至变得更加复杂。有一些搜索引擎，可以使用不同的用户接口进行访问，可以访问不同的数据集，并产生不同的结果集。在这种情况下，联合和聚合这两种方式可以提供帮助。

联合 意味着使用某种工具注册所有可用的搜索引擎，将您所进行的搜索转发给所有这些搜索引擎，然后检索结果，并在单个列表中显示经过组合的结果。在大多数情况下，很难以统一的方式对结果进行排序。（在某些搜索引擎中，在对结果的相关性评分中，85% 是一个“好”的评分，而在其他的引擎中，好的评分是 95%。）因此，在使用联合的时候，很有可能会将来自每个来源的结果分离开来。（在这种情况下，面向方面的搜索可能是很有帮助的。）

在使用聚合 的时候，中央搜索引擎将汇总所有的搜索内容。对某个位置进行搜索，并从所有的来源返回统一的结果。因此，聚合的方式非常方便，但是却难以实现，因为它需要通过爬网的方式处理所有可用的数据来源，并且扩展搜索引擎。多数情况下，您将不得不接受几个不同层次的联合和聚合（对于目前而言）。

回页首

门户搜索工具箱

随着需要搜索的信息越来越多，我们可以使用的搜索方式也越来越多。WebSphere Portal Search Development 团队希望帮助您使用不同的搜索方式，而有了这些方式，可以让最终用户在企业中查找信息的任务变得更加容易。这正是我们发布公共 API 以及免费提供搜索工具的原因。这些工具的目标是帮助您进行试验，以便开发出更有效的搜索应用程序，并对我们周围日益增长的信息空间，找到合适的搜索方式。

由于 Rhino 是 JavaScript 的一种基于 Java 的实现，所以对于 Java 开发人员来说，它应该特别易于使用。JavaScript 的（以及 Rhino 的）语法非常类似于 Java 编程语言。这两种语言都采用了与 Java 编程语言相似的循环和条件结构，并且遵循类似的语法模式来表示这些结构。

虽然 Rhino 与本系列文章中介绍的其他编程语言具有很多共同点，但对于 Java 平台上的编程而言，它也有独特之处（可能有时有些不同的地方）。Rhino 是一种 基于原型的（prototype-based）语言，而不是一种 基于类的（class-based）语言。在 Rhino 中，您可以构建对象，而不是类。除了类的对象实例之外，这样做还可以让您避免构建和操作类的开发、部署和执行成本。正如您将在文中发现的那样，诸如 Rhino 这类基于原型的语言在开发和运行基于 GUI 的应用程序时尤其有效。

开始使用 Rhino

可以从 Mozilla 的 Web 站点（请参阅 参考资料）上下载最新的 Rhino 引擎（在撰写本文时是 Rhino-1.5r5）。将软件包解压至选定的目录中。顶层目录 rhino1_5r5 是软件包的一部分。该目录中包含一些文档、例子、源代码和 js.jar 文件，而 js.jar 文件应该包含在 classpath 中。

我将广泛地使用交互式 shell，它是在 org.mozilla.javascript.tools.shell包中实现的。可以调用这个 shell，以交互模式（在这种模式中，可以输入要计算的表达式或要执行的代码）或批处理模式运行它。在批处理模式中， -e 选项可以用来运行包含 JavaScript/Rhino 源代码的字符串， -f 选项可以用来执行包含脚本代码的文件。例如，输入下面的命令将以交互模式调用解释器：

关于本系列文章 虽然 alt.lang.jre 系列文章的大部分读者都对 Java 语言以及它如何在跨平台的虚拟机上运行都非常熟悉，但是却很少有人知道，Java 运行时环境可以支持除 Java 语言之外的其他语言。本系列文章是对 JRE 可用语言的一个概括性介绍。这里介绍的大部分语言都是开源的，可以免费使用，不过也可以购买商业产品。JRE 可以支持本系列文章中介绍的所有语言，这些文章的作者都相信所介绍的语言增强了 Java 平台的动态特性和灵活性。

javaorg.mozilla.javascript.tools.shell.Main
            

然后您应该会看到解释器的版本号，后面跟着提示符 js> 。按 Ctrl+Z （Windows 系统上）或 Ctrl+D（Unix 系统上），就可以退出这个 shell。

回页首

历史简介

在开始学习 Rhino 基础知识之前，先了解一下有关 JavaScript 的起源和目的可能会非常有用，JavaScript 为 Rhino 提供了很多独特的特性。JavaScript 的历史与 Web 浏览器动态表示和操作 Web 页面内容的能力是相符合的。JavaScript 的第一个版本（最初称为 LiveScript）是由 Netscape Communications 公司于 1995 年发布的，它是 Netscape Navigator 2.0 Web 浏览器的一部分。JavaScript 打算为程序员提供一种简单而直观的方法，编写一些可以在 Web 页面上下文中执行任务的简单脚本。在随后的一年中，Microsoft 引入了 JScript，它自己的用于 Internet Explorer 的 JavaScript 端口。

这两个版本的 JavaScript 都包括一个基于对象的 API，称为 文档对象模型（Document Object Model）或 DOM，用以访问和操作 Web 页面的内容。JavaScript 的第三个实现是一种新的脚本语言，称为 EcmaScript，其目的是对自己和 DOM 进行标准化。不幸的是，Microsoft 和 Netscape 都没有完全实现 EcmaScript 标准，因此到今天都还存在兼容方面的问题。

随着 Java 语言在 20 世纪 90 年代末期取得的成功，Netscape 计划发布 Javagator，它是 Navigator 中一个 100% 的纯 Java 实现。虽然 Javagator 从来没能开花结果，但是 Netscape 对 JavaScript 的移植（称为 Rhino）已经经过时间的考验存活了下来。Rhino 是 JavaScript 1.5 脚本语言的一个 100% 的纯 Java 实现，不包含 DOM API。实际上，Rhino 有时仍然被当作 Netscape 的基于 Java 的 JavaScript。

回页首

JavaScript 中的 "Java"

在 Rhino 的第一个发行版本中，Netscape 显然想利用 Java 编程语言所取得的成功。在该公司自己的脚本语言中，很明显地从 Java 语言中借用了一些基本的语法。这使得它特别适合 Java 开发人员学习和使用。例如，考虑一下清单 1 中给出的 Java 函数与 Rhino 函数之间的相似性，Rhino 函数测试了给定的数字是否为素数：

function isPrime (num)
            {
            if (num <= 1) {
            print("Please enter a positive integer >= 2.")
            return false
            }
            var prime = true
            var sqrRoot = Math.round(Math.sqrt(num))
            for (var n = 2; prime & n <= sqrRoot; ++n) {
            prime = (num % n != 0)
            }
            return prime
            }
            

除了几处例外，该程序与 Java 程序非常类似：

• 圆括号用来分隔代码块。
  
  
• for 和 if 结构的语法与 Java 语言的相同。
  
  
• Rhino 与 Java 语言采用相同的算术和条件操作符（例如，对 sqrRoot变量的赋值），甚至可以支持类似的访问其他算术函数的方法。
  
  
• Rhino 允许使用预先定义的布尔常量 true 和 false 。

虽然没有在这里显示，但您应该注意到，Rhino 的 while 和 do...while 循环的结构都与 Java 语言的相同。

回页首

具体区别

当然，Rhino 和 Java 语言之间有一些显著的区别。首先，由于 Rhino 是采用动态类型的语言，因此在函数和变量的声明中看不到类型。您可以使用 function 关键字开始函数的声明，使用 var 关键字来声明局部变量（这与全局变量不同），但是不用包括正在声明的变量的类型。Rhino 运行库将在执行过程中推断变量的类型。与 Java 语言不同，Rhino 没有语句结束符（在 Java 语言中是分号），不过它也可以支持语句结束符，这是可选的。

Rhino 和 Java 语言另外一个主要区别是，您可以从解释器中运行如清单 1 所示的程序。如果假设函数的定义在某一个文件中，例如 isprime.js，那么就可以在解释器的提示符中输入下面的命令，其中 path 指向存储该文件的绝对路径：

load("<path>/isprime.js")
            

在返回提示符之前，需要在 Rhino 的解释器中输入下列命令，然后立即就会看到结果 true ：

 isPrime(37)
            

采用这种方法，Rhino 解释器的功能类似于“便签本”，可以在其中输入简单的 Java 代码块进行测试和调试。由于这两种语言的语法是如此相似，因此通常可以从 Java 程序中剪切一些相关代码，将其粘贴到 .js 文件中，并在解释器中加载该文件，然后从 shell 中调用它。

当然，并不是 Rhino 语言与 Java 语言的所有区别都如此微小。在下一节中，您将看到 Rhino 用来区分自己的一些最有用的方法，我们将从大家比较熟悉的文本表示和经常使用的数据类型入手，其中包括数组、hash 表（或称为 联合数组（associative arrays））、正则表达式、函数以及您可能碰到的对象等。

回页首

数组

Rhino 中的数组可以表示为放在方括号中的一串使用逗号分隔的数值列表。因此，下面就是 Rhino 中的数组：

            numbers = [0, 1, 2, 3, 5, 24]
            names = ["Mike", "Joe", "Betty", "Therese", "Lynn Marie"]
            arrayOfArrays = [1, [2, 3], [3, 4, 5, [6, 7]], 8]
            

第三个例子说明数组中的元素不一定非得是简单类型。

联合数组

联合数组（associative array）是另外一种数据类型，它可以表示为一个字符串。联合数组在其他语言中有时称为 词典（dictionary）或 hash 表，它是一系列关键字-值对，关键字和值使用冒号（:）分隔开。Rhino 中的联合数组的作用与 Java 语言中的 java.util.HashMap 非常相似。下面是 Rhino 中的联合数组：

            person = {name:"Mike Squillace", age:37, position:"software engineer"}
            link = {text:"IBM Home", url:"http://www.ibm.com"}
            

可以使用两种方法来引用该列表中的元素。要设置刚才定义的 person hash 表中的 age 属性，您可以这样使用： person["age"] = 39 ，或者使用 person.age = 39 。要读取该值并将其保存在变量 myAge 中，您可以这样使用： myAge = person["age"] ，或者使用 myAge = person.age .

Rhino 将典型的有索引的数组作为一种特殊的联合数组来对待：它们只是一些关键字是正整数的联合数组。因此，下面这两行代码实际上定义的是完全相同的数组：

a1 = ["fee", "fi", "fo"]
            a2 = {0:"fee", 1:"fi", 2:"fo"}
            

通过属性进行循环

Rhino 提供了一种特殊的循环结构： for...in 结构，它可以通过联合数组中的属性进行循环。下列代码输出了刚才定义的 person 联合数组，以及这些属性的值：

for (prop in person) {
            print("person[" + prop + "] = " + person[prop])
            }
            

当然，我是通过一个类 hash 表结构实现循环的，因此不能保证每个属性及其值都可以输出。

回页首

正则表达式

与数组类似，在 Rhino 中也可以使用 正则表达式来表示文本，使用 Perl 和其他脚本语言的用户应该非常熟悉其语法。在 Rhino 中，当表示为文字值时，正则表达式是通过正向斜线（/）来分隔的。

在 Rhino 中，正则表达式被传递给字符串对象的方法，以便更简单地执行文本处理任务。例如，下面的第一行代码定义了一个正则表达式，它可以匹配算术表达式中的正整数和标准算术操作符。第二行代码通过调用 match 函数处理给定的表达式，如下所示：

tokenExpr = /\d+|[\+\-\*\/]/g
            "38-4+98/5".match(tokenExpr)
            

结果是生成一个 Rhino 字符串数组，数组的元素包含以下内容：

"38", "-", "4", "+","98",  "/", and "5"
            

回页首

函数显式声明

最后，Rhino 提供了 函数数据类型。正如前面介绍的那样，Rhino 作为第一类数据类型支持函数 —— 可以从函数中返回，也可以传递到函数中，还可以在变量声明中使用。因此，我可以在解释器提示符中编写下面的代码，并得到结果 9，这是定义平方函数的期望结果：

square = function (x) { return x * x }
            

按照这个平方函数的定义，我输入了以下内容：

square(3)
            

这样定义的函数不但可以用来处理文本，还可以用来处理其他数据。例如，我可以定义一个如下所示的联合数组函数：

fnList = {
            square:function (x) {return x * x},
            cube:function (x) {return x * x * x},
            sqrt:function (x) {return Math.sqrt(x)}
            }
            

然后我可以对数组中的列表循环调用该函数，输出每个函数的值，就像它是一个数字一样。例如，我可以编写下面的代码：

for (fnName in fnList) {
            print("The " + fnName + " of " + 3 + " is " + fnList[fnName](3))
            }
            

将获得如下所示结果：

The square of 3 is 9
            the sqrt of 3 is 1.7320508075688772
            The cube of 3 is 27
            

回页首

Rhino 中的对象

在使用联合数组并且将函数表示为文本之后，就可以在 Rhino 中将任何对象表示为联合数组。实际上，对象的文本表示只不过是一个联合数组，它可能包含某些函数作为一些值。下面这个例子将展示在 Rhino 中使用对象是多么简单，Rhino 处理这些对象表现得多么强大。在开始这个例子之前，请再次考虑 person hash 表的例子：

person = {name:"Mike Squillace", age:37, position:"software engineer"}
            

在 Rhino 中，这是一个联合数组的文本表示，不过更确切的说，它是一个对象的文本表示。这种表示在 Rhino 中也称为 对象初始化。刚才定义的值的类型是由解释器在输入上面的定义之后根据下面的代码进行判断的：

[object Object]
            

上面的代码说明了变量 person 中存放的值是 Object类型的。

添加方法

然后，我将向您展示，在重新定义 person 对象，以包含检索该对象的第一个名称的函数时，会出现什么样的情况。我将通过编写下面的代码来展示这一点：

person = {
            name:"Mike Squillace",
            age:37,
            position:"software engineer",
            getFirstName:function () {return this.name.split(" ")[0]}
            }
            

该函数（更确切地说是方法） getFirstName 使用了 this 指针来引用当前的对象，并对 name 属性调用 split 方法。然后， split 方法返回一个数组，其中保存了根据空格字符将给定字符串分割成子字符串的结果。最后取得该数组的第一个值并返回。

我们已经很熟悉调用新的 getFirstName 函数的方式，如下所示：

person.getFirstName()
            

圆括号告诉 Rhino 解释器我正在调用一个函数，而不是简单地引用一个对象的属性。然而要注意的是，该函数本身也只是另一个 person 对象的属性，如果没有圆括号，它将引用一个未定义的值。

添加更多的方法

Rhino 还可以允许动态地为对象添加属性和方法。例如，如果想添加一个检索通过 person 对象表示的某人名字的方法，那么只需简单输入下列代码即可：

person.getLastName = function () {return this.name.split(" ")[1]}
            

现在，当我输入下面的方法时，就可以得到想要的结果，在本例中，这个结果是 "Squillace"：

person.getLastName()
            

（注意，您可以使用 delete 操作符来删除任何属性，例如 delete person.getLastName 。）

回页首

使用原型

虽然上面这个例子非常有趣，但是您可能不希望一直使用对象初始化来定义个别某些人。幸运的是，Rhino 提供了另外一种创建对象的方法：使用 构造函数（constructor function）。例如，下面的函数可以作为一名 Person 对象的构造函数：

function Person (name, age, job) {
            this.name = name || "<unknown>"
            this.age = age
            this.job = job || "<unemployed>"
            this.getFirstName = function () {return this.name.split(" ")[0]}
            this.getLastName = function () {return this.name.split(" ")[1]}
            }
            

拥有构造函数之后，就可以使用 new 操作符来创建对象了，如下所示：

mike = new Person("Mike Squillace", 37, "software engineer")
            

任何函数都可以用作构造函数，不过通常希望使用定义（使用 this 指针来引用正在定义的对象）对象属性的函数以及为这些属性赋值（或函数）的函数作为构造函数。

无类编码

作为一个 Java 开发人员，您很可能会认为下一个步骤是在 Rhino 中定义 Person 类。实际上，Rhino 并不需要这样定义类 —— 因为它根本就不使用类！在 Rhino 中既没有类，也没有类的实例，只有特定的对象。当调用 new 操作符时，构造函数就为对象创建一个所谓的 原型（prototype）；也就是说，它创建了一个 模板（template），从中构建给定类型的对象。

基于类的语言与基于原型的语言的比较 诸如 C++ 和 Java 之类的 基于类的语言使用一个类定义来表示一组具有特定属性集的对象，包括用来表示类的实例和这些实例可以执行的任务类型的数据。一旦编写并编译了类定义，就不能在运行时再对其进行修改，该列的所有实例都包含该类中定义的数据和方法（也可能 只有这些数据或方法）。在这种情况下，所有的类都是 Class 类的实例。 基于原型的语言并不区分类和实例；它们只识别基于原型或模板的特殊对象。原型定义了对象初始化时使用的属性。基于原型的实例的属性以及原型本身在任何时间都可以修改。因此，不需要一个“类”对象或数据类型。从某种意义上来说，我们可以认为基于原型的语言是基于对象的差异性，而不是基于对象的共同性。

在诸如 Rhino 之类的基于原型的语言中，您可以修改特定对象的属性，或者其原型的属性。例如，如果想为刚才定义的 mike 对象中添加一个特殊属性，可以使用下面的方法：

mike.disability = "blind"
            

我还可以通过引用 Person 构造函数的原型属性来修改 Person 的属性。如果以后想为所有从这个构造函数中派生出来的对象都添加一个 birthdate 属性，可以使用下面的方法：

Person.prototype.birthdate = null
            

然后使用：

mike.birthDate = new Date(66, 10, 3)
            // months are zero-based: this is 11/3/66
            

还要注意基于 Person 原型创建的新对象都有 birthdate 属性，因此下面的代码是有效的：

jami = new Person("Jami Bomer", 25, "unemployed")
            jami.birthdate = new Date(79, 5, 28)
            

每天，企业都要面对产品质量、法人责任、竞争环境的风云变幻、品牌衰退等问题的威胁。如果没有一个系统收集和分析能够指出潜在威胁的数据，那么企业就只能祈祷运气降临到自己头上了。

世界最大的轮胎制造商在 2000 年 8 月付出了惨重的代价才深深体会到了这一点。当时该公司在一款流行的运动休闲车的轮胎外胎面突然脱落造成的一连串事故后召回了 650 万个轮胎。根据美国高速公路交通安全局（National Highway Traffic Safety Administration，NHTSA）的统计，单在美国境内，由于轮胎引起的交通事故就可能达到 750 起，造成 62 人死亡。汽车制造商声称早在 1998 年就已经对这些轮胎的质量产生了怀疑。尽管早已指出了这个问题，但汽车和轮胎制造商未能意识到问题的严重性，直到很久之后，这个问题给这些公司及其顾客带来了可怕的后果。

涉及国家防御的政府机构也遇到了类似的问题。智能服务中的信息日益泛滥。整理所有信息并将它们放到一起以精确地指出紧急威胁并及时做出反映不再是件容易的事情了。幸好，数据挖掘技术可以帮助发现各种数据中隐藏的警告。

预警系统提供了系统地收集和分析数据以识别出现的威胁或问题的能力。为了让这些系统有用，只要数据中累积了足够多的证据支持该问题，就必须马上识别威胁。该系统不能遗漏太多真正的威胁，也不能预测太多永远不发生的威胁。好的预警系统有助于识别潜在的问题、分析它们的特征和起因，并量化它们的严重性。在某个特定月份中在某种条件下检测故障率的突然上升只是其任务的一部分；系统还应该能够估计这个故障率会否继续上升，并预测如果不予理睬其影响又如何。

这些系统有许多用途。跟踪新闻稿、专利公布和合并与收购活动可以帮助确认由于竞争对手、供应商、顾客或合作伙伴的策略变化而导致的潜在威胁。监控和分析新闻组和邮件列表中顾客张贴的内容和对呼叫中心的投诉可以帮助发现市场动态和品牌观念的趋势。汽车制造商经常扫描大型的保修索赔数据库，以检测零部件故障率的趋势，从而可以指出质量或安全问题。在与经济诈骗、洗钱、贪污、有组织犯罪和恐怖份子融资的斗争中，一些全球金融机构最近联合了力量来收集并利用公共信息，以更好地确认与客户交易相关的法律、规章和信誉风险。

管理已确认的重要问题涉及到一个组织的方方面面。因此，完善的预警系统通常包含了工作流管理和协作能力，以支持与打开、调查、关闭重要问题以及调度和跟踪操作（以便管理重要问题）相关的业务过程。官僚主义、过时的策略和组织的划分范围都可以给信息共享和集成式分析造成障碍。但是，这是数据挖掘的专题，我们假设这些非技术问题都可以解决，所以把精力完全放在技术问题上。

虽然每个领域都不同，但这些预警系统都有许多相同的元素。我们将详细说明这些元素。

预警只是一种可能性，表示数据中隐含威胁的迹象。这些初期指标通常来自各种不同的来源。所收集的数据也许会来自现有的内部系统，该系统是为支持操作需要（如呼叫中心的保修索赔处理或顾客联系管理）而构建的。也可能来自外部数据库、新闻或专利服务器和 Web 的搜索结果。在确认所有相关来源之后，数据收集器会按常规计划或者甚至实时地搜索、选择、传送所有可能相关的数据，并供预警解决方案使用。在最近与汽车制造商一起进行的一项工作中，我们每天都从保修索赔系统、生产系统、呼叫中心、法律责任案例的资源库和 NHTSA 中收集数据。

警告指标通常被无关数据掩藏。对无关的故障和事件的观察也许永远也不能对预测警报趋势有所贡献。允许趋势发展需要集成来自所有可用来源的信息的能力。当任何信息可用时，数据仓库就将该信息合并到公共数据体系结构中，从而为预警解决方案提供了坚实的数据基础。不管信息来源如何，它都可以捕捉到涉及同一实体的所有信息。数据仓库还使数据在长时间内可被快速访问，从而使趋势和重要问题浮现出来。趋势的发展需要多长时间可能取决于产品的预期寿命（用忙闲度或服务时间来衡量）、保修期、法律责任期等。

信息抽取

在我们的实践中，我们发现一些最有价值的警告指标通常都包含在非结构化的数据中，尤其是文本。在汽车制造公司中，要处理取自六个来源（包括非结构化的文本字段）的数据，如关于故障的原因或症状的专家注释、对制造商的呼叫中心和 NHTSA 的客户投诉的副本以及诉讼案例的摘要。我们构建的解决方案每天会自动处理数以百计的记录，以寻找可以提高安全性或其它重要问题的指标。

进入预警解决方案的非结构化的数据使信息抽取成为必要。信息抽取是指将非结构化的数据转换成结构化的数据格式的过程，从而支持数据集成或数据分析。

信息抽取（只关注文本数据）的相关技术包括：

特性抽取。文本挖掘工具可以定义和派生一组特性，这些特性会捕捉适合于正在被分析的文档集合的关键术语和概念。特性可以是多单词术语、人名、组织名和地名、缩写和关键的数字，如货币金额和日期。算法将“信用透支（credit facility）”、“信用额度（credit line）”、“里昂信贷银行（Credit Lyonnais）”和“瑞士信贷银行（Credit Suisse）”看成是四种独立的概念。每个特性都有可能成为一段结构化数据。

文档群集和分类。捕捉关键术语和概念的特性通常也描绘了文档内容的常规性质。根据特性，可以将文档分成一个或多个类（类别）。如果给定一组文档，群集技术就会构成一组组主题类似的文档。每个组都可以用该组中文档最突出的特性标记。当存在一组预先定义的类别和已经分配到这些类别的文档的示例时，文档分类技术就可以归纳出区别这些类别的模型。这些模型可以让您根据任何文档的特性，自动将其分类到一个或多个预先定义的类别。已分配的类表示结构化数据的有价值部分，不管该分配是由群集技术还是由分类技术执行的。

信息抽取的自然语言处理。信息抽取通常要求在语句级别对文本进行更详细的分析。通常，特定种类的实体、事件、操作和它们之间的关系是潜在威胁域中的重要部分。例如，在汽车的示例中，我们创建的解决方案必须在每个文本块中标识所引用的汽车特定的零部件、对这些零部件所做的故障或症状报告，以及任何严重事件的发生（如翻车或死亡事故）。在金融服务中，将人名或业务实体名与特定的犯罪行为的定罪和所记载的辩解相关联是很重要的。线点科技的垂直搜索系统产品（VSE）使用可伸缩自然语言处理技术来分析大文档集合的内容，从而抽取信息并生成反映这些文档的词法和概念内容的助诊文件。所抽取的信息用于查询改进、导航文档数据库中的重要概念和准备并提供文档摘要。

VSE包括用于词法和形态分析、语音部分标记、语法和句法分析以及解析的组件。输入中的文档被当作单词流提供给VSE。在输出中，VSE通过在被称为解析树的多级别层次结构中捕捉单词及其用法的特征之间的关系，来显示文档的结构。图 2 显示了在处理包含语句“Side air bag didn't deploy when vehicle was involved in accident.”的文档之后生成的解析树的简化版本。请注意，树上描述的关系确定了“vehicle”是动词组“was involved”的被动语态主语，并且有一个谓语介词短语“in accident”。解析树还确定了侧气囊没有弹出，而且用“when”从句进一步限定了该语句。如果没有这种文本分析，那么句子中每个单词的角色就会不能识别。如果没有那些资料，您就不能确定，例如，是气囊还是汽车没有弹出。

准备解析树是信息抽取的第一步。下一步是检查所关心的模式的树。主题专家为信息抽取准备了特定于领域的业务规则。每个规则都包含了与解析树的各组成部分相匹配的模式，以及用于只要发现匹配就以结构化数据格式从树中抽取信息块的指令。

以下是一个业务规则的示例，它将抽取一个实例，在该实例中，某个汽车零部件（如气囊）显示了“no deployment”故障。该规则的模式将指定一个主动语态句子，其中：

1. 主语短语匹配汽车零部件。

2. 动词组包含了任何时态的动词“to deploy”，但却是以否定形式。

规则的信息抽取操作将指定“no deployment”作为故障代码，将主语短语中所匹配的汽车零部件的代码指定为故障零部件。在一个领域中有几百个信息抽取规则并不罕见。通常，每个规则都要对每个文档进行处理，因此拥有一个非常有效的规则处理引擎很重要。例如，在汽车的示例中，我们设计了一个可以一整夜处理接近 10 万个文档的规则引擎。

Talent 中的自然语言处理组件和规则处理引擎的体系结构都是与语言无关的，但所实现的许多分析函数都主要适用于英语。多语言领域需要特定于语言的分析组件或在信息抽取之前将文档翻译成英文的机器翻译技术

准备好数据基础之后，即已经有了正确集成的来自所有相关来源的数据和从任何非结构化的数据中抽取的信息，就可能查找预警指标、监控趋势和深入地分析数据。

查询、报告和在线分析处理（OLAP）工具是任何预警系统的必备部件。可以编制标准报告来按常规调度表生成和发布报告。在汽车公司里，我们编制了许多报告以满足新的管理报告需求。这些工具还提供了对用于特别分析以及分析预警系统识别的潜在问题的数据的访问。所关心的一些问题是：重要问题后面的事件是什么？随着时间的流逝，它们的频率趋势是什么？这些事件在什么条件下会发生？随着时间的流逝，是否会出现模式？这些工具有助于证实、反驳和改进搜索这些和其它问题的答案时的假设有效的预警系统应该在数据可用时主动分析数据。通常，预警信号首先作为数据中的异常出现：偏离所建立的标准和预期的行为。如果在搜索异常之前没有假设预期有什么行为，那么搜索异常是最复杂的。搜索应该尽可能公正并且是数据驱动的。可以从历史数据归纳出各种情况的预期行为的模型。这样的模型让分析员可以将实际观察到的行为与预期行为进行比较，并确定任何偏差是否可能很重要。

出于某些原因，异常检测是一项很困难的任务。首先，通常很难开发精确的预期行为模型。其次，通常可能发生异常的潜在情况的数量非常大；因此搜索空间通常也很大。考虑观察汽车引擎着火事故。通常都会从许多角度来描述每个事故，包括汽车的品牌和型号、里程表上的里程数和事故的地理位置。要确定着火事故发生率是否有异常涉及独立地分析多维数据立方体中所有聚合级别的所有单元。单元的每个聚合相当于一组不同的条件（在这组条件下，可能在着火率中出现异常）：例如，某个特定品牌和型号的汽车或在某个特定地理位置发生的异常。

预警数据仓库会经常用新数据进行更新。可以借助查询、报告和 OLAP 工具来访问这些数据。同时，发现驱动的数据挖掘操作会经常查找异常并帮助发现模式和异常的趋势。在任何时候都会有一组重要问题正在进行处理。其中一些刚被确认为潜在重要问题，而且其它的可能处于调查和管理的各个阶段。整个系统的事件状态通常以数据和过程的形式通过仪表板（dashboard）（可以定制以满足每个用户的需要）提供给分析员和管理层。

仪表板提供了一个新的数据访问和表示层，它可以：

• 围绕业务活动（如打开一个用于调查的新的重要问题）组织仓库中的事故、事件和相关数据
• 定义与这些活动相关的业务度量，管理它们的工作流
• 提供交互式导航或探索的功能
• 通过动态链接的记分卡、报告、图表以及突出显示重要信息的地图来提供数据的集成视图
• 将对决策支持工具的访问集成到工作流管理系统中，并为分析员提供一个协作环境。

政府相关的垂直搜索引擎  

主要表现为面向内部的垂直搜索和面向外部的垂直搜索，面向内部的垂直搜索主要是指政府内部专网网站群的搜索，同时集成数据库搜索功能，为政府工作人员和领导提供快速定位信息的方式，为日常工作和领导决策提供支持；面向外部的垂直搜索主要是指政府门户网站群搜索，同时集成法律法规等数据库搜索功能，整合政务服务资源，为民众和企业提供更好的服务，最大的发挥政务资源的效用。  

垂直搜索、企业搜索、互联网搜索的区别

信息采集：融合了互联网搜索和企业搜索的特点  

     从采集方式看，互联网搜索以被动方式为主，搜索引擎和被采集的网页没有约定的、标准的格式；企业搜索以主动方式为主，被采集的办公文档、CRM和ERP中的数据等都和企业搜索引擎有着约定好的采集接口和安全接口；垂直搜索则采用被动和主动想结合的方式，通过主动方式，有效采集网页中标引的元数据，整合上下游网页资源或者商业数据库，提供更加准确的搜索服务。如：中华人民共和国中央人民政府网站垂直搜索引擎，它通过规范副省级政府门户网站网页的表达方式，达到有效采集网页元数据的目的，为企业和个人提供更精准的政务信息搜索服务。  

从对采集深度、动态网页采集的优先级、结构化数据库信息采集来看，互联网搜索采用广度为先的策略，所以对采集深度要求不高，而垂直搜索和企业搜索需要挖掘出行业内所有相关的网页信息，所以往往采用深度为先的策略，同时由于行业内的一些有商业价值的信息采用动态发布的方式，如：企业数据库、供求信息等，所以垂直搜索对动态网页的采集优先级别较高。另外，在实际应用中，垂直搜索和企业搜索都需要集成和采集关系数据库中的结构化信息，如：垂直搜索中政府需要集成法律法规库、企业搜索中需要采集ERP、CRM中的信息等。  

信息加工：非结构化信息和结构化信息是垂直搜索的特色  

垂直搜索引擎和普通的网页搜索引擎的最大区别是对网页信息进行了结构化信息抽取加工，也就是将网页的非结构化数据抽取成特定的结构化信息数据，好比网页搜索是以网页为最小单位，而垂直搜索是以结构化数据为最小单位。  

垂直搜索的结构化信息提取和加工主要包括两种：网页元数据的提取，标题、作者、发表时间、版权所有等等；内容中结构化实体信息的提取，人名、地名、组织机构名、电话号码等等。同时，这些数据存储到数据库，进行进一步的加工处理，如：去重、分类等，最后分词、索引再以搜索的方式满足用户的需求。  

目前，从垂直搜索的应用情况看，大部分垂直搜索的结构化信息提取都是依靠手工、半手工的方式来完成，面对互联网的海量信息，很难保证信息的实时性和有效性，因此对智能化的，结构化信息提取技术的需求非常迫切。同时国内非结构化信息的智能提取技术目前也取得重大进展，在一些领域得到有效应用，智能化是垂直搜索引擎的发展趋势。  

信息检索：结构化和非结构化相结合的检索方式  

     从信息检索看， 垂直搜索不但能够对网页信息中的结构化信息进行检索，而且能够提供结构化和非结构化信息相结合的检索方式。比如我们找工作关注的：职位信息： 软件工程师；公司名称：软件公司；地点：北京海淀。  

    从检索结果的排序方式看，互联网搜索通过PageRank算法来实现，企业搜索大多采用检索内容和检索词的相关度进行排序，相对于互联网搜索和企业搜索，垂直搜索的排序需求更加多样化，如：按时间排序、按相关度排序、按某个结构化字段排序（如：购物搜索中的按价格排序等等）。 

垂直搜索引擎在政府门户中的应用价值  

整合政务资源，有效提升政务资源价值  

    门户技术中的“网站群技术”和“全文检索技术“有效的整合了行政领导关系比较紧密地部门内部的信息资源，垂直搜索技术则有效整合了行政领导关系比较松散地机构间的信息资源，使得政务信息资源的聚拢和整合得以最大化，政务资源的可挖掘能力得到提高，从而有效地提升了政务资源的价值。  

一站式检索和导航服务，提高政府门户的公众服务水平  

   面对多如繁星的政府门户网站，用户查询信息和网上办事时往往无所适从，政务垂直搜索引擎的建设恰恰解决了这个问题，用户可以通过搜索引擎的各种检索方式，方便的获取过去需要访问多个网站才能查全的信息，同时也可以通过检索获取网上办事的入口，例如：在央网搜索引擎的规划中将继续开发服务搜索这个模块，通过检索您就可以轻松获取副部级网站上的办事链接网址。一站式检索和导航服务，大大方便了市民和企业，提高了政府门户网站的服务水平。  

政治体制改革环境下，“凝聚”组织机构的有效手段  

   市场格局的变化，按照“大社会、小政府”的思维模式，政府介入微观经济领域越来越少，国家各个行业的部分机构由事业型机构转为企业。部委和下面的机构之间已经没有了行政领导职能，但是业务上还是存在千丝万缕的联系，两者还存在业务指导关系。垂直搜索引擎将两者有效的“凝聚在一起”，通过“信息的关联”把大家联系在一起，有利于行业内的交流和协作。 

垂直搜索引擎在政府门户中的应用展望 

“门户+搜索”将会成为政府门户网站建设的新模式  

  正如上面所述，门户技术（网站群和内容管理技术）只是解决了行政领导关系比较紧密的政府机构的信息资源整合，对于行政领导关系比较松散的政府机构的信息资源整合，则必须采用被动搜索的方式。随着地市级、县级政务门户的普及，省级门户首先考虑采用搜索技术整合下属门户网上资源，为民众、企业提供便捷的信息获取手段和导航服务。实践证明很多省级、部委门户已经展开了政府门户垂直搜索引擎的建设，并取得了很好的效果，“门户+搜索”正在成为政府门户网站建设的新模式。  

联合搜索将会成为政府门户垂直搜索的特色  

   随着政府门户中垂直搜索引擎的建设，当下级政府部门已经建立了自身职责范围内的信息资源的整合和搜索以后，上级部门则可不采用被动抓取的方式来整合这部分资源，可以通过联合搜索的方式搜索这部分资源，即：将用户的关键词发送到下级政府部门的搜索引擎，对结果集合并后返回给用户。联合搜索的方式具有下面两个优点：第一，省时省力，节约资金，防止重复建设；第二，和被动的抓取方式相比，获取的信息比较全面和及时。 

北京线点科技有限公司助力WEB2.0垂直搜

 线点垂直搜索产品，专为WEB2.0设计
安装简单,维护方便，完备的后台管理功能
分布式搜索,海量数据瞬间展现
集群,超线程技术，信息采集准确高效
SOA发布，RSS支持，二次开发方便快速
博客搜索、职位搜索、象酷讯、奇虎一样搜索

记得2000年左右网络上开始大量出现免费个人主页空间，当时的小编还只是一个刚刚进入IT圈的小朋友，看着这些空间那叫一个口水横流，于是乎立刻申请了 一个。又经过了一个多月的刻苦修炼和先后三次的改版，自己有生以来的第一个个人主页诞生了。可看着每天寥寥无几的访问量，心里那叫一个难受，可一时间也想 不到好办法解决问题。突然有天发现一篇介绍如何在搜索引擎注册自己个人网站的文章，于是小编就照着文章所讲的分别在SOHU、网易等搜索引擎的相关分类目 录下注册了自己的个人主页。直至今日，小编才确切的知道了当时盛行的搜索引擎都属“目录搜索引擎”。这实际上是小编第一次使用、认识搜索引擎，再后来通过 每天个人主页不断上升的数字小编感觉到了搜索引擎的神奇。

其实正是由于搜索引擎，才使小编的个人主页被更多的人所熟识，以至于后来有多份工作都是因为这个个人主页所带来的机会。其实这些经历或许很多人都有切身的 体会，同样也有很多人因此去全身投入到互联网工作中。这正像那句话讲的“世界真奇妙，不看不知道”，小编在此多加一句“到底怎么看，搜索引擎帮你忙！”

前言

搜索引擎的门槛到底有多高？搜索引擎的门槛主要是技术门槛，包括网页数据的快速采集、海量数据的索引和存储、搜索结果的相关性排序、搜索效率的毫秒级要 求、分布式处理和负载均衡、自然语言的理解技术等等，这些都是搜索引擎的门槛。对于一个复杂的系统来说，各方面的技术固然重要，但整个系统的架构设计也同 样不可忽视，搜索引擎也不例外。

搜索引擎技术和分类

搜索引擎的技术基础是全文检索技术，从20世纪60年代，国外对全文检索技术就开始有研究。全文检索通常指文本全文检索，包括信息的存储、组织、表现、查 询、存取等各个方面，其核心为文本信息的索引和检索，一般用于企事业单位。随着互联网信息的发展，搜索引擎在全文检索技术上逐渐发展起来，并得到广泛的应 用，但搜索引擎还是不同于全文检索。搜索引擎和常规意义上的全文检索主要区别有以下几点：

1. 数据量 传统全文检索系统面向的是企业本身的数据或者和企业相关的数据，一般索引库规模多在GB级，数据量大的也只有几百万条；但互联网网页搜索需要处理几十亿的网页，搜索引擎的策略都是采用服务器群集和分布式计算技术。
2. 内容相关性 , 信息太多，查准和排序就特别重要，Google等搜索引擎采用网页链接分析技术，根据互联网上网页被链接次数作为重要性评判的依据；但全文检索的数据源中相互链接的程度并不高，不能作为判别重要性的依据，只能基于内容的相关性排序。
3. 安全性. 互联网搜索引擎的数据来源都是互联网上公开的信息，而且除了文本正文以外，其它信息都不太重要；但企业全文检索的数据源都是企业内部的信息，有等级、权限 等限制，对查询方式也有更严格的要求，因此其数据一般会安全和集中地存放在数据仓库中以保证数据安全和管理的要求。
4. 个性化和智能化. 搜索引擎面向的是互联网访问者，由于其数据量和客户数量的限制，自然语言处理技术、知识检索、知识挖掘等计算密集的智能计算技术很难应用，这也是目前搜索引擎技术努力的方向；而全文检索数据量小，检索需求明确，客户量少，在智能化和个性可走得更远。

搜索引擎与全文检索除了以上的区别外，还结合互联网信息的特点形成了三个不同的类型：

• 全文检索搜索引擎 ：全文搜索引擎是名副其实的搜索引擎，国外具代表性的有Google (http://www.google.com) 、yahoo(http://search.yahoo.com) 、AllTheWeb (http://www.alltheweb.com ) 等，国内著名的有百度（http://www.Baidu.com）、中搜（http://www.zhongsou.com）。它们都是通过从互联网上提取的各个网站的信息（以网页文字为主）而建立的数据库，检索与用户查询条件匹配的相关记录，然后按一定的排列顺序将结果返回给用户，也是目前常规意义上的搜索引擎。
• 目录搜索引擎 ：目录索引虽然有搜索功能，但在严格意义上算不上是真正的搜索引擎，仅仅是按目录分类的网站链接列表而已。用户完全可以不用进行关键词查询，仅靠分类目录也可找到需要的信息。国外比较著名的目录索引搜索引擎有yahoo（http://www.yahoo.com）Open Directory Project（DMOZ）（http://www.dmoz.com/）、LookSmart（http://www.looksmart.com）等。国内的搜狐（http://www.sohu.com）、新浪（http://www.sina.com）、网易（http://www.163.com）搜索也都具有这一类功能。
• 元搜索引擎 ：元搜索引擎在接受用户查询请求时，同时在其它多个引擎上进行搜索，并将结果返回给用户。著名的元搜索引擎有Dogpile（http://www.dogpile.com）、Vivisimo（http://www.vivisimo.com）等，国内元搜索引擎中具代表性的有搜星搜索引擎（http://www.soseen.com/），优客搜索（http://www.yok.com）。在搜索结果排列方面，有的直接按来源引擎排列搜索结果，如Dogpile，有的则按自定的规则将结果重新排列组合，如Vivisimo。
• 其他的像新浪(http://search.sina.com.cn) 、网易(http://search.163.com)、 A9（http://www.A9.com） 等搜索引擎都是调用其它全文检索搜索引擎，或者在其搜索结果的基础上做了二次开发。

搜索引擎的系统架构

1. 从互联网上抓取网页. 利用能够从互联网上自动收集网页的网络蜘蛛程序，自动访问互联网，并沿着任何网页中的所有URL爬到其它网页，重复这过程，并把爬过的所有网页收集到服务器中。
2. 建立索引数据库 . 由索引系统程序对收集回来的网页进行分析，提取相关网页信息（包括网页所在URL、编码类型、页面内容包含的关键词、关键词位置、生成时间、大小、与其它 网页的链接关系等），根据一定的相关度算法进行大量复杂计算，得到每一个网页针对页面内容中及超链中每一个关键词的相关度（或重要性），然后用这些相关信 息建立网页索引数据库。
3. 在索引数据库中搜索 . 当用户输入关键词搜索后，分解搜索请求，由搜索系统程序从网页索引数据库中找到符合该关键词的所有相关网页。
4. 对搜索结果进行处理排序 . 所有相关网页针对该关键词的相关信息在索引库中都有记录，只需综合相关信息和网页级别形成相关度数值，然后进行排序，相关度越高，排名越靠前。最后由页面生成系统将搜索结果的链接地址和页面内容摘要等内容组织起来返回给用户。 下图是一个典型的搜索引擎系统架构图，搜索引擎的各部分都会相互交错相互依赖。其处理流程按照如下描述：

“网络蜘蛛”从互联网上抓取网页，把网页送入“网页数据库”，从网页中“提取URL”，把URL送入“URL数据库”，“蜘蛛控制”得到网页的URL，控制“网络蜘蛛”抓取其它网页，反复循环直到把所有的网页抓取完成。 系统从“网页数据库”中得到文本信息，送入“文本索引”模块建立索引，形成“索引数据库”。同时进行“链接信息提取”，把链接信息（包括锚文本、链接本身等信息）送入“链接数据库”，为“网页评级”提供依据。 “用户”通过提交查询请求给“查询服务器”，服务器在“索引数据库”中进行相关网页的查找，同时“网页评级”把查询请求和链接信息结合起来对搜索结果进行相关度的评价，通过“查询服务器”按照相关度进行排序，并提取关键词的内容摘要，组织最后的页面返回给“用户”。

搜索引擎的索引和搜索

数据的索引分为三个步骤：网页内容的提取、词的识别、标引库的建立。

互联网上大部分信息都是以HTML格式存在，对于索引来说，只处理文本信息。因此需要把网页中文本内容提取出来，过滤掉一些脚本标示符和一些无用的广告信 息，同时记录文本的版面格式信息[1]。词的识别是搜索引擎中非常关键的一部分，通过字典文件对网页内的词进行识别。对于西文信息来说，需要识别词的不同 形式，例如：单复数、过去式、组合词、词根等，对于一些亚洲语言（中文、日文、韩文等）需要进行分词处理[3]。识别出网页中的每个词，并分配唯一的wordID号，用于为数据索引中的标引模块服务。

标引库的建立是数据索引中结构最复杂的一部分。一般需要建立两种标引：文档标引和关键词标引。 文档标引分配每个网页一个唯一的docID号，根据docID标引出在这个网页中出现过多少过wordID，每个wordID出现的次数、位置、大小写格 式等，形成docID对应wordID的数据列表；关键词标引其实是对文档标引的逆标引，根据wordID标引出这个词出现在那些网页（用wordID表 示），出现在每个网页的次数、位置、大小写格式等，形成wordID对应docID的列表。

关于索引数据的详细数据结构，有兴趣的朋友可以参看文献[4]。

搜索的处理过程是对用户的搜索请求进行满足的过程，通过用户输入搜索关键字，搜索服务器对应关键词字典，把搜索关键词转化为wordID，然后在标引库中 得到docID列表，对docID列表进行扫描和wordID的匹配，提取满足条件的网页，然后计算网页和关键词的相关度，根据相关度的数值返回前K篇结 果（不同的搜索引擎每页的搜索结果数不同）返回给用户。如果用户查看的第二页或者第多少页，重新进行搜索，把排序结果中在第K+1到2*K的网页组织返回 给用户。其处理流程如下图所示：

搜索引擎细化趋势

从技术上讲，各种搜索引擎都具有类似的系统架构，其不同在于搜索的数据源的不同。除了上面提到的网页搜索引擎以外，下面列举几个典型的搜索引擎：

• 新闻搜索引擎 . 看新闻是许多网民上网的主要目的，新闻搜索也就成了查看新闻的重要工具。新闻搜索引擎实现的过程比较简单，一般是扫描国内外有名的新闻网站，抓取新闻网 页，建立自己的新闻数据库，然后提供搜索，只是对新闻网页抓取的频率要求很高，有的需要做到几分钟扫描一次。现在许多大型的网页搜索引擎都提供相应的新闻 搜索功能，如：Google新闻搜索（http://news.google.com），中搜新闻搜索（http://news.zhongsou.com），百度新闻搜索（http://news.baidu.com）等。
• 音乐搜索引擎 . 有了互联网以后，音乐得到了广泛的传播，对于喜欢音乐的网民来说，音乐搜索引擎成了最钟爱的工具。音乐搜索引擎需要监控互联网上大型的音乐网站，抓取其音乐数据的描述信息，形成自己的数据库，音乐的下载和试听都会在其原来的音乐网站上进行。目前有：搜刮网（http://www.sougua.com），百度mp3搜索（http://mp3.baidu.com），1234567搜索（http://www.1234567.com）等。
• 图像搜索引擎 . 通过图像搜索引擎可以找到自己感兴趣的图片链接，各大搜索引擎也提供了图像搜索功能。图像文件本身不能够被搜索引擎索引，但搜索引擎可以通过链接文本分析和图片注解等得到图片的信息。目前有：Google图像搜索（http://images.google.com/），VisionNext搜索（http://www.eefind.com），百度图像搜索（http://images.baidu.com）等。
• 商机搜索引擎 . 电子商务一直是互联网的热点，商机搜索对电子商务的发展也起到了巨大的推动作用，商机搜索让互联网经济和传统经营紧密结合在一起，给传统的企业提供了一个 新的销售模式。商机搜索引擎，通过抓取电子商务网站的商品信息和其他商业信息，给访问者提供统一的搜索平台。目前有：soaso价格搜索引擎（http://www.soaso.com），8848购物搜索（http://www.8848.com），阿里巴巴商机搜索（http://www.alibaba.com）等。

这些看来不经意的举动都让我们切身感受到搜索引擎对我们网络使用方式的改变起到了重要作用。并且，正因为搜索引擎的兴起以及社会各界对其重视程度日渐高 涨，还由此创造了一个全新的职位——SEO。实际上，搜索引擎经济的崛起，又一次向人们证明了网络所蕴藏的巨大商机。网络离开了搜索将只剩下空洞杂乱的数 据，以及大量等待去费力挖掘的金矿。

前言

研究搜索引擎技术的文章不少，但大部分讨论的是如何评价网页的重要性，对于网络蜘蛛研究的文章不多。网络蜘蛛技术并不是一项十分高深的技术，但要做一个强 大的网络蜘蛛，却非易事。在目前磁盘容量已经不是瓶颈的时候，搜索引擎一直在扩大自己的网页数量。最大的搜索引擎Google（http://www.google.com）从2002年的10亿网页增加到现在近40亿网页；最近雅虎搜索引擎（http://search.yahoo.com/）号称收录了45亿个网页；国内的中文搜索引擎百度（http://www.baidu.com）的中文页面从两年前的七千万页增加到了现在的两亿多。据估计，整个互联网的网页数达到100多亿，而且每年还在快速增长。因此一个优秀的搜索引擎，需要不断的优化网络蜘蛛的算法，提升其性能。

或许有些人有疑问，为何搜索引擎需要用网络蜘蛛抓取网站所有的网页，为什么不在搜索者输入关键词后只把那些需要的结果抓取过来？这实际上是效率问题，搜索 引擎不可能在搜索时实时去检查每个网页，而是需要把网页先抓取下来，按照关键词建立好索引，每次搜索的结果都会直接从搜索引擎建立好索引的数据库中查找， 然后把结果返回给访问者。关于搜索引擎系统架构方面的知识，参考文献[3]，本文主要介绍网络蜘蛛的相关技术。

网络蜘蛛基本原理

对于搜索引擎来说，要抓取互联网上所有的网页几乎是不可能的，从目前公布的数据来看，容量最大的搜索引擎也不过是抓取了整个网页数量的百分之四十左右。这 其中的原因一方面是抓取技术的瓶颈，无法遍历所有的网页，有许多网页无法从其它网页的链接中找到；另一个原因是存储技术和处理技术的问题，如果按照每个页 面的平均大小为20K计算（包含图片），100亿网页的容量是100×2000G字节，即使能够存储，下载也存在问题（按照一台机器每秒下载20K计算， 需要340台机器不停的下载一年时间，才能把所有网页下载完毕）。同时，由于数据量太大，在提供搜索时也会有效率方面的影响。因此，许多搜索引擎的网络蜘 蛛只是抓取那些重要的网页，而在抓取的时候评价重要性主要的依据是某个网页的链接深度。

在抓取网页的时候，网络蜘蛛一般有两种策略：广度优先和深度优先（如下图所示）。广度优先是指网络蜘蛛会先抓取起始网页中链接的所有网页，然后再选择其中 的一个链接网页，继续抓取在此网页中链接的所有网页。这是最常用的方式，因为这个方法可以让网络蜘蛛并行处理，提高其抓取速度。深度优先是指网络蜘蛛会从 起始页开始，一个链接一个链接跟踪下去，处理完这条线路之后再转入下一个起始页，继续跟踪链接。这个方法有个优点是网络蜘蛛在设计的时候比较容易。两种策 略的区别，下图的说明会更加明确。

由于不可能抓取所有的网页，有些网络蜘蛛对一些不太重要的网站，设置了访问的层数。例如，在上图中，A为起始网页，属于0层，B、C、D、E、F属于第1 层，G、H属于第2层，I属于第3层。如果网络蜘蛛设置的访问层数为2的话，网页I是不会被访问到的。这也让有些网站上一部分网页能够在搜索引擎上搜索 到，另外一部分不能被搜索到。对于网站设计者来说，扁平化的网站结构设计有助于搜索引擎抓取其更多的网页。

网络蜘蛛在访问网站网页的时候，经常会遇到加密数据和网页权限的问题，有些网页是需要会员权限才能访问。当然，网站的所有者可以通过协议让网络蜘蛛不去抓 取（下小节会介绍），但对于一些出售报告的网站，他们希望搜索引擎能搜索到他们的报告，但又不能完全免费的让搜索者查看，这样就需要给网络蜘蛛提供相应的 用户名和密码。网络蜘蛛可以通过所给的权限对这些网页进行网页抓取，从而提供搜索。而当搜索者点击查看该网页的时候，同样需要搜索者提供相应的权限验证。

网站与网络蜘蛛

每个网络蜘蛛都有自己的名字，在抓取网页的时候，都会向网站标明自己的身份。网络蜘蛛在抓取网页的时候会发送一个请求，这个请求中就有一个字段为User －agent，用于标识此网络蜘蛛的身份。例如Google网络蜘蛛的标识为GoogleBot，Baidu网络蜘蛛的标识为BaiDuSpider， Yahoo网络蜘蛛的标识为Inktomi Slurp。如果在网站上有访问日志记录，网站管理员就能知道，哪些搜索引擎的网络蜘蛛过来过，什么时候过来的，以及读了多少数据等等。如果网站管理员发 现某个蜘蛛有问题，就通过其标识来和其所有者联系。下面是博客中国（http://www.blogchina.com）2004年5月15日的搜索引擎访问日志：

感谢车东提供相应数据

网络蜘蛛进入一个网站，一般会访问一个特殊的文本文件Robots.txt，这个文件一般放在网站服务器的根目录下，如：http://www.blogchina.com/robots.txt。 网站管理员可以通过robots.txt来定义哪些目录网络蜘蛛不能访问，或者哪些目录对于某些特定的网络蜘蛛不能访问。例如有些网站的可执行文件目录和 临时文件目录不希望被搜索引擎搜索到，那么网站管理员就可以把这些目录定义为拒绝访问目录。Robots.txt语法很简单，例如如果对目录没有任何限 制，可以用以下两行来描述：

User-agent: *

Disallow:

当然，Robots.txt只是一个协议，如果网络蜘蛛的设计者不遵循这个协议，网站管理员也无法阻止网络蜘蛛对于某些页面的访问，但一般的网络蜘蛛都会遵循这些协议，而且网站管理员还可以通过其它方式来拒绝网络蜘蛛对某些网页的抓取。

网络蜘蛛在下载网页的时候，会去识别网页的HTML代码，在其代码的部分，会有META标识。通过这些标识，可以告诉网络蜘蛛本网页是否需要被抓取，还可 以告诉网络蜘蛛本网页中的链接是否需要被继续跟踪。例如：表示本网页不需要被抓取，但是网页内的链接需要被跟踪。

关于Robots.txt的语法和META Tag语法，有兴趣的读者查看文献[4]

现在一般的网站都希望搜索引擎能更全面的抓取自己网站的网页，因为这样可以让更多的访问者能通过搜索引擎找到此网站。为了让本网站的网页更全面被抓取到， 网站管理员可以建立一个网站地图，即Site Map。许多网络蜘蛛会把sitemap.htm文件作为一个网站网页爬取的入口，网站管理员可以把网站内部所有网页的链接放在这个文件里面，那么网络蜘 蛛可以很方便的把整个网站抓取下来，避免遗漏某些网页，也会减小对网站服务器的负担。

内容提取

对于doc、pdf等文档，这种由专业厂商提供的软件生成的文档，厂商都会提供相应的文本提取接口。网络蜘蛛只需要调用这些插件的接口，就可以轻松的提取文档中的文本信息和文件其它相关的信息。

HTML等文档不一样，HTML有一套自己的语法，通过不同的命令标识符来表示不同的字体、颜色、位置等版式，如：、、等， 提取文本信息时需要把这些标识符都过滤掉。过滤标识符并非难事，因为这些标识符都有一定的规则，只要按照不同的标识符取得相应的信息即可。但在识别这些信 息的时候，需要同步记录许多版式信息，例如文字的字体大小、是否是标题、是否是加粗显示、是否是页面的关键词等，这些信息有助于计算单词在网页中的重要程 度。同时，对于HTML网页来说，除了标题和正文以外，会有许多广告链接以及公共的频道链接，这些链接和文本正文一点关系也没有，在提取网页内容的时候， 也需要过滤这些无用的链接。例如某个网站有“产品介绍”频道，因为导航条在网站内每个网页都有，若不过滤导航条链接，在搜索“产品介绍”的时候，则网站内 每个网页都会搜索到，无疑会带来大量垃圾信息。过滤这些无效链接需要统计大量的网页结构规律，抽取一些共性，统一过滤；对于一些重要而结果特殊的网站，还 需要个别处理。这就需要网络蜘蛛的设计有一定的扩展性。

对于多媒体、图片等文件，一般是通过链接的锚文本（即，链接文本）和相关的文件注释来判断这些文件的内容。例如有一个链接文字为“张曼玉照片”，其链接指 向一张bmp格式的图片，那么网络蜘蛛就知道这张图片的内容是“张曼玉的照片”。这样，在搜索“张曼玉”和“照片”的时候都能让搜索引擎找到这张图片。另 外，许多多媒体文件中有文件属性，考虑这些属性也可以更好的了解文件的内容。

动态网页一直是网络蜘蛛面临的难题。所谓动态网页，是相对于静态网页而言，是由程序自动生成的页面，这样的好处是可以快速统一更改网页风格，也可以减少网 页所占服务器的空间，但同样给网络蜘蛛的抓取带来一些麻烦。由于开发语言不断的增多，动态网页的类型也越来越多，如：asp、jsp、php等。这些类型 的网页对于网络蜘蛛来说，可能还稍微容易一些。网络蜘蛛比较难于处理的是一些脚本语言（如VBScript和JavaScript）生成的网页，如果要完 善的处理好这些网页，网络蜘蛛需要有自己的脚本解释程序。对于许多数据是放在数据库的网站，需要通过本网站的数据库搜索才能获得信息，这些给网络蜘蛛的抓 取带来很大的困难。对于这类网站，如果网站设计者希望这些数据能被搜索引擎搜索，则需要提供一种可以遍历整个数据库内容的方法。

对于网页内容的提取，一直是网络蜘蛛中重要的技术。整个系统一般采用插件的形式，通过一个插件管理服务程序，遇到不同格式的网页采用不同的插件处理。这种 方式的好处在于扩充性好，以后每发现一种新的类型，就可以把其处理方式做成一个插件补充到插件管理服务程序之中。

更新周期

搜索引擎的更新周期对搜索引擎搜索的查全率有很大影响。如果更新周期太长，则总会有一部分新生成的网页搜索不到；周期过短，技术实现会有一定难度，而且会 对带宽、服务器的资源都有浪费。搜索引擎的网络蜘蛛并不是所有的网站都采用同一个周期进行更新，对于一些重要的更新量大的网站，更新的周期短，如有些新闻 网站，几个小时就更新一次；相反对于一些不重要的网站，更新的周期就长，可能一两个月才更新一次。

一般来说，网络蜘蛛在更新网站内容的时候，不用把网站网页重新抓取一遍，对于大部分的网页，只需要判断网页的属性（主要是日期），把得到的属性和上次抓取的属性相比较，如果一样则不用更新。

结论

本文主要讨论了网络蜘蛛相关的技术要点，如果要设计好的网络蜘蛛，需要了解更多的技术细节，可以参考文献[5]。

网络蜘蛛在搜索引擎中占有重要位置，对搜索引擎的查全、查准都有影响，决定了搜索引擎数据容量的大小，而且网络蜘蛛的好坏直接影响搜索结果页中的死链接 （即链接所指向的网页已经不存在）的个数。目前如何发现更多的网页、如何正确提取网页内容、如果下载动态网页、如何提供抓取速度、如何识别网站内内容相同 的网页等都是网络蜘蛛需要进一步改进的问题。

HttpURLConnection是基于HTTP协议的，其底层通过socket通信实现。如果不设置超时（timeout），在网络异常的情况下，可能会导致程序僵死而不继续往下执行。可以通过以下两个语句来设置相应的超时：
System.setProperty("sun.net.client.defaultConnectTimeout", 超时毫秒数字符串);
System.setProperty("sun.net.client.defaultReadTimeout", 超时毫秒数字符串);

其中： sun.net.client.defaultConnectTimeout：连接主机的超时时间（单位：毫秒）
sun.net.client.defaultReadTimeout：从主机读取数据的超时时间（单位：毫秒）

例如：
System.setProperty("sun.net.client.defaultConnectTimeout", "30000");
System.setProperty("sun.net.client.defaultReadTimeout", "30000");

JDK 1.5以前的版本，只能通过设置这两个系统属性来控制网络超时。在1.5中，还可以使用HttpURLConnection的父类URLConnection的以下两个方法：
setConnectTimeout：设置连接主机超时（单位：毫秒）
setReadTimeout：设置从主机读取数据超时（单位：毫秒）

例如：
HttpURLConnection urlCon = (HttpURLConnection)url.openConnection();
urlCon.setConnectTimeout(30000);
urlCon.setReadTimeout(30000);

我们不可能列举所有可能的顽固，我们会针对几种最常见的问题进行处理。当然了，正如前面说到的，如果我们自己使用java.net.HttpURLConnection来搞定这些问题是很恐怖的事情，因此在开始之前我们先要介绍一下一个开放源码的项目，这个项目就是Apache开源组织中的httpclient，它隶属于Jakarta的commons项目，目前的版本是2.0RC2。commons下本来已经有一个net的子项目，但是又把httpclient单独提出来，可见http服务器的访问绝非易事。

Commons-httpclient项目就是专门设计来简化HTTP客户端与服务器进行各种通讯编程。通过它可以让原来很头疼的事情现在轻松的解决，例如你不再管是HTTP或者HTTPS的通讯方式，告诉它你想使用HTTPS方式，剩下的事情交给httpclient替你完成。本文会针对我们在编写HTTP客户端程序时经常碰到的几个问题进行分别介绍如何使用httpclient来解决它们，为了让读者更快的熟悉这个项目我们最开始先给出一个简单的例子来读取一个网页的内容，然后循序渐进解决掉前进中的所形侍狻?/font>

1． 读取网页(HTTP/HTTPS)内容

        public String getEncoding() {
            System.out.println("获得编码：" + encod);
            return encod;
        }
    };

    det.Init(nsIC);

    det.DoIt(buf, buf.length, false);
    det.DataEnd();
    String encode = nsIC.getEncoding();

词库包含有以下种 ， 其功能对应分别为：

snotforeign 消除部分组合歧异  例如：博客中搜索 （中搜）

numbers_u8 分词处理，分简体和繁体， 中英文数字 例如：二零零六

foreign_u8 外来词处理

surname_u8  人名区分

bothlexu8 分词词库主体

内存中的词库组织形式为：

词条(keyword)  类别(type)

其中，词条 就是 bothlexu8 文件中的一行或其子串 ， 类别 有两种 ， 一种是 原始词（bothlexu8 文件中的一行） ， 一种是原始词截取的子串（用于最大切分）

然后是分词算法，描述如下：

从待切分字串str中取出一个字符（currentchar），把这个字符加到匹配字符串（currentword）中去，到词典中去匹配（同时匹配currentword+next currentchar），如果匹配成功，则取出匹配的字符串，得到该串的类型，如果是1（原始词），则匹配成功，在取下一个字符的时候将该词加入Token；如果匹配类别是2（原始词子串），表示有可能不是最大匹配，则继续取字符进行下一次匹配 ，如果匹配不成功表示当前字符已是最大匹配，加入Token；如果匹配成功则继续取字匹配。如果当前字符是与前一字符不同类别（中英文、数字、字符等），则当前currentword加入 Token，去掉标点符号等字符。

加入Token 同时记录词的位置信息（包含标点符号等字符） ， 当前词库取词只取4个字符或者以下的词条，如有需要可以将该值加到8个或以上，对性能有些影响，不适合太大。另外，平移窗口大小是1个字符 ， 也可以扩展到2个字符或者3个字符甚至更大，但是，增大平移窗口需要有对窗口的处理，也比较麻烦。

这个算法的处理效率为 2万字/秒 ，不过是单线程的 ， 要是能够到多线程，速度估计可以在提高N倍，如果可以达到20W字/秒，就比较有用了。

另外分词准确程度取决词库，没有完善的知识库，这是一个缺陷，组合歧异识别在这里面只是一个可有可无的小功能，以后的工作就是不断的完善知识库，增加歧异消除和新词识别（名字，如人名、地名、机构名等）功能

　　所有搜索引擎的祖先，是1990年由Montreal的McGill University学生Alan Emtage、Peter Deutsch、Bill Wheelan发明的Archie(Archie FAQ)。当时World Wide Web还未出现。Archie是第一个自动索引互联网上匿名FTP网站文件的程序，但它还不是真正的搜索引擎。Archie是一个可搜索的FTP文件名列表，用户必须输入精确的文件名搜索，然后Archie会告诉用户哪一个FTP地址可以下载该文件。

　　由于Archie深受欢迎，受其启发，Nevada System Computing Services大学于1993年开发了一个Gopher（Gopher FAQ）搜索工具Veronica（Veronica FAQ）。Jughead是后来另一个Gopher搜索工具。

　　由于专门用于检索信息的Robot程序象蜘蛛(spider)一样在网络间爬来爬去，因此，搜索引擎的Robot程序被称为spider(Spider FAQ)程序。世界上第一个Spider程序，是MIT Matthew Gray的World wide Web Wanderer，用于追踪互联网发展规模。刚开始它只用来统计互联网上的服务器数量，后来则发展为也能够捕获网址（URL）。

　　与Wanderer相对应，1993年10月Martijn Koster创建了ALIWEB（Martijn Koster Annouces the Availability of Aliweb），它相当于Archie的HTTP版本。ALIWEB不使用网络搜寻Robot，如果网站主管们希望自己的网页被ALIWEB收录，需要自己提交每一个网页的简介索引信息，类似于后来大家熟知的Yahoo。

　　1993年底，一些基于此原理的搜索引擎开始纷纷涌现，其中最负盛名的三个是：Scotland的JumpStation、Colorado 大学Oliver McBryan的The World Wide Web Worm（First Mention of McBryan’s World Wide Web Worm）、NASA的Repository-Based Software Engineering (RBSE) spider。

　　1993年2月，6个Stanford（斯坦福）大学生的想法是分析字词关系，以对互联网上的大量信息作更有效的检索。这就是Excite。后来曾以概念搜索闻名，2002年5月，被Infospace收购的Excite停止自己的搜索引擎，改用元搜索引擎Dogpile

　　1994年1月，第一个既可搜索又可浏览的分类目录EINet Galaxy（Tradewave Galaxy）上线。除了网站搜索，它还支持Gopher和Telnet搜索。　

　　1994年4月，Stanford两名博士生，美籍华人Jerry Yang（杨致远）和David Filo共同创办了Yahoo。随着访问量和收录链接数的增长，Yahoo目录开始支持简单的数据库搜索。因为Yahoo!的数据是手工输入的，所以不能真正被归为搜索引擎，事实上只是一个可搜索的目录。搜索效率明显提高。（Yahoo以后陆续使用Altavista、Inktomi、Google提供搜索引擎服务）

　　1994年初，Washington大学CS学生Brian Pinkerton开始了他的小项目WebCrawler（Brian Pinkerton Announces the Availability of Webcrawler）。1994年4月20日，WebCrawler正式亮相时仅包含来自6000个服务器的内容。WebCrawler是互联网上第一个支持搜索文件全部文字的全文搜索引擎，在它之前，用户只能通过URL和摘要搜索，摘要一般来自人工评论或程序自动取正文的前100个字。（后来webcrawler陆续被AOL和Excite收购，现在和excite一样改用元搜索引擎Dogpile）

　　Lycos（Carnegie Mellon University Center for Machine Translation Announces Lycos ）是搜索引擎史上又一个重要的进步。Carnegie Mellon University的Michael Mauldin将John Leavitt的spider程序接入到其索引程序中，创建了Lycos。1994年7月20日，数据量为54,000的Lycos正式发布。除了相关性排序外，Lycos还提供了前缀匹配和字符相近限制，Lycos第一个在搜索结果中使用了网页自动摘要，而最大的优势还是它远胜过其它搜索引擎的数据量：1994年8月－－394,000 documents；1995年1月－－1.5 million documents；1996年11月－－over 60 million documents。（注：1999年4月，Lycos停止自己的Spider，改由Fast提供搜索引擎服务）

　　Infoseek（Steve Kirsch Announces Free Demos Of the Infoseek Search Engine）是另一个重要的搜索引擎，虽然公司声称1994年1月已创立，但直到年底它的搜索引擎才与公众见面。起初，Infoseek只是一个不起眼的搜索引擎，它沿袭Yahoo!和Lycos的概念，并没有什么独特的革新。但是它的发展史和后来受到的众口称赞证明，起初第一个登台并不总是很重要。Infoseek友善的用户界面、大量附加服务（such as UPS tracking, News, a directory, and the like) 使它声望日隆。而1995年12月与Netscape的战略性协议，使它成为一个强势搜索引擎：当用户点击Netscape浏览器上的搜索按钮时，弹出Infoseek的搜索服务，而此前由Yahoo!提供该服务。（注：Infoseek后来曾以相关性闻名，2001年2月，Infoseek停止了自己的搜索引擎，开始改用Overture的搜索结果）

　　1995年，一种新的搜索引擎形式出现了——元搜索引擎（A Meta Search Engine Roundup）。用户只需提交一次搜索请求，由元搜索引擎负责转换处理后提交给多个预先选定的独立搜索引擎，并将从各独立搜索引擎返回的所有查询结果，集中起来处理后再返回给用户。第一个元搜索引擎，是Washington大学硕士生 Eric Selberg 和 oren Etzioni 的 Metacrawler。元搜索引擎概念上好听，但搜索效果始终不理想，所以没有哪个元搜索引擎有过强势地位。　

　　DEC的AltaVista(2001年夏季起部分网友需通过p-roxy访问，无p-roxy可用qbseach单选altavista搜索，只能显示第一页搜索结果)是一个迟到者，1995年12月才登场亮相（AltaVista Public Beta Press Release ）。但是，大量的创新功能使它迅速到达当时搜索引擎的顶峰。Altavista最突出的优势是它的速度（搜索引擎9238：比较搞笑，设计altavista的目的，据说只是为了展示DEC Alpha芯片的强大运算能力）。　　而Altavista的另一些新功能，则永远改变了搜索引擎的定义。AltaVista是第一个支持自然语言搜索的搜索引擎，AltaVista是第一个实现高级搜索语法的搜索引擎（如AND, or, NOT等)。用户可以用AltaVista搜索Newsgroups（新闻组）的内容并从互联网上获得文章，还可以搜索图片名称中的文字、搜索Titles、搜索Java applets、搜索ActiveX objects。AltaVista也声称是第一个支持用户自己向网页索引库提交或删除URL的搜索引擎，并能在24小时内上线。AltaVista最有趣的新功能之一，是搜索有链接指向某个URL的所有网站。在面向用户的界面上，AltaVista也作了大量革新。它在搜索框区域下放了“tips”以帮助用户更好的表达搜索式，这些小tip经常更新，这样，在搜索过几次以后，用户会看到很多他们可能从来不知道的的有趣功能。这系列功能，逐渐被其它搜索引擎广泛采用。1997年，AltaVista发布了一个图形演示系统LiveTopics，帮助用户从成千上万的搜索结果中找到想要的。

　　然后到来的是HotBot。1995年9月26日，加州伯克利分校CS助教Eric Brewer、博士生Paul Gauthier创立了Inktomi（UC Berkeley Announces Inktomi），1996年5月20日，Inktomi公司成立，强大的HotBot出现在世人面前。声称每天能抓取索引1千万页以上，所以有远超过其它搜索引擎的新内容。HotBot也大量运用cookie储存用户的个人搜索喜好设置。（Hotbot曾是随后几年最受欢迎的搜索引擎之一，后被Lycos收购）

　　Northernlight 公司于1995年9月成立于马萨诸塞州剑桥，1997年8月，Northernlight搜索引擎正式现身。它曾是拥有最大数据库的搜索引擎之一，它没有Stop Words，它有出色的Current News、7,100多出版物组成的Special Collection、良好的高级搜索语法，第一个支持对搜索结果进行简单的自动分类。（2002年1月16日，Northernlight公共搜索引擎关闭，随后被divine收购，但在Nlresearch，选中"World Wide Web only"，仍可使用Northernlight搜索引擎）

　　1998年10月之前，Google只是Stanford大学的一个小项目BackRub。1995年博士生Larry Page开始学习搜索引擎设计，于1997年9月15日注册了google.com的域名，1997年底，在Sergey Brin和Scott Hassan、Alan Steremberg的共同参与下，BachRub开始提供Demo。1999年2月，Google完成了从Alpha版到Beta版的蜕变。Google公司则把1998年9月27日认作自己的生日。

　　Google在Pagerank、动态摘要、网页快照、DailyRefresh、多文档格式支持、地图股票词典寻人等集成搜索、多语言支持、用户界面等功能上的革新，象Altavista一样，再一次永远改变了搜索引擎的定义。

　　在2000年中以前，Google虽然以搜索准确性备受赞誉，但因为数据库不如其它搜索引擎大，缺乏高级搜索语法，所以使用价值不是很高，推广并不快。直到2000年中数据库升级后，又借被Yahoo选作搜索引擎的东风，才一飞冲天。

　　Fast（Alltheweb）公司创立于1997年，是挪威科技大学(NTNU)学术研究的副产品。1999年5月，发布了自己的搜索引擎AllTheWeb。Fast创立的目标是做世界上最大和最快的搜索引擎，几年来庶几近之。Fast（Alltheweb）的网页搜索可利用ODP自动分类，支持Flash和pdf搜索，支持多语言搜索，还提供新闻搜索、图像搜索、视频、MP3、和FTP搜索，拥有极其强大的高级搜索功能。

　　Teoma 起源于1998年Rutgers大学的一个项目。Apostolos Gerasoulis教授带领华裔Tao Yang教授等人创立Teoma于新泽西Piscataway，2001年春初次登场，2001年9月被提问式搜索引擎Ask Jeeves收购，2002年4月再次发布。Teoma的数据库目前仍偏小，但有两个出彩的功能：支持类似自动分类的Refine；同时提供专业链接目录的Resources。

　　Wisenut 由韩裔Yeogirl Yun创立。2001年春季发布Beta版，2001年9月5日发布正式版，2002年4月被分类目录提供商looksmart收购。wisenut也有两个出彩的功能：包含类似自动分类和相关检索词的WiseGuide；预览搜索结果的Sneak-a-Peek。

　　Gigablast 由前Infoseek工程师Matt Wells创立，2002年3月展示pre-beta版，2002年7月21日发布Beta版。Gigablast的数据库目前仍偏小，但也提供网页快照，一个特色功能是即时索引网页，你的网页刚提交它就能搜索（注：这个spammers的肉包子功能暂已关闭）。

　　Openfind 创立于1998年1月，其技术源自台湾中正大学吴升教授所领导的GAIS实验室。Openfind起先只做中文搜索引擎，曾经是最好的中文搜索引擎，鼎盛时期同时为三大著名门户新浪、奇摩、雅虎提供中文搜索引擎，但2000年后市场逐渐被Baidu和Google瓜分。2002年6月，Openfind重新发布基于GAIS30 Project的Openfind搜索引擎Beta版，推出多元排序(PolyRankTM)，宣布累计抓取网页35亿，开始进入英文搜索领域，此后技术升级明显加快。

　　北大天网 是国家"九五"重点科技攻关项目"中文编码和分布式中英文信息发现"的研究成果，由北大计算机系网络与分布式系统研究室开发，于1997年10月29日正式在CERNET上提供服务。2000年初成立天网搜索引擎新课题组，由国家973重点基础研究发展规划项目基金资助开发，收录网页约6000万，利用教育网优势，有强大的ftp搜索功能。

16 Sep 2004 00:13:31
Mon, 28 Aug 2006
Thu, 7 Sep 2006 22:23 GMT
29 Dec 2005 09:10:00 -0500
8/8/2006
16 Sep 2004 00:13:32
03/08/2006
July 27 2004 17:49:07.
January 31 2005 16:40:37.
Friday, 15 9 2006 12:00:00 -0700
1158993184
Thu, 21 Sep 2006 19:19 GMT
2006-05-17
9/23/2006 9:25:57 PM
Thu, 21 Sep 2006 19:19 GMT
2006-8-28
9/23/2006 8:32:12 AM
2006-11-03 12:37 AM
2006-11-04 05:05 PM
2006-10-10T12:24:05+08:00
2006-11-04T14:19:34Z
Sat,04 Nov 2006 23:37:53 +0800
Sat, 4 Nov 2006 22:24:38 +0800
Sat, 04 Nov 2006 15:30:13 GMT+8
日, 19 二月 2006 07:17:58 GMT
2006-11-04 19:03:31
Sat, 04 Nov 2006 06:43:14 GMT
2006-11-04 23:13:52
Sat, 04 Nov 2006 15:11:52 GMT
2006-11-3星期五(Friday)晴
2005-12-10 20:33:39 星期六
2006-10-30 17:45:35 星期一
2006-06-27T17:29:35Z
2006-06-27T17:29:35Z
2006-06-27T17:29:35Z
2006-06-27T17:29:35Z
2006-06-27T17:29:35Z
2006-11-2 19:08:49
Fri, 03 Nov 2006 13:57:15 +0000
Sun, 29 Oct 2006 17:57:00 -0600
Fri, 03 Nov 2006 07:10:04 +0000
Sat, 04 Nov 2006 19:00:57 GMT
Sat, 04 Nov 2006 14:56:00 GMT
2006-10-15 11:10
2006-11-04 20:07:32
Sat, 04 Nov 2006 13:27:09 +0000
Sat, 04 Nov 2006 00:58:15 +0800
Sun, 29 Oct 2006 17:57:00 -0600
Thu, 26 Oct 2006 14:39:52 +0000
11.2 2006 / 14:54
2006-11-4 21:47:00
2006-8-22 16:48
2006-10-24 15:52:08

import java.text.*;
import java.util.*;

public class DateUtil {
    /**
     * GMT 时间转换 ， 0.2版本功能， 正则表达式 ， 部分存在 bug ， 去掉 时区标志
     * 后续版本将会保留时区标志
     *
     * @param date
     *            指定时间字符串。
     * @return 指定日期的下一个星期
     */
    public static synchronized java.util.Date getRegtime(String time) {
        StringBuffer strb = new StringBuffer();
        for (int i = 0; time != null && i < time.length(); i++) {
            if (time.charAt(i) != '?')
                strb.append(time.charAt(i));
            else
                strb.append(" ");
        }
        if (time.indexOf("UTC") > 0) {
            strb = new StringBuffer(strb.substring(0, strb.indexOf("UTC")));
            if (strb.charAt(strb.length() - 1) == ' ') {
                strb = new StringBuffer(strb.substring(0, strb.length() - 1));
            }
        }
        if (time.indexOf("EDT") > 0) {
            strb = new StringBuffer(strb.substring(0, strb.indexOf("EDT")));
            if (strb.charAt(strb.length() - 1) == ' ') {
                strb = new StringBuffer(strb.substring(0, strb.length() - 1));
            }
        }
        if(time.indexOf("T")>0 && time.indexOf("Z")>0)
        {
            strb = new StringBuffer(strb.toString().replace('T',' ').replace('Z',' '))  ;
        }

        if (time.indexOf("CDT") > 0) {
            strb = new StringBuffer(strb.substring(0, strb.indexOf("CDT")));
            if (strb.charAt(strb.length() - 1) == ' ') {
                strb = new StringBuffer(strb.substring(0, strb.length() - 1));
            }
        }
        if (time.indexOf("GMT") > 0) {
            strb = new StringBuffer(strb.substring(0, strb.indexOf("GMT")));
            if (strb.charAt(strb.length() - 1) == ' ') {
                strb = new StringBuffer(strb.substring(0, strb.length() - 1));
            }
        }

        if (time.indexOf("CST") > 0) {
            strb = new StringBuffer(strb.substring(0, strb.indexOf("CST")));
            if (strb.charAt(strb.length() - 1) == ' ') {
                strb = new StringBuffer(strb.substring(0, strb.length() - 1));
            }
        }
        if (time.indexOf("PDT") > 0) {
            strb = new StringBuffer(strb.substring(0, strb.indexOf("PDT")));
            if (strb.charAt(strb.length() - 1) == ' ') {
                strb = new StringBuffer(strb.substring(0, strb.length() - 1));
            }
        }

        SimpleDateFormat format = new SimpleDateFormat(
                "EEE MMM dd HH:mm:ss z yyyy", Locale.US);
        if(time!=null && time.matches("\\d{1,4}\\-[a-zA-Z]{1,}-\\d{1,2} \\d{1,2}:\\d{1,2}:\\d{1,2}"))
        {
            format = new SimpleDateFormat(
                "yyyy-MMM-dd HH:mm:ss", Locale.US);
        }else if(time!=null && time.matches("\\d{1,4} [a-zA-Z]{1,} \\d{4} \\d{1,2}:\\d{1,2}:\\d{1,2} [a-zA-Z]{1,}"))
        {
            //10 Sep 2006 16:00:00 GMT
            format = new SimpleDateFormat(
                "dd MMM yyyy HH:mm:ss", Locale.US);
        }else if(time!=null && time.matches("\\d{8}"))
        {
            format = new SimpleDateFormat(
                "yyyyMMdd", Locale.US);
        }else if(time!=null && time.matches("[a-zA-Z]{1,},\\d{2} \\d{2} \\d{4} \\d{1,2}:\\d{1,2}:\\d{1,2}"))
        {
            //Sat,23 09 2006 13:19:52
            format = new SimpleDateFormat(
                    "EEE,dd MM yyyy hh:mm:ss", Locale.US);
        }else if(time!=null && time.matches("[a-zA-Z]{3}, \\d{2} [a-zA-Z]{3} \\d{4} \\d{1,2}:\\d{1,2}"))
        {
            //Sat, 23 Sep 2006 01:41
            format = new SimpleDateFormat(
                    "EEE, dd MMM yyyy hh:mm", Locale.US);
        }else if(time!=null && time.matches("\\d{1},\\d{1,2} [a-zA-Z]{3} \\d{4} \\d{1,2}:\\d{1,2}:\\d{1,2}"))
        {
            //0,17 Sep 2006 22:30:16
            strb = new StringBuffer(time.substring(time.indexOf(",")+1,time.length())) ;
            format = new SimpleDateFormat(
                    "dd MMM yyyy hh:mm:ss", Locale.US);
        }else if(time!=null && time.matches("\\d{2}/\\d{2}/\\d{2} \\d{2}:\\d{2}:\\d{2}"))
        {
            //01/01/01 16:10:01
            format = new SimpleDateFormat(
                    "dd/MM/yy hh:mm:ss", Locale.US);
        }else if(time!=null && time.matches("\\d{1,2}/\\d{1,2}/\\d{4} \\d{1,2}:\\d{1,2}:\\d{1,2} [a-zA-Z]{2}"))
        {
            //11/3/2002 10:02:13 PM

            format = new SimpleDateFormat(
                    "MM/dd/yyyy hh:mm:ss a", Locale.US);
        }else if(time!=null && time.matches("\\d{4}-\\d{1,2}-\\d{1,2} \\d{1,2}:\\d{1,2}:\\d{1,2} [a-zA-Z]{3}"))
        {
            //2006-9-13 15:17:25 GMT
            format = new SimpleDateFormat(
                    "yyyy-MM-dd hh:mm:ss", Locale.US);
        }else if(time!=null && time.matches("\\d{4}-\\d{1,2}-\\d{1,2}[a-zA-Z]{1}\\d{1,2}:\\d{1,2}:\\d{1,2}"))
        {
            //2006-09-16T22:16:00
            strb = new StringBuffer(time.replace("T"," ")) ;
            format = new SimpleDateFormat(
                    "yyyy-MM-dd hh:mm:ss", Locale.US);
        }else if(time!=null && time.matches("[a-zA-Z]{3,}, \\d{2} [a-zA-Z]{3,} \\d{4} \\d{1,2}:\\d{1,2} [a-zA-Z]{3}"))
        {
            //Wednesday, 20 September 2006 00:00 GMT
            format = new SimpleDateFormat(
                    "EEE, dd MMM yyyy hh:mm", Locale.US);
        }else if(time!=null && time.matches("\\d{4}-\\d{1,2}-\\d{1,2}T\\d{1,2}:\\d{1,2}:\\d{1,2}-\\d{1,2}:\\d{1,2}"))
        {
            //2005-02-27T08:36:00-05:00
            strb = new StringBuffer(time.replace("T"," ").substring(0,time.lastIndexOf("-"))) ;
            format = new SimpleDateFormat(
                    "yyyy-MM-dd hh:mm:ss", Locale.US);
        }else if(time!=null && time.matches("\\d{4}--\\d{1,2}-\\d{1,2}-T\\d{1,2}: \\d{1,2}:\\d{1,2}:-\\d{1,2}:\\d{1,2}"))
        {
            strb = new StringBuffer(time.replace("T"," ").replace(" ","").substring(0,time.lastIndexOf("-"))) ;
            format = new SimpleDateFormat(
                    "yyyy--MM-dd-hh:mm:ss", Locale.US);

        }else if(time!=null && time.matches("\\d{4}-\\d{1,2}-\\d{1,2} \\d{1,2}:\\d{1,2}:\\d{1,2}"))
        {
//            System.out.println("time:"+time);
            format = new SimpleDateFormat(
                    "yyyy-MM-dd hh:mm:ss", Locale.US);
        }else if(time!=null && time.matches("[a-zA-Z]{3} \\w{4} \\d{4} \\d{1,2}:\\d{1,2}[a-zA-Z]{2}"))
        {
            //Jul 31st 2006 10:08PM
//            System.out.println("time"+time);
            strb = new StringBuffer(time.replace("st","").replace("nd","").replace("th","")) ;
            format = new SimpleDateFormat(
                    "MMM dd yyyy hh:mma", Locale.US);
        }else if(time!=null && time.matches("[a-zA-Z]{1,2}, \\d{1,2} [a-zA-Z]{3} \\d{4} \\d{1,2}:\\d{1,2}:\\d{1,2} -\\d{4}"))
        {
            strb = new StringBuffer(time.substring(time.indexOf(",")+2,time.length())) ;
            format = new SimpleDateFormat(
                    "dd MMM yyyy HH:mm:ss Z", Locale.US);
        }else if(time!=null && time.matches("[1]\\d{9}"))
        {
            format = new SimpleDateFormat(
                    "dd MMM yyyy HH:mm:ss Z", Locale.US);
            strb = new StringBuffer(format.format(new Date(Long.parseLong(time)*1000)))  ;
        }else if(time!=null && time.matches("[a-zA-Z]{3,}, \\d{1,2} [a-zA-Z]{3,} \\d{4}, \\d{1,2}:\\d{1,2}:\\d{1,2} [a-zA-Z]{2}ST"))
        {
            //Saturday, 23 September 2006, 11:32:29 SAST
            format = new SimpleDateFormat(
                    "EEE, dd MMM yyyy, HH:mm:ss Z", Locale.US);
        }else if(time!=null && time.matches("\\d{4}-\\d{1,2}-\\d{1,2} [^\\x00-\\xff]{1,} \\d{1,2}:\\d{1,2}:\\d{1,2}"))
        {
            //2006-9-22 锟斤拷锟斤拷 08:40:18
            strb = new StringBuffer(time.replaceAll("[^\\x00-\\xff]{1,}","")) ;
            format = new SimpleDateFormat(
                    "yyyy-MM-dd  HH:mm:ss", Locale.US);
        }else if(time!=null && time.matches("[a-zA-Z]{3}, \\d{1,2} [a-zA-Z]{3} \\d{4} \\d{1,2}:\\d{1,2} [a-zA-Z]{3,}"))
        {//Thu, 7 Sep 2006 22:23 GMT
            format = new SimpleDateFormat(
                    "EEE, dd MMM yyyy HH:mm", Locale.US);
        }else if(time!=null && time.matches("\\d{4}/\\d{1,2}/\\d{1,2} \\d{1,2}:\\d{1,2}"))
        {//2006/09/23 21:54
            format = new SimpleDateFormat(
                    "yyyy/MM/dd hh:mm", Locale.US);
        }else if(time!=null && time.matches("[a-zA-Z]{3}, \\d{1,2} [a-zA-Z]{3} \\d{4}"))
        {//Tue, 19 Sep 2006
            format = new SimpleDateFormat(
                    "EEE, dd MMM yyyy", Locale.US);
        }else if(time!=null && time.matches("\\d{4}[^\\x00-\\xff]{1,}\\d{1,2}[^\\x00-\\xff]{1,}\\d{1,2}[^\\x00-\\xff]{1,}"))
        {
            strb = new StringBuffer(time.replaceAll("[^\\x00-\\xff]{1,}","-")) ;
            format = new SimpleDateFormat(
                    "yyyy-MM-dd", Locale.US);
        }else if(time!=null && time.matches("[a-zA-Z]{1,}, \\d{1,2} [a-zA-Z]{1,} \\d{4} \\d{1,2}:\\d{1,2}:\\d{1,2}"))
        {//Sa, 23 Sep 2006 13:49:25
            if(time.indexOf(", ")>0)
                strb = new StringBuffer(time.substring(time.indexOf(", ")+2,time.length())) ;
            format = new SimpleDateFormat(
                    "dd MMM yyyy hh:mm:ss", Locale.US);
        }else if(time!=null && time.matches("[a-zA-Z]{1,} [a-zA-Z]{1,} \\d{1,2} \\d{1,2}:\\d{1,2}:\\d{1,2} [a-zA-Z ]{1,} \\d{4}"))
        {//Sat Sep 23 15:29:45 CD  2006
         //Wed Sep 14 13:14:23 U C 2005
//         System.out.println(time);
         if(time!=null && time.matches("[a-zA-Z]{1,} [a-zA-Z]{1,} \\d{1,2} \\d{1,2}:\\d{1,2}:\\d{1,2} [a-zA-Z]{1,}  \\d{4}"))
         {
             //Sat Sep 23 15:29:45 CD  2006
             strb = new StringBuffer(time.replaceAll("[a-zA-Z]{1,}  ", " "));
             format = new SimpleDateFormat(
                    "EEE MMM dd hh:mm:ss yyyy", Locale.US);
         }else
         {
             //Wed Sep 14 13:14:23 U C 2005
//             strb = new StringBuffer(time.replace(" [a-zA-Z]{1} [a-zA-Z]{1} ", " "));
//             System.out.println(strb.toString());
             format = new SimpleDateFormat(
                    "EEE MMM dd hh:mm:ss 'U C' yyyy", Locale.US);
         }

        }else if(time!=null && time.matches("[a-zA-Z]{1,} \\d{1,2}, \\d{4}, \\d{1,2}:\\d{1,2}[a-zA-Z]{2}"))
        {//September 20, 2006, 11:56AM
            format = new SimpleDateFormat(
                    "MMM dd, yyyy, hh:mma", Locale.US);
      &nbs