mongodb数据导入hbase,spark读取hbase数据分析

最新推荐文章于 2021-11-30 14:26:05 发布
最新推荐文章于 2021-11-30 14:26:05 发布
阅读量476 收藏 2
点赞数
文章标签： 大数据 数据库 scala
原文链接：https://my.oschina.net/penngo/blog/842108
版权

为什么80%的码农都做不了架构师？>>>   hot3.png

使用mavn管理相关依赖包pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.spark.test</groupId>
  <artifactId>spark_test</artifactId>
  <packaging>jar</packaging>
  <version>1.0-SNAPSHOT</version>
  <name>spark_test</name>
  <url>http://maven.apache.org</url>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>
	<dependency>
      <groupId>org.apache.spark</groupId>
      <artifactId>spark-core_2.11</artifactId>
      <version>2.1.0</version>
    </dependency>
	<dependency>
	    <groupId>org.apache.spark</groupId>
		<artifactId>spark-sql_2.11</artifactId>
		<version>2.1.0</version>
	</dependency>
	<dependency>
		<groupId>org.apache.spark</groupId>
		<artifactId>spark-mllib_2.11</artifactId>
		<version>2.1.0</version>
	</dependency>
    <dependency>
      <groupId>org.apache.spark</groupId>
      <artifactId>spark-streaming_2.11</artifactId>
      <version>2.1.0</version>
    </dependency>
	<dependency>
        <groupId>org.apache.hadoop</groupId>
        <artifactId>hadoop-client</artifactId>
        <version>2.2.0</version>
    </dependency>
	<dependency>
		<groupId>org.apache.hbase</groupId>
		<artifactId>hbase-client</artifactId>
		<version>1.2.4</version>
	</dependency>
      <!--
      <dependency>
          <groupId>org.apache.hbase</groupId>
          <artifactId>hbase-spark</artifactId>
          <version>1.2.0-cdh5.9.0</version>
      </dependency>
      -->
      <dependency>
          <groupId>org.apache.hbase</groupId>
          <artifactId>hbase-server</artifactId>
          <version>1.2.4</version>
      </dependency>
      <!--
	  <dependency>
		  <groupId>org.lionsoul</groupId>
		  <artifactId>jcseg-core</artifactId>
		  <version>2.1.0</version>
	  </dependency>
      -->
      <dependency>
          <groupId>org.mongodb</groupId>
          <artifactId>mongodb-driver</artifactId>
          <version>3.3.0</version>
      </dependency>
      <dependency>
          <groupId>org.jsoup</groupId>
          <artifactId>jsoup</artifactId>
          <version>1.10.1</version>
      </dependency>
      <dependency>
          <groupId>commons-io</groupId>
          <artifactId>commons-io</artifactId>
          <version>2.5</version>
      </dependency>
      <!--
      <dependency>
          <groupId>com.alibaba</groupId>
          <artifactId>fastjson</artifactId>
          <version>1.2.21</version>
      </dependency>
      -->
      <dependency>
          <groupId>commons-dbutils</groupId>
          <artifactId>commons-dbutils</artifactId>
          <version>1.6</version>
      </dependency>
      <dependency>
          <groupId>mysql</groupId>
          <artifactId>mysql-connector-java</artifactId>
          <version>6.0.5</version>
      </dependency>
  </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

把mongodb数据导入hbase,方便spark分析统计

package com.spark.test.export;

import com.mongodb.MongoClient;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoCursor;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.model.Filters;
import com.mongodb.client.model.Sorts;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.client.BufferedMutator;
import org.apache.hadoop.hbase.client.Mutation;
import org.apache.hadoop.hbase.client.Put;
import org.apache.log4j.Logger;
import org.bson.Document;
import org.jsoup.Jsoup;
import org.jsoup.safety.Whitelist;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;

/**
 * mongodb数据保存到hbase
 */
public class MongoHbase {
    private static Logger log = Logger.getLogger(MongoHbase.class);

    private static String HBASE_COLUMN_NAME = "column";
    private static String HBASE_TABLE = "news";
    private static String MONGO_TABLE = "news";
    private Configuration hbaseConfig;
    private MongoDatabase database;
    private MongoCollection<Document> collection;
    //    private Table hbaseTable;
    private BufferedMutator hbaseMutatorTable;

