(转载)Nutch 2.0 之 抓取流程简单分析

最新推荐文章于 2018-01-03 20:36:22 发布
最新推荐文章于 2018-01-03 20:36:22 发布
阅读量2.2k 收藏
点赞数
分类专栏： Big data
Nutch 2.0 抓取流程介绍
---------------------


1. 整体流程


InjectorJob => GeneratorJob => FetcherJob => ParserJob => DbUpdaterJob => SolrIndexerJob


InjectorJob : 从文件中得到一批种子网页，把它们放到抓取数据库中去
GeneratorJob: 从抓取数据库中产生要抓取的页面放到抓取队列中去
FetcherJob:   对抓取队列中的网页进行抓取,在reducer中使用了生产/消费者模型
ParserJob:    对抓取完成的网页进行解析，产生一些新的链接与网页内容的解析结果
DbUpdaterJob: 把新产生的链接更新到抓取数据库中去
SolrIndexerJob: 对解析后的内容进行索引建立


2. InjectorJob分析



  下面是InjectorJob的启动函数，代码如下

[java]  view plain  copy
  1.  public Map<String,Object> run(Map<String,Object> args) throws Exception {  
  2.    getConf().setLong("injector.current.time", System.currentTimeMillis());  
  3.    Path input;  
  4.    Object path = args.get(Nutch.ARG_SEEDDIR);  
  5.    if (path instanceof Path) {  
  6.      input = (Path)path;  
  7.    } else {  
  8.      input = new Path(path.toString());  
  9.    }  
  10.    numJobs = 2;  
  11.    currentJobNum = 0;  
  12.    status.put(Nutch.STAT_PHASE, "convert input");  
  13.    currentJob = new NutchJob(getConf(), "inject-p1 " + input);  
  14.    FileInputFormat.addInputPath(currentJob, input);  
  15. // mapper方法，从文件中解析出url，写入数据库  
  16.    currentJob.setMapperClass(UrlMapper.class);  
  17.    currentJob.setMapOutputKeyClass(String.class);  
  18. // map 的输出为WebPage，它是用Gora compile生成的，可以通过Gora把它映射到不同的数据库中，  
  19.    currentJob.setMapOutputValueClass(WebPage.class);  
  20. // 输出到GoraOutputFormat  
  21.    currentJob.setOutputFormatClass(GoraOutputFormat.class);  
  22.    DataStore<String, WebPage> store = StorageUtils.createWebStore(currentJob.getConfiguration(),  
  23.        String.class, WebPage.class);  
  24.    GoraOutputFormat.setOutput(currentJob, store, true);  
  25.    currentJob.setReducerClass(Reducer.class);  
  26.    currentJob.setNumReduceTasks(0);  
  27.    currentJob.waitForCompletion(true);  
  28.    ToolUtil.recordJobStatus(null, currentJob, results);  
  29.    currentJob = null;  
  30.   
  31.   
  32.    status.put(Nutch.STAT_PHASE, "merge input with db");  
  33.    status.put(Nutch.STAT_PROGRESS, 0.5f);  
  34.    currentJobNum = 1;  
  35.    currentJob = new NutchJob(getConf(), "inject-p2 " + input);  
  36.    StorageUtils.initMapperJob(currentJob, FIELDS, String.class,  
  37.        WebPage.class, InjectorMapper.class);  
  38.    currentJob.setNumReduceTasks(0);  
  39.    ToolUtil.recordJobStatus(null, currentJob, results);  
  40.    status.put(Nutch.STAT_PROGRESS, 1.0f);  
  41.    return results;  
  42.  }  

   
   因为InjectorJob扩展自NutchTool，实现了它的run方法。


   我们可以看到，这里有两个MR任务，第一个主要是从文件中读入种子网页，写到DataStore数据库中，第二个MR任务主要是对数据库中的WebPage对象做一个分数与抓取间隔的设置。它使用到一个initMapperJob方法，代码如下

