大数据学习day17------第三阶段-----scala05------1.Akka RPC通信案例改造和部署在多台机器上 2. 柯里化方法 3. 隐式转换 4 scala的泛型

时间:2023-08-12 16:36:02

1.Akka RPC通信案例改造和部署在多台机器上

 1.1 Akka RPC通信案例的改造(主要是把一些参数不写是)

Master

package com._51doit.akka.rpc

import akka.actor.{Actor, ActorRef, ActorSystem, Props}
import com.typesafe.config.ConfigFactory import scala.concurrent.duration._
import scala.collection.mutable // Actor编程模型进行通信,需要让其与AKKA发生点关系(此处实现Actor特质)
class Master extends Actor {
// 定义一个map,用来接收数据
val id2Worker = new mutable.HashMap[String, WorkerInfo]() // 在preStart中启动定时器,定期检查超超时的Worker,然后剔除
override def preStart(): Unit = {
import context.dispatcher context.system.scheduler.schedule(0 millisecond, 10000 millisecond, self, CheckTimeOutWorker)
} override def receive: Receive = {
// Master匹配并接收Worker发送过来的注册消息
case RegisterWorker(id, memory, cores) => {
//将数据封装起来,保存到内存中
val workerInfo: WorkerInfo = new WorkerInfo(id, memory, cores)
id2Worker(id) = workerInfo
//向Worker反馈一个注册成功的消息
sender() ! RegisteredWorker
}
// Master匹配并接收Worker发送过来的心跳汇报消息
case Heartbeat(workerId) => {
// 根据workId去map中查找相对应的WorkerInfo
if (id2Worker.contains(workerId)) {
//根据ID取出WorkerInfo
val workerInfo = id2Worker(workerId)
//获取当前时间
val currentTime = System.currentTimeMillis()
//更新最近一次心跳时间
workerInfo.lastUpdateTime = currentTime
}
}
// 匹配定时器发送的内容,用于提出超时的worker
case CheckTimeOutWorker => {
val currentTime = System.currentTimeMillis()
// 取出map中的值,并计算出超时的worker
val values: Iterable[WorkerInfo] = id2Worker.values
val deadWorkers: Iterable[WorkerInfo] = values.filter(value => currentTime - value.lastUpdateTime > 10000)
// 移除所有超时的worker
deadWorkers.foreach(dw => id2Worker -= dw.id)
println("current alive worker is : " + id2Worker.size)
}
}
} object Master {
val MASTER_ACTOR_SYSTEM = "MASTER_ACTOR_SYSTEM"
val MASTER_ACTOR = "MASTER_ACTOR" def main(args: Array[String]): Unit = {
val host = args(0)
val port = args(1).toInt
val configStr =
s"""
|akka.actor.provider = "akka.remote.RemoteActorRefProvider" // 负责通信的核心类,有必要可以自己定义
|akka.remote.netty.tcp.hostname = "$host"
|akka.remote.netty.tcp.port = "$port"
""".stripMargin // 此方法负责切割
val conf = ConfigFactory.parseString(configStr)
val actorSystem = ActorSystem.apply(MASTER_ACTOR_SYSTEM, conf)
// 通过ActorSystem对象创建Actor(通过反射指定特定类型的Actor实例)
val masterActor: ActorRef = actorSystem.actorOf(Props[Master], name = MASTER_ACTOR) }
}

Worker

package com._51doit.akka.rpc

import java.util.UUID

