基于lucene的nutch索引详解

1. 索引流程详解

1.1. crawl中涉及nutch的部分

1.1.1. nutch索引产生所需的文件路径以及产生的索引路径

  Path linkDb = new Path(dir + "/linkdb");

  Path segments = new Path(dir + "/segments");

  Path indexes = new Path(dir + "/indexes");

 这些都是产生索引文件必需的文件路径，在crawl中的main()方法中被配置。此外，还得配置索引产生的路径，如下：

  Path index = new Path(dir + "/index");

1.1.2. nutch中选择使用何种索引的方式

  在nutch的crawl代码刚开始不久，就有以下两行代码：

String indexerName = "lucene";

     String solrUrl = null;

    boolean isSolrIndex = StringUtils.equalsIgnoreCase(indexerName, "solr");

  接下来，在以后的代码中，会根据以上变量的值选择使用何种索引方式，是采用lucene还是solr。也就是说，你可以通过改变这两个变量的值，来选择何种索引方式。

1.1.3. 索引开始

  从这段代码开始，索引就开始了。

  FileStatus[] fstats = fs.listStatus(segments, HadoopFSUtil.getPassDirectoriesFilter(fs));

//这是FileSystem带有的一个方法，你可以查看Hadoop API来了解详细，该方法的目的旨在提取segments下的各个以时间命名的文件夹的路径。

      if (isSolrIndex) {  //结合前面讲解的内容，该判断将选择采用何种索引方式。此处将的是lucene索引，所以不再详述solr。

        SolrIndexer indexer = new SolrIndexer(conf);

        indexer.indexSolr(solrUrl, crawlDb, linkDb, 

            Arrays.asList(HadoopFSUtil.getPaths(fstats)));

      }

      else {

        //从这里开始，就进行lucene索引了。

        DeleteDuplicates dedup = new DeleteDuplicates(conf);        

        if(indexes != null) {

          // Delete old indexes

          if (fs.exists(indexes)) {

            LOG.info("Deleting old indexes: " + indexes);

            fs.delete(indexes, true);

          }

          // Delete old index

          if (fs.exists(index)) {

            LOG.info("Deleting old merged index: " + index);

            fs.delete(index, true);

          }

        }

        

        Indexer indexer = new Indexer(conf);

        indexer.index(indexes, crawlDb, linkDb, 

            Arrays.asList(HadoopFSUtil.getPaths(fstats)));

/*从该方法中可以看出，创建索引所需的文件需要哪些了，分别是crawlDb、lindDb、segments中的内容，当然这是只是初步的认识，在后面讲解每个文件中的哪些子文件被用到了，又有什么作用，重点是segments中的内容。*/

//Arrays.asList方法是用来获得诸如E:\out\segments\20120221153925的path数组的。在Indexer

//中的index方法中可以得到体现：

    // public void index(Path luceneDir, Path crawlDb,

     //               Path linkDb, List<Path> segments)

        

        IndexMerger merger = new IndexMerger(conf);

/*上一步产生的indexes文件夹，下面是对indexes的合并，最终产生index索引文件,将重点讲解上面的索引过程，下面的索引合并过程有必要的话自己去了解吧。*/

        if(indexes != null) {

          dedup.dedup(new Path[] { indexes });

          fstats = fs.listStatus(indexes, HadoopFSUtil.getPassDirectoriesFilter(fs));

          merger.merge(HadoopFSUtil.getPaths(fstats), index, tmpDir);

        }

      }    

      

    } else {

      LOG.warn("No URLs to fetch - check your seed list and URL filters.");

    }

    if (LOG.isInfoEnabled()) { LOG.info("crawl finished: " + dir); }

  }

}

1.1.4. 分析Indexer的index方法

   public void index(Path luceneDir, Path crawlDb,

                    Path linkDb, List<Path> segments)