[java]  view plain  copy
  1. public static <K, V> void initMapperJob(Job job,  
  2.     Collection<WebPage.Field> fields,  
  3.     Class<K> outKeyClass, Class<V> outValueClass,  
  4.     Class<? extends GoraMapper<String, WebPage, K, V>> mapperClass,  
  5.     Class<? extends Partitioner<K, V>> partitionerClass, boolean reuseObjects)  
  6. throws ClassNotFoundException, IOException {  
  7.  // 这里是生成一个DataStore的抽象，这里的DataStore用户可以不同的模块，如Hbase，MySql等  
  8.   DataStore<String, WebPage> store = createWebStore(job.getConfiguration(),  
  9.       String.class, WebPage.class);  
  10.   if (store==null) throw new RuntimeException("Could not create datastore");  
  11.   Query<String, WebPage> query = store.newQuery();  
  12.   query.setFields(toStringArray(fields));  
  13.   GoraMapper.initMapperJob(job, query, store,  
  14.       outKeyClass, outValueClass, mapperClass, partitionerClass, reuseObjects);  
  15.   GoraOutputFormat.setOutput(job, store, true);  
  16. }  

   

3. GeneratorJob 源代码分析



   下面是GeneratorJob的run方法代码

[java]  view plain  copy
  1.  public Map<String,Object> run(Map<String,Object> args) throws Exception {  
  2.    // map to inverted subset due for fetch, sort by score  
  3.    Long topN = (Long)args.get(Nutch.ARG_TOPN);  
  4.    Long curTime = (Long)args.get(Nutch.ARG_CURTIME);  
  5.    if (curTime == null) {  
  6.      curTime = System.currentTimeMillis();  
  7.    }  
  8.    Boolean filter = (Boolean)args.get(Nutch.ARG_FILTER);  
  9.    Boolean norm = (Boolean)args.get(Nutch.ARG_NORMALIZE);  
  10.    // map to inverted subset due for fetch, sort by score  
  11.    getConf().setLong(GENERATOR_CUR_TIME, curTime);  
  12.    if (topN != null)  
  13.      getConf().setLong(GENERATOR_TOP_N, topN);  
  14.    if (filter != null)  
  15.      getConf().setBoolean(GENERATOR_FILTER, filter);  
  16.    int randomSeed = Math.abs(new Random().nextInt());  
  17.    batchId = (curTime / 1000) + "-" + randomSeed;  
  18.    getConf().setInt(GENERATOR_RANDOM_SEED, randomSeed);  
  19.    getConf().set(BATCH_ID, batchId);  
  20.    getConf().setLong(Nutch.GENERATE_TIME_KEY, System.currentTimeMillis());  
  21.    if (norm != null)  
  22.      getConf().setBoolean(GENERATOR_NORMALISE, norm);  
  23.    String mode = getConf().get(GENERATOR_COUNT_MODE, GENERATOR_COUNT_VALUE_HOST);  
  24.    if (GENERATOR_COUNT_VALUE_HOST.equalsIgnoreCase(mode)) {  
  25.      getConf().set(URLPartitioner.PARTITION_MODE_KEY, URLPartitioner.PARTITION_MODE_HOST);  
  26.    } else if (GENERATOR_COUNT_VALUE_DOMAIN.equalsIgnoreCase(mode)) {  
  27.        getConf().set(URLPartitioner.PARTITION_MODE_KEY, URLPartitioner.PARTITION_MODE_DOMAIN);  
  28.    } else {  
  29.      LOG.warn("Unknown generator.max.count mode '" + mode + "', using mode=" + GENERATOR_COUNT_VALUE_HOST);  
  30.      getConf().set(GENERATOR_COUNT_MODE, GENERATOR_COUNT_VALUE_HOST);  
  31.      getConf().set(URLPartitioner.PARTITION_MODE_KEY, URLPartitioner.PARTITION_MODE_HOST);  
  32.    }  
  33.   
  34.   
  35. // 上面是设置一些要使用要的常量  
  36.    numJobs = 1;  
  37.    currentJobNum = 0;  
  38. // 生成一个job  
  39.    currentJob = new NutchJob(getConf(), "generate: " + batchId);  
  40. // 初始化Map,这里的Map的输出类型为<SelectorEntry,WebPage>, 使用 SelectorEntryPartitioner来进行切分  
  41.    StorageUtils.initMapperJob(currentJob, FIELDS, SelectorEntry.class,  
  42.        WebPage.class, GeneratorMapper.class, SelectorEntryPartitioner.class, true);  
  43. // 初始化Reducer, 使用了generatorReducer来进行聚合处理  
  44.    StorageUtils.initReducerJob(currentJob, GeneratorReducer.class);  
  45.    currentJob.waitForCompletion(true);  
  46.    ToolUtil.recordJobStatus(null, currentJob, results);  
  47.    results.put(BATCH_ID, batchId);  
  48.    return results;  
  49.  }  
  50.     


  好像比原来的Generate简单很多，这里的GeneratorMapper完成的工作与之前的版本是一样的，如url的正规化，过滤，分数的设置，而GeneratorReducer完成的工作也和之前差不多，只是输出变成了DataStore，如HBase，完成以后会每个WebPage进行打标记，表示当前WebPage所完成的一个状态。