import akka.actor.{Actor, ActorRef, ActorSelection, ActorSystem, Props}
import com.typesafe.config.ConfigFactory
import scala.concurrent.duration._ /**
* Worker Actor最好在构造方法执行之后,receive方法之前,向Master建立连接
*/
class Worker(val masterHost: String, val masterPort: Int, val memory: Int, val cores: Int) extends Actor {
var masterRef: ActorSelection = _ val WORKER_ID: String = UUID.randomUUID().toString
val HEARTBEAT_INTERVAL: Int = 5000
// 生命周期方法(一定并且按一定顺序执行的方法)
// 在构造方法之后,receive方法之前,执行一次preStart
override def preStart(): Unit = {
// Worker向Master建立网络连接,得到一个master代理对象
masterRef = context.actorSelection(s"akka.tcp://${Master.MASTER_ACTOR_SYSTEM}@$masterHost:$masterPort/user/${Master.MASTER_ACTOR}")
println(s"akka.tcp://${Master.MASTER_ACTOR_SYSTEM}@masterHost:masterPort/user/${Master.MASTER_ACTOR}")
// //Worker向Master发送注册的信息
masterRef ! RegisterWorker(WORKER_ID, memory, cores)
}
// 重写用于接收消息的方法
override def receive: Receive = {
//Master反馈给Worker的消息
case RegisteredWorker => { //导入隐式转换
import context.dispatcher
//启动一个定时器,定期向Master发送心跳,使用Akka框架封装的定时器
//定期给自己发送消息,然后再给Master发送心跳
//参数依次为第一次的延迟时间,多少时间执行一次,消息发送给谁(此处找不到master,发送给masterRef代理对象也不行,),发送的消息
context.system.scheduler.schedule(0 millisecond, HEARTBEAT_INTERVAL millisecond, self, SendHeartbeat)
}
//自己给自己发送的消息
case SendHeartbeat => { //可以进行一些逻辑判断
//向Master发送心跳消息
masterRef ! Heartbeat(WORKER_ID)
}
}
} object Worker{
val WORKER_ACTOR_SYSTEM = "WORKER_ACTOR_SYSTEM"
val WORKER_ACTOR = "WORKER_ACTOR" def main(args: Array[String]): Unit = {
val masterHost = args(0)
val masterPort = args(1).toInt
val workerHost = args(2)
val workerPort = args(3).toInt
val memory = args(4).toInt
val cores = args(5).toInt
val configStr =
s"""
|akka.actor.provider = "akka.remote.RemoteActorRefProvider" // 负责通信的核心类,有必要可以自己定义
|akka.remote.netty.tcp.hostname = "$workerHost"
|akka.remote.netty.tcp.port = "$workerPort"
""".stripMargin // 此方法负责切割
val conf = ConfigFactory.parseString(configStr)
val workerActorSystem = ActorSystem(WORKER_ACTOR_SYSTEM, conf)
val workerActor: ActorRef = workerActorSystem.actorOf(Props(new Worker(masterHost,masterPort,memory,cores)), name = WORKER_ACTOR) }
}

此处自己犯的错误:创建与master的连接时忘了加符号(s   $), 以下是自己写的

"akka.tcp://${Master.MASTER_ACTOR_SYSTEM}@masterHost:masterPort/user/${Master.MASTER_ACTOR}"

正确的

 masterRef = context.actorSelection(s"akka.tcp://${Master.MASTER_ACTOR_SYSTEM}@$masterHost:$masterPort/user/${Master.MASTER_ACTOR}")

1.2 将上述代码部署到多台机器上

 1.2.1  打包

 (1)第一种方法:指定main方法的形式

在pom.xml文件中指定,如下

大数据学习day17------第三阶段-----scala05------1.Akka RPC通信案例改造和部署在多台机器上 2. 柯里化方法 3. 隐式转换 4 scala的泛型

打包步骤:直接双击如下图中的package即可

大数据学习day17------第三阶段-----scala05------1.Akka RPC通信案例改造和部署在多台机器上 2. 柯里化方法 3. 隐式转换 4 scala的泛型

akka-rpc-1.0-SNAPSHOT.jar中是既包括了自己写的代码,也包括了需要的一些依赖包(正是我们需要的jar包),而另一个jar包只包括自己写的代码

打包的包名如上表所示是pom.xml中定义了(如下图),默认是打的包为jar

大数据学习day17------第三阶段-----scala05------1.Akka RPC通信案例改造和部署在多台机器上 2. 柯里化方法 3. 隐式转换 4 scala的泛型

由于一个面方法只能运行一次,但worker和master都要运行,所以需要将pom.xml文件中的main方法分别改为worker和master进行打包,这正是这种方法的缺点,麻烦

分别将jar包拖至桌面,运行命令以及结果如下

大数据学习day17------第三阶段-----scala05------1.Akka RPC通信案例改造和部署在多台机器上 2. 柯里化方法 3. 隐式转换 4 scala的泛型

