目录
参考文章
- Gitter Chat，Akka 在线交流平台
- Akka Forums，Akka 论坛
- Akka in GitHub，Akka 开源项目仓库
- Akka Official Website，Akka 官网
- Akka Java API，Akka 应用程序编程接口
- 《Akka入门与实践》 [加]Jason Goodwin（贾森·古德温）
文章系列
- Akka 学习（一）Actor 初步认识与环境搭建 已完成
- Akka 学习（二）第一个入门程序 已完成
- Akka 学习（三）Actor的基本使用 已完成
- Akka 学习（四）Remote Actor 已完成
- Akka 学习（五）消息传递的方式 已完成
- Akka 学习（六）Actor的监督机制 已完成
- Akka 学习（七）Actor的生命周期 已完成
- Akka 学习（八）路由与Dispatcher 已完成
- Akka 学习（九）Akka Cluster 已完成
Akka 基础篇就此结束了，Akka基础篇主要介绍Akka的基本概念与一些基本术语，使用方式
代码：https://github.com/Eason-shu/Akka
一 基本案例
1.1 Java 版
需求：我们将在这个例子中构建一个简单的Actor，这个Actor接收一个字符串“Ping”，返回字符串“Pong”作为响应。
- 编码
import akka.actor.AbstractActor;
import akka.actor.ActorRef;
import akka.actor.Status;
import akka.japi.pf.ReceiveBuilder;
import scala.PartialFunction;
/**
* @description: Java 收消息测试
* @author: shu
* @createDate: 2022/11/27 16:10
* @version: 1.0
*/
public class JavaPongActor extends AbstractActor {
public PartialFunction receive() {
// Actor字符匹配
return ReceiveBuilder
.matchEquals("Ping", s ->
// System.out.println("收到消息："+s.toString()))
sender().tell("收到：OVER,OVER消息！", ActorRef.noSender()))
.matchAny(x ->
sender().tell(
new Status.Failure(new Exception("unknown message")), self()
))
.build();
}
}
- 测试
@Test
public void JavaPongActorTest(){
// 创建一个actor
TestActorRef<JavaPongActor> actorRef = TestActorRef.create(system, Props.create(JavaPongActor.class));
// 发送消息
actorRef.tell("Ping",ActorRef.noSender());
// 返回的消息
// actorRef.receive(ReceiveBuilder
// .matchEquals("收到：OVER,OVER消息！", message -> {
// System.out.printf("收到的key:%s",message);
// })
// .matchAny(o -> System.out.printf("收到的消息:%s",o))
// .build());
}
参数讲解
- AbstractActor：首先，我们继承了AbstractActor。这是一个Java 8特有的API，利用了Java 8的匿名函数（lambda）的特性。
- Receive：AbstractActor类有一个receive方法，其子类必须实现这个方法或是通过构造函数调用该方法。
- ReceiveBuilder：连续调用ReceiveBuilder的方法，为所有需要匹配处理的输入消息类型提供响应方法的描述，然后调用build()方法生成需要返回的PartialFunction。
- Match:ReceiveBuilder提供了一些值得一提的match方法，scala中的模式匹配。
ReceiveBuilder
.matchEquals("Ping", s -> System.out.println("It's Ping: " + s))
.match(String.class, s -> System.out.println("It's a string: " + s))
.matchAny(x -> System.out.println("It's something else: " + x))
.build
- tell():sender()函数会返回一个ActorRef，tell()是最基本的单向消息传输模式，第一个参数是我们想要发送至对方信箱的消息，第二个参数则是希望对方Actor看到的发送者。
1.2 Scala版
- 代码
import akka.actor.{Actor, Status}
import sun.rmi.runtime.Log
/**
* @description: Scala 收消息测试
* @author: shu
* @createDate: 2022/11/27 17:00
* @version: 1.0
*/
class ScalaPongActor extends Actor {
override def receive: Receive = {
case "Ping" => println("收到消息")
/
case "Ping" => sender() ! "Pong"
case _ =>
sender() ! Status.Failure(new Exception("unknown message"))
}
}
我们对比Java 版本来看，他更加简洁明了
- 测试
import akka.actor.ActorSystem
import akka.testkit.TestActorRef
import org.scalatest.{FunSpecLike, Matchers}
class AkkademyDbSpec extends FunSpecLike with Matchers {
// 获取系统实例
implicit val system = ActorSystem()
describe("akkademyDb") {
describe("given SetRequest") {
// 测试1
it("should place key/value into map") {
// 创建Actor实例
val actorRef = TestActorRef(new AkkaDba)
// 发送消息
actorRef ! SetRequest("key", "123456")
// 验证消息
val akkademyDb = actorRef.underlyingActor
akkademyDb.map.get("key") should equal("123456")
}
// 测试2
it("PONG TEST"){
val actorRef = TestActorRef(new ScalaPongActor)
actorRef ! ("Ping")
}
}
}
}
参数解释
- Actor：要定义一个Actor，首先要继承Actor基类。Actor基类是基本的Scala Actor API，非常简单，并且符合Scala语言的特性。
- Receive：在Actor中重写基类的receive方法。并且返回一个PartialFunction，要注意的是，receive方法的返回类型是Receive，Receive只不过是定义的一种类型，表示scala.PartialFunction[scala.Any,scala.Unit]。
- tell方法（!）：我们使用tell方法向发送方发送响应消息，在Scala中，通过“! ”来调用tell方法，在tell方法“! ”的方法签名中，有一个隐式的ActorRef参数。如果在Actor外部调用tell方法的话，该参数的默认值会设为noSender。
def ! (message: Any)(implicit sender: ActorRef = Actor.noSender): Unit
- Actor中有一个隐式的变量self，Actor通过self得到消息发送者的值，因此Actor中tell方法的消息发送者永远是self。
二 Actor的创建
- 访问Actor的方法和访问普通对象的方法有所不同，我们从来都不会得到Actor的实例，从不调用Actor的方法，也不直接改变Actor的状态，反之，只向Actor发送消息。（总之，我们不能向Java new关键字一样来实例化对象）
- 除此之外，我们也不会直接访问Actor的成员，而是通过消息传递来请求获取关于Actor状态的信息，使用消息传递代替直接方法调用可以加强封装性。
2.1 Actor的创建
在Akka中，Actor大致分为两类：UntypedActor和TypedActor，它们的使用场景有比较明显的区别，❑ UntypedActor：基于经典的Actor模型实现，能完整表达Akka-Actor的设计思想，推荐使用它来定义Actor，❑ TypedActor（Akka2.5后废弃）：会比较方便地把正常OOP的代码包装成异步执行的Actor，比较符合程序员的API调用逻辑，但是不太能表达基于消息的处理方式，在一般情况下，不推荐使用它。
- Java 版本
import akka.actor.ActorRef;
import akka.actor.ActorSystem;
import akka.actor.Props;
import akka.actor.UntypedActor;
import akka.event.Logging;
import akka.event.LoggingAdapter;
/**
* @description: UntypedActor基于经典的Actor模型实现，能完整表达Akka-Actor的设计思想，推荐使用它来定义Actor。
* @author: shu
* @createDate: 2022/12/15 10:34
* @version: 1.0
*/
public class AkkaDemo extends UntypedActor {
private LoggingAdapter log = Logging.getLogger( this .getContext().system(), this);
/**
* 收到消息
* @param msg
* @throws Exception
* @throws Exception
*/
@Override
public void onReceive(Object msg) throws Exception, Exception {
if (msg instanceof String) {
log.info( msg.toString());
} else {
unhandled( msg);
}
}
/**
* 创建ActorRef实例
* @param args
*/
public static void main(String[] args) {
//参数为ActorSystem的名字，可以不传
ActorSystem system =ActorSystem. create( "sys" );
//参数分别是构造器和Actor的名字，名字可以不传
ActorRef actorRef =system.actorOf(Props.create(AkkaDemo.class), "actorDemo" );
}
}
- Scala
import akka.actor.{ActorRef, ActorSystem, Props, UntypedActor}
import akka.event.{Logging, LoggingAdapter}
/**
* @description:
* @author: shu
* @createDate: 2022/12/15 10:48
* @version: 1.0
*/
class AkkaScalaDemo extends UntypedActor{
// 日志
val log: LoggingAdapter =Logging(context.system,this);
// ActorSystem
val system: ActorSystem = ActorSystem.create("sysScala");
/**
* 重写方法
* @param message
*/
override def onReceive(message: Any): Unit = {
if(message.isInstanceOf[String]){
log.info(message.toString)
}
else {
unhandled();
}
}
/**
* 主函数
* @param args
*/
def main(args: Array[String]): Unit = {
val actorRef = system.actorOf(Props.create(classOf[AkkaScalaDemo]), "actorScalaDemo")
}
}
- onReceive方法是用于接收并处理消息的地方，这里我们通过类型做了简单的匹配，当匹配不到相应的消息类型时，推荐使用unhandled进行处理。
- 在做Actor的调试时，可以采用LoggingAdapter来进行日志打印，以便获得更详细的信息。
2.2 ActorRef的创建
- 在Akka中，这个指向Actor实例的引用叫做ActorRef。
- ActorRef是一个无类型的引用，将其指向的Actor封装起来，提供了更高层的抽象，并且给用户提供了一种与Actor进行通信的机制。
- 有一点可能相当明显：我们也正是在Actor系统中创建新的Actor并获取指向Actor的引用，actorOf方法会生成一个新的Actor，并返回指向该Actor的引用。
//Java
//参数为ActorSystem的名字，可以不传
ActorSystem system =ActorSystem. create( "sys" );
//参数分别是构造器和Actor的名字，名字可以不传
ActorRef actorRef =system.actorOf(Props.create(ActorDemo.class), "actorDemo" );
//Scala
val system: ActorSystem = ActorSystem.create("sysScala");
val actor: ActorRef =actorSystem.actorOf(Props(classOf[ActorDemo]))
- 要注意的是，这里我们实际上并没有新建Actor，例如，我们没有调用actorOf(new PongActor)。
- ActorSystem是一个比较重量级的对象，一般来说每个应用程序只需要创建一个该对象；在创建ActorSystem和Actor时，最好都给出名字，在该示例中，它们的名字分别是sys和actorDemo，同时要注意，在同一个ActorSystem中Actor不能重名。
- actorOf返回的不是Actor本身，而是ActorRef，即Actor的引用，我们就是通过该引用来进行消息通信的。
- 假如Actor的构造函数有参数，可以通过create方法传入。
需要在Actor中创建子Actor
import akka.actor.ActorRef;
import akka.actor.ActorSystem;
import akka.actor.Props;
import akka.actor.UntypedActor;
import akka.event.Logging;
import akka.event.LoggingAdapter;
/**
* @description: UntypedActor基于经典的Actor模型实现，能完整表达Akka-Actor的设计思想，推荐使用它来定义Actor。
* @author: shu
* @createDate: 2022/12/15 10:34
* @version: 1.0
*/
public class AkkaDemo extends UntypedActor {
private LoggingAdapter log = Logging.getLogger( this .getContext().system(), this);
/**
* 该Actor下的子Actor，受到当前Actor的监督
*/
ActorRef childActor=getContext().actorOf(Props.create(JavaPongActor.class), "childActor" );
/**
* 收到消息
* @param msg
* @throws Exception
* @throws Exception
*/
@Override
public void onReceive(Object msg) throws Exception, Exception {
if (msg instanceof String) {
log.info( msg.toString());
} else {
unhandled( msg);
}
}
/**
* 创建ActorRef实例
* @param args
*/
public static void main(String[] args) {
//参数为ActorSystem的名字，可以不传
ActorSystem system =ActorSystem.create( "sys" );
//参数分别是构造器和Actor的名字，名字可以不传
ActorRef actorRef =system.actorOf(Props.create(AkkaDemo.class), "actorDemo" );
}
}
- Scala
import akka.actor.{ActorRef, ActorSystem, Props, UntypedActor}
import akka.event.{Logging, LoggingAdapter}
/**
* @description:
* @author: shu
* @createDate: 2022/12/15 10:48
* @version: 1.0
*/
class AkkaScalaDemo extends UntypedActor{
// 日志
val log: LoggingAdapter =Logging(context.system,this);
// ActorSystem
val system: ActorSystem = ActorSystem.create("sysScala");
/**
* 该Actor下的子Actor，受到当前Actor的监督
*/
val childActor: ActorRef = getContext.actorOf(Props.create(classOf[JavaPongActor]), "childActor")
/**
* 重写方法
* @param message
*/
override def onReceive(message: Any): Unit = {
if(message.isInstanceOf[String]){
log.info(message.toString)
}
else {
unhandled();
}
}
/**
* 主函数
* @param args
*/
def main(args: Array[String]): Unit = {
val actorRef = system.actorOf(Props.create(classOf[AkkaScalaDemo]), "actorScalaDemo")
}
}
2.3 Props的使用
- 为了保证能够将Actor的实例封装起来，不让其被外部直接访问，我们将所有构造函数的参数传给一个Props的实例。
- Props允许我们传入Actor的类型以及一个变长的参数列表。
//Java
Props.create(PongActor.class, arg1, arg2, argn);
//Scala
Props(classOf[PongActor], arg1, arg2, argn)
- 我们可以创建一个工厂方法，用于生成这样的Props示例
//Java
public static Props props(String response) {
return Props.create(this.class, response);
}
//Scala
object ScalaPongActor {
def props(response: String): Props = {
Props(classOf[ScalaPongActor], response)
}
}
- 然后就可以使用Props的工厂方法来创建Actor
//Java
ActorRef actor = actorSystem.actorOf(JavaPongActor.props("PongFoo"));
//Scala
val actor: ActorRef = actorSystem.actorOf(ScalaPongActor props
"PongFoo")
我的理解向前端组件的卡槽，用来传递值
2.4 ActorSelection的使用
我们可以通过ActorRef.path来查看该路径
●akka://default/user/$$a
该路径是一个URI，它甚至可以指向使用akka.tcp协议的远程Actor,
● akka.tcp://my-sys@remotehost:5678/user/CharlieChaplin
理解
要注意的是，路径的前缀说明使用的协议是akka.tcp，并且指定了远程Actor系统的主机名和端口号，如果知道Actor的路径，就可以使用actorSelection来获取指向该Actor引用的ActorSelection（无论该Actor在本地还是远程）。
ActorSelection selection = system.actorSelection("akka.tcp://
actorSystem@host.jason-goodwin.com:5678/user/KeanuReeves");
寻找一个Actor
ActorSelection=[ActorSystem/ActorContext ].
actorSelection([path]);
actorSelection方法会返回一个ActorSelection对象，它并不等同于ActorRef，但是你几乎可以使用同样的方式（tell或ask）来与Actor进行通信，当所查路径不存在时，消息肯定也就不会发送成功。
- Java
import akka.actor.*;
/**
* @description:
* @author: shu
* @createDate: 2022/12/15 11:19
* @version: 1.0
*/
class LookupActor extends UntypedActor {
private ActorRef target = null;
{
target = getContext().actorOf(Props.create(TargetActor.class), "targetActor");
}
@Override
public void onReceive(Object msg) throws Exception {
if (msg instanceof String) {
if ("find".equals(msg)) {
ActorSelection as = getContext().actorSelection("targetActor");
as.tell(new Identify("A001"), getSelf());
}
}
// ActorIdentity 系统默认消息
else if (msg instanceof ActorIdentity) {
ActorIdentity ai = (ActorIdentity) msg;
if (ai.correlationId().equals("A001")) {
ActorRef ref=ai.getRef();
if(ref!=null) {
System.out.println("ActorIdentity: " + ai.correlationId() + ""+ ref);
ref.tell("hello target", getSelf());
}
}
} else {
unhandled(msg);
}
}
public static void main(String[] args) {
//参数为ActorSystem的名字，可以不传
ActorSystem system =ActorSystem.create( "sys" );
//参数分别是构造器和Actor的名字，名字可以不传
ActorRef actorRef =system.actorOf(Props.create(LookupActor.class), "actorDemo" );
// 发送消息
actorRef.tell("find",ActorRef.noSender());
}
}
- Scala
import akka.actor.{ActorIdentity, ActorRef, ActorSelection, ActorSystem, Identify, Props, UntypedActor}
/**
* @description:
* @author: shu
* @createDate: 2022/12/15 11:28
* @version: 1.0
*/
class
LookupScalaActor extends UntypedActor {
var target: ActorRef = getContext.actorOf(Props.create(classOf[TargetActor]), "childActor")
override def onReceive(msg: Any): Unit = {
if (msg.isInstanceOf[String]) if ("find" == msg) {
val as = getContext.actorSelection("targetActor")
as.tell(new Identify("A001"), getSelf)
}
else { // ActorIdentity 系统默认消息
msg match {
case ai: ActorIdentity =>
if (ai.correlationId == "A001") {
val ref = ai.getRef
if (ref != null) {
System.out.println("ActorIdentity: " + ai.correlationId + "" + ref)
ref.tell("hello target", getSelf)
}
}
case _ => unhandled(msg)
}
}
}
def main(args: Array[String]): Unit = { //参数为ActorSystem的名字，可以不传
val system = ActorSystem.create("sys")
//参数分别是构造器和Actor的名字，名字可以不传
val actorRef = system.actorOf(Props.create(classOf[LookupActor]), "actorDemo")
// 发送消息
actorRef.tell("find", ActorRef.noSender)
}
}
通过路径查询Actor
- Java
import akka.actor.ActorNotFound;
import akka.actor.ActorRef;
import akka.actor.ActorSelection;
import akka.actor.ActorSystem;
import akka.dispatch.OnFailure;
import akka.dispatch.OnSuccess;
import akka.util.Timeout;
import scala.concurrent.Future;
import scala.concurrent.duration.Duration;
/**
* @description:
* @author: shu
* @createDate: 2022/12/15 11:33
* @version: 1.0
*/
public class SearchTest {
public static void main(String[] args) {
ActorSystem system =ActorSystem.create( "sys" );
ActorSelection as = system.actorSelection("/user/lookupActor/targetActor");
Timeout timeout = new Timeout(Duration.create(2, "seconds"));
Future<ActorRef> fu = as.resolveOne(timeout);
fu.onSuccess(new OnSuccess<ActorRef>() {
@Override
public void onSuccess(ActorRef ref) throws Throwable {
System.out.println("查找到Actor:" + ref);
}
}, system.dispatcher());
fu.onFailure(new OnFailure() {
@Override
public void onFailure(Throwable ex) throws Throwable {
if(ex instanceof ActorNotFound) {
System.out.println("没找到Actor:"+ex.getMessage());
}
}
}, system.dispatcher());
}
}
三 Promise、Future和事件驱动的编程模型
3.1 阻塞与事件驱动
事件阻塞
- 进行IO操作时，编写的都是阻塞式的代码，我们调用一个同步的API时，调用的方法不会立即返回：应用程序会等待该调用执行完成，例如，如果发起一个HTTP请求的话，只有在请求完成后，才会收到返回的响应对象，由于发起调用的线程会暂停执行并等待，因此等待IO操作完成的代码都是阻塞的，在IO操作完成之前，发起调用的线程无法进行任何其他操作。
多线程知识参考：
多线程进行阻塞IO的问题？
● 代码没有在返回类型中明确表示错误
● 代码没有在返回类型中明确表示延时
● 阻塞模型的吞吐量受到线程池大小的限制
● 创建并使用许多线程会耗费额外的时间用于上下文切换，影响系统性能。
3.2 Future进行Actor响应
3.2.1 Java版
- 依赖
<dependency>
<groupId>org.scala-lang.modules</groupId>
<artifactId>scala-java8-compat_2.11</artifactId>
<version>1.0.2</version>
</dependency>
- 代码
import akka.actor.AbstractActor;
import akka.actor.ActorRef;
import akka.actor.Status;
import akka.japi.pf.ReceiveBuilder;
import scala.PartialFunction;
/**
* @description: Java 收消息测试
* @author: shu
* @createDate: 2022/11/27 16:10
* @version: 1.0
*/
public class JavaPongActor extends AbstractActor {
public PartialFunction receive() {
// Actor字符匹配
return ReceiveBuilder
.matchEquals("Ping", s ->
// System.out.println("收到消息："+s.toString()))
sender().tell("Pong", ActorRef.noSender()))
.matchAny(x ->
sender().tell(
new Status.Failure(new Exception("unknown message")), self()
))
.build();
}
}
- 测试
import akka.actor.ActorRef;
import akka.actor.ActorSystem;
import akka.actor.Props;
import akka.pattern.AskableActorRef;
import akka.util.Timeout;
import org.junit.Test;
import scala.concurrent.Future;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import static scala.compat.java8.FutureConverters.toJava;
/**
* @description:
* @author: shu
* @createDate: 2022/11/27 18:49
* @version: 1.0
*/
public class PongActorTest {
ActorSystem system = ActorSystem.create();
ActorRef actorRef = system.actorOf(Props.create(JavaPongActor.class));
@Test
public void shouldReplyToPingWithPong() throws Exception {
// 采用Ask的方式来询问消息
Future sFuture =new AskableActorRef(actorRef).ask( "Ping", Timeout.apply(1000));
// 将scala转换成java
final CompletionStage<String> cs = toJava(sFuture);
final CompletableFuture<String> jFuture =
(CompletableFuture<String>) cs;
assert (jFuture.get(1000, TimeUnit.MILLISECONDS)
.equals("Pong"));
// 打印获取的值
System.out.println("获取的信息："+jFuture.get());
}
@Test
public void shouldReplyToUnknownMessageWithFailure() throws
Exception {
Future sFuture = new AskableActorRef(actorRef).ask( "unknown", Timeout.apply(5000));
final CompletionStage<String> cs = toJava(sFuture);
final CompletableFuture<String> jFuture =
(CompletableFuture<String>) cs;
jFuture.get(1000, TimeUnit.MILLISECONDS);
}
}
成功
失败
3.2.2 Scala 版
- 代码
import akka.actor.{Actor, Status}
import sun.rmi.runtime.Log
/**
* @description: Scala 收消息测试
* @author: shu
* @createDate: 2022/11/27 17:00
* @version: 1.0
*/
class ScalaPongActor extends Actor {
override def receive: Receive = {
case "Ping" => sender() ! "Pong"
case _ =>
sender() ! Status.Failure(new Exception("unknown message"))
}
}
- 测试
/**
* @description:
* @author: shu
* @createDate: 2022/11/27 19:44
* @version: 1.0
*/
import akka.actor.{ActorRef, ActorSystem, Props}
import akka.pattern.ask
import akka.util.Timeout
import org.scalatest.{FunSpecLike, Matchers}
import scala.concurrent.Await
import scala.concurrent.duration._
import scala.language.postfixOps
class ScalaAskExamplesTest extends FunSpecLike with Matchers {
val system: ActorSystem = ActorSystem()
implicit val timeout: Timeout = Timeout(5 second)
val pongActor: ActorRef = system.actorOf(Props(classOf[ScalaPongActor]))
describe("Pong actor") {
// 正确测试
it("should respond with Pong") {
val future = pongActor ? "Ping" //uses the implicit timeout
val result = Await.result(future.mapTo[String], 1 second)
assert(result == "Pong")
println(result)
}
// 失败测试
it("should fail on unknown message") {
val future = pongActor ? "unknown"
intercept[Exception]{
Await.result(future.mapTo[String], 1 second)
}
println( Await.result(future.mapTo[String], 1 second))
}
}
}
成功
失败
3.2.3 总结
无论是在Java还是Scala的例子中，如果Future返回失败，那么阻塞线程会抛出异常。Future失败会产生一个Throwable, Java 8的CompletableFuture会对这个Throwable进行封装并抛出ExecutionException，而Scala API则会直接抛出这个Throwable。（Scala没有受检异常，所以可以直接抛出Throwable，而Java会在这里抛出一个非受检的异常类型。
注意：我们可以抽离成为公共类
/**
* 抽离成公共类
* @param message
* @return
*/
public CompletionStage<String> askPong(String message){
Future sFuture = new AskableActorRef(actorRef).ask(message, Timeout.apply(1000));
CompletionStage<String> cs = toJava(sFuture);
return cs;
}
/**
* 抽离成公共类
* @param message
* @return
*/
def askPong(message: String): Future[String] = (pongActor ? message).mapTo[String]
3.3 成功处理
- java
thenAccept方法操作返回结果
/**
* thenAccept测试
* @throws Exception
*/
@Test public void printToConsole() throws Exception {
askPong("Ping").
thenAccept(x -> System.out.println("replied with: " + x));
Thread.sleep(100);
}
- scala
onSuccess函数来处理
// 成功处理测试
it("should print to console"){
(pongActor ? "Ping").onSuccess({
case x: String => println("replied with: " + x)
})
Thread.sleep(100)
}
注意到onSuccess接受一个部分函数作为参数，所以非常适合用来处理Akka的无类型响应（通过模式匹配来判断返回结果的类型）。
3.4 失败处理
- java
/**
* 错误处理
*/
@Test
public void ErrorResult(){
askPong("cause error").handle((x, t) -> {
if(t!=null){
System.out.println("Error: " + t);
}
return null;
});
}
handle接受一个BiFunction作为参数，该函数会对成功或失败情况进行转换。handle中的函数在成功情况下会提供结果，在失败情况下则会提供Throwable，因此需要检查Throwable是否存在（结果和Throwable中只有一个不是null）。如果Throwable存在，就向日志输出一条语句。由于我们需要在该函数中返回一个值，而失败情况下又不需要对返回值做任何操作，因此直接返回null。
- scala
onFailure()函数
it("结果处理测试"){
askPong("causeError").onFailure {
case e: Exception => println("Got exception")
}
}
3.5 恢复
很多时候，在发生错误的时候我们仍然想要使用某个结果值。如果想要从错误中恢复的话，可以对该Future进行转换，使之包含一个成功的结果值。
- java
/**
* 失败默认值
*/
@Test
public void Recover(){
CompletionStage<String> cs = askPong("cause error")
.exceptionally(t -> {
return "default";
});
}
- scala
it("失败默认值"){
val f = askPong("causeError").recover {
case t: Exception => "default"
}
}
异步恢复
我们经常需要在发生错误时使用另一个异步方法来恢复，下面是两个用例。重试某个失败的操作。没有命中缓存时，需要调用另一个服务的操作。
- java
askPong("cause error")
.handle( (pong, ex) -> ex == null
? CompletableFuture.completedFuture(pong)
: askPong("Ping")
).thenCompose(x -> x);
- scala
askPong("causeError").recoverWith({
case t: Exception => askPong("Ping")
})
3.6 链式调用
应用函数式风格来处理延迟和失败的好处之一就是可以把多个操作组合起来，而在组合的过程中无需处理异常。我们可以把注意力放在成功的情况上，在链式操作的结尾再收集错误。
- java
CompletionStage<String> cs = askPong("Ping").thenCompose(x ->
askPong("Ping"));
- scala
val f: Future[String] = askPong("Ping").flatMap(x => askPong("Ping"))
3.7 结果转换
- java
/**
* 处理结果测试
* @throws ExecutionException
* @throws InterruptedException
*/
@Test
public void CoverResult() throws ExecutionException, InterruptedException {
// 将处理结果转为大写
CompletableFuture<String> future = (CompletableFuture<String>) askPong("Ping").thenApply(x -> x.toUpperCase(Locale.ROOT));
System.out.println(future.get());
}
/**
* 异步转换结果
*/
@Test
public void AsyncCoverResult(){
CompletionStage<CompletionStage<String>> futureFuture =
askPong("Ping").thenApply(this::askPong);
}
- scala
it("结果处理测试"){
//
val result= askPong("Ping").map(_.toUpperCase())
println(Await.result(result.mapTo[String], 1 second));
// 异步结果处理
val futureFuture: Future[Future[String]] =
askPong("Ping").map(x => {
askPong(x)
})
}
3.8 组合Future
- Java
@Test
public void CompletableFuture() throws ExecutionException, InterruptedException {
CompletableFuture<String> future = (CompletableFuture<String>) askPong("Ping")
.thenCombine(askPong("Ping"), (a, b) -> {
return a + b; //"PongPong"
});
System.out.println(future.get());
}
- scala
it("组合结果测试"){
val f1 = askPong("Ping")
val f2 = askPong("Ping")
val futureAddition: Future[String] = {
for (
res1 <- f1;
res2 <- f2
) yield res1 + res2
}
println(Await.result(futureAddition.mapTo[String], 1 second));
}
这个例子展示了一种处理多个不同类型Future的机制。通过这种方法，可以并行地执行任务，同时处理多个请求，更快地将响应返回给用户。
3.9 处理集合
在Scala中，如果我们有一个消息列表，对于列表中的每个消息，向PongActor发送查询，最后会得到如下的一个Future列表
// 返回列表
it("Future list"){
// list
val listOfFutures: List[Future[String]] = List("Ping", "Ping",
"failed").map(x => askPong(x))
// 转换结果为list
val futureOfList: Future[List[String]] = Future.sequence(listOfFutures)
futureOfList.foreach(x=> println(x))
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