4. FetcherJob 源代码分析



   使用了Gora的 fetcher比原来简单了很多，下面是其run的源代码

[java]  view plain  copy
  1.  public Map<String,Object> run(Map<String,Object> args) throws Exception {  
  2.    checkConfiguration();  
  3.    String batchId = (String)args.get(Nutch.ARG_BATCH);  
  4.    Integer threads = (Integer)args.get(Nutch.ARG_THREADS);  
  5.    Boolean shouldResume = (Boolean)args.get(Nutch.ARG_RESUME);  
  6.    Integer numTasks = (Integer)args.get(Nutch.ARG_NUMTASKS);  
  7.   
  8.    if (threads != null && threads > 0) {  
  9.      getConf().setInt(THREADS_KEY, threads);  
  10.    }  
  11.    if (batchId == null) {  
  12.      batchId = Nutch.ALL_BATCH_ID_STR;  
  13.    }  
  14.    getConf().set(GeneratorJob.BATCH_ID, batchId);  
  15.    if (shouldResume != null) {  
  16.      getConf().setBoolean(RESUME_KEY, shouldResume);  
  17.    }  
  18.      
  19.    LOG.info("FetcherJob : timelimit set for : " + getConf().getLong("fetcher.timelimit", -1));  
  20.    LOG.info("FetcherJob: threads: " + getConf().getInt(THREADS_KEY, 10));  
  21.    LOG.info("FetcherJob: parsing: " + getConf().getBoolean(PARSE_KEY, false));  
  22.    LOG.info("FetcherJob: resuming: " + getConf().getBoolean(RESUME_KEY, false));  
  23.   
  24.   
  25.    // set the actual time for the timelimit relative  
  26.    // to the beginning of the whole job and not of a specific task  
  27.    // otherwise it keeps trying again if a task fails  
  28.    long timelimit = getConf().getLong("fetcher.timelimit.mins", -1);  
  29.    if (timelimit != -1) {  
  30.      timelimit = System.currentTimeMillis() + (timelimit * 60 * 1000);  
  31.      getConf().setLong("fetcher.timelimit", timelimit);  
  32.    }  
  33.    numJobs = 1;  
  34.    currentJob = new NutchJob(getConf(), "fetch");  
  35. // 得到它过滤的字段  
  36.    Collection<WebPage.Field> fields = getFields(currentJob);  
  37. // 初始化mapper, 其输出为<IntWritable,FetchEntry>  
  38. // 在mapper中输入数据进行过滤，主要是对不是同一个batch与已经fetch的数据进行过滤  
  39.    StorageUtils.initMapperJob(currentJob, fields, IntWritable.class,  
  40.        FetchEntry.class, FetcherMapper.class, FetchEntryPartitioner.class, false);  
  41. // 初始化reducer  
  42.    StorageUtils.initReducerJob(currentJob, FetcherReducer.class);  
  43.    if (numTasks == null || numTasks < 1) {  
  44.      currentJob.setNumReduceTasks(currentJob.getConfiguration().getInt("mapred.map.tasks",  
  45.          currentJob.getNumReduceTasks()));  
  46.    } else {  
  47.      currentJob.setNumReduceTasks(numTasks);  
  48.    }  
  49.    currentJob.waitForCompletion(true);  
  50.    ToolUtil.recordJobStatus(null, currentJob, results);  
  51.    return results;  
  52.  }  


  这里把原来在Mapper中使用到的生产者与消费者模型用到了reducer中，重写了reducer的run方法，在其中打开多个抓取线程，对url进行多线程抓取，有兴趣可以看一下FetcherReducer这个类。




5. ParserJob 代码分析



   下面是ParserJob.java中的run代码

