Spark连接Mysql、Hive、HBase

最新推荐文章于 2022-10-29 11:25:08 发布
最新推荐文章于 2022-10-29 11:25:08 发布
阅读量509 收藏 5
点赞数 1
文章标签： spark mysql hive hbase
本文链接：https://blog.csdn.net/alisa_Ge/article/details/112427617
版权

本篇使用到的开发工具IntelliJ IDEA,jdk版本为：jdk1.8，虚拟机版本为CentOS 7，scala版本为：scala-2.11.12，Spark版本为spark-2.4.4-bin-hadoop2.6

MySQL版本为：5.6.50 MySQL Community Server (GPL)，hive版本为：hive-1.1.0-cdh5.14.2，HBase版本为：hbase-1.2.0-cdh5.14.2。

一、使用Spark连接Mysql

新建一个maven项目sparkConnect

在pom.xml文件中

<properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <scala.version>2.11.12</scala.version>
        <spark.version>2.4.4</spark.version>
    </properties>

    <repositories>
        <repository>
            <id>cloudera</id>
            <url>https://repository.cloudera.com/artifactory/cloudera-repos/</url>
        </repository>
    </repositories>

    <dependencies>
        <!--scala-->
        <dependency>
            <groupId>org.scala-lang</groupId>
            <artifactId>scala-library</artifactId>
            <version>${scala.version}</version>
        </dependency>

        <!-- spark-core -->
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-core_2.11</artifactId>
            <version>2.4.4</version>
        </dependency>

        <!-- spark-sql -->
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-sql_2.11</artifactId>
            <version>2.4.4</version>
        </dependency>

        <!-- spark-hive -->
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-hive_2.11</artifactId>
            <version>2.4.4</version>
        </dependency>

    <!-- spark-graphx -->
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-graphx_2.11</artifactId>
            <version>2.4.4</version>
        </dependency>

        <!-- mysql-connector-java JDBC驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.32</version>
        </dependency>



        <!-- log4j -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

        <!-- junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
        </dependency>


    </dependencies>


    <build>
        <plugins>
            <!--java打包插件-->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.2</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
                <executions>
                    <execution>
                        <phase>compile</phase>
                        <goals>
                            <goal>compile</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>

            <!--scala打包插件-->
            <plugin>
                <groupId>org.scala-tools</groupId>
                <artifactId>maven-scala-plugin</artifactId>
                <version>2.15.2</version>
                <executions>
                    <execution>
                        <id>scala-compile-first</id>
                        <goals>
                            <goal>compile</goal>
                        </goals>
                        <configuration>
                            <includes>
                                <include>**/*.scala</include>
                            </includes>
                        </configuration>
                    </execution>
                </executions>
            </plugin>

            <!--将依赖打入jar包-->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-assembly-plugin</artifactId>
                <version>2.6</version>
                <configuration>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                </configuration>
                <executions>
                    <execution>
                        <id>make-assembly</id>
                        <phase>package</phase>
                        <goals>
                            <goal>single</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

在resources目录中新建一个log4j.properties

log4j.rootLogger=WARN, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - %m%n
log4j.appender.logfile=org.apache.log4j.FileAppender
log4j.appender.logfile.File=target/spring.log
log4j.appender.logfile.layout=org.apache.log4j.PatternLayout
log4j.appender.logfile.layout.ConversionPattern=%d %p [%c] - %m%n

创建Spark2Mysql.scala

import java.util.Properties

import org.apache.spark.sql.{DataFrame, SparkSession}

object Spark2Mysql extends App {
  val spark: SparkSession = SparkSession.builder()
    .master("local")
    .appName(this.getClass.getName)
    .getOrCreate()
  val url = "jdbc:mysql://single:3306/school"
  val tableName = "score"
  val props = new Properties()

  //设置要访问的用户名，密码，及driver
  props.setProperty("user", "root")
  props.setProperty("password", "******")
  props.setProperty("driver", "com.mysql.jdbc.Driver")
  //通过spark.read.jdbc方法读取mysql中的数据
  val df1: DataFrame = spark.read.jdbc(url, tableName, props)
//  df1.show()
  //通过append追加方式，更新原表
  df1.write.mode("append").jdbc(url, tableName, props)
  //创建临时表score2,并使用spark.sql查询临时表中的数据
  df1.createOrReplaceTempView("score1")
  spark.sql("select * from score1").show()
}

运行结果如下：

二、Spark连接Hive

新建一个maven项目

在pom.xml文件中

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
    <hadoop.version>2.6.0-cdh5.14.2</hadoop.version>
    <hive.version>1.1.0-cdh5.14.2</hive.version>
    <hbase.version>1.2.0-cdh5.14.2</hbase.version>
    <scala.version>2.11.12</scala.version>
    <spark.version>2.4.4</spark.version>
  </properties>

  <repositories>
    <repository>
      <id>cloudera</id>
      <url>https://repository.cloudera.com/artifactory/cloudera-repos/</url>
    </repository>
  </repositories>

  <dependencies>
    <!--scala-->
    <dependency>
      <groupId>org.scala-lang</groupId>
      <artifactId>scala-library</artifactId>
      <version>${scala.version}</version>
    </dependency>

    <!-- spark-core -->
    <dependency>
      <groupId>org.apache.spark</groupId>
      <artifactId>spark-core_2.11</artifactId>
      <version>2.4.4</version>
    </dependency>

    <!-- spark-sql -->
    <dependency>
      <groupId>org.apache.spark</groupId>
      <artifactId>spark-sql_2.11</artifactId>
      <version>2.4.4</version>
    </dependency>

    <!-- spark-hive -->
    <dependency>
      <groupId>org.apache.spark</groupId>
      <artifactId>spark-hive_2.11</artifactId>
      <version>2.4.4</version>
    </dependency>

    <!-- mysql-connector-java -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.31</version>
    </dependency>

    <!-- spark-graphx -->
    <dependency>
      <groupId>org.apache.spark</groupId>
      <artifactId>spark-graphx_2.11</artifactId>
      <version>2.4.4</version>
    </dependency>


    <!-- hadoop -->
    <dependency>
      <groupId>org.apache.hadoop</groupId>
      <artifactId>hadoop-common</artifactId>
      <version>${hadoop.version}</version>
    </dependency>
    <dependency>
      <groupId>org.apache.hadoop</groupId>
      <artifactId>hadoop-client</artifactId>
      <version>${hadoop.version}</version>
    </dependency>
    <dependency>
      <groupId>org.apache.hadoop</groupId>
      <artifactId>hadoop-hdfs</artifactId>
      <version>${hadoop.version}</version>
    </dependency>

    <!-- log4j -->
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.17</version>
    </dependency>

    <!-- junit -->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
    </dependency>
  </dependencies>


  <build>
    <plugins>
      <!--java打包插件-->
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.2</version>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
          <encoding>UTF-8</encoding>
        </configuration>
        <executions>
          <execution>
            <phase>compile</phase>
            <goals>
              <goal>compile</goal>
            </goals>
          </execution>
        </executions>
      </plugin>

      <!--scala打包插件-->
      <plugin>
        <groupId>org.scala-tools</groupId>
        <artifactId>maven-scala-plugin</artifactId>
        <version>2.15.2</version>
        <executions>
          <execution>
            <id>scala-compile-first</id>
            <goals>
              <goal>compile</goal>
            </goals>
            <configuration>
              <includes>
                <include>**/*.scala</include>
              </includes>
            </configuration>
          </execution>
        </executions>
      </plugin>

      <!--将依赖打入jar包-->
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-assembly-plugin</artifactId>
        <version>2.6</version>
        <configuration>
          <descriptorRefs>
            <descriptorRef>jar-with-dependencies</descriptorRef>
          </descriptorRefs>
        </configuration>
        <executions>
          <execution>
            <id>make-assembly</id>
            <phase>package</phase>
            <goals>
              <goal>single</goal>
            </goals>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>