    public MongoHbase(){
        initHbase();
        initMongodb();
    }
    private void initHbase(){
        hbaseConfig = HBaseConfiguration.create();
        hbaseConfig.set("hbase.zookeeper.property.clientPort", "2181");
        hbaseConfig.set("hbase.zookeeper.quorum", "192.168.1.45");
    }
    private void initMongodb(){
        MongoClient mongoClient = new MongoClient("192.168.1.44" , 27017);
        database = mongoClient.getDatabase("db_news");
        collection = database.getCollection(MONGO_TABLE);
    }

    /**
     * 新闻数据保存到hbase
     * @param startTime
     * @param endTime
     * @param collection
     * @param count
     * @throws Exception
     */
    public void saveDataToHbase(long startTime, long  endTime, MongoCollection<Document> collection, long count) throws Exception{

        int pageSize = 100;
        long totalPage = (long)Math.ceil((double)count  / pageSize );
        Whitelist html_filter = Whitelist.none();
        for(int page = 0; page < totalPage; page++){
            MongoCursor<Document> cursor = collection.find(Filters.and(Filters.gte("publish_timestamp", startTime),
                    Filters.lt("publish_timestamp", endTime), Filters.eq("status", 1))).sort(Sorts.descending("publish_timestamp"))
                    .skip(page * pageSize).limit(pageSize).iterator();
            List<Mutation> mutations = new ArrayList<Mutation>();
            while(cursor.hasNext()){
                // 获取mongodb数据
                Document doc = cursor.next();
                String id = doc.getString("id");
                String title = doc.getString("title");
                String content = doc.getString("content");
                content = Jsoup.clean(content, html_filter); // 去掉文章中的html
                String publishtime = doc.getString("publishtime");
                String source = doc.getString("source");
                Long publish_timestamp = doc.getLong("publish_timestamp");
                String rowKey = id;

                // 保存到hbase
                String url = doc.getString("url");
                Long status = Double.valueOf(doc.get("status").toString()).longValue();
                Put put = new Put(rowKey.getBytes());
                put.addColumn(HBASE_COLUMN_NAME.getBytes(), "id".getBytes(), id.getBytes());
                put.addColumn(HBASE_COLUMN_NAME.getBytes(), "title".getBytes(), title.getBytes("UTF-8"));
                put.addColumn(HBASE_COLUMN_NAME.getBytes(), "content".getBytes(), content.getBytes("UTF-8"));
                put.addColumn(HBASE_COLUMN_NAME.getBytes(), "publishtime".getBytes(), publishtime.getBytes());
                put.addColumn(HBASE_COLUMN_NAME.getBytes(), "source".getBytes(), source.getBytes("UTF-8"));
                put.addColumn(HBASE_COLUMN_NAME.getBytes(), "publish_timestamp".getBytes(), publish_timestamp.toString().getBytes());
                put.addColumn(HBASE_COLUMN_NAME.getBytes(), "url".getBytes(), url.getBytes());
                put.addColumn(HBASE_COLUMN_NAME.getBytes(), "status".getBytes(), status.toString().getBytes());

                mutations.add(put);
                if(mutations.size() > 1000){
                    hbaseMutatorTable.mutate(mutations);
                    hbaseMutatorTable.flush();
                    mutations.clear();
                    mutations = new ArrayList<Mutation>();
                }
            }
            cursor.close();
            if(mutations.size() > 0){
                hbaseMutatorTable.mutate(mutations);
                hbaseMutatorTable.flush();
                mutations.clear();
            }
        }
    }

