驾驶心思从而领会人生某些都不夸

于是乎大家反思,生活为何是一地鸡毛?婚姻为何是包围?有了儿女后为啥处处焦虑?

 

记念相当寓言故事,大概哈,一个很帅的大将,为了保住天子的人命,愿意娶一位丑陋却魔法无边的女巫做妻子,女巫跟将军说,我一天里有一半时日可以做美女,另一半时日就是这般事儿了,你怎么选?白天仍旧夜晚?全国人包括国王听了后都分外惋惜将军,将军却很平静,他说:“这一个业务,应该由你协调来控制。”将军这话说得就是布置,结局就是,女巫当然希望团结白天晚间都是嫦娥呀,于是将军就获取了美女归,爽歪歪了嘛~

 


 

批判是内哄的工作,无论批判旁人如故批判旁人都向来会耗费自己的能量。

 

“可以不记得带书本或书包,偶尔体验一下忘事也是足以的 ”

 


  case class Item(id: Int, name: String, price: Double)

  def getItem(itemId: Int): Future[HttpResponse] = for {
    response <- Http().singleRequest(HttpRequest(method=HttpMethods.GET,uri = s"http://localhost:8011/item/$itemId"))
  } yield response

  def extractEntity[T](futResp: Future[HttpResponse])(implicit um: Unmarshaller[ResponseEntity,T]) = {
    futResp.andThen {
      case Success(HttpResponse(StatusCodes.OK, _, entity, _)) =>
        Unmarshal(entity).to[T]
          .onComplete {
            case Success(t) => println(s"Got response entity: ${t}")
            case Failure(e) => println(s"Unmarshalling failed: ${e.getMessage}")
          }
      case Success(_) => println("Exception in response!")
      case Failure(err) => println(s"Response Failed: ${err.getMessage}")
    }
  }
  extractEntity[Item](getItem(13))

当今那个extractEntity[Item](getItem(13))能够实现全经过的监控管理了。用平等的情势实现PUT操作:

场景

本来,我们仍然采纳了前方几篇商量里的马尔斯halling格局来展开多少格式的自动转换:

归因

一旦大家需要对数据沟通过程进展更仔细的管控,用Host-Level-Api会更加适合。下边我们就针对Host-Level-Api构建一个客户端的工具库:

回归生活,正向坚韧不拔

 

“甚至足以不记得带钥匙依旧午餐,也是一种体验”

服务端代码:

“生活每一个当下都是友善的报应安排,不去诟病也是足以的”

 

故事归故事,寓意依旧很大的,扣题前日的情怀管理,就是不管什么时候,管好自己的心态,任别人做去,任别人说去,一切都是允许的,对人家对自己都少去鉴定,什么人还尚未做不好事情的时候吗。激情是魔鬼,修炼很值得。赢得人生,起码需要稳住自己,平稳平和去做团结的每一件事,尽量不去被打搅。一地鸡毛可以有,一地鹅绒也可以有,一地黄金更可以有,选用松手的心态,就会完全的为友好储存能量。能量只要丰盛多,内心就会变强大。一个心灵平时性强大的人,不管什么样,都能更好的面对每日。指引好自己的心气,就有可能成功一切。

管理,客户端源代码: 

允许“孩子可以哭,也足以哭久一点”

   Akka-http的客户端连接情势除Connection-Level和Host-Level之外还有一种相当有利于的形式:Request-Level-Api。这种形式免除了连年Connection的概念,任啥时候候可以直接调用singleRequest来与服务端沟通。下面我们用多少个例证来示范singleRequest的用法:

本来了,心绪就是心态,啥地方来的那么多不易,当下来了就是来了。所以我们需要磨练,磨炼允许。

import akka.actor._
import akka.http.scaladsl.settings.ConnectionPoolSettings
import akka.stream._
import akka.stream.scaladsl._
import akka.http.scaladsl.Http
import akka.http.scaladsl.model._

import scala.util._
import de.heikoseeberger.akkahttpjson4s.Json4sSupport
import org.json4s.jackson

import scala.concurrent._
import akka.http.scaladsl.unmarshalling.Unmarshal
import akka.http.scaladsl.unmarshalling._
import akka.http.scaladsl.marshalling.Marshal

