public abstract class UntypedActor extends java.lang.Object implements Actor
This class is the Java cousin to the Actor Scala interface.
Subclass this abstract class to create a MDB-style untyped actor.
An actor has a well-defined (non-cyclic) life-cycle. - ''RUNNING'' (created and started actor) - can receive messages - ''SHUTDOWN'' (when 'stop' or 'exit' is invoked) - can't do anything
The Actor's own ActorRef is available as getSelf(), the current
message’s sender as getSender() and the UntypedActorContext as
getContext(). The only abstract method is onReceive() which is invoked for
each processed message unless dynamically overridden using getContext().become().
Here is an example on how to create and use an UntypedActor:
public class SampleUntypedActor extends UntypedActor {
public static class Reply implements java.io.Serializable {
final public ActorRef sender;
final public Result result;
Reply(ActorRef sender, Result result) {
this.sender = sender;
this.result = result;
}
}
private static SupervisorStrategy strategy = new OneForOneStrategy(10, Duration.create("1 minute"),
new Function<Throwable, Directive>() {
@Override
public Directive apply(Throwable t) {
if (t instanceof ArithmeticException) {
return resume();
} else if (t instanceof NullPointerException) {
return restart();
} else if (t instanceof IllegalArgumentException) {
return stop();
} else {
return escalate();
}
}
});
@Override
public SupervisorStrategy supervisorStrategy() {
return strategy;
}
public void onReceive(Object message) throws Exception {
if (message instanceof String) {
String msg = (String) message;
if (msg.equals("UseSender")) {
// Reply to original sender of message
getSender().tell(msg, getSelf());
} else if (msg.equals("SendToSelf")) {
// Send message to the actor itself recursively
getSelf().tell("SomeOtherMessage", getSelf());
} else if (msg.equals("ErrorKernelWithDirectReply")) {
// Send work to one-off child which will reply directly to original sender
getContext().actorOf(Props.create(Worker.class)).tell("DoSomeDangerousWork", getSender());
} else if (msg.equals("ErrorKernelWithReplyHere")) {
// Send work to one-off child and collect the answer, reply handled further down
getContext().actorOf(Props.create(Worker.class)).tell("DoWorkAndReplyToMe", getSelf());
} else {
unhandled(message);
}
} else if (message instanceof Reply) {
final Reply reply = (Reply) message;
// might want to do some processing/book-keeping here
reply.sender.tell(reply.result, getSelf());
} else {
unhandled(message);
}
}
}
Actor.emptyBehavior$, Actor.ignoringBehavior$| Constructor and Description |
|---|
UntypedActor() |
| Modifier and Type | Method and Description |
|---|---|
ActorContext |
context()
Stores the context for this actor, including self, and sender.
|
UntypedActorContext |
getContext()
Returns this UntypedActor's UntypedActorContext
The UntypedActorContext is not thread safe so do not expose it outside of the
UntypedActor.
|
ActorRef |
getSelf()
Returns the ActorRef for this actor.
|
ActorRef |
getSender()
The reference sender Actor of the currently processed message.
|
abstract void |
onReceive(java.lang.Object message)
To be implemented by concrete UntypedActor, this defines the behavior of the
UntypedActor.
|
void |
postRestart(java.lang.Throwable reason)
User overridable callback: By default it calls
preStart(). |
void |
postStop()
User overridable callback.
|
void |
preRestart(java.lang.Throwable reason,
scala.Option<java.lang.Object> message)
User overridable callback: '''By default it disposes of all children and then calls
postStop().''' |
void |
preStart()
User overridable callback.
|
scala.PartialFunction<java.lang.Object,scala.runtime.BoxedUnit> |
receive()
This defines the initial actor behavior, it must return a partial function
with the actor logic.
|
ActorRef |
self()
The 'self' field holds the ActorRef for this actor.
|
SupervisorStrategy |
supervisorStrategy()
User overridable definition the strategy to use for supervising
child actors.
|
void |
unhandled(java.lang.Object message)
Recommended convention is to call this method if the message
isn't handled in
onReceive(java.lang.Object) (e.g. |
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, waitaroundPostRestart, aroundPostStop, aroundPreRestart, aroundPreStart, aroundReceive, senderpublic ActorContext context()
Actorforward.
WARNING: Only valid within the Actor itself, so do not close over it and publish it to other threads!
ActorContext is the Scala API. getContext returns a
UntypedActorContext, which is the Java API of the actor
context.
public final ActorRef self()
Actorself ! message
public abstract void onReceive(java.lang.Object message)
throws java.lang.Throwable
message - (undocumented)java.lang.Throwablepublic UntypedActorContext getContext()
public ActorRef getSelf()
public ActorRef getSender()
public SupervisorStrategy supervisorStrategy()
supervisorStrategy in interface Actorpublic void preStart()
throws java.lang.Exception
public void postStop()
throws java.lang.Exception
public void preRestart(java.lang.Throwable reason,
scala.Option<java.lang.Object> message)
throws java.lang.Exception
postStop().'''
Is called on a crashed Actor right BEFORE it is restarted to allow clean
up of resources before Actor is terminated.preRestart in interface Actorreason - (undocumented)message - (undocumented)java.lang.Exceptionpublic void postRestart(java.lang.Throwable reason)
throws java.lang.Exception
preStart().
Is called right AFTER restart on the newly created Actor to allow reinitialization after an Actor crash.postRestart in interface Actorreason - (undocumented)java.lang.Exceptionpublic final scala.PartialFunction<java.lang.Object,scala.runtime.BoxedUnit> receive()
Actorpublic void unhandled(java.lang.Object message)
onReceive(java.lang.Object) (e.g. unknown message type).
By default it fails with either a DeathPactException (in
case of an unhandled Terminated message) or publishes an UnhandledMessage
to the actor's system's EventStream.