Scala的各种工具类

最新推荐文章于 2024-07-17 17:32:50 发布
最新推荐文章于 2024-07-17 17:32:50 发布
阅读量311 收藏 1
点赞数 1
文章标签： scala
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_66455465/article/details/130020017
版权

1.落地到Clickhouse

import com.bawei.operators4.STest
import org.apache.flink.configuration.Configuration
import org.apache.flink.streaming.api.functions.sink.{RichSinkFunction, SinkFunction}
import org.apache.flink.streaming.api.scala._

import java.sql.{Connection, DriverManager, PreparedStatement}

object SinkToClickhouse {
  def main(args: Array[String]): Unit = {
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)
    val stream: DataStream[String] = env.socketTextStream("hdp1", 9999)
    val mapDS: DataStream[STest] = stream.map(x => {
      val li: Array[String] = x.split(",")
      STest(li(0), li(1), li(2).trim.toInt, li(3).trim.toLong)
    })

    mapDS.addSink(new ClickhouseSinkFunction)
    
    env.execute()

  }
}

class ClickhouseSinkFunction extends RichSinkFunction[STest]{
  var conn: Connection = null
  var ps: PreparedStatement = null
  //打开资源创建链接
  override def open(parameters: Configuration): Unit = {
    Class.forName("ru.yandex.clickhouse.ClickHouseDriver")
    conn = DriverManager.getConnection("jdbc:clickhouse://hdp1:8123", "default", "")
    ps = conn.prepareStatement("insert into t_score values (?,?,?,?)")
  }

  //关闭资源
  override def close(): Unit = {
    ps.close()
    conn.close()
  }

  override def invoke(value: STest, context: SinkFunction.Context): Unit = {
    ps.setString(1,value.name)
    ps.setString(2,value.subject)
    ps.setInt(3,value.score)
    ps.setLong(4,value.ts)
    ps.executeUpdate()
  }
}

2.落地到File

import org.apache.flink.api.common.serialization.{SimpleStringEncoder, SimpleStringSchema}
import org.apache.flink.core.fs.Path
import org.apache.flink.streaming.api.functions.sink.filesystem.StreamingFileSink
import org.apache.flink.streaming.api.functions.sink.filesystem.rollingpolicies.DefaultRollingPolicy
import org.apache.flink.streaming.api.scala.{DataStream, StreamExecutionEnvironment}
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaProducer

import java.util.Properties
import java.util.concurrent.TimeUnit

object SinkToFile {
  def main(args: Array[String]): Unit = {
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)
    val stream: DataStream[String] = env.socketTextStream("hdp1", 9999)
    //将stream落地到file
    /*val sink: StreamingFileSink[String] = StreamingFileSink
      .forRowFormat(new Path("result/sink"), new SimpleStringEncoder[String]("UTF-8"))
      .withRollingPolicy(
        DefaultRollingPolicy.builder()
          .withRolloverInterval(TimeUnit.SECONDS.toMillis(15))
          .withInactivityInterval(TimeUnit.SECONDS.toMillis(5))
          .withMaxPartSize(1024 * 1024 * 1024)
          .build())
      .build()
    stream.addSink(sink)*/
    stream.writeAsText("result2/sink")

    env.execute()

  }
}

3.落地到Hbase

import org.apache.flink.api.common.serialization.SimpleStringSchema
import org.apache.flink.configuration.Configuration
import org.apache.flink.streaming.api.functions.sink.{RichSinkFunction, SinkFunction}
import org.apache.flink.streaming.api.scala.{DataStream, StreamExecutionEnvironment}
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaProducer
import org.apache.hadoop.hbase.{HBaseConfiguration, TableName}
import org.apache.hadoop.hbase.client.{Connection, ConnectionFactory, Put, Table}
import org.apache.hadoop.hbase.util.Bytes

import java.util.{Date, Properties}

object SinkToHbase {
  def main(args: Array[String]): Unit = {
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)
    val stream: DataStream[String] = env.socketTextStream("hdp1", 9999)
    //将stream落地到kafka


    stream.addSink(new HbaseSink)
    
    env.execute()

  }
}

//create 't_result','info'
class HbaseSink extends RichSinkFunction[String]{
  var connection: Connection = null