import scala.collection.SortedMap
import akka.http.scaladsl.common._

trait JsonCodec extends Json4sSupport {
  import org.json4s.DefaultFormats
  import org.json4s.ext.JodaTimeSerializers
  implicit val serilizer = jackson.Serialization
  implicit val formats = DefaultFormats ++ JodaTimeSerializers.all
}
object JsConverters extends JsonCodec

class PooledClient(host: String, port: Int, poolSettings: ConnectionPoolSettings)
                  (implicit sys: ActorSystem, mat: ActorMaterializer) {

  import sys.dispatcher

  private val cnnPool: Flow[(HttpRequest, Int), (Try[HttpResponse], Int), Http.HostConnectionPool] =
    Http().cachedHostConnectionPool[Int](host = host, port = port, settings = poolSettings)

  def requestSingleResponse(req: HttpRequest): Future[HttpResponse] = {
    Source.single(req -> 1)
      .via(cnnPool)
      .runWith(Sink.head).flatMap {
      case (Success(resp), _) => Future.successful(resp)
      case (Failure(fail), _) => Future.failed(fail)
    }
  }

  def orderedResponses(reqs: Iterable[HttpRequest]): Future[Iterable[HttpResponse]] = {
    Source(reqs.zipWithIndex.toMap)
      .via(cnnPool)
      .runFold(SortedMap[Int, Future[HttpResponse]]()) {
        case (m, (Success(r), idx)) => m + (idx -> Future.successful(r))
        case (m, (Failure(f), idx)) => m + (idx -> Future.failed(f))
      }.flatMap { m => Future.sequence(m.values) }
  }
}
class QueuedRequestsClient(host: String, port: Int, poolSettings: ConnectionPoolSettings)
                          (qsize: Int = 10, overflowStrategy: OverflowStrategy = OverflowStrategy.dropNew)
                  (implicit sys: ActorSystem, mat: ActorMaterializer) {
  import sys.dispatcher
  private val cnnPool: Flow[(HttpRequest,Promise[HttpResponse]),(Try[HttpResponse],Promise[HttpResponse]),Http.HostConnectionPool] =
    Http().cachedHostConnectionPool[Promise[HttpResponse]](host=host,port=port,settings=poolSettings)

  val queue =
    Source.queue[(HttpRequest, Promise[HttpResponse])](qsize, overflowStrategy)
      .via(cnnPool)
      .to(Sink.foreach({
        case ((Success(resp), p)) => p.success(resp)
        case ((Failure(e), p))    => p.failure(e)
      })).run()

  def queueRequest(request: HttpRequest): Future[HttpResponse] = {
      val responsePromise = Promise[HttpResponse]()
      queue.offer(request -> responsePromise).flatMap {
        case QueueOfferResult.Enqueued    => responsePromise.future
        case 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."))
      }
  }
}
object ClientRequesting extends App {
  import JsConverters._

  implicit val sys = ActorSystem("sysClient")
  implicit val mat = ActorMaterializer()
  implicit val ec = sys.dispatcher

  implicit val jsonStreamingSupport = EntityStreamingSupport.json()
    .withParallelMarshalling(parallelism = 8, unordered = false)

  case class Item(id: Int, name: String, price: Double)

  def extractEntity[T](futResp: Future[HttpResponse])(implicit um: Unmarshaller[ResponseEntity,T]) = {
    futResp.andThen {
      case Success(HttpResponse(StatusCodes.OK, _, entity, _)) =>
        Unmarshal(entity).to[T]
          .onComplete {
            case Success(t) => println(s"Got response entity: ${t}")
            case Failure(e) => println(s"Unmarshalling failed: ${e.getMessage}")
          }
      case Success(_) => println("Exception in response!")
      case Failure(err) => println(s"Response Failed: ${err.getMessage}")
    }
  }


  (for {
    response <- Http().singleRequest(HttpRequest(method=HttpMethods.GET,uri="http://localhost:8011/message"))
    message <- Unmarshal(response.entity).to[String]
  } yield message).andThen {
    case Success(msg) => println(s"Received message: $msg")
    case Failure(err) => println(s"Error: ${err.getMessage}")
  }  //.andThen {case _ => sys.terminate()}