(2)第二种方法:不指定main方法的形式(pom文件中不指定main方法)

打包形式一样,只是运行的命令变了,运行命令和运行结果如下:

大数据学习day17------第三阶段-----scala05------1.Akka RPC通信案例改造和部署在多台机器上 2. 柯里化方法 3. 隐式转换 4 scala的泛型

这样便能部署到多台机器上去(此处自己没有用多台机器,但只要ip改变下就行,)

 2. 柯里化方法

  定义一个方法,可以有多个括号传递参数,这样的方法叫做柯里化方法。单存的使用柯里化方法没什么意义,其是为了结合隐式转换使用的

object KeLiDemo extends App {
// 正常定义方法
def m(x: Int, y: Int) = {
x + y
}
println(m(1,2))
//柯里化方法
def kl(x: Int)(y: Int): Int ={
x + y
}
println(kl(1)(3))
val f = kl(8) _ // f = (y: Int) => 8+y
println(f) // function1,若柯里化方法第二课括号是2个参数,则此处就为function2
}

3 隐式转换

3.1 铺垫 

(1)柯里化方法使用参数的默认值的时候,这个参数一定要被implicit修饰,普通方法则不需要

object ImplicitValueDemo extends App {
//定义普通的方法,传递普通的参数,可以使用,不用定义成implicit的参数
def m1(x: Int = 8): Int = { // 传递一个默认值,若没有传入参数,则方法使用默认值
x * x
}
//普通方法可以使用implicit修饰的默认值,但不能使用执行环境中的implicit的值(见(2))
def m2(implicit x: Int = 8): Int = {
x * x
}
// 柯里化方法,后面的括号参数有默认值(普通默认值),不能使用
def kl(x: Int)(y: Int=8): Int ={
x + y
}
// 柯里化结合隐式值(被implicit修饰的参数)
def kl2(x: Int)(implicit y: Int=8): Int ={
x + y
}
println(m1(2)) // 4
println(m2()) // 64
// 这样会报错,柯里化方法中普通的默认值不能使用
// println(kl(2)) // 报缺少参数的错
println(kl2(2)) //10
}

(2)柯里化结合隐式参数传参

  scala的柯里化结合隐式参数,程序中有用implicit修饰的参数,程序执行时,会到程序的执行环境(context)中找用implicit修饰的且参数类型一致的参数,有就传递过来使用,不需要变量名一致 。如果传递参数,优先使用传递的参数,如果有implicit修饰的类型一致的参数,用该隐式值,如果还没有,用默认值

  在程序中,有多个用implicit修饰的类型一致的隐式值,会出错

此例其他部分同(1)

  implicit val abc: Int = 666
println(m2()) //64,说明定义的参数传不进去
println(kl2(2)) // 668,abc值被传进来了

(3)从object和class中导入隐式值

  •  从object中,直接导入这个object中的属性即可

创建一个MyContext类

object MyContext {
implicit val ab = 88
}

下面其他代码同(1)

  import MyContext._
println(kl2(2)) // 90
  • 从类中,先要new一个实例,然后再导入隐式值

MyClass

class MyClass {
implicit val aa = 100
}

下面其他代码同(1)

  //如果是类,先要new实例,然后在导入隐式值
val mc = new MyClass
import mc.aa
println(kl2(2)) //102

 3.2 简介

  当在scala中使用1 to 3 时,相当于1.to(3),但是Int中没有to方法,但为什么能使用呢?答案是使用了隐式转换(其可以理解为更加高级的装饰),RichInt这个类中有to方法,相当于将Int装饰成了RichInt

   //int 转成了 RichInt
//隐式转换,扩展了功能,功能更多,调用更方便
1 to 10 //没有使用隐式转换,使用隐式转换更加方便
new RichInt(1).to(10)

   隐式转换的本质就是对类、方法的增强和扩展,其就是装饰模式的特殊表现形式。隐式转换就是在编译时,去上下文中查找相关方法或参数【类型是否一致、转换成另外的类型就有其他的方法了】

案例:给File类添加read方法

   我们都知道,File类中没有读取某个文档所有内容的方法,但我们如何它添加这个方法呢?