  override def open(parameters: Configuration): Unit = {
    val config = HBaseConfiguration.create
    config.set("hbase.zookeeper.quorum", "hdp1")
    connection = ConnectionFactory.createConnection(config)
  }

  override def close(): Unit = {
    connection.close()
  }

  override def invoke(value: String, context: SinkFunction.Context): Unit = {
    //"hello kitty"
    //"hello snoopy"
    //"hello a a"
    //put 't_result','时间戳+hello kitty','info:line','hello kitty'
    val t_stu: Table = connection.getTable(TableName.valueOf("t_result"))
    val put: Put = new Put(Bytes.toBytes(new Date().getTime+value))
    put.addColumn(Bytes.toBytes("info"), Bytes.toBytes("line"), Bytes.toBytes(value))
    t_stu.put(put)
  }
}

4.落地到Kafka

import org.apache.flink.api.common.serialization.SimpleStringSchema
import org.apache.flink.streaming.api.scala.{DataStream, StreamExecutionEnvironment}
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaProducer

import java.util.Properties

object SinkToKafka {
  def main(args: Array[String]): Unit = {
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)
    val stream: DataStream[String] = env.socketTextStream("hdp1", 9999)
    //将stream落地到kafka
    val properties = new Properties
    properties.setProperty("bootstrap.servers", "hdp1:9092")
    val myProducer = new FlinkKafkaProducer[String]("test", new SimpleStringSchema(),  properties)

    stream.addSink(myProducer)
    
    env.execute()

  }
}

5.落地到Mysql

import org.apache.flink.api.common.serialization.SimpleStringSchema
import org.apache.flink.configuration.Configuration
import org.apache.flink.streaming.api.functions.sink.{RichSinkFunction, SinkFunction}
import org.apache.flink.streaming.api.scala._
import org.apache.flink.streaming.api.windowing.assigners.TumblingProcessingTimeWindows
import org.apache.flink.streaming.api.windowing.time.Time
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaProducer

import java.sql.{Connection, DriverManager, PreparedStatement}
import java.util.Properties

object SinkToMysql {
  def main(args: Array[String]): Unit = {
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)
    val stream: DataStream[String] = env.socketTextStream("hdp1", 9999)
    //将stream落地到kafka
    val counts = stream.flatMap {_.toLowerCase.split("\\W+") filter {_.nonEmpty}}
      .map {(_, 1)}
      .keyBy(_._1)
      .window(TumblingProcessingTimeWindows.of(Time.seconds(5)))
      .sum(1)
    counts.addSink(new MysqlSink)

    env.execute()

  }
}

class MysqlSink extends RichSinkFunction[(String,Int)]{

  var conn: Connection = null
  var ps: PreparedStatement = null

  //打开资源创建链接
  override def open(parameters: Configuration): Unit = {
    Class.forName("com.mysql.jdbc.Driver")
    conn = DriverManager.getConnection("jdbc:mysql://hdp1:3306/mydb?characterEnCoding=utf8", "root", "root")
    ps = conn.prepareStatement("insert into t_wc values(?,?)")
  }
  //关闭资源
  override def close(): Unit = {
    ps.close()
    conn.close()
  }

  //拿到流中的每一条数据，将数据保存到指定位置
  override def invoke(value: (String, Int), context: SinkFunction.Context): Unit = {
    ps.setString(1,value._1)
    ps.setInt(2,value._2)
    ps.executeUpdate()
  }
}

6.从Clickhouse读取

import org.apache.flink.configuration.Configuration
import org.apache.flink.streaming.api.functions.source.{RichSourceFunction, SourceFunction}
import org.apache.flink.streaming.api.scala._

import java.sql.{Connection, DriverManager, PreparedStatement, ResultSet}

object SourceFromClickhouse {
  def main(args: Array[String]): Unit = {
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)
    //1、读取clickhouse数据
    val stream: DataStream[(String, Int)] = env.addSource(new ClickhouseSourceFunction)
    stream.print()
    //2、输出数据内容
    env.execute()
  }
}