/*这个方法运行了一个job，该job用来创建indexes。要看懂分布式程序首先得去了解mapreduce*/

  throws IOException {

    LOG.info("Indexer: starting");

    final JobConf job = new NutchJob(getConf());

    job.setJobName("index-lucene " + luceneDir);

//该方法中最重要的方法，将在1.1.5中详解

    IndexerMapReduce.initMRJob(crawlDb, linkDb, segments, job);

    FileOutputFormat.setOutputPath(job, luceneDir);

//下面就涉及到索引管理了。

    LuceneWriter.addFieldOptions("segment", LuceneWriter.STORE.YES, LuceneWriter.INDEX.NO, job);

    LuceneWriter.addFieldOptions("digest", LuceneWriter.STORE.YES, LuceneWriter.INDEX.NO, job);

    LuceneWriter.addFieldOptions("boost", LuceneWriter.STORE.YES, LuceneWriter.INDEX.NO, job);

    NutchIndexWriterFactory.addClassToConf(job, LuceneWriter.class);

    JobClient.runJob(job);

    LOG.info("Indexer: done");

  }

1.1.5. initMRJob方法

  public static void initMRJob(Path crawlDb, Path linkDb,

                           Collection<Path> segments,

                           JobConf job) {

    LOG.info("IndexerMapReduce: crawldb: " + crawlDb);

    LOG.info("IndexerMapReduce: linkdb: " + linkDb);

for (final Path segment : segments) {

/*将sgements下的路径作为job的文件添加路径，添加的内容包括（全在segments/xxxxxxx下）：

parse_text

parse_data

crawl_fetch

crawl_parse

这些文件夹下的包含的内容如下：

parse_text:包了网页中的文本内容，列如博客中的正文内容

parse_data：包含了网页的一些状态信息，如：标题、外连接等，以crawlDatum的格式存放。

crawl_fetch：包含了每个url的抓取状态信息。Crawldb中状态信息的更新需要它做参数。

crawl_parse:这个不清楚。

*/

      LOG.info("IndexerMapReduces: adding segment: " + segment);

      FileInputFormat.addInputPath(job, new Path(segment, CrawlDatum.FETCH_DIR_NAME));

      FileInputFormat.addInputPath(job, new Path(segment, CrawlDatum.PARSE_DIR_NAME));

      FileInputFormat.addInputPath(job, new Path(segment, ParseData.DIR_NAME));

      FileInputFormat.addInputPath(job, new Path(segment, ParseText.DIR_NAME));

    }

    FileInputFormat.addInputPath(job, new Path(crawlDb, CrawlDb.CURRENT_NAME));

    FileInputFormat.addInputPath(job, new Path(linkDb, LinkDb.CURRENT_NAME));

    job.setInputFormat(SequenceFileInputFormat.class);

//最重要的是MapReduce.class,将在1.1.6中讲解

    job.setMapperClass(IndexerMapReduce.class);

    job.setReducerClass(IndexerMapReduce.class);

    job.setOutputFormat(IndexerOutputFormat.class);

    job.setOutputKeyClass(Text.class);

    job.setMapOutputValueClass(NutchWritable.class);

    job.setOutputValueClass(NutchWritable.class);

  }

}

1.1.6. 核心分布式类讲解

  public class IndexerMapReduce extends Configured