    public void run(int dataCount){
        Date currentDate = new Date();
        Calendar startCalendar = Calendar.getInstance();
        startCalendar.setTime(currentDate);
        startCalendar.set(Calendar.HOUR_OF_DAY, 0);
        startCalendar.set(Calendar.MINUTE, 0);
        startCalendar.set(Calendar.SECOND, 0);
        startCalendar.set(Calendar.MILLISECOND, 0);
        Calendar endCalendar = Calendar.getInstance();


        Calendar stopCalendar = Calendar.getInstance();
        stopCalendar.setTime(startCalendar.getTime());
        stopCalendar.add(Calendar.DATE, -dataCount);
        try{
            while(startCalendar.getTime().getTime() > stopCalendar.getTime().getTime()){
                Date date = startCalendar.getTime();
                endCalendar.setTime(date);
                endCalendar.add(Calendar.DATE, 1);
                long startTime = startCalendar.getTimeInMillis() / 1000;
                long endTime = endCalendar.getTimeInMillis() / 1000;

                long count = collection.count(Filters.and(
                        Filters.gte("publish_timestamp", startTime),
                        Filters.lt("publish_timestamp", endTime),
                        Filters.eq("status", 1)));

                if(count > 0){
                    saveDataToHbase(startTime, endTime, collection, count);
                }
                startCalendar.add(Calendar.DATE, -1);
            }
        }
        catch(Exception e){
            log.error("保存数据失败====", e);
        }

    }

    public static void main(String... args) throws Exception {
        MongoHbase MongoHbase = new MongoHbase();
        MongoHbase.run(7); // 一个星期数据
    }
}

spark读取hbase数据分析（以tfidf为例子）

package com.spark.test.export;

import com.spark.test.tfidf.zhuti.MongoData;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.io.ImmutableBytesWritable;
import org.apache.hadoop.hbase.mapreduce.TableInputFormat;
import org.apache.hadoop.hbase.protobuf.ProtobufUtil;
import org.apache.hadoop.hbase.protobuf.generated.ClientProtos;
import org.apache.hadoop.hbase.util.Base64;
import org.apache.log4j.Logger;
import org.apache.spark.api.java.JavaPairRDD;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.Function;
import org.apache.spark.ml.feature.HashingTF;
import org.apache.spark.ml.feature.IDF;
import org.apache.spark.ml.feature.IDFModel;
import org.apache.spark.ml.feature.Tokenizer;
import org.apache.spark.sql.Dataset;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.SparkSession;
import scala.Tuple2;

/**
 * spark读取hbase数据作统计
 */
public class SparkHbase {
    private static Logger log = Logger.getLogger(SparkHbase.class);
    private static SparkSession spark = null;
    public static String splitTag = "@==@";
    private static Configuration hbaseConfig;
    private static String HBASE_COLUMN_NAME = "column";
    private static String HBASE_TABLE = "news";


