Akka（36）： Http：Client-side-Api，Client-Connections

2024-04-09 04:48
文章标签 36 http api client akka side connections

本文主要是介绍Akka（36）： Http：Client-side-Api，Client-Connections，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

   Akka-http的客户端Api应该是以HttpRequest操作为主轴的网上消息交换模式编程工具。我们知道：Akka-http是搭建在Akka-stream之上的。所以，Akka-http在客户端构建与服务器的连接通道也可以用Akka-stream的Flow来表示。这个Flow可以通过调用Http.outgoingConnection来获取：

  /*** Creates a [[akka.stream.scaladsl.Flow]] representing a prospective HTTP client connection to the given endpoint.* Every materialization of the produced flow will attempt to establish a new outgoing connection.** To configure additional settings for requests made using this method,* use the `akka.http.client` config section or pass in a [[akka.http.scaladsl.settings.ClientConnectionSettings]] explicitly.*/def outgoingConnection(host: String, port: Int = 80,localAddress: Option[InetSocketAddress] = None,settings:     ClientConnectionSettings  = ClientConnectionSettings(system),log:          LoggingAdapter            = system.log): Flow[HttpRequest, HttpResponse, Future[OutgoingConnection]] =_outgoingConnection(host, port, settings.withLocalAddressOverride(localAddress), ConnectionContext.noEncryption(), ClientTransport.TCP, log)

我们看到：这个函数实现了对Server端地址host+port的设定，返回的结果类型是Flow[HttpRequest,HttpResponse,Future[OutgoingConnection]]。这个Flow代表将输入的HttpRequest转换成输出的HttpResponse。这个转换过程包括了与Server之间的Request,Response消息交换。下面我们试着用这个Flow来向Server端发送request，并获取response： 

  val connFlow: Flow[HttpRequest,HttpResponse,Future[Http.OutgoingConnection]] =Http().outgoingConnection("akka.io")def sendHttpRequest(req: HttpRequest) = {Source.single(req).via(connFlow).runWith(Sink.head)}sendHttpRequest(HttpRequest(uri="/")).andThen{case Success(resp) => println(s"got response: ${resp.status.intValue()}")case Failure(err) => println(s"request failed: ${err.getMessage}")}.andThen {case _ => sys.terminate()}

以上用法只能处理零星短小的requests，这是因为虽然connFlow是一次性实例化，但每次调用runWith都会构建新的connection，而实例化和构建新connection会拖慢系统运行速度，不适用于像streaming这样大量消息的相互传递。

上面的这种模式就是所谓Connection-Level-Client-Side-Api。这种模式可以让用户有更大程度的自由度控制connection的构建、使用及在connection上发送request的方式。一般来讲，当返回response的entity被完全消耗后系统会自动close connection，这套api还提供了一些手动方法可以在有需要的情况下手动进行connection close，如下：

 //close connection by cancelling response entityresp.entity.dataBytes.runWith(Sink.cancelled)//close connection by receiving response with close headerHttp().bindAndHandleSync({ req ⇒ HttpResponse(headers = headers.Connection("close") :: Nil) },"akka.io",80)(mat)

Akka-http客户端api还有一种实用的Host-Level-Client-Side-Api模式。这套api能自动针对每个端点维护一个连接池（connection-pool），用户只需对连接池进行配置。系统按照连接池配置自动维护池内线程的生、死、动、停。akka-http.host-connection-pool配置中max-connections,max-open-requests,pipelining-limit等控制着connection、在途request的数量，需要特别注意。针对某个端点的连接池是通过Http().cachedHostConnectionPool(endPoint)获取的。同样，获取的也是一个client-flow实例。因为系统自动维护着线程池，所以client-flow实例可以任意引用，无论调用次数与调用时间间隔。cachedHostConnectionPool()函数定义如下：

  /*** Same as [[#cachedHostConnectionPool]] but for encrypted (HTTPS) connections.** If an explicit [[ConnectionContext]] is given then it rather than the configured default [[ConnectionContext]] will be used* for encryption on the connections.** To configure additional settings for the pool (and requests made using it),* use the `akka.http.host-connection-pool` config section or pass in a [[ConnectionPoolSettings]] explicitly.*/def cachedHostConnectionPoolHttps[T](host: String, port: Int = 443,connectionContext: HttpsConnectionContext = defaultClientHttpsContext,settings:          ConnectionPoolSettings = defaultConnectionPoolSettings,log:               LoggingAdapter         = system.log)(implicit fm: Materializer): Flow[(HttpRequest, T), (Try[HttpResponse], T), HostConnectionPool] = {val cps = ConnectionPoolSetup(settings, connectionContext, log)val setup = HostConnectionPoolSetup(host, port, cps)cachedHostConnectionPool(setup)}

