Scala och Akka 101

Scala & Akka 101

Scala API
Akka documentation
Akka API

Scala

Konstanter

val a:Int = 1
val b = 2

Variabler

var c: Int = 4
var d = 5
d += 1 // d = 6

Class

class Simple(name: String) {
   def hello: String = {
      "Hello " + name
   }
}

// skapa nytt objekt
val obj = new Simple("name")

Object

object Simple {
   def hello(name: String) = "Hello " + name
}

// peka på object
val obj = Simple
obj.hello("name")

Case class

case class Colour(s: String)

// skapa nytt objekt
val obj = Colour("blue")

Case object

case object Blue

// peka på object
val obj = Blue

Patten matching

def someFunction(v: Any) = v match {
   case i: Int => … // matchar på integers och lägger värdet i 'i'
   case s: String => … // matchar på strings och lägger värdet i 's'
   case Colour(c: String) => … // matchar på case classen Colour och lägger in dess värde i 'c'
   case Colour(c: String) if(c == "blue") => …  // matchar bara om värdet i Colour är lika med "blue"
   case Blue => // matchar objektet Blue
   case x => // matchar alla objekt och lägger värdet i 'x'
   case _ => // matchar alla objekt och ignorerar värdet
}

Map

// skapa (mutable) map
val map = Map[Int, String]()

// lägg till
map += 1 -> "value"

// ta bort
map -= 1

// iterera igenom en map och kör en funktion med varje nyckel och värde 
map.foreach { case (key, value) => funktion(key, value) }

List

// skapa immutable list
var list = List[String]()

// lägg till
list += "value"

// iterera igenom och kör en funktion med varje element
list.foreach { x -> funktion(x) }

Set

// skapa
val set = Set[String]()

// lägg till
set += "value"

// kontrollera om ett set innehåller ett värde
set.contains("value")

Akka

Skapa ett Actor system

import akka.actor._
val system = ActorSystem("system")

Actor

import akka.actor._
class MyActor extends Actor {
   def receive = {
      case msg: Int => println(10 + msg)
      case msg: String => println("Hello " + msg)
      case Colour(n) => println(n) 
   }
}

Skapa actor

val actor = system.actorOf(Props(new MyActor), "myActorName")

Skapa actor med parametrar

val actor = system.actorOf(Props(new MyActor(p1,p2)), "myActorName")

Skapa "barn"-actor från annan actor###

val childActor = context.actorOf(Props(new MyActor), "childActorName")

Skicka ett meddelande till en actor

actor ! message

Vidarebefordra ett meddelande till en actor

Ett vidarebefordrat meddelande refererar till actorn som skickade meddelandet från början

actor.forward(message)

Referenser i en actor###

// referens till actorn själv
self 

// referens till actorn som skickat meddelandet
sender

// exempel på att skicka tillbaks ett meddelande till den anropande actorn
sender ! "msg"

Använda scheduler

// Skicka objektet 'Message' till actor-referensen 'actor' var femte sekund
import akka.util.duration._
context.system.scheduler.schedule(5 seconds, 1 second, actor, Message)

supervisorStrategy

// starta om barn-actors vid RuntimeException
override val supervisorStrategy = OneForOneStrategy() {
  case RuntimeException => Restart
}