    /**
     * 初始化spark
     * @return
     */
    private static SparkSession initSpark(String name) {
        // cache时序列化
        System.setProperty("spark.serializer",
                "org.apache.spark.serializer.KryoSerializer");
        if (spark == null) {
            String os = System.getProperty("os.name").toLowerCase();
            log.info("os.name====" + os + " " + os.indexOf("windows"));
            // linux上运行
            if(os.indexOf("windows") == -1){
                spark = SparkSession
                        .builder()
                        .appName("Spark_" + name)
                        .getOrCreate();
            }
            // window上运行调试
            else{
                System.setProperty("hadoop.home.dir", "D:/hadoop/hadoop-2.6.4");
                System.setProperty("HADOOP_USER_NAME", "root");
                spark = SparkSession
                        .builder()
                        .appName("Spark_" + name).master("spark://spark-serv1:7077")
                        .getOrCreate();

            }

        }

        return spark;
    }
    private static void initHbaseConf(){

    }
    private static void initHbaseTable(){
        if(hbaseConfig == null){
            hbaseConfig = HBaseConfiguration.create();
            hbaseConfig.set("hbase.zookeeper.property.clientPort", "2181");
            hbaseConfig.set("hbase.zookeeper.quorum", "192.168.1.45");
        }
        try {
            Connection connection = ConnectionFactory.createConnection(hbaseConfig);
//            Admin admin = connection.getAdmin();
//            TableName tableName = TableName.valueOf(HBASE_TABLE);
            hbaseConfig.set(TableInputFormat.INPUT_TABLE, HBASE_TABLE);
            Scan scan = new Scan();
            ClientProtos.Scan proto = ProtobufUtil.toScan(scan);
            String ScanToString = Base64.encodeBytes(proto.toByteArray());
            hbaseConfig.set(TableInputFormat.SCAN, ScanToString);
        } catch (Exception e) {
            log.error("initHbaseTable error=========", e);
            e.printStackTrace();
        }

    }
    /**
     *
     * @param type all(全量)|delta（增量）
     * @return
     */
    private static Dataset<Row> readHbase(final String type) throws Exception{
        log.info("spark.sparkContext().defaultParallelism()=====" + spark.sparkContext().defaultParallelism());
        JavaSparkContext jsc = new JavaSparkContext(spark.sparkContext());//.addJar();

        JavaPairRDD<ImmutableBytesWritable, Result> javaPairRDD = jsc.newAPIHadoopRDD(hbaseConfig, TableInputFormat.class, ImmutableBytesWritable.class,
                Result.class);
        // 过滤hbase时间
        JavaPairRDD<ImmutableBytesWritable, Result> filterRDD = javaPairRDD.filter(new Function<Tuple2<ImmutableBytesWritable, Result>, Boolean>(){
            public Boolean call(Tuple2<ImmutableBytesWritable, Result> tuple2) throws Exception{
                Result result = tuple2._2();
                String id = new String(result.getValue(HBASE_COLUMN_NAME.getBytes(), "id".getBytes()));
                String content = new String(result.getValue(HBASE_COLUMN_NAME.getBytes(), "content".getBytes()));

                String publish_timestamp = new String(result.getValue(HBASE_COLUMN_NAME.getBytes(), "publish_timestamp".getBytes()));
                Long time = Long.valueOf(publish_timestamp);
                if(content == null || content.trim().equals("")){
                    return false;
                }
                if("all".equals(type) == true && (time > (System.currentTimeMillis() / 1000 - 60 * 60 * 24 * 365))){
                    return true;
                }
                // 增量数据
                else if("delta".equals(type) == true && (time > (System.currentTimeMillis() / 1000 - 60 * 60 * 24 * 7))){
                }
                return false;
            }
        });

        filterRDD = filterRDD.repartition(10);
        JavaRDD<MongoData> javaRdd = filterRDD.map(new Function<Tuple2<ImmutableBytesWritable, Result>, MongoData>() {
            public MongoData call(Tuple2<ImmutableBytesWritable, Result> tuple2) throws Exception{
                Result result = tuple2._2();
                String id = new String(result.getValue(HBASE_COLUMN_NAME.getBytes(), "id".getBytes()));
                String title = new String(result.getValue(HBASE_COLUMN_NAME.getBytes(), "title".getBytes()));
                String content = new String(result.getValue(HBASE_COLUMN_NAME.getBytes(), "content".getBytes()));
                String source = new String(result.getValue(HBASE_COLUMN_NAME.getBytes(), "source".getBytes()));
                String publish_timestamp = new String(result.getValue(HBASE_COLUMN_NAME.getBytes(), "publish_timestamp".getBytes()));
                String url = new String(result.getValue(HBASE_COLUMN_NAME.getBytes(), "url".getBytes()));
                String data_type = new String(result.getValue(HBASE_COLUMN_NAME.getBytes(), "data_type".getBytes()));
                String summary = new String(result.getValue(HBASE_COLUMN_NAME.getBytes(), "summary".getBytes()));

                MongoData mongoData = new MongoData();
                mongoData.setId(id);
                mongoData.setTitle(title);
                mongoData.setSource(source);
                mongoData.setSegment(content);
                mongoData.setPublish_timestamp(publish_timestamp);
                mongoData.setUrl(url);
                mongoData.setData_type(data_type);
                mongoData.setSummary(summary);
                return mongoData;
            }
        });

        Dataset<Row> dataset = spark.createDataFrame(
                javaRdd,
                MongoData.class
        );
        //dataset.show();
        return dataset;
    }