在resources目录下放入hive-site.xml文件

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<?xml-stylesheet type="text/xsl" href="configuration.xsl"?>
<configuration>
<property>
  <name>hive.metastore.warehouse.dir</name>
  <value>hdfs://single:9000/opt/software/hadoop/hive110/warehouse</value>
</property>
<property>
  <name>javax.jdo.option.ConnectionURL</name>
  <value>jdbc:mysql://192.168.153.130:3306/hive110?createDatabaseIfNotExist=true</value>
</property>
<property>
  <name>javax.jdo.option.ConnectionDriverName</name>
  <value>com.mysql.jdbc.Driver</value>
</property>
<property>
  <name>javax.jdo.option.ConnectionUserName</name>
  <value>root</value>
</property>
<property>
  <name>javax.jdo.option.ConnectionPassword</name>
  <value>root</value>
</property>
</configuration>

创建Spark2Hive.scala

import org.apache.spark.sql.SparkSession

object Spark2Hive extends App {
  val spark: SparkSession = SparkSession.builder()
    .master("local")
    .appName(this.getClass.getName)
    .enableHiveSupport()//开启hive支持
    .getOrCreate()

  //读取hive中数据表
  spark.sql("select * from exam.stu").show()
}

运行结果如下：

三、Spark连接HBase