(1)装饰者模式

  正常想到的就是装饰模式和继承,但继承的话相对来讲笨重一点,并且继承一个类后就不能继承别的类了,以下是使用装饰模式

class RichFile(val file: File) {
// 一次读取某个文档的所有内容
def read() : String = {
Source.fromFile(file).mkString }
}
object RichFile {
def main(args: Array[String]): Unit = {
// 读取文件中的所有内容,返回一个字符串
val file = new File("E:/javafile/words.txt")
val richFile = new RichFile(file)
val content = richFile.read()
println(content)
}
}

执行后能读出文档中的所有内容。但是这种包装形式用起来太麻烦,此时可以使用隐式转换

(2)隐式转换

创建一个MyContext类,并在类中创建一个将file转换成RichFile的方法

object MyContext {
// 定义一个方法,将file转成RichFile
// 就是事先将File包装成RichFile
implicit def file2RichFile(file:File):RichFile = {
new RichFile(file)
}
}
class RichFile(val file: File) {
// 一次读取某个文档的所有内容
def read() : String = {
Source.fromFile(file).mkString }
}
object RichFile {
def main(args: Array[String]): Unit = {
// 读取文件中的所有内容,返回一个字符串
val file = new File("E:/javafile/words.txt")
import MyContext._
val content: String = file.read()
println(content)
}
}

 说明:程序在编译时,发现调用了file的read方法,但是file上没有read方法,scala会在程序的上下文进行查找,看有没有一个方法或者函数,可以将自身转换成另外一种类型,这个另外的类型定义了read方法(参数的个数和返回值一致

 注意:隐式转换优先使用返回相同类型的函数

object MyContext {

  //定义一个方法,将file转成RichFile
//就是事先将Flie包装成RichFile implicit def file2RichFile(file: File): RichFile = {
println("Method Invoke")
new RichFile(file)
} //优先使用隐式转换函数,没有找到对应的函数,在找方法
implicit val fileToRichFIle = (file: File) => {
println("Function Invoke")
new RichFile(file)
} }

运行后会发现打印出Function Invoke

 4. Scala的泛型

4.1 简介:

 scala的泛型用[]表示,其分为逆变和协变

  逆变: -A  方法的输入参数类型

  协变: +R  方法返回值的类型

注意:scala的泛型和java的不同处在于,scala的泛型是指明了输入和输出的,java则没有

 4.2 泛型的上下文界定

(1)[T <: Comparable[T]] 上界  upper bound   <T extends Comparable>,相当于T实现了Comparable接口
(2)[T >: Comparable[T]] 下界 lower bound <T super Comparable> 相当于T是Comparable的父类
(3)[T <% Comparable] 视图界定 view bound 可以实现隐式转换
(4)[T : Comparable] 上下文界定 context bound

(1)[T <: Comparable[T]] 上界 

class Pair[T <: Comparable[T]]{
def bigger(first: T, second: T) = {
if(first.compareTo(second) > 0) first else second
}
} object Pair {
def main(args: Array[String]): Unit = {
//装的是Scala的Int
val pair = new Pair[Integer] val r = pair.bigger(5, 10)
print(r)
}
}

此处new Paire[Integer]中的Integer若改为Int则会报错,显示Int没有实现Comparable的接口,但是为什么后面调用bigger方法传的却能是Int类型的数值?====> 内部会实现Int到Integer的转换(隐式转换)

但如果要在new Paire[Integer]中写Int类型该怎么改呢?====>如下

(3)[T <% Comparable] 视图界定

视图界定就是为了实现隐式转换的,视图界定需要传入一个隐式转换方法或函数(MyPredef中),优先使用函数

此处将Int===>Intger, 因为scala默认导入Predef对象,而在这个object中有将Int转换为Integer的方法

class Pair[T <% Comparable[T]]{
def bigger(first: T, second: T): T = {
if(first.compareTo(second) > 0) first else second
}
} object Pair {
def main(args: Array[String]): Unit = {
//装的是Scala的Int
val pair = new Pair[Int] val r = pair.bigger(5, 10)
print(r)
}
}