implements Mapper<Text, Writable, Text, NutchWritable>,

          Reducer<Text, NutchWritable, Text, NutchDocument> {

  public static final Log LOG = LogFactory.getLog(IndexerMapReduce.class);

  private IndexingFilters filters;

  private ScoringFilters scfilters;

  public void configure(JobConf job) {

    setConf(job);

    this.filters = new IndexingFilters(getConf());

/*初始化nutch索引插件，这是nutch索引管理的核心，所有Nutch索引都是通过插件机制完成的*/

    this.scfilters = new ScoringFilters(getConf());

  }

  public void map(Text key, Writable value,

      OutputCollector<Text, NutchWritable> output, Reporter reporter) throws IOException {

    output.collect(key, new NutchWritable(value));

  }

/*最重要的是reduce方法*/

  public void reduce(Text key, Iterator<NutchWritable> values,

                     OutputCollector<Text, NutchDocument> output, Reporter reporter)

    throws IOException {

    Inlinks inlinks = null;

    CrawlDatum dbDatum = null;

    CrawlDatum fetchDatum = null;

    ParseData parseData = null;

    ParseText parseText = null;

/*注意values是Iterator类型，同时注意前面FileInputPath添加的路径是有多个的，所以value的值的类型可以是多种类型的。这个循环通过判断每个value的不同类型来将他们分类，在CrawlDatum类中，有一堆final类型的静态常量，每个阶段的value，其状态都在这些静态常量中细分着，每种状态会有一个常量来区分，而每种状态又有多个静态常量来表述。所以对于CrawlDatum，对其又可以进行细分。*/

    while (values.hasNext()) {

      final Writable value = values.next().get(); // unwrap

      if (value instanceof Inlinks) {

        inlinks = (Inlinks)value;

      } else if (value instanceof CrawlDatum) {

        final CrawlDatum datum = (CrawlDatum)value;

        if (CrawlDatum.hasDbStatus(datum))

          dbDatum = datum;

        else if (CrawlDatum.hasFetchStatus(datum)) {

          // don't index unmodified (empty) pages

          if (datum.getStatus() != CrawlDatum.STATUS_FETCH_NOTMODIFIED)

            fetchDatum = datum;

        } else if (CrawlDatum.STATUS_LINKED == datum.getStatus() ||

                   CrawlDatum.STATUS_SIGNATURE == datum.getStatus() ||

                   CrawlDatum.STATUS_PARSE_META == datum.getStatus()) {

          continue;

        } else {

          throw new RuntimeException("Unexpected status: "+datum.getStatus());

        }

      } else if (value instanceof ParseData) {

        parseData = (ParseData)value;

      } else if (value instanceof ParseText) {

        parseText = (ParseText)value;

      } else if (LOG.isWarnEnabled()) {

        LOG.warn("Unrecognized type: "+value.getClass());

      }

    }

    if (fetchDatum == null || dbDatum == null

        || parseText == null || parseData == null) {

      return;                                     // only have inlinks

    }

    if (!parseData.getStatus().isSuccess() ||

        fetchDatum.getStatus() != CrawlDatum.STATUS_FETCH_SUCCESS) {

      return;

    }

//创建索引

    NutchDocument doc = new NutchDocument();

    final Metadata metadata = parseData.getContentMeta();

//parseData对应一个类来管理，就是parseData,可以通过其中的一些方法获得相应的内容。

    // add segment, used to map from merged index back to segment files

    doc.add("segment", metadata.get(Nutch.SEGMENT_NAME_KEY));

    // add digest, used by dedup

    doc.add("digest", metadata.get(Nutch.SIGNATURE_KEY));

    final Parse parse = new ParseImpl(parseText, parseData);

    try {

      // extract information from dbDatum and pass it to

      // fetchDatum so that indexing filters can use it

      final Text url = (Text) dbDatum.getMetaData().get(Nutch.WRITABLE_REPR_URL_KEY);

      if (url != null) {

        fetchDatum.getMetaData().put(Nutch.WRITABLE_REPR_URL_KEY, url);

      }

      // run indexing filters

      doc = this.filters.filter(doc, parse, key, fetchDatum, inlinks);

//此处调用插件进行索引建立。关于插件，将在第2节中讲解。

    } catch (final IndexingException e) {

      if (LOG.isWarnEnabled()) { LOG.warn("Error indexing "+key+": "+e); }

      return;

    }

    // skip documents discarded by indexing filters

    if (doc == null) return;

    float boost = 1.0f;

    // run scoring filters

    try {

      boost = this.scfilters.indexerScore(key, doc, dbDatum,

              fetchDatum, parse, inlinks, boost);

    } catch (final ScoringFilterException e) {

      if (LOG.isWarnEnabled()) {

        LOG.warn("Error calculating score " + key + ": " + e);

      }

      return;

    }

    // apply boost to all indexed fields.

    doc.setScore(boost);

    // store boost for use by explain and dedup

    doc.add("boost", Float.toString(boost));

    output.collect(key, doc);

  }

2. 索引管理详解

2.1. 插件

Nutch的索引都是以插件的形式实现的。nutch-site.xml中添加插件扩展，实现插件使用。如：<name>plugin.includes</name>

<value>analysis-(zh)|protocol-http|urlfilter-regex|parse-(text|html|js|pdf)|index-(basic|anchor|more)|query-(basic|site|url|more|custom)|response-(json|xml)|summary-lucene|scoring-opic|urlnormalizer-(pass|regex|basic)</value>。

以分词为例：

  首先，在插件的包中，有个plugin.xml，里面有

<plugin

   id="analysis-zh"

   name="Chinese Analysis Plug-in"

   version="1.0.0"

   provider-name="net.paoding.analysis">。nutch-site.xml中的插件扩展要和id相匹配才行。

2.2. 自定义插件

在索引插件中，关键是得到你想添加到索引field中的内容。对于索引中的一些细节，参考《lucene+nutch搜索引擎开发》这本书。