4bd6b7aab1
* Receive class that wraps PartialFunction, to avoid
scary scala types
* move AbstractActorContext to AbstractActor.ActorContext
* converting docs, many, many UntypedActor
* removing UntypedActor docs
* add unit test for ReceiveBuilder
* MiMa filters
* consistent use of getContext(), self(), sender()
* rename cross references
* migration guide
* skip samples for now
* improve match type safetyi, add matchUnchecked
* the `? extends P` caused code like this to compile:
`match(String.class, (Integer i) -> {})`
* added matchUnchecked, since it can still be useful (um, convenient)
to be able to do:
`matchUnchecked(List.class, (List<String> list) -> {})`
* eleminate some scala.Option
* preRestart
* findChild
* ActorIdentity.getActorRef
105 lines
2.5 KiB
Java
105 lines
2.5 KiB
Java
/**
|
|
* Copyright (C) 2009-2017 Lightbend Inc. <http://www.lightbend.com>
|
|
*/
|
|
package docs.actorlambda;
|
|
|
|
import docs.AbstractJavaTest;
|
|
import org.junit.AfterClass;
|
|
import org.junit.BeforeClass;
|
|
import org.junit.Test;
|
|
import scala.concurrent.Await;
|
|
import scala.concurrent.duration.Duration;
|
|
|
|
import akka.actor.AbstractActor;
|
|
import akka.actor.ActorRef;
|
|
import akka.actor.ActorSystem;
|
|
import akka.actor.Props;
|
|
import akka.testkit.JavaTestKit;
|
|
|
|
//#import
|
|
import akka.actor.Actor;
|
|
import akka.actor.IndirectActorProducer;
|
|
//#import
|
|
|
|
public class DependencyInjectionDocTest extends AbstractJavaTest {
|
|
|
|
public static class TheActor extends AbstractActor {
|
|
|
|
final String s;
|
|
|
|
public TheActor(String s) {
|
|
this.s = s;
|
|
}
|
|
|
|
@Override
|
|
public Receive createReceive() {
|
|
return receiveBuilder()
|
|
.match(String.class, msg -> {
|
|
sender().tell(s, self());
|
|
})
|
|
.build();
|
|
}
|
|
}
|
|
|
|
static ActorSystem system = null;
|
|
|
|
@BeforeClass
|
|
public static void beforeClass() {
|
|
system = ActorSystem.create("DependencyInjectionDocTest");
|
|
}
|
|
|
|
@AfterClass
|
|
public static void afterClass() throws Exception {
|
|
Await.ready(system.terminate(), Duration.create("5 seconds"));
|
|
}
|
|
|
|
//this is just to make the test below a tiny fraction nicer
|
|
private ActorSystem getContext() {
|
|
return system;
|
|
}
|
|
|
|
static
|
|
//#creating-indirectly
|
|
class DependencyInjector implements IndirectActorProducer {
|
|
final Object applicationContext;
|
|
final String beanName;
|
|
|
|
public DependencyInjector(Object applicationContext, String beanName) {
|
|
this.applicationContext = applicationContext;
|
|
this.beanName = beanName;
|
|
}
|
|
|
|
@Override
|
|
public Class<? extends Actor> actorClass() {
|
|
return TheActor.class;
|
|
}
|
|
|
|
@Override
|
|
public TheActor produce() {
|
|
TheActor result;
|
|
//#obtain-fresh-Actor-instance-from-DI-framework
|
|
result = new TheActor((String) applicationContext);
|
|
//#obtain-fresh-Actor-instance-from-DI-framework
|
|
return result;
|
|
}
|
|
}
|
|
//#creating-indirectly
|
|
|
|
@Test
|
|
public void indirectActorOf() {
|
|
final String applicationContext = "...";
|
|
//#creating-indirectly
|
|
|
|
final ActorRef myActor = getContext().actorOf(
|
|
Props.create(DependencyInjector.class, applicationContext, "TheActor"),
|
|
"TheActor");
|
|
//#creating-indirectly
|
|
new JavaTestKit(system) {
|
|
{
|
|
myActor.tell("hello", getRef());
|
|
expectMsgEquals("...");
|
|
}
|
|
};
|
|
}
|
|
|
|
}
|