[java]  view plain  copy
  1.  @Override  
  2.  public Map<String,Object> run(Map<String,Object> args) throws Exception {  
  3.    String batchId = (String)args.get(Nutch.ARG_BATCH);  
  4.    Boolean shouldResume = (Boolean)args.get(Nutch.ARG_RESUME);  
  5.    Boolean force = (Boolean)args.get(Nutch.ARG_FORCE);  
  6.      
  7.    if (batchId != null) {  
  8.      getConf().set(GeneratorJob.BATCH_ID, batchId);  
  9.    }  
  10.    if (shouldResume != null) {  
  11.      getConf().setBoolean(RESUME_KEY, shouldResume);  
  12.    }  
  13.    if (force != null) {  
  14.      getConf().setBoolean(FORCE_KEY, force);  
  15.    }  
  16.    LOG.info("ParserJob: resuming:\t" + getConf().getBoolean(RESUME_KEY, false));  
  17.    LOG.info("ParserJob: forced reparse:\t" + getConf().getBoolean(FORCE_KEY, false));  
  18.    if (batchId == null || batchId.equals(Nutch.ALL_BATCH_ID_STR)) {  
  19.      LOG.info("ParserJob: parsing all");  
  20.    } else {  
  21.      LOG.info("ParserJob: batchId:\t" + batchId);  
  22.    }  
  23.    currentJob = new NutchJob(getConf(), "parse");  
  24.      
  25.    Collection<WebPage.Field> fields = getFields(currentJob);  
  26. // 初始化mapper，输出类型为<String,WebPage>, 解析全部在maper完成  
  27.    StorageUtils.initMapperJob(currentJob, fields, String.class, WebPage.class,  
  28.        ParserMapper.class);  
  29. // 初始化reducer,这里是支持把<key,values>写到数据库中  
  30.    StorageUtils.initReducerJob(currentJob, IdentityPageReducer.class);  
  31.    currentJob.setNumReduceTasks(0);  
  32.   
  33.   
  34.    currentJob.waitForCompletion(true);  
  35.    ToolUtil.recordJobStatus(null, currentJob, results);  
  36.    return results;  
  37.  }  


   

6. DbUpdaterJob 代码分析


下面是DbUpdaterjob的run方法代码

[java]  view plain  copy
  1.  public Map<String,Object> run(Map<String,Object> args) throws Exception {  
  2.    String crawlId = (String)args.get(Nutch.ARG_CRAWL);  
  3.    numJobs = 1;  
  4.    currentJobNum = 0;  
  5.    currentJob = new NutchJob(getConf(), "update-table");  
  6.    if (crawlId != null) {  
  7.      currentJob.getConfiguration().set(Nutch.CRAWL_ID_KEY, crawlId);  
  8.    }  
  9.    //job.setBoolean(ALL, updateAll);  
  10.    ScoringFilters scoringFilters = new ScoringFilters(getConf());  
  11.    HashSet<WebPage.Field> fields = new HashSet<WebPage.Field>(FIELDS);  
  12.    fields.addAll(scoringFilters.getFields());  
  13.      
  14.    // Partition by {url}, sort by {url,score} and group by {url}.  
  15.    // This ensures that the inlinks are sorted by score when they enter  
  16.    // the reducer.  
  17.      
  18.    currentJob.setPartitionerClass(UrlOnlyPartitioner.class);  
  19.    currentJob.setSortComparatorClass(UrlScoreComparator.class);  
  20.    currentJob.setGroupingComparatorClass(UrlOnlyComparator.class);  
  21.      
  22. // 这里的maper读取webpage中的outlinks字段值，对每个外链接计算分数  
  23.    StorageUtils.initMapperJob(currentJob, fields, UrlWithScore.class,  
  24.        NutchWritable.class, DbUpdateMapper.class);  
  25. // 对新生成的外链接设置一些分数，状态等信息，再把新的WebPage写回数据库  
  26.    StorageUtils.initReducerJob(currentJob, DbUpdateReducer.class);  
  27.    currentJob.waitForCompletion(true);  
  28.    ToolUtil.recordJobStatus(null, currentJob, results);  
  29.    return results;  
  30.  }  



7. SolrIndexerJob 代码分析


下面是其run方法的源代码

