What is the difference between Typed and UnTyped Actors in Akka? When to use what?

Question

I have tried to read the Akka documentation to find out the exact difference between Typed and Untyped actors. When to use what? I am not sure what I'm missing. Can somebody point me to something relevant or provide an answer to this question here itself?

Answer 1

UntypedActor is simply the name for Actor but as the Java API.

Here are some links to documentation:

Java:

• http://akka.io/docs/akka/1.2/java/typed-actors.html
• http://akka.io/docs/akka/1.2/java/untyped-actors.html

Scala:

• http://akka.io/docs/akka/1.2/scala/typed-actors.html
• http://akka.io/docs/akka/1.2/scala/actors.html

The difference is that TypedActors have a static interface, and the invocations of the methods on that interface is transformed into message sends. UntypedActors can receive any message.

Hope that helps.

Cheers, √

Answer 2

Actors (Untyped)

For actors (Scala) to receive messages, they must mixin the Consumer trait. For example, the following actor class (Consumer1) implements the endpointUri method, which is declared in the Consumer trait, in order to receive messages from the file:data/input/actor Camel endpoint. Untyped actors (Java) need to extend the abstract UntypedConsumerActor class and implement the getEndpointUri() and onReceive(Object) methods.

Actors (Typed)

Typed actors can also receive messages from Camel endpoints. In contrast to (untyped) actors, which only implement a single receive or onReceive method, a typed actor may define several (message processing) methods, each of which can receive messages from a different Camel endpoint. For a typed actor method to be exposed as Camel endpoint it must be annotated with the @consume annotation. For example, the following typed consumer actor defines two methods, foo and bar.

Reference

Answer 3

Untyped actors respond to messages sent, while typed actors respond to method calls(the parameter values are the messages).

Typed Actor Model is used in order to define strict contracts for actors that can respond to only the predefined set of messages. In this case, every message need not be encapsulated as one object; typed actors allow us to define separate methods that accept multiple inputs as defined by the contract. In Java parlance, typed actors provide the Java interface in the object-oriented world.[1]

[1] Akka Essentials