Ordered和Ordering

  在scala中有两个特质Ordered、Ordering,这两个特质是专门用来作比较的。Ordered实现了Comparable接口,Ordered并且对Comparable接口进行了扩展;Ordering 实现了 Comparator接口, Ordering 对Comparator接口进行了扩展。定义这两个特质的目的就是为了进行比较时更加方便  

class Pair2[T <% Ordered[T]] {
def bigger(first: T, second: T): T = {
if(first >= second) first else second
}
} object Pair2{
def main(args: Array[String]): Unit = {
val p = new Pair2[Int]
val r = p.bigger(5, 8)
println(r)
}
}

此处Int先转换成了Ordering[Int](在Ordering特质中)   ,Ordered中有一个隐式转方法,可以将Ordering[T] 转成 Ordered[T] ,这块源码还不怎么看的懂,以后来看

现在要比较自己定义的类,类如下

//将比较规则和类耦合在一起了,所以不用继承的方式
//class Boy(val name: String, var fv: Double) extends Comparable[Boy]{
  ovverride def compareTo(o:Boy):Int={
    (this.fv - o.fv).toInt
  }
} class Boy(val name: String, var fv: Double){ override def toString = s"Boy($name, $fv)"
}

MyPredef

object MyPredef {
implicit val boy2OrderedBoy: Boy => Ordered[Boy] = (boy:Boy) => new Ordered[Boy]{
override def compare(that: Boy): Int = {
(boy.fv - that.fv).toInt
}
}
}

业务代码

class Pair2[T <% Ordered[T]] {
def bigger(first: T, second: T): T = {
if(first >= second) first else second
}
} object Pair2 {
def main(args: Array[String]): Unit = {
// val p = new Pair2[Int]
// val r = p.bigger(5, 8)
// println(r)
import MyPredef.boy2OrderedBoy
val p: Pair2[Boy] = new Pair2[Boy]
val res: Boy = p.bigger(new Boy("老王", 99.9), new Boy("老李", 88.9))
print(res)
}
}

(4)[T : Comparable] 上下文界定 

  上下文界定,也是为了实现Scala的隐式转换的,上下文界定,需要传入一个隐式的object(MyPredef中的object)

MyProdef

object MyPredef {

  implicit object OrderingMan extends Ordering[Man] {
override def compare(x: Man, y: Man): Int = {
x.age - y.age
}
}
}

业务代码

class Pair3[T : Ordering] {

  def bigger(first: T, second: T): T = {
//implicitly将Ordering跟T关联在一起
val ord = implicitly[Ordering[T]]
if(ord.gt(first, second)) first else second
}
} object Pair3 { def main(args: Array[String]): Unit = { import MyPredef.OrderingMan val p = new Pair3[Man] val r = p.bigger(new Man("laozhao", 18), new Man("laoduan", 33)) println(r) } }

4.3 使用柯里化结合隐式参数,实现隐式转化(不需要上下文界点也不需要视图界点)

  写前面的代码时,其出现如下提示,这正是提示使用此方法

大数据学习day17------第三阶段-----scala05------1.Akka RPC通信案例改造和部署在多台机器上 2. 柯里化方法 3. 隐式转换 4 scala的泛型

案例

/**
* 使用柯里化结合隐式参数,实现隐式转换
*/ import MyPredef._ class Pair4[T] { /**
* 柯里化结合隐式参数,实现隐式转换,传入一个隐式转换函数
* 这种方式和视图界定的效果是一样的
*/
def choose(first: T, second: T)(implicit ord: T => Ordered[T]): T = { if(first >= second) first else second } /**
* 使用柯里化结合隐式参数,需要传入一个隐式的object
* 这种方式可以实现类似上下文界定
*/
def select(first: T, second: T)(implicit ord: Ordering[T]): T = { if(ord.gteq(first, second)) first else second } } object Pair4 { def main(args: Array[String]): Unit = { // val p = new Pair4[Boy]
// // val r = p.choose(new Boy("laozhao", 9999.99), new Boy("laoduan", 999.99))
//
// println(r) val p = new Pair4[Man] val r = p.select(new Man("laozhao", 18), new Man("laodaun", 33)) println(r)
}
}