class ClickhouseSourceFunction extends RichSourceFunction[(String,Int)] {
  var conn: Connection = null
  //打开资源创建链接
  override def open(parameters: Configuration): Unit = {
    Class.forName("ru.yandex.clickhouse.ClickHouseDriver")
    conn= DriverManager.getConnection("jdbc:clickhouse://hdp1:8123", "default", "")
  }
  //关闭资源
  override def close(): Unit = {
    conn.close()
  }
  //执行数据查询等
  override def run(sourceContext: SourceFunction.SourceContext[(String, Int)]): Unit = {
    val ps: PreparedStatement = conn.prepareStatement("select * from t_student")
    val rs: ResultSet = ps.executeQuery()
    while (rs.next()){
      val name: String = rs.getString("name")
      val age: Int = rs.getInt("age")
      sourceContext.collect((name,age))
    }
  }
  override def cancel(): Unit = ???
}

7.从Hbase读取

import org.apache.flink.configuration.Configuration
import org.apache.flink.streaming.api.functions.source.{RichSourceFunction, SourceFunction}
import org.apache.flink.streaming.api.scala._
import org.apache.hadoop.hbase.{Cell, CellUtil, HBaseConfiguration, TableName}
import org.apache.hadoop.hbase.client.{Connection, ConnectionFactory, Result, ResultScanner, Scan, Table}
import org.apache.hadoop.hbase.util.Bytes

import java.util
import java.util.List

object SourceFromHbase {
  def main(args: Array[String]): Unit = {
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)
    val stream: DataStream[String] = env.addSource(new HbaseSource)
    stream.print()
    env.execute()
  }
}

class HbaseSource extends RichSourceFunction[String] {

  var connection: Connection = null
  override def open(parameters: Configuration): Unit = {
    val config  = HBaseConfiguration.create
    config.set("hbase.zookeeper.quorum", "hdp1")
    connection = ConnectionFactory.createConnection(config)
  }

  override def close(): Unit = {
    connection.close()
  }

  override def run(sourceContext: SourceFunction.SourceContext[String]): Unit = {
    val t_stu: Table = connection.getTable(TableName.valueOf("t_stu"))
    val scan: Scan = new Scan
    val scanner: ResultScanner = t_stu.getScanner(scan)
    var result: Result = scanner.next
    while ( {
      result != null
    }) { //外层遍历行
      val cells: util.List[Cell] = result.listCells
      import scala.collection.JavaConversions._
      for (c <- cells) { //内层遍历单元格
        val rk: String = Bytes.toString(CellUtil.cloneRow(c))
        val f: String = Bytes.toString(CellUtil.cloneFamily(c))
        val q: String = Bytes.toString(CellUtil.cloneQualifier(c))
        val v: String = Bytes.toString(CellUtil.cloneValue(c))
        sourceContext.collect(rk + "," + f + "," + q + "," + v)
      }
      result = scanner.next
    }
  }

  override def cancel(): Unit = ???
}

8.从Kafkka读取

import org.apache.flink.api.common.serialization.SimpleStringSchema
import org.apache.flink.streaming.api.scala._
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaConsumer

import java.util.Properties

object SourceFromKafka {
  def main(args: Array[String]): Unit = {
    //1、获取（创建）流处理执行环境
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)
    //2、通过流处理环境对象来获取数据源
    val properties = new Properties()
    properties.setProperty("bootstrap.servers", "hdp1:9092")
    properties.setProperty("group.id", "group1")
    val stream = env
      .addSource(new FlinkKafkaConsumer[String]("test", new SimpleStringSchema(), properties))
    //3、数据转换分析 略
    //4、数据落地
    stream.print()
    //5、提交执行
    env.execute()
  }
}

9.从Mysql读取

import org.apache.flink.configuration.Configuration
import org.apache.flink.streaming.api.functions.source.{RichSourceFunction, SourceFunction}
import org.apache.flink.streaming.api.scala._

import java.sql.{Connection, DriverManager, PreparedStatement, ResultSet}

object SourceFromMysql {
  def main(args: Array[String]): Unit = {
    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)
    //1、读取mysql数据
    //val stream: DataStream[String] = env.addSource(new UDFSourceFunction)
    val stream: DataStream[(String, Int)] = env.addSource(new MysqlSourceFunction)
    stream.print()
    //2、输出数据内容
    env.execute()
  }
}