    private static Dataset<Row> tfidf(Dataset<Row> dataset) {
        Tokenizer tokenizer = new Tokenizer().setInputCol("segment").setOutputCol("words");
        Dataset<Row> wordsData = tokenizer.transform(dataset);
        //int numFeatures = 20;
        HashingTF hashingTF = new HashingTF()
                .setInputCol("words")
                .setOutputCol("rawFeatures");
        Dataset<Row> featurizedData = hashingTF.transform(wordsData);
        IDF idf = new IDF().setInputCol("rawFeatures").setOutputCol("features");
        IDFModel idfModel = idf.fit(featurizedData);
        Dataset<Row> rescaledData = idfModel.transform(featurizedData);
        return rescaledData;
    }

    public static void run(String type){
        initSpark(type);
        initHbaseTable();
        try{
            Dataset<Row> dataset = readHbase(type);
            Dataset<Row> tfidfDataset = tfidf(dataset);
            // 数据保存到hdfs, repartition(1)保存为一个文件
            tfidfDataset.select("title", "words", "rawFeatures", "features", "segment")
                    .repartition(1).write().text("hdfs://192.168.1.45:9000/tfidf");
        }
        catch(Exception e){
            log.error("数据出错===", e);
        }
    }

    public static void main(String... args) throws Exception {
        run("all");
//        run("delta");
    }
}

 

转载于:https://my.oschina.net/penngo/blog/842108

