scala akka http类型不匹配

Question

我使用开放 api 创建了一个项目，然后添加了一个端点 GET /product 应该返回一个产品（我正在测试它，所以我只想让它返回任何产品）。

运行项目时出现以下错误。

[error]  found   : org.openapitools.server.model.Product.type
[error]  required: (?, ?, ?) => ?
[error]     def toEntityMarshallerProduct: ToEntityMarshaller[Product] = jsonFormat3(Product)

日志指向 jsonFormat3 中的 Product

我注意到这是由产品模型的属性数量引起的，如果我将它们减少到 3 个，它就可以了！这很奇怪！有谁知道如何解决这个问题？

这是产品模型文件

package org.openapitools.server.model
final case class Product (
  id: Int,
  name: String,
  isAvailable: Boolean,
  description: String,
  category: String
)

这是 productAPI 文件

package org.openapitools.server.api

import akka.http.scaladsl.server.Directives._
import akka.http.scaladsl.server.Route
import akka.http.scaladsl.model.StatusCodes
import akka.http.scaladsl.marshalling.ToEntityMarshaller
import akka.http.scaladsl.unmarshalling.FromEntityUnmarshaller
import akka.http.scaladsl.unmarshalling.FromStringUnmarshaller
import org.openapitools.server.AkkaHttpHelper._
import org.openapitools.server.model.Product


class ProductApi(
    productService: ProductApiService,
    productMarshaller: ProductApiMarshaller
) {

  
  import productMarshaller._

  lazy val route: Route =
    path("product" / "all") { 
      get {  
            productService.productAllGet()
      }
    } 
}




trait ProductApiService {

  def productAllGet200(responseProduct: Product)(implicit toEntityMarshallerProduct: ToEntityMarshaller[Product]): Route =
    complete((200, responseProduct))

  def productAllGet()(implicit toEntityMarshallerProduct: ToEntityMarshaller[Product]): Route 

}

trait ProductApiMarshaller {
  implicit def toEntityMarshallerProduct: ToEntityMarshaller[Product]



}

这是主文件

import akka.actor.typed.{ActorSystem, ActorRef}
import akka.actor.typed.scaladsl.Behaviors

import akka.http.scaladsl.Http
import akka.http.scaladsl.server.Route
import akka.http.scaladsl.server.Directives._
import akka.http.scaladsl.model.StatusCodes
// for JSON serialization/deserialization following dependency is required:
// "com.typesafe.akka" %% "akka-http-spray-json" % AkkaHttpVersion
import akka.http.scaladsl.marshalling.ToEntityMarshaller
import akka.http.scaladsl.marshallers.sprayjson.SprayJsonSupport._
import spray.json.DefaultJsonProtocol._

import scala.io.StdIn

import akka.util.Timeout
import scala.concurrent.duration._
import scala.concurrent.{ ExecutionContext, Future }

import org.openapitools.server.api._
import org.openapitools.server.model._

object Main extends App {

// needed to run the route
implicit val system = ActorSystem(Behaviors.empty, "product")
// implicit val materializer = ActorMaterializer()
// needed for the future map/flatmap in the end and future in fetchItem and saveOrder
implicit val executionContext = system.executionContext

object DefaultMarshaller extends ProductApiMarshaller {
def toEntityMarshallerProduct: ToEntityMarshaller[Product] = jsonFormat3(Product)
}

object DefaultService extends ProductApiService {
def productAllGet() (implicit toEntityMarshallerProduct: ToEntityMarshaller[Product]) : Route = {
val reponse = Future {
Product(1,"product",false,"desc","pizza")
}

requestcontext => {
(reponse).flatMap {
(product: Product) =>
productAllGet200(product)(toEntityMarshallerProduct)(requestcontext)
}
}




}
}

val api = new ProductApi(DefaultService, DefaultMarshaller)

val host = "localhost"
val port = 3005

val bindingFuture = Http().newServerAt(host, port).bind(pathPrefix("api"){api.route})
println(s"Server online at http://${host}:${port}/\nPress RETURN to stop...")

bindingFuture.failed.foreach { ex =>
println(s"${ex} Failed to bind to ${host}:${port}!")
}

StdIn.readLine() // let it run until user presses return
bindingFuture
.flatMap(_.unbind()) // trigger unbinding from the port
.onComplete(_ => system.terminate()) // and shutdown when done
}

我注意到这是由产品模型的属性数量引起的，如果我将它们减少到 3 个，它就可以了！这很奇怪！有谁知道如何解决这个问题？

Answer 1

尝试使用由您的 api 提供的数据传输对象 (DTO) 和内部处理的域模型对象。

所以您将使用 jsonFormat3 作为您的 DTO，而无需使用 jsonFormat5。

案例类内部的简单映射器或辅助方法提供了一个平滑的集成。

例如：

final case class Product (
  id: Int,
  name: String,
  isAvailable: Boolean,
  description: String,
  category: String
) {

  def toDto: ProductDTO = ProductDTO(prop0, prop1, prop2)

}
final case class ProductDTO (
prop0: X,
prop1: Y,
prop2: Z
) {

  def toDomain(propA: X, propB: Y): Product = Product(id, name, isAvailable, description, category)

}

object ProductSupport extends SprayJsonSupport with DefaultJsonProtocol {
   implicit val productFormat = json3Format(ProductDTO)
}