/*
class UDFSourceFunction extends SourceFunction[String] {
  override def run(sourceContext: SourceFunction.SourceContext[String]): Unit = {
    for(i<- 0.to(10)){
      sourceContext.collect("xiaoming"+i)
    }
  }
  override def cancel(): Unit = ???
}*/
class MysqlSourceFunction extends RichSourceFunction[(String,Int)] {
  var conn: Connection = null
  //打开资源创建链接
  override def open(parameters: Configuration): Unit = {
    Class.forName("com.mysql.jdbc.Driver")
    conn= DriverManager.getConnection("jdbc:mysql://hdp1:3306/mydb?characterEnCoding=utf8", "root", "root")
  }
  //关闭资源
  override def close(): Unit = {
    conn.close()
  }
  //执行数据查询等
  override def run(sourceContext: SourceFunction.SourceContext[(String, Int)]): Unit = {
    val ps: PreparedStatement = conn.prepareStatement("select * from t_student")
    val rs: ResultSet = ps.executeQuery()
    while (rs.next()){
      val name: String = rs.getString("name")
      val age: Int = rs.getInt("age")
      sourceContext.collect((name,age))
    }
  }
  override def cancel(): Unit = ???
}

大数据盼盼
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
scala连接mysql工具类_scala 封装jdbc的常用操作，自动关闭数据库的连接资源
weixin_42566451的博客
01-25 312
Scala中貌似没有try-with的概念，在Java中则可以使用try-with自动释放连接资源，如：输入输出流、数据库连接。在Scala中如果想要实现自动释放数据库的连接资源时，需要自己封装。借鉴网上大神的博客，给大家分享一下我自己的Scala jdbc操作工具类。case class CloseAble[A def map[B](f: A => B): B =try f(a)final...
Scala 操作Redis使用连接池工具类RedisUtil
08-25
Scala 操作Redis使用连接池工具类RedisUtil 在 Scala 中操作 Redis 时，连接池工具类 RedisUtil 是非常重要的。下面我们将详细介绍 RedisUtil 的使用方法和实现原理。 首先，我们需要了解什么是 Redis。Redis 是一...
JDBC方式连接MySQL、Oracle、Hive、Spark等，通用工具类（Scala版）
GulfMoon
08-14 1888
通过JDBC方式连接MySQL、Oracle、Hive、Spark等数据库，对返回的结果进行处理，方便后续使用；在创建连接时使用了池化技术，保证高效。
scala 常用工具类整理
kk阿彬
06-27 753
scala 常用工具类整理 一共分为：DateUtils NumberUtils ParamsUtils StringUtils ValidUtils package commons.utils import java.text.SimpleDateFormat import java.util.{Calendar, Date} import net.sf.json.JSONObject import org.joda.time.DateTime import org.joda.time.format.Da
scala-jdbc连接池和工具类
program哲学
01-28 2935
连接池 import java.sql.{Connection, DriverManager} import java.util.{LinkedList, ResourceBundle} import org.apache.spark.Logging /** * 数据库连接池工具类 * Created by EX-ZHANGYONGTIAN001 on 2018-12-18. */...
scala中使用自己封装的工具类
csdncjh的博客
11-02 4014
需求：用scala代码，在hbase中做条件查询 scala中使用自己封装的工具类 object SparkHBase2 { def main(args: Array[String]): Unit = { val table=HBaseTools.openTable("t_prod_weixin_art"); val rows=HBaseTools.scanValueDa
Scala自定义MEID效验工具类
L, there!
07-10 329
import java.util.regex.Pattern import java.util.zip.CRC32 object MeidUtils { /** * 将字符串转换成为Int类型 * @param s str * @return Int */ def parseInt(s:String):Int={ try { s.i...
scala 项目构建工具
08-09
在 Scala 中，SBT（Simple Build Tool）是默认的项目构建工具，它使得构建、管理和打包 Scala 和 Java 项目变得简单易行。本主题将深入探讨 Scala 项目构建工具 SBT，特别是关于版本 0.13.12 的使用。 SBT 0.13.12 ...
WebSocket 常用工具类
04-18
因此，开发者通常会使用现成的WebSocket库或工具类来简化工作。在这个压缩包中包含的"websocket-sharp.dll"是一个针对.NET Framework的WebSocket库，它为C#开发者提供了一个方便的WebSocket客户端和服务器实现。 **...
intellij的scala工具bin文件
07-12
"intellij的scala工具bin文件"是指IntelliJ IDEA中用于支持Scala编程语言的特定二进制工具集合。 Scala是一种强大的静态类型编程语言，它融合了面向对象和函数式编程的特性，被广泛应用于大数据处理领域，特别是...
这些年整理的一些常用Utils工具类 , 希望对大家开发有所裨益
08-31
各种各样的工具 , 总有一个适合你 , 常用Utils工具类 , 希望对大家开发有所裨益 . 佛祖保佑 , 没有bug
Scala开发规范_最新版本
08-09
- Scala鼓励使用case类，它们提供了简洁的语法和默认的equals、hashCode和toString实现。 - 优先使用对象而不是静态方法，以支持面向对象设计原则。 - 抽象类和接口通过trait实现，trait可以多重继承。 5. **...
scala连接mysql工具类_【Scala】Scala使用scalikejdbc工具连接MySQL(推荐)
weixin_33539366的博客
01-25 121
package com.ruozeimport scalikejdbc._import scalikejdbc.config._object ScalalikeJdbc{def main(args:Array[String]):Unit = {//默认加载db.default.*配置信息DBs.setupAll()1.通过scalikejdbc查询user表所有的数据,封装进对象中val memb...
scala调用jdbc连接数据库
梦里花落的博客
09-07 3509
from：http://mkaz.com/solog/scala/using-scala-with-jdbc-to-connect-to-mysql.html Using Scala with JDBC to connect to MySQL Date: May 27, 2011 A howto on connecting Scala to a MySQL database us
Scala JDBC 操作 Mysql
热门推荐
小杨的技术博客
03-28 2万+
文章目录表结构依赖代码MysqlConnectCRUD测试参考 表结构 CREATE TABLE `scala_jdbc_test` ( `id` int(10) unsigned NOT NULL AUTO_INCREMENT, `name` varchar(32) COLLATE utf8mb4_unicode_ci DEFAULT NULL, `age` tinyint(1) D...
1.scala安装及开发工具IDEA配置scala环境
每天进步一点点
01-13 1万+
因为scala是运行在JVM平台上的，所以安装Scala之前要安装JDK，注意版本是：jdk1.8 1. scala安装： 1.1 windows上安装scala： 访问Scala官网http://www.scala-lang.org/下载Scala编译器安装包，目前最新版本是2.12.x，但是目前大多数的框架都是用2.11.x编写开发的，Spark2.x使用的就是2.11.x，所以这里推荐...
Flink中richfunction的一点小作用
a6822342的博客
10-12 1万+
①传递参数 所有需要用户定义的函数都可以转换成richfunction，例如实现map operator中你需要实现一个内部类，并实现它的map方法：data.map (new MapFunction<String, Integer>() { public Integer map(String value) { return Integer.parseInt(value); } });然后我们
Flink算子之RichParallelSourceFunction、RichSourceFunction因数据源不同，存在的差异
为一个人走几座城
03-12 2723
两套代码流程，完全一样。但是在读取到同样的数据后，数据返回给addSource算子后，通过transform算子后，继承RichSourceFunction的消息会出现丢失。 但是是区分数据源的，MySQL就没有类似的情况，但是Elasticsearch就会出现。 public class ElasticSource extends RichParallelSourceFunction<String>/RichSourceFunction { @Override pub.
Scala学习笔记18: Either 类型
最新发布
Taerge0110的博客
07-17 355
Either类型为 Scala 开发者提供了一种更优雅、更安全的方式来处理可能失败的操作;它鼓励开发在代码中显式地处理成功和失败两种情况, 从而提高代码的健壮性和可读性 .
Scala编程实战：Scala Cookbook
作者 Alvin Alexander 是一位知名的软件开发者和作家，他在书中详细介绍了 Scala 的各种技术和最佳实践。 本书涵盖了广泛的 Scala 知识点，包括但不限于： 1. **基础语法**：讲解 Scala 的基本数据类型，如整型、...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值