函数返回结果类型：Flow[(HttpRequest,T),(Try[HttpResponse],T),HostConnectionPool]。因为线程池内的线程是异步构建request和接收response的，而返回response的顺序未必按照发送request的顺序，所以需要一个tuple2的T类型标示request与返回的response进行匹配。线程池会根据idle-timeout自动终止，也可以手动通过HostConnectionPool.shutDown()实现： 

  /*** Represents a connection pool to a specific target host and pool configuration.*/final case class HostConnectionPool private[http] (setup: HostConnectionPoolSetup)(private[http] val gateway: PoolGateway) { // enable test access/*** Asynchronously triggers the shutdown of the host connection pool.** The produced [[scala.concurrent.Future]] is fulfilled when the shutdown has been completed.*/def shutdown()(implicit ec: ExecutionContextExecutor): Future[Done] = gateway.shutdown()private[http] def toJava = new akka.http.javadsl.HostConnectionPool {override def setup = HostConnectionPool.this.setupoverride def shutdown(executor: ExecutionContextExecutor): CompletionStage[Done] = HostConnectionPool.this.shutdown()(executor).toJava}}

也可以通过Http().shutdownAllConnectionPools()一次性终止ActorSystem内所有线程池: 

  /*** Triggers an orderly shutdown of all host connections pools currently maintained by the [[akka.actor.ActorSystem]].* The returned future is completed when all pools that were live at the time of this method call* have completed their shutdown process.** If existing pool client flows are re-used or new ones materialized concurrently with or after this* method call the respective connection pools will be restarted and not contribute to the returned future.*/def shutdownAllConnectionPools(): Future[Unit] = {val shutdownCompletedPromise = Promise[Done]()poolMasterActorRef ! ShutdownAll(shutdownCompletedPromise)shutdownCompletedPromise.future.map(_ ⇒ ())(system.dispatcher)}

我们用cachedHostConnectionPool获取一个client-flow实例：

Flow[(HttpRequest,T),(Try[HttpResponse],T),HostConnectionPool]后就可以进行输入HttpRequest到HttpResponse的转换处理。如下面的例子：

  val pooledFlow: Flow[(HttpRequest,Int),(Try[HttpResponse],Int),Http.HostConnectionPool] =Http().cachedHostConnectionPool[Int](host="akka.io",port=80)def sendPoolRequest(req: HttpRequest, marker: Int) = {Source.single(req -> marker).via(pooledFlow).runWith(Sink.head)}sendPoolRequest(HttpRequest(uri="/"), 1).andThen{case Success((tryResp, mk)) =>tryResp match {case Success(resp) => println(s"got response: ${resp.status.intValue()}")case Failure(err) => println(s"request failed: ${err.getMessage}")}case Failure(err) => println(s"request failed: ${err.getMessage}")}.andThen {case _ => sys.terminate()}

在以上这个例子里实际同样会遇到Connection-Level-Api所遇的的问题，这是因为获取的线程池内的线程还是有限的，只能缓解因为request速率超出response速率所造成的request积压。目前最有效的方法还是通过使用一个queue来暂存request后再逐个处理：

    val QueueSize = 10// This idea came initially from this blog post:// http://kazuhiro.github.io/scala/akka/akka-http/akka-streams/2016/01/31/connection-pooling-with-akka-http-and-source-queue.htmlval poolClientFlow = Http().cachedHostConnectionPool[Promise[HttpResponse]]("akka.io")val queue =Source.queue[(HttpRequest, Promise[HttpResponse])](QueueSize, OverflowStrategy.dropNew).via(poolClientFlow).toMat(Sink.foreach({case ((Success(resp), p)) => p.success(resp)case ((Failure(e), p))    => p.failure(e)}))(Keep.left).run()def queueRequest(request: HttpRequest): Future[HttpResponse] = {val responsePromise = Promise[HttpResponse]()queue.offer(request -> responsePromise).flatMap {case QueueOfferResult.Enqueued    => responsePromise.futurecase QueueOfferResult.Dropped     => Future.failed(new RuntimeException("Queue overflowed. Try again later."))case QueueOfferResult.Failure(ex) => Future.failed(ex)case QueueOfferResult.QueueClosed => Future.failed(new RuntimeException("Queue was closed (pool shut down) while running the request. Try again later."))}}val responseFuture: Future[HttpResponse] = queueRequest(HttpRequest(uri = "/"))responseFuture.andThen {case Success(resp) => println(s"got response: ${resp.status.intValue()}")case Failure(err) => println(s"request failed: ${err.getMessage}")}.andThen {case _ => sys.terminate()}

下面是本次Akka-http-client-side-connection讨论的示范源代码： 

import akka.actor._
import akka.http.javadsl.{HostConnectionPool, OutgoingConnection}
import akka.stream._
import akka.stream.scaladsl._
import akka.http.scaladsl.Http
import akka.http.scaladsl.model._import scala.concurrent._
import scala.util._object ClientApiDemo extends App {implicit val sys = ActorSystem("ClientSys")implicit val mat = ActorMaterializer()implicit val ec = sys.dispatcher
/*val connFlow: Flow[HttpRequest,HttpResponse,Future[Http.OutgoingConnection]] =Http().outgoingConnection("www.sina.com")def sendHttpRequest(req: HttpRequest) = {Source.single(req).via(connFlow).runWith(Sink.head)}sendHttpRequest(HttpRequest(uri="/")).andThen{case Success(resp) =>//close connection by cancelling response entityresp.entity.dataBytes.runWith(Sink.cancelled)println(s"got response: ${resp.status.intValue()}")case Failure(err) => println(s"request failed: ${err.getMessage}")}//   .andThen {case _ => sys.terminate()}//close connection by receiving response with close headerHttp().bindAndHandleSync({ req ⇒ HttpResponse(headers = headers.Connection("close") :: Nil) },"akka.io",80)(mat)val pooledFlow: Flow[(HttpRequest,Int),(Try[HttpResponse],Int),Http.HostConnectionPool] =Http().cachedHostConnectionPool[Int](host="akka.io",port=80)def sendPoolRequest(req: HttpRequest, marker: Int) = {Source.single(req -> marker).via(pooledFlow).runWith(Sink.head)}sendPoolRequest(HttpRequest(uri="/"), 1).andThen{case Success((tryResp, mk)) =>tryResp match {case Success(resp) => println(s"got response: ${resp.status.intValue()}")case Failure(err) => println(s"request failed: ${err.getMessage}")}case Failure(err) => println(s"request failed: ${err.getMessage}")}.andThen {case _ => sys.terminate()}
*/val QueueSize = 10// This idea came initially from this blog post:// http://kazuhiro.github.io/scala/akka/akka-http/akka-streams/2016/01/31/connection-pooling-with-akka-http-and-source-queue.htmlval poolClientFlow = Http().cachedHostConnectionPool[Promise[HttpResponse]]("akka.io")val queue =Source.queue[(HttpRequest, Promise[HttpResponse])](QueueSize, OverflowStrategy.dropNew).via(poolClientFlow).toMat(Sink.foreach({case ((Success(resp), p)) => p.success(resp)case ((Failure(e), p))    => p.failure(e)}))(Keep.left).run()def queueRequest(request: HttpRequest): Future[HttpResponse] = {val responsePromise = Promise[HttpResponse]()queue.offer(request -> responsePromise).flatMap {case QueueOfferResult.Enqueued    => responsePromise.futurecase QueueOfferResult.Dropped     => Future.failed(new RuntimeException("Queue overflowed. Try again later."))case QueueOfferResult.Failure(ex) => Future.failed(ex)case QueueOfferResult.QueueClosed => Future.failed(new RuntimeException("Queue was closed (pool shut down) while running the request. Try again later."))}}val responseFuture: Future[HttpResponse] = queueRequest(HttpRequest(uri = "/"))responseFuture.andThen {case Success(resp) => println(s"got response: ${resp.status.intValue()}")case Failure(err) => println(s"request failed: ${err.getMessage}")}.andThen {case _ => sys.terminate()}}






这篇关于Akka（36）： Http：Client-side-Api，Client-Connections的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

原文地址:
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.chinasem.cn/article/887204。

相关文章

Nginx中配置HTTP/2协议的详细指南

Nginx中配置HTTP/2协议的详细指南

《Nginx中配置HTTP/2协议的详细指南》HTTP/2是HTTP协议的下一代版本,旨在提高性能、减少延迟并优化现代网络环境中的通信效率,本文将为大家介绍Nginx配置HTTP/2协议想详细步骤,需... 目录一、HTTP/2 协议概述1.HTTP/22. HTTP/2 的核心特性3. HTTP/2 的优
阅读更多...
使用Python自建轻量级的HTTP调试工具

使用Python自建轻量级的HTTP调试工具

《使用Python自建轻量级的HTTP调试工具》这篇文章主要为大家详细介绍了如何使用Python自建一个轻量级的HTTP调试工具,文中的示例代码讲解详细,感兴趣的小伙伴可以参考一下... 目录一、为什么需要自建工具二、核心功能设计三、技术选型四、分步实现五、进阶优化技巧六、使用示例七、性能对比八、扩展方向建
阅读更多...
Feign Client超时时间设置不生效的解决方法

Feign Client超时时间设置不生效的解决方法

《FeignClient超时时间设置不生效的解决方法》这篇文章主要为大家详细介绍了FeignClient超时时间设置不生效的原因与解决方法,具有一定的的参考价值,希望对大家有一定的帮助... 在使用Feign Client时，可以通过两种方式来设置超时时间：1.针对整个Feign Client设置超时时间
阅读更多...
使用Python实现快速搭建本地HTTP服务器

使用Python实现快速搭建本地HTTP服务器

《使用Python实现快速搭建本地HTTP服务器》：本文主要介绍如何使用Python快速搭建本地HTTP服务器,轻松实现一键HTTP文件共享,同时结合二维码技术,让访问更简单,感兴趣的小伙伴可以了... 目录1. 概述2. 快速搭建 HTTP 文件共享服务2.1 核心思路2.2 代码实现2.3 代码解读3.
阅读更多...
基于Flask框架添加多个AI模型的API并进行交互

基于Flask框架添加多个AI模型的API并进行交互

《基于Flask框架添加多个AI模型的API并进行交互》：本文主要介绍如何基于Flask框架开发AI模型API管理系统,允许用户添加、删除不同AI模型的API密钥,感兴趣的可以了解下... 目录1. 概述2. 后端代码说明2.1 依赖库导入2.2 应用初始化2.3 API 存储字典2.4 路由函数2.5 应
阅读更多...
Go语言中最便捷的http请求包resty的使用详解

Go语言中最便捷的http请求包resty的使用详解

《Go语言中最便捷的http请求包resty的使用详解》go语言虽然自身就有net/http包,但是说实话用起来没那么好用,resty包是go语言中一个非常受欢迎的http请求处理包,下面我们一起来学... 目录安装一、一个简单的get二、带查询参数三、设置请求头、body四、设置表单数据五、处理响应六、超
阅读更多...
如何使用Docker部署FTP和Nginx并通过HTTP访问FTP里的文件

如何使用Docker部署FTP和Nginx并通过HTTP访问FTP里的文件

《如何使用Docker部署FTP和Nginx并通过HTTP访问FTP里的文件》本文介绍了如何使用Docker部署FTP服务器和Nginx,并通过HTTP访问FTP中的文件,通过将FTP数据目录挂载到N... 目录docker部署FTP和Nginx并通过HTTP访问FTP里的文件1. 部署 FTP 服务器 (
阅读更多...
C#集成DeepSeek模型实现AI私有化的流程步骤(本地部署与API调用教程)

C#集成DeepSeek模型实现AI私有化的流程步骤(本地部署与API调用教程)

《C#集成DeepSeek模型实现AI私有化的流程步骤(本地部署与API调用教程)》本文主要介绍了C#集成DeepSeek模型实现AI私有化的方法,包括搭建基础环境,如安装Ollama和下载DeepS... 目录前言搭建基础环境1、安装 Ollama2、下载 DeepSeek R1 模型客户端 ChatBo
阅读更多...
Qt实现发送HTTP请求的示例详解

Qt实现发送HTTP请求的示例详解

《Qt实现发送HTTP请求的示例详解》这篇文章主要为大家详细介绍了如何通过Qt实现发送HTTP请求,文中的示例代码讲解详细,具有一定的借鉴价值,感兴趣的小伙伴可以跟随小编一起学习一下... 目录1、添加network模块2、包含改头文件3、创建网络访问管理器4、创建接口5、创建网络请求对象6、创建一个回复对
阅读更多...
golang获取prometheus数据(prometheus/client_golang包)

golang获取prometheus数据(prometheus/client_golang包)

《golang获取prometheus数据(prometheus/client_golang包)》本文主要介绍了使用Go语言的prometheus/client_golang包来获取Prometheu... 目录1. 创建链接1.1 语法1.2 完整示例2. 简单查询2.1 语法2.2 完整示例3. 范围值
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2