[java]  view plain  copy
  1.   @Override  
  2.   public Map<String,Object> run(Map<String,Object> args) throws Exception {  
  3.     String solrUrl = (String)args.get(Nutch.ARG_SOLR);  
  4.     String batchId = (String)args.get(Nutch.ARG_BATCH);  
  5.     NutchIndexWriterFactory.addClassToConf(getConf(), SolrWriter.class);  
  6.     getConf().set(SolrConstants.SERVER_URL, solrUrl);  
  7.   
  8.   
  9. // 初始化 job  
  10.     currentJob = createIndexJob(getConf(), "solr-index", batchId);  
  11.     Path tmp = new Path("tmp_" + System.currentTimeMillis() + "-"  
  12.                 + new Random().nextInt());  
  13. // 设置输出索引到文件，输出格式使用IndexeroutputFormat, 其默认调用Solr的API把数据传给Solr建立索引  
  14.     FileOutputFormat.setOutputPath(currentJob, tmp);  
  15.     currentJob.waitForCompletion(true);  
  16.     ToolUtil.recordJobStatus(null, currentJob, results);  
  17.     return results;  
  18.   }  



有兴趣可以看一下SolrWriter，它实现了NutchIndexerWriter这个接口，来把数据写到不同的后台搜索引擎中，这里默认使用了Solr，当然你也可以通过实现它来扩展你自己的搜索引擎，当然nutch还提供了插件来自定义索引的字段值,也就是IndexingFilter.java这个接口。


8. 总结

    Nutch 2.0个人感觉现在还是不成熟的，有很多功能还没有完成，主要的改变还是在它的数据存储层，把原来的数据存储进行了抽象，使其可以更好的运行在大规模数据抓取中，而且可以让用户来扩展具体的数据存储。当然数据存储层的变化带来了一些流程上的变化，有一些操作可以支持使用数据库操作来完成，这也大大减少了一些原来要MR任务来完成的代码。总之nutch 2.0  还是让我们看到了nutch的一个发展方向。希望它发现的越来越好吧。


转载地址：http://blog.csdn.net/amuseme_lu/article/details/7777426

fjssharpsword
关注
专栏目录
Nutch 2.0 之 抓取流程简单分析
lemo的专栏
07-23 1万+
Nutch 2.0 抓取流程介绍 --------------------- 1. 整体流程 InjectorJob => GeneratorJob => FetcherJob => ParserJob => DbUpdaterJob => SolrIndexerJob InjectorJob : 从文件中得到一批种子网页，把它们放到抓取数据库中去 Generator
[Nutch]Nutch抓取过程分析
Kandy
04-24 1905
Nutch爬虫抓取数据的整个过程。
nutch2.0抓取流程--nutch2crawling
sunny6142496的专栏
11-14 1810
原文http://wiki.apache.org/nutch/Nutch2Crawling第一次翻译可能有不合适的地方欢迎大家指正，红色字体部分是我还不太懂的地方 This document describes the crawling jobs of Nutch2 (NutchGora). 本文描述nutch2 gora版抓取作业 Introduction简介 A cra
nutch1.3数据流程图
豹先生
10-10 1038
流程入口org.apache.nutch.crawl   crawl.java    Crawl::run  里面的很多类中都使用了mapreduce框架进行数据处理 ulrs:存放在hdfs中的待爬取的urls种子列表 Injector:使用mapreduce任务将urls
nutch总体输入输出流程图解析
加俊
04-12 178
          附件里面有word文档，请下载查看。
nutch入门
java
01-03 944
环境nutch官网 http://nutch.apache.org/ linux系统 CentOS 7.3 64位 jdk1.8 apache-nutch-1.14-src.tar.gzyum search jdk | grep java yum install java-1.8.0-openjdk vi /etc/profile#set java environment JAV
Nutch1.7二次开发培训讲义 之 腾讯微博抓取分析
03-12
### Nutch 1.7 二次开发培训讲义之腾讯微博抓取分析 #### 一、概述 Nutch 是一个开源的网络爬虫项目，它提供了灵活的数据抓取能力，并支持二次开发定制功能。本篇培训讲义主要针对的是如何使用 Nutch 1.7 版本对...
Nutch全文搜索引擎安装配置与抓取流程解析
通过以上步骤，Nutch就可以完成从抓取网页到建立索引，再到提供搜索服务的基本流程。在实际应用中，可能还需要根据需求进行更复杂的配置，如配置抓取策略、调整索引参数、优化搜索性能等。同时，Nutch还可以与其他大...
分析Nutch的工作流程
08-07
Nutch的工作流程主要包括以下几个步骤：构建初始URL集合、注入（Inject）、生成抓取列表（Generate）、抓取页面（Fetch）、解析页面（Parse）、更新索引（Index）。接下来我们将详细地探讨每个步骤的具体实现。 ###...
nutch-2.0源码解读——简介
sunny6142496的专栏
11-12 1502
这段时间读了nutch2.0的部分源码，经过对源码的分析对nutch2.0有了初步的了解，这里将记录下对源码的分析和分析中遇到的问题，以便以后学习和解决问题。      本篇将从以下几方面概要介绍nutch2.0      nutch2.0 gora版介绍     nutch2.0的搭建     运行nutch命令抓取 1.nutch2.0 gora版介绍         nutc
浅析爬虫nutch2.0（一）
swrd456的专栏
04-30 806
前言：         作为一名程序猿，业务时间总想捣鼓点事情，不局限于工作那点东西。一来可以学习新东西，二来可以锻炼下自己的写作和总结能力，毕竟看的印象和理解远远低于写下来的记录。       为什么选择nutch，主要因为nutch是一个比较完整的爬虫和索引搜索系统，而且可以自己爬数据进行分析，数据为王的时代，拥有一些数据搜集和分析能力相当重要。另外nutch涉及到的技术比较多，而且都是目
【Nutch2.2.1基础教程之2.2】集成Nutch/Hbase/Solr构建搜索引擎之二：内容分析
weixin_30381793的博客
07-13 117
请先参见“集成Nutch/Hbase/Solr构建搜索引擎之一：安装及运行”，搭建测试环境 http://blog.csdn.net/jediael_lu/article/details/37329731 一、被索引的域 Schema.xml 1、文档基本内容 在使用solr对Nutch抓取到的网页进行索引时，schema.xml被替换成以下内容。 文件中指定了哪些...
Nutch
weixin_30387663的博客
03-21 80
nutch 插件开发[资料整理]:http://my.oschina.net/cloudcoder/blog/472915 Nutch2.3+Mongodb+ElasticSearch:http://www.cnblogs.com/zhjsll/p/4703170.html 在线文档-nutch2.0 http://tool.oschina.net/apidocs/apidoc?api=nut...
Lucene Nutch 入门简明教程总结(转载 收藏)
狂徒技术分享
10-14 136
原文地址：http://cid-47027e68f36cbaf5.spaces.live.com/blog/cns!47027E68F36CBAF5!443.entry 先声明，是个菜鸟的总结。总结的是一件很菜鸟的事情。 事情的起因是1月2号，在实验室，黄黄的书架上看到一本书《Lucene in action》。觉得有意思，拿过来一看。又见Nutch是基于Lucene的一个开源搜索引擎...
【Nutch】GeneratorJob
玉衡
06-04 786
GeneratorJob: 从抓取数据库中产生要抓取的页面放到抓取队列中去
Nutch相关框架安装使用最佳指南
03-19 176
一、nutch1.2 二、nutch1.5.1 三、nutch2.0 四、配置SSH 五、安装Hadoop Cluster（伪分布式运行模式）并运行Nutch 六、安装Hadoop Cluster（分布式运行模式）并运行Nutch 七、配置Ganglia监控Hadoop集群和HBase集群 八、Hadoop配置Snappy压缩 九、Hadoop配置Lzo压缩 十、配置zooke...
【Nutch基础教程之七】Nutch的2种运行模式：local及deploy
weixin_30590285的博客
12-21 206
在对nutch源代码运行ant runtime后，会创建一个runtime的目录，在runtime目录下有deploy和local 2个目录。 [jediael@jediael runtime]$ ls deploy local 这2个目录分别代表nutch的2种运行方式：部署模式及本地模式。 1、nutch.sh中关于2种运行方式的执行 if $local; ...
Nutch 强大的全文索引与网络爬虫框架
修的专栏
12-24 2148
从官网 http://nutch.apache.org/ 上能看到Nutch做的越来越好了，最后更新版本是 v1.9 于 2014年8月16日发布，可见该框架的活跃度和开发受欢迎度还是很大的。 废话不多说，主要特点高扩展性和高伸缩性，主要可以看到，它能和哪些东东一起使用吧。顺便要讲一句： Nutch分为两个版本，1.x和2.x。1.x最新版本为1.9，2.x最新版本为2.2.1。两个版
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值