新建一个maven项目。

在pom.xml中（这里需要强调的是<!-- spark-hbase -->两个依赖必须要放到最后，不然报错）

<?xml version="1.0" encoding="UTF-8"?>
<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/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>cn.alisa</groupId>
    <artifactId>sparkConnect</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <hadoop.version>2.6.0-cdh5.14.2</hadoop.version>
        <hive.version>1.1.0-cdh5.14.2</hive.version>
        <hbase.version>1.2.0-cdh5.14.2</hbase.version>
        <scala.version>2.11.12</scala.version>
        <spark.version>2.4.4</spark.version>
    </properties>

    <repositories>
        <repository>
            <id>cloudera</id>
            <url>https://repository.cloudera.com/artifactory/cloudera-repos/</url>
        </repository>
    </repositories>

    <dependencies>
        <!--scala-->
        <dependency>
            <groupId>org.scala-lang</groupId>
            <artifactId>scala-library</artifactId>
            <version>${scala.version}</version>
        </dependency>

        <!-- spark-core -->
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-core_2.11</artifactId>
            <version>2.4.4</version>
        </dependency>

        <!-- spark-sql -->
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-sql_2.11</artifactId>
            <version>2.4.4</version>
        </dependency>

        <!-- spark-hive -->
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-hive_2.11</artifactId>
            <version>2.4.4</version>
        </dependency>


        <!-- mysql-connector-java -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.31</version>
        </dependency>

        <!-- spark-graphx -->
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-graphx_2.11</artifactId>
            <version>2.4.4</version>
        </dependency>


        <!-- hadoop -->
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-common</artifactId>
            <version>${hadoop.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-client</artifactId>
            <version>${hadoop.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-hdfs</artifactId>
            <version>${hadoop.version}</version>
        </dependency>

        <!-- log4j -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

        <!-- junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
        </dependency>

        <!-- spark-hbase -->
        <dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-client</artifactId>
            <version>${hbase.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hbase</groupId>
            <artifactId>hbase-server</artifactId>
            <version>${hbase.version}</version>
        </dependency>

    </dependencies>


    <build>
        <plugins>
            <!--java打包插件-->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.2</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
                <executions>
                    <execution>
                        <phase>compile</phase>
                        <goals>
                            <goal>compile</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>

            <!--scala打包插件-->
            <plugin>
                <groupId>org.scala-tools</groupId>
                <artifactId>maven-scala-plugin</artifactId>
                <version>2.15.2</version>
                <executions>
                    <execution>
                        <id>scala-compile-first</id>
                        <goals>
                            <goal>compile</goal>
                        </goals>
                        <configuration>
                            <includes>
                                <include>**/*.scala</include>
                            </includes>
                        </configuration>
                    </execution>
                </executions>
            </plugin>

            <!--将依赖打入jar包-->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-assembly-plugin</artifactId>
                <version>2.6</version>
                <configuration>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                </configuration>
                <executions>
                    <execution>
                        <id>make-assembly</id>
                        <phase>package</phase>
                        <goals>
                            <goal>single</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

创建Spark2HBaseRead.scala文件

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.spark.SparkContext
import org.apache.spark.rdd.RDD
import org.apache.spark.sql.SparkSession
import org.apache.hadoop.hbase.util.Bytes

object Spark2HBase extends App {
  val spark: SparkSession = SparkSession.builder()
    .master("local")
    .appName(this.getClass.getName)
    .getOrCreate()

  //建立HBase的连接
  val conf: Configuration = HBaseConfiguration.create()
  conf.set("hbase.zookeeper.property.clientPort", "2181")//设置zookeeper client端口
  conf.set("hbase.zookeeper.quorum", "192.168.153.130") // 设置zookeeper quorum
  conf.set(TableInputFormat.INPUT_TABLE, "kb10:student")
  val sc: SparkContext = spark.sparkContext
  //读取数据并转化成rdd
  val HbaseRDD: RDD[(ImmutableBytesWritable, Result)] = sc.newAPIHadoopRDD(conf, classOf[TableInputFormat],
    classOf[ImmutableBytesWritable],
    classOf[Result])
  val count: Long = HbaseRDD.count()
  println(count)
  HbaseRDD.foreach({ case (_, result) => {
    //获取行键
    val key = Bytes.toString(result.getRow)
    //通过列族和列名获取列
    val name = Bytes.toString(result.getValue("basicinfo".getBytes, "name".getBytes))
    val age = Bytes.toString(result.getValue("basicinfo".getBytes, "age".getBytes))
    println("Row key:" + key + " Name:" + name + " Age:" + age)
  }}
  )
  sc.stop()

}

运行结果如下：

创建Spark2HBaseWrite.scala文件

import org.apache.hadoop.conf.Configuration
import org.apache.hadoop.hbase.HBaseConfiguration
import org.apache.hadoop.hbase.client.Put
import org.apache.hadoop.hbase.io.ImmutableBytesWritable
import org.apache.hadoop.hbase.mapred.TableOutputFormat
import org.apache.hadoop.hbase.mapreduce.TableInputFormat
import org.apache.hadoop.hbase.util.Bytes
import org.apache.hadoop.mapred.JobConf
import org.apache.spark.SparkContext
import org.apache.spark.rdd.RDD
import org.apache.spark.sql.SparkSession

object Spark2HBaseWrite extends App {
  val spark: SparkSession = SparkSession.builder()
    .master("local")
    .appName(this.getClass.getName)
    .getOrCreate()

  //建立HBase的连接
  val conf: Configuration = HBaseConfiguration.create()
  conf.set("hbase.zookeeper.property.clientPort", "2181") //设置zookeeper client端口
  conf.set("hbase.zookeeper.quorum", "192.168.153.130") // 设置zookeeper quorum
  val jobConf = new JobConf(conf)
  jobConf.setOutputFormat(classOf[TableOutputFormat])
  jobConf.set(TableOutputFormat.OUTPUT_TABLE, "kb10:student")
  val sc: SparkContext = spark.sparkContext
    //往HBase中插入两条数据
  val dataRDD: RDD[String] = sc.makeRDD(Array("1003,alisa,22", "1004,jason,34"))
  private val rdd: RDD[(ImmutableBytesWritable, Put)] = dataRDD.map(_.split(",")).map({ arr => {
    //  一个Put对象就是一行记录，在构造方法中指定主键
    //  所有插入的数据必须用org.apache.hadoop.hbase.util.Bytes.toBytes方法转换
    //Put.add方法接收三个参数：列族，列名，数据
    val put = new Put(Bytes.toBytes(arr(0)))
    put.add(Bytes.toBytes("basicinfo"), Bytes.toBytes("name"), Bytes.toBytes(arr(1)))
    put.add(Bytes.toBytes("basicinfo"), Bytes.toBytes("age"), Bytes.toBytes(arr(2)))
    //必须有这两个返回值，put为要传入的数据
    //转化成RDD[(ImmutableBytesWritable,Put)]类型才能调用saveAsHadoopDataset
    (new ImmutableBytesWritable, put)
  }
  })
  rdd.saveAsHadoopDataset(jobConf)
  sc.stop()
}

运行过Spark2HBaseWrite.scala文件后，执行Spark2HBaseRead运行结果如下：

榴芒姐姐
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
spark连接mysql，hbase
JamesBaiLove的博客
04-10 298
spark内存计算框架 RDD的创建方式 1、通过已经存在的scala集合去构建 val rdd1=sc.parallelize(List(1,2,3,4,5)) val rdd2=sc.parallelize(Array("hadoop","hive","spark")) val rdd3=sc.makeRDD(List(1,2,3,4)) 2、加载外部的数据源去构建 val rdd1=sc.textFile("/words.txt") 3、从已...
第4集-Hadoop环境搭建 - linux（centos7） - 安装配置mysql5.5.44.pdf
09-17
第4集-Hadoop环境搭建 - linux（centos7） - 安装配置mysql5.5.44.pdf
java 大数据 spark flink redis hive hbase kafka 面试题 数据结构 算法 设计模式.zip
最新发布
12-31
Java前后开发面试题，大厂进阶之路，基于JavaGuide、Cyc大佬、牛客上的面经及王道考研相关视频，并改进了其中说法矛盾或含糊之处。 包含计算机网络知识、JavaSE、JVM、Spring、Springboot、SpringCloud、Mybatis、多线程并发、netty、MySQL、MongoDB、Elasticsearch、Redis、HBASE
Spark与Mysql的交互
12-14
背景 　　Spark在对目标数据进行计算后，RDD格式的数据一般都会存在HDFS，Hive，HBase中，另一方面，对于非RDD格式的数据，可能会存放在像Mysql中这种传统的RDMS中. 　　但是写入过程中经常出现各种各样的问题， stackoverflow上有很多帖子: 　　Error writing spark dataframe to mysql table JDBC batch insert performance 　　还有些其他的贴 　　- Using Apache Spark and MySQL for Data Analysis 　　- spark 1.3.0 将d
hadoop搭建 zookeeper_hbase_hive_sqoop_mysql_spark_hdfs.doc
10-20
hadoop环境搭建，涉及zookeeper、hbase、hive、mysql、kafka等服务的搭建测试运用。
spark读取hbase数据，并使用spark sql保存到mysql
03-22
使用spark读取hbase中的数据，并插入到mysql中
Spark踩坑记——数据库（Hbase+Mysql）
weixin_30369087的博客
07-14 170
目录 前言 Spark Streaming持久化设计模式 DStreams输出操作 使用foreachRDD的设计模式 Spark访问Hbase Hbase通用连接类 Hbase输出操作 填坑记录 ...
Spark连接MySQL数据库
qq_44486439的博客
02-19 823
Spark连接MySQL数据库 环境 java 12.0.1 Spark version 3.0.0-preview2 Scala 2.12.10 Apache Maven 3.6.3 MySQL Server version: 5.7.18-20170830-log 20170531 mysql-connector-java-8.0.21.jar IntelliJ IDEA 2020.2.3 (Ultimate Edition) Maven配置文件 <?xml version="1.0" enco
spark hbase mysql_Spark读HBase写MySQL
weixin_39957186的博客
01-19 186
1Spark读HBaseSpark读HBase黑名单数据，过滤出当日新增userid，并与mysql黑名单表内userid去重后，写入mysql。def main(args: Array[String]): Unit = {@volatile var broadcastMysqlUserids: Broadcast[Array[String]] = nullval today = args(0)v...
mysql hbase交互_Spark 与 JDBC、Hbase之间的交互
weixin_31527905的博客
02-26 95
importjava.sql.DriverManagerimportorg.apache.spark.{SparkConf, SparkContext}/*** Author yangxu* Date 2020/5/9 10:43*/object JdbcWrite {val driver= "com.mysql.jdbc.Driver"val url= "jdbc:mysql://hadoop1...
Hadoop+Spark+Hive+HBase+Oozie+Kafka+Flume+Flink+ES+Redash等详细安装部署
06-22
1、内容概要：Hadoop+Spark+Hive+HBase+Oozie+Kafka+Flume+Flink+Elasticsearch+Redash等大数据集群及组件搭建指南（详细搭建步骤+实践过程问题总结）。 2、适合人群：大数据运维、大数据相关技术及组件初学者。 3、...
spark学习之maven导入依赖的一些问题
scfvlog的博客
10-29 2702
maven版本过高会无法导入部分scala的依赖，但也不必担心我们换一个版本即可，我这里用的maven仓库版本是3.8.6差不多是最新版的了（现在最新版本的是4.0了），刚开始导入依赖会出现很多问题，maven提示下载好了，但是依赖并没有导入进来导致jar还是不可用，所以这时候我们应该改变version才可以。解决方法：我们换一种方式去导入，把版本也换了，这个时候我们发现maven无法下载了。问题真的多，我去上网查了之后人家让加一个阿里云的依赖就好了，然后我加了最后就好了，下面是完成体。
Spark整合Hive
Nice的博客
09-18 429
Hive数据库 Apache Hive是Hadoop上的SQL引擎，Spark SQL编译时可以包含Hive支持，也可以不包含。包含Hive支持的Spark SQL可以支持Hive表访问、UDF(用户自定义函数)以及 Hive 查询语言(HiveQL/HQL)等。需要强调的 一点是，如果要在Spark SQL中包含Hive的库，并不需要事先安装Hive。一般来说，最好还是在编译Spark SQL时...
spark连接mysql
深海小黄鱼
03-14 1120
引入mysql的jar包 package com.agm.database import java.sql.DriverManager import org.apache.spark.SparkContext import org.apache.spark.rdd.JdbcRDD import org.apache.spark.SparkConf import org.
Spark Sql 详细介绍
GIS摆渡人
12-22 277
0. SparkSQL SparkSQL完全脱离了Hive的限制。 SparkSQL支持查询原生的RDD。 1. DataSet DataSet是分布式的数据集合。DataSet是在Spark1.6中添加的新的接口。它集中了RDD的优点（强类型和可以用强大lambda函数）以及Spark SQL优化的执行引擎。DataSet可以通过JVM的对象进行构建，可以用函数式的转换（map...
Spark——基于JDBC connector读写MySQL、Oracle、PostgreSQL、Greenplum
Carson073的博客
08-18 1923
在大数据开发场景中，数据同步有很多种工具可以实现，其中包括DataX、FlinkCDC、Spark、Canal、sqoop等等，这边文章主要是描述Spark做多种数据源的同步，原理是基于jdbc驱动。
spark hbase mysql_sparkSQL统计HBase表,写入mysql
weixin_42659196的博客
01-19 141
val hbaseConf = org.apache.hadoop.hbase.HBaseConfiguration.create()hbaseConf.set("hbase.zookeeper.quorum","s1sl11,s1ma11,s1sl22")hbaseConf.set("hbase.zookeeper.property.clientPort", "2181")hbaseConf.s...
SparkCore： RDD数据源[连接JDBC,Hadoop,Hbase]
04-23 4671
RDD数据源 普通文本文件 sc.textFile("./dir/*.txt") 如果传递目录，则将目录下的所有文件读取作为RDD。文件路径支持通配符。 但是这样对于大量的小文件读取效率并不高，应该使用wholeTextFiles def wholeTextFiles(path: String, minPartitions: Int = defaultMinPartitions): RDD[(...
Spark写入数据到hbase，本地idea运行
东城庞太师
09-17 524
废话不多说，上代码： package day02.com.toHbase import org.apache.hadoop.hbase.HBaseConfiguration import org.apache.hadoop.hbase.client.Put import org.apache.hadoop.hbase.io.ImmutableBytesWritable import org.apache.hadoop.hbase.mapred.TableOutputFormat import org.
spark sql与hive hbase mysql集成
03-16
Spark SQL可以与Hive、HBase和MySQL集成。 与Hive集成：Spark SQL可以通过HiveContext连接到Hive，使用Hive的元数据和查询语言。这样可以在Spark中使用Hive表和查询，同时也可以在Hive中使用Spark SQL的功能。 与HBase集成：Spark SQL可以通过HBase数据源连接到HBase，读取和写入HBase表。这样可以在Spark中使用HBase表，同时也可以在HBase中使用Spark SQL的功能。 与MySQL集成：Spark SQL可以通过JDBC连接到MySQL，读取和写入MySQL表。这样可以在Spark中使用MySQL表，同时也可以在MySQL中使用Spark SQL的功能。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值