  (for {
    entity <- Marshal("Wata hell you doing?").to[RequestEntity]
    response <- Http().singleRequest(HttpRequest(method=HttpMethods.PUT,uri="http://localhost:8011/message",entity=entity))
    message <- Unmarshal(response.entity).to[String]
  } yield message).andThen {
    case Success(msg) => println(s"Received message: $msg")
    case Failure(err) => println(s"Error: ${err.getMessage}")
  } //.andThen {case _ => sys.terminate()}


  def getItem(itemId: Int): Future[HttpResponse] = for {
    response <- Http().singleRequest(HttpRequest(method=HttpMethods.GET,uri = s"http://localhost:8011/item/$itemId"))
  } yield response

  extractEntity[Item](getItem(13))

  def putItem(item: Item): Future[HttpResponse] =
   for {
    reqEntity <- Marshal(item).to[RequestEntity]
    response <- Http().singleRequest(HttpRequest(method=HttpMethods.PUT,uri="http://localhost:8011/item",entity=reqEntity))
   } yield response

  extractEntity[Item](putItem(Item(23,"Item#23", 46.0)))
     .andThen { case _ => sys.terminate()}

  val settings = ConnectionPoolSettings(sys)
    .withMaxConnections(8)
    .withMaxOpenRequests(8)
    .withMaxRetries(3)
    .withPipeliningLimit(4)
  val pooledClient = new PooledClient("localhost",8011,settings)

  def getItemByPool(itemId: Int): Future[HttpResponse] = for {
    response <- pooledClient.requestSingleResponse(HttpRequest(method=HttpMethods.GET,uri = s"http://localhost:8011/item/$itemId"))
  } yield response

  extractEntity[Item](getItemByPool(13))

  def getItemsByPool(itemIds: List[Int]): Future[Iterable[HttpResponse]] = {
    val reqs = itemIds.map { id =>
      HttpRequest(method = HttpMethods.GET, uri = s"http://localhost:8011/item/$id")
    }
    val rets = (for {
      responses <- pooledClient.orderedResponses(reqs)
    } yield responses)
    rets
  }
  val futResps = getItemsByPool(List(3,5,7))

  futResps.andThen {
    case Success(listOfResps) => {
      listOfResps.foreach { r =>
        r match {
          case HttpResponse(StatusCodes.OK, _, entity, _) =>
            Unmarshal(entity).to[Item]
              .onComplete {
                case Success(t) => println(s"Got response entity: ${t}")
                case Failure(e) => println(s"Unmarshalling failed: ${e.getMessage}")
              }
          case _ => println("Exception in response!")
        }
      }
    }
    case _ => println("Failed to get list of responses!")
  }

  val queuedClient = new QueuedRequestsClient("localhost",8011,settings)()

  def putItemByQueue(item: Item): Future[HttpResponse] =
    for {
      reqEntity <- Marshal(item).to[RequestEntity]
      response <- queuedClient.queueRequest(HttpRequest(method=HttpMethods.PUT,uri="http://localhost:8011/item",entity=reqEntity))
    } yield response

  extractEntity[Item](putItemByQueue(Item(23,"Item#23", 46.0)))
    .andThen { case _ => sys.terminate()}


}

图为增城白水寨,喜欢徒步的心上人可以去爬9999阶梯观赏最大落差瀑布

 

比如说:大哥不爱吃饭,舅妈一直觉得是二弟阿姨不善做菜的因由,因为三哥就爱在舅妈家吃饭。于是当舅妈的幼子先河不乐意吃饭的时候,舅妈就要用一些能力去摆脱是不是团结也不会做菜的来头,或者归咎于外甥就是太偏食。无论什么样,只要批判的口子一经出现,就需要花费自己许多的能力去抚平,因为事件总会两面性的暴发在各类人身上,事件是合理的,也是持平的,有些人这地点做得好,那下边做不佳,人又是有共性的,每三次的批判别人,潜意识里都会炫耀给协调。这也是怎么出轨门的男主角那么惹众怒,但是倘使观众们真认真起来,也会打扰到自己生活的一个原因。“天下男人一般坏,乌鸦一般黑”有这种执念的人,往往自己先不好过,因为内哄就在如此的祥林嫂循环里日益自己削弱自己了。所以,举个不确切的事例,天下男人要么乌鸦,我们都不亮堂始末是什么,放下裁判,每个人的事情都有自己的走向,每个人都要为自己担负,大家也一如既往,先对友好担当。假如批判会裁减自己造成能量不足从而心绪往不良指导,这是不是就内容倒置了?

 