weixin_34238633
关注
python读取mongodb导入hbase
I_T_T_I的博客
05-20 158
# -*- coding: UTF-8 -*- # 获得编码格式 import chardet # 读取和打开url from urllib import request import requests import os # 关闭https证书验证 import ssl import time import json import pymysql import time import traceback from random import choice from bs4 import Beauti
mongoDB同步数据到Hbase
MrGrant.blog
04-23 5545
MongoDB作为一个适用于敏捷开发的数据库，MongoDB的数据模式可以随着应用程序的发展而灵活地更新。与此同时，它也为开发人员 提供了传统数据库的功能：二级索引，完整的查询系统以及严格一致性等等。 MongoDB能够使企业更加具有敏捷性和可扩展性，各种规模的企业都可以通过使用MongoDB来创建新的应用，提高与客户之间的工作效率，加快产品上市时间，以及降低企业成本。 MongoDB是专为可扩...
kettle MongoDB数据迁移至Hbase
weixin_62526435的博客
11-30 2491
本文使用kettle工具，实现 MongoDB数据迁移至Hbase
mongodb数据迁移到hbase
weixin_30838921的博客
09-03 496
mongodb数据迁移到hbase 导入包 # encoding: utf-8 ''' @author: zcc @license: (C) Copyright 2013-2017, Node Supply Chain Manager Corporation Limited. @software: pycharm @file: ggsn_to_hbase.py @time: 9/1/17 2:...
spark读取mongodb存入hbase
yrsg666的博客
05-29 467
https://blog.csdn.net/yangang1223/article/details/80051928#commentsedit
技术分享：基于HBase和Spark构建企业级数据处理平台
大数据Spark教程详解
02-10 542
基于HBase和Spark构建企业级数据处理平台,面临的场景:金融风控;个性化推荐；社交Feeds;时空时序以及大数据等。作者：大数据与机器学习 面临的场景 金融风控 用户画像库 爬虫抓取信息 反欺诈系统 订单数据 个性化推荐 用户行为分析 用户画像 推荐引擎 海量实时数据处理 社交Feeds 海量帖子、文章 聊天、评论 海量实时数据处理 时空时序 监控数...
基于HBase和Spark构建企业级数据处理平台
大数据基础入门教程
03-24 607
场景需求和挑战 面临的场景 金融风控 用户画像库 爬虫抓取信息 反欺诈系统 订单数据 个性化推荐 用户行为分析 用户画像 推荐引擎 海量实时数据处理 社交Feeds 海量帖子、文章 聊天、评论 海量实时数据处理 时空时序 监控数据 轨迹、设备数据 地理信息 ...
Spark+Cassandra实践：高性能数据分析平台构建
"许鹏分享了使用Spark+Cassandra构建高性能数据分析平台的第二部分，主要讨论spark-cassandra-connector的实现细节，聚焦于如何高效地从Cassandra读取大量数据到本地内存或磁盘。" 在大数据分析领域，Spark以其卓越...
Spark+Cassandra实践：高性能数据分析平台探索
面对实际工程中选择数据仓库的挑战，如HBase、MongoDB或Cassandra等，开发者需要根据具体业务需求和性能指标来决策。选择Cassandra可能是因为其在高并发读写和分布式存储上的优势。然而，实施过程中可能会遇到如数据...
mongo-all-hbase:Spark扫描mongo的库和表，将所有库下的所有表都全量写入hbase
05-03
本项目 "mongo-all-hbase" 提供了一个解决方案，使用 Apache Spark 来批量读取 MongoDB 中的所有数据库和集合，并将数据全量导入到 HBase 中。这个工具对于需要在大数据场景下进行数据迁移或整合的用户来说非常实用...
MapReduce-从HBase读取数据处理后再写入HBase
weixin_30902251的博客
09-28 266
MapReduce-从HBase读取处理后再写入HBase 代码如下 package com.hbase.mapreduce; import java.io.IOException; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.conf.Configured; import...
hadoop组件---面向列的开源数据库(四)---kettle抽入mongodb数据导入hbase
直到世界的尽头
03-14 3082
我们在前面的案例中已经使用kettle把数据导入到hive中。 本章我们来尝试把数据导入到hbase里。 参考链接: https://wiki.pentaho.com/display/BAD/Loading+Data+into+HBase kettle案例七连接hive–抽取mongodb的数据保存到hive 下载hadoop cluster配置文件 从服务器hadoop etc的配置...
spark读取mongodb数据
xubc的大数据笔记
06-26 1万+
val spark = SparkSession.builder .appName(this.getClass.getName().stripSuffix("$")) .getOrCreate() val df = spark.read.format("com.mongodb.spark.sql").options( Map
mongoDB+hive/hbase数据导入，Datax配置及脚本
HusbandWang的博客
06-25 5206
一、在对mongodb数据拉取过程中，发现md中存储的是一个个的集合，字段不固定，多的几十条，少的几条，这样再json配置时，会导致数据的匹配不对，有脏读，乱读等现象，下面把解决办法贴下，不到之处请谅解。    首先对于字段相对固定的，我采取的是mongodb-&gt;datax-&gt;hive的途径json配置：{ "job": { "setting": { "speed": { ...
spark从mongodb导入数据到hive
feng的博客
11-15 3911
1、首先添加mongo-spark依赖，官网地址 https://docs.mongodb.com/spark-connector/ org.mongodb.spark mongo-spark-connector_2.10 1.1.0 2、直接上代码 object Mongo2Hive {
kettle 把MongoDB数据迁移到hbase
weixin_40532625的博客
10-24 935
1.数据结构： MongoDB数据结构，需要把mongoDataList里的每一个dataIID转换为列名，列名的名称需要在SQL Server中进行查询。 2.问题： 因为每个存储内容名称一样，list中默认getfiled取到第一个内容，需要遍历 3.步骤 把list中的列都遍历出来 用遍历出来的列id在sqlserver中查询id对应的Name 把name赋值为列名，...
Mongodb 数据同步（和 hbase）
sun007700的专栏
02-13 431
MongoDB数据同步工具之 MongoShake mongoDB同步数据到Hbase https://blog.csdn.net/yangang1223/article/details/80051928
Hadoop与MongoDB整合（Hive篇）
热门推荐
光于前裕于后的博客
06-17 2万+
1.背景公司希望使用MongoDB作为后端业务数据库，使用Hadoop平台作为数据平台。最开始是先把数据从MongoDB导出来，然后传到HDFS，然后用Hive/MR处理。我感觉这也太麻烦了，现在不可能没有人想到这个问题，于是就搜了一下，结果真找到一个MongoDB Connector for Hadoop2.MongoDB简介–摘自邹贵金的《mongodb》一书NoSQL数据库与传统的关系型数据库
MongoDB中数据导入
世界那么大，我想去看看！
07-20 5338
MongoDB的数据导入MongoDB 是一款NoSql数据库，既然是数据库，那么就需要有数据来提供给我们使用，下面我们首先导入数据。导入数据MongoDB官方提供了示例数据库文件，我们就使用官方提供的数据，使用test数据库和restaurants集合。下面是restaurants集合中的一个示例文档：{ "address": { "building": "1007", "coord":
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值