[Activator-HelloAkka] Define our Actors

The Actor is the unit of
execution in Akka. Actors are object-oriented in the sense that they
encapsulate state and behavior, but they have much stronger isolation than
regular objects in Java or Scala.

The Actor model prevents
sharing state between Actors and the only way to observe another actor‘s
state is by sending it a message asking for it.

Actor模型限制分Actor們之間的共享狀態,
唯一觀察其他actor的方法是對它發送一個asking訊息.

Actors are extremely
lightweight, they are only constrained by memory of which they consume
only a few hundred bytes each — this means you can easily create millions
of concurrent Actors in a single application. Their strong isolation
principles together with the event-driven model (that we will talk about
later on) and location transparency makes it easy to solve hard
concurrency and scalability problems in an intuitive way.

Actors是極度輕量的,
他們只消費幾百個字節在內存的限制當中- 那表示你可以在一個簡單的應用程序輕松地建立數以百萬個並發Actors. 他們強大的隔離原則,
再加上事件驅動模型以及位置透明度使它很輕松地以直覺的方式去處理硬並發與可擴展性問題.

You create an Actor in Java by defining a class that
extendsUntypedActor and implement the onReceive
method (in Scala you have to extend Actor trait and implement
the receive method). It is in theonReceive
method that you define the behavior; how the Actor should react to the
different messages it receives. An Actor can have — and often has — state.
Accessing or mutating the internal state of an Actor is fully thread safe
since protected by the Actor model.

So, let‘s now create a Greeter Actor with a single
variable greeting as its state, holding on to the latest
defined greeting, and in its onReceivemethod let‘s add the
behavior for how it should react upon receiving the
WhoToGreet and the Greet messages.

Let‘s start by creating our Actor in Java (you can find the code in the
HelloAkkaJava.java
file):

// Java code

public static class Greeter extends UntypedActor {

    String greeting = "";
public void onReceive(Object message) {

        if (message instanceof WhoToGreet)

            greeting = "hello, " + ((WhoToGreet) message).who;
else if (message instanceof Greet)

            getSender().tell(new Greeting(greeting), getSelf());
else unhandled(message);

    }

}

Actors like this one are “untyped” in the sense that the type of
message received is not restricted—it is Object as shown
above. There are also typed actors, but we will not concern ourselves with
those now, the normal actors are the untyped ones.

Don‘t worry about the getSender(), tell(..)
and getSelf() API calls, we will get to that soon when we
talk about sending and replying to messages.

Now let‘s implement it in Scala. As you can see, Scala‘s pattern
matching features really simplify working with Actors, but apart from that
it‘s pretty similar to the Java version (you can find the code in theHelloAkkaScala.scala
file).

// Scala code

class Greeter extends Actor {

  var greeting = ""
def receive = {

    case WhoToGreet(who) => greeting = s"hello, $who"

    case Greet           => sender ! Greeting(greeting)

  }

}

You will notice one difference to the Java version: here we do not
explicitly pass unhandled messages to the unhandled() method.
This is not necessary since the behavior defined by the
receive method is expressed as a so-called partial
function, which means that all messages for which no matching
case statement is written down will be recognized as being
not handled and Akka will automatically pass them to the
unhandled() method for you.

Another difference is that the trait from which the Scala actor
inherits is just called Actor. This is the Scala API while
UntypedActor is the Java API for the same kind of
actor.

[Activator-HelloAkka] Define our Actors,布布扣,bubuko.com