感到情商这一个事儿是从有了娃后,孩子频繁是最能激励出父母内在表现的一个合理。每日和子女的互相(心理撕扯及相互关怀)都让家长一点一滴体味到祥和的内在转变。那种体会来源于父母的自问。而反思的重力是为了变成更好的父母,为了子女而做的反省是最大的主观能动性发挥。

下边是此次商量的示范源代码:

岳丈买了有趣的归来,氛围协调,洋洋得意系数。因为孩子第一次玩也要命雀跃,把玩具拆了(男孩儿一般喜欢拆轮子)或者把颜料打翻了(确实不佳把控),和谐被打破了,停顿一下,是不是有很多次感觉一个好的考虑和愿意,就因男女的后续行动而被毁掉掉,整段垮掉了,有木有?这时,就会容易刺激父母的一部分不佳心理,例如站在五叔的立场,心血一翻,没够几秒就被秒了,能好受吗?岳母立场,好不容易收拾干净的厅堂又被颜料毁了。心情需要开口啊,心绪是个鬼,跟着好走他就好,跟着坏走他就坏。不良心境由于这瞬间的行径侵占了家庭,出口只好归纳责任,要么一起责备孩子不小心,要么大姨责备三叔不该买回来。无论什么样都损坏了和谐,得不偿失。

以上是个PUT操作。我们需要先构建数据载体HttpEntity。格式转换函数马尔斯hal也回到Future[HttpEntity],所以也足以涵盖在for语句内。关注一下这多少个andThen,它可以连续不断一串多少个monadic运算,在不影响上游运算结果的情事下促成部分副功用总结。值得注意的是下面这多少个例子尽管表现形式很简短,但大家无能为力对数据转换过程中的分外及response的状态码等展开监察。所以我们应有把全体经过拆分成两片段:先得到response,再具体处理response,包括审批状态,处理数据等:


  (for {
    response <- Http().singleRequest(HttpRequest(method=HttpMethods.GET,uri="http://localhost:8011/message"))
    message <- Unmarshal(response.entity).to[String]
  } yield message).andThen {
    case Success(msg) => println(s"Received message: $msg")
    case Failure(err) => println(s"Error: ${err.getMessage}")
  }.andThen {case _ => sys.terminate()}

实在都是因为大家把握不住当下,或者说我们让当下的不良心思牵引着走了。大家违背了应当引导的自由化,应该把握的趋势。人生就是由许五个立时组合的,结局结果咋样,其实早已设定,我们假使能把即刻把持好,其实就已经是最美好的历程,一般经过美好已经是很好的风波,起码这多少个ING是好的。咋样完成把控当下,这就只能把控当下的心理。说了心境是个鬼,所以,察觉警惕激情非常重大,不是颇具情怀都是好的,有些不良的心气会令人轻则毁掉激情,重则家破人亡。所以,做每天最好的自己,就是当每一个不良激情侵袭时,一定要顿时发觉,并用心调整,这里要分手,发生在投机身边相比较密切的人和事,这个影响自然是很大的,相比容易发现,这时,就要归纳,到底是干吗?孩子拆新玩具的车轮,只是好奇,对儿女来说不设有怎么玩是磨损,只存在玩和不玩,所以不要标签孩子。孩子不是刻意破坏,尽管指望儿女了然这一个动作对您的震慑,就不可能不跟孩子说清楚,说清楚了,就足以了。打翻了颜色弄脏了家里也不是老爹的错,因为爹爹本意并非如此,但足以请求伯伯的匡助,并让孩子也一并赞助,让大家都知晓这么些工作的拍卖就能够了。

下面是那多少个工具函数的现举办使示范:

人生在于每天,每一日在于当下,当下在于每一个好的激情,心情是一个经过,也是一个鬼东西。识别这多少个东西,警惕这多少个东西,别老不知死活去激活或者吸引他糟糕的单方面。冲动是魔鬼,这是句名言啊,情绪是一个潜在的事物,却像瓦斯扳平,时不时会趁着有些场地或生活细节泄显露来,如何驯服这魔鬼,并与之共处好天天,甚至能把死神转变为天使,这也是门生活形式。

 

“岳父可以生气,小姑也足以生气或烦躁”

 

制止批判

  val settings = ConnectionPoolSettings(sys)
    .withMaxConnections(8)
    .withMaxOpenRequests(8)
    .withMaxRetries(3)
    .withPipeliningLimit(4)
  val pooledClient = new PooledClient("localhost",8011,settings)

  def getItemByPool(itemId: Int): Future[HttpResponse] = for {
    response <- pooledClient.requestSingleResponse(HttpRequest(method=HttpMethods.GET,uri = s"http://localhost:8011/item/$itemId"))
  } yield response

  extractEntity[Item](getItemByPool(13))

  def getItemsByPool(itemIds: List[Int]): Future[Iterable[HttpResponse]] = {
    val reqs = itemIds.map { id =>
      HttpRequest(method = HttpMethods.GET, uri = s"http://localhost:8011/item/$id")
    }
    val rets = (for {
      responses <- pooledClient.orderedResponses(reqs)
    } yield responses)
    rets
  }
  val futResps = getItemsByPool(List(3,5,7))

  futResps.andThen {
    case Success(listOfResps) => {
      listOfResps.foreach { r =>
        r match {
          case HttpResponse(StatusCodes.OK, _, entity, _) =>
            Unmarshal(entity).to[Item]
              .onComplete {
                case Success(t) => println(s"Got response entity: ${t}")
                case Failure(e) => println(s"Unmarshalling failed: ${e.getMessage}")
              }
          case _ => println("Exception in response!")
        }
      }
    }
    case _ => println("Failed to get list of responses!")
  }

  val queuedClient = new QueuedRequestsClient("localhost",8011,settings)()


  def putItemByQueue(item: Item): Future[HttpResponse] =
    for {
      reqEntity <- Marshal(item).to[RequestEntity]
      response <- queuedClient.queueRequest(HttpRequest(method=HttpMethods.PUT,uri="http://localhost:8011/item",entity=reqEntity))
    } yield response

  extractEntity[Item](putItemByQueue(Item(23,"Item#23", 46.0)))
    .andThen { case _ => sys.terminate()}
class PooledClient(host: String, port: Int, poolSettings: ConnectionPoolSettings)
                  (implicit sys: ActorSystem, mat: ActorMaterializer) {

  import sys.dispatcher

  private val cnnPool: Flow[(HttpRequest, Int), (Try[HttpResponse], Int), Http.HostConnectionPool] =
    Http().cachedHostConnectionPool[Int](host = host, port = port, settings = poolSettings)
//单一request
  def requestSingleResponse(req: HttpRequest): Future[HttpResponse] = {
    Source.single(req -> 1)
      .via(cnnPool)
      .runWith(Sink.head).flatMap {
      case (Success(resp), _) => Future.successful(resp)
      case (Failure(fail), _) => Future.failed(fail)
    }
  }
//组串request
  def orderedResponses(reqs: Iterable[HttpRequest]): Future[Iterable[HttpResponse]] = {
    Source(reqs.zipWithIndex.toMap)
      .via(cnnPool)
      .runFold(SortedMap[Int, Future[HttpResponse]]()) {
        case (m, (Success(r), idx)) => m + (idx -> Future.successful(r))
        case (m, (Failure(f), idx)) => m + (idx -> Future.failed(f))
      }.flatMap { m => Future.sequence(m.values) }
  }
}

下边是一种相比安全的格局:使用了queue来暂存request从而解决因发送方与接受方速率不同所发生的题目:

class QueuedRequestsClient(host: String, port: Int, poolSettings: ConnectionPoolSettings)
                          (qsize: Int = 10, overflowStrategy: OverflowStrategy = OverflowStrategy.dropNew)
                  (implicit sys: ActorSystem, mat: ActorMaterializer) {
  import sys.dispatcher
  private val cnnPool: Flow[(HttpRequest,Promise[HttpResponse]),(Try[HttpResponse],Promise[HttpResponse]),Http.HostConnectionPool] =
    Http().cachedHostConnectionPool[Promise[HttpResponse]](host=host,port=port,settings=poolSettings)

  val queue =
    Source.queue[(HttpRequest, Promise[HttpResponse])](qsize, overflowStrategy)
      .via(cnnPool)
      .to(Sink.foreach({
        case ((Success(resp), p)) => p.success(resp)
        case ((Failure(e), p))    => p.failure(e)
      })).run()

  def queueRequest(request: HttpRequest): Future[HttpResponse] = {
      val responsePromise = Promise[HttpResponse]()
      queue.offer(request -> responsePromise).flatMap {
        case QueueOfferResult.Enqueued    => responsePromise.future
        case 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."))
      }
  }
}
 (for {
    entity <- Marshal("Wata hell you doing?").to[RequestEntity]
    response <- Http().singleRequest(HttpRequest(method=HttpMethods.PUT,uri="http://localhost:8011/message",entity=entity))
    message <- Unmarshal(response.entity).to[String]
  } yield message).andThen {
    case Success(msg) => println(s"Received message: $msg")
    case Failure(err) => println(s"Error: ${err.getMessage}")
  }.andThen {case _ => sys.terminate()}

 

 

import akka.actor._
import akka.stream._
import akka.http.scaladsl.Http
import akka.http.scaladsl.server.Directives._

import de.heikoseeberger.akkahttpjson4s.Json4sSupport
import org.json4s.jackson
trait JsonCodec extends Json4sSupport {
  import org.json4s.DefaultFormats
  import org.json4s.ext.JodaTimeSerializers
  implicit val serilizer = jackson.Serialization
  implicit val formats = DefaultFormats ++ JodaTimeSerializers.all
}
object JsConverters extends JsonCodec


object TestServer extends App with JsonCodec {
  implicit val httpSys = ActorSystem("httpSystem")
  implicit val httpMat = ActorMaterializer()
  implicit val httpEC = httpSys.dispatcher

  import JsConverters._

  case class Item(id: Int, name: String, price: Double)
  val messages = path("message") {
    get {
      complete("hello, how are you?")
    } ~
    put {
      entity(as[String]) {msg =>
        complete(msg)
      }
    }
  }
  val items =
    (path("item" / IntNumber) & get) { id =>
       get {
         complete(Item(id, s"item#$id", id * 2.0))
       }
    } ~
      (path("item") & put) {
        entity(as[Item]) {item =>
          complete(item)
        }
     }

  val route = messages ~ items

  val (host, port) = ("localhost", 8011)

  val bindingFuture = Http().bindAndHandle(route,host,port)


  println(s"Server running at $host $port. Press any key to exit ...")

  scala.io.StdIn.readLine()

  bindingFuture.flatMap(_.unbind())
    .onComplete(_ => httpSys.terminate())

}
  def putItem(item: Item): Future[HttpResponse] =
   for {
    reqEntity <- Marshal(item).to[RequestEntity]
    response <- Http().singleRequest(HttpRequest(method=HttpMethods.PUT,uri="http://localhost:8011/item",entity=reqEntity))
   } yield response

  extractEntity[Item](putItem(Item(23,"Item#23", 46.0)))
     .andThen { case _ => sys.terminate()}

 

import de.heikoseeberger.akkahttpjson4s.Json4sSupport
import org.json4s.jackson
...
trait JsonCodec extends Json4sSupport {
  import org.json4s.DefaultFormats
  import org.json4s.ext.JodaTimeSerializers
  implicit val serilizer = jackson.Serialization
  implicit val formats = DefaultFormats ++ JodaTimeSerializers.all
}
object JsConverters extends JsonCodec
...
  import JsConverters._

  implicit val jsonStreamingSupport = EntityStreamingSupport.json()
    .withParallelMarshalling(parallelism = 8, unordered = false)

这是一个GET操作:用Http().singleRequest直接把HttpRequest发送给服务端uri并得到重回的HttpResponse。我们见到,整组函数的归来类型都是Future[?],所以用for-comprehension来把装有实际运算包嵌在Future运算情势内(context)。上边那个例子是客户端上传数据示范:

Post Author: admin

发表评论

电子邮件地址不会被公开。 必填项已用*标注