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

最新推荐文章于 2017-04-30 12:48:34 发布
最新推荐文章于 2017-04-30 12:48:34 发布
阅读量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
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Nutch1.7二次开发培训讲义 之 腾讯微博抓取分析
03-12
Nutch1.7二次开发培训讲义 之 腾讯微博抓取分析
分析Nutch的工作流程
08-07
描述Nutch的工作流程，介绍Nutch对页面获取、分析、建立索引的过程。
Nutch 2.0 之 抓取流程简单分析
每天积累一点，一年后你会发现，自己变化很大
11-20 604
1. 整体流程 InjectorJob => GeneratorJob => FetcherJob => ParserJob => DbUpdaterJob => SolrIndexerJob InjectorJob : 从文件中得到一批种子网页，把它们放到抓取数据库中去 GeneratorJob: 从抓取数据库中产生要抓取的页面放到抓取队列中去 FetcherJob:   对
nutch2.0抓取流程--nutch2crawling
sunny6142496的专栏
11-14 1779
原文http://wiki.apache.org/nutch/Nutch2Crawling第一次翻译可能有不合适的地方欢迎大家指正，红色字体部分是我还不太懂的地方 This document describes the crawling jobs of Nutch2 (NutchGora). 本文描述nutch2 gora版抓取作业 Introduction简介 A cra
nutch2.0完全分布式部署配置
lengyue365的专栏
08-16 3109
nutch2.0的分布式环境依赖hadoop-0.20.2和hbase-0.90.*。 测试做在两台机器上，A(master)：192.168.20.215，B(slave)：192.168.20.214   目的是在A机上运行进程： Hadoop: NameNode, SecondaryNameNode, JobTracker Hbase: HMaster 在B机上运行进程： Ha
nutch-2.0介绍
lengyue365的专栏
08-23 70
开始钻研～～～～～～～～～
Nutch爬虫工作流程及文件格式详细分析.doc
02-18
Nutch爬虫工作流程及文件格式详细分析！！！！！
Apache Nutch网络爬虫-其他
06-12
</p><p>Hadoop是大数据的核心技术之一，而Nutch集Hadoop之大成，是Hadoop的源头。学习Hadoop，没有数据怎么办？用Nutch抓！学了Hadoop的Map Reduce以及HDFS，没有实用案例怎么办？学习Nutch！Nutch的很多代码是用Map...
Nutch搜索引擎·Nutch浅入分析（第5期）
10-29
1.1 Nutch 基本原理 1.1.1 Nutch 基本组成 1.1.2 Nutch 工作流程 1.2 Nutch 流程详解 1.2.1 Nutch 数据流程 1.2.2 Nutch 流程分析
【Nutch】GeneratorJob
玉衡
06-04 753
GeneratorJob: 从抓取数据库中产生要抓取的页面放到抓取队列中去
Nutch 2.0 终于来了
lemo的专栏
07-17 4796
Nutch 2.0 终于来了 ------------------------- 带着大部分人的期待，Nutch 2.0终于发布了，它在Nutch 1.x的基础上做了比较大的改变，主要还是在它的存储层的抽象上，Nutch 2.0的计划最终由使用者对于Nutch对No-sql的不支持而建立起来的，最初的版本叫做NutchBase，由Dogacan Guney进行开发，最初始版本由于过于依赖H
浅析爬虫nutch2.0（一）
swrd456的专栏
04-30 774
前言：         作为一名程序猿，业务时间总想捣鼓点事情，不局限于工作那点东西。一来可以学习新东西，二来可以锻炼下自己的写作和总结能力，毕竟看的印象和理解远远低于写下来的记录。       为什么选择nutch，主要因为nutch是一个比较完整的爬虫和索引搜索系统，而且可以自己爬数据进行分析，数据为王的时代，拥有一些数据搜集和分析能力相当重要。另外nutch涉及到的技术比较多，而且都是目
nutch1.3数据流程图
豹先生
10-10 1014
流程入口org.apache.nutch.crawl   crawl.java    Crawl::run  里面的很多类中都使用了mapreduce框架进行数据处理 ulrs:存放在hdfs中的待爬取的urls种子列表 Injector:使用mapreduce任务将urls
nutch的一些基础整理
Ｇroup-0800
03-22 421
一、关于配置文件： nutch-default.xml：爬虫的默认配置。在${nutch_home}/conf目录。 nutch-site.xml：理论上是nutch-default.xml的覆盖。 core-default.xml, hdfs-default.xml, mapred-default.xml：用于配置 Hadoop，与 hadoop-core-xxx.jar 相关。 m
【Nutch】ParserJob
玉衡
08-23 1311
parse的主要工作是对抓取的网页进行解析，解析出其中的text，outlinks和metadata等信息。 首先： package org.apache.nutch.parse;
nutch总体输入输出流程图解析
加俊
04-12 143
          附件里面有word文档，请下载查看。
node-v12.16.3-x86.msi
最新发布
04-25
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
云计算基础课件—架构dr.pptx
04-25
云计算基础课件—架构dr.pptx
（）擅长处理和分析大量分布式的非结构化数据，以分批的方式进行历史分析。 A、Hadoop B、NoSQL数据库 C、Web D、Nutch
06-11
B、NoSQL数据库擅长处理和分析大量分布式的非结构化数据，以分批的方式进行历史分析。与关系型数据库不同，NoSQL数据库采用了非关系型的数据存储方式，可以支持海量的非结构化数据存储和高并发的数据访问。NoSQL...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值