在Akka HTTP中，可以使用akka.http.scaladsl.unmarshalling.FromEntityUnmarshaller来解组具有泛型类型参数的类。以下是一个示例代码：

import akka.actor.ActorSystem
import akka.http.scaladsl.Http
import akka.http.scaladsl.model._
import akka.http.scaladsl.unmarshalling.FromEntityUnmarshaller
import akka.stream.ActorMaterializer
import akka.util.ByteString
import scala.concurrent.Future

case class MyResponse[T](data: T)

object MyResponseUnmarshaller {
  implicit def myResponseUnmarshaller[T](implicit um: FromEntityUnmarshaller[T]): FromEntityUnmarshaller[MyResponse[T]] =
    new FromEntityUnmarshaller[MyResponse[T]] {
      override def apply(entity: HttpEntity): Future[MyResponse[T]] = {
        // 解码实体到ByteString
        entity.dataBytes.runFold(ByteString.empty)(_ ++ _).flatMap { body =>
          // 使用其他解组器解组data字段
          um(entity.withData(body)).map { data =>
            MyResponse(data)
          }
        }
      }
    }
}

object Main extends App {
  implicit val system = ActorSystem()
  implicit val materializer = ActorMaterializer()
  import system.dispatcher

  // 假设我们有一个从JSON解组的解组器
  implicit val jsonUnmarshaller: FromEntityUnmarshaller[String] = ???

  // 注册MyResponseUnmarshaller
  implicit val myResponseUnmarshaller: FromEntityUnmarshaller[MyResponse[String]] =
    MyResponseUnmarshaller.myResponseUnmarshaller[String]

  val response: Future[MyResponse[String]] = Http().singleRequest(HttpRequest(uri = "http://example.com")).flatMap(_.entity.toStrict(1000.millis)).flatMap { entity =>
    // 使用MyResponse[String]解组器解组响应实体
    Unmarshal(entity).to[MyResponse[String]]
  }

  response.onComplete { 
    case scala.util.Success(result) => println(result)
    case scala.util.Failure(error) => println(error.getMessage)
  }
}

在上面的示例代码中，我们首先定义了一个MyResponse类，其中的data字段是泛型类型。然后，我们创建了一个名为MyResponseUnmarshaller的伴生对象，其中包含一个myResponseUnmarshaller隐式值，它实现了FromEntityUnmarshaller[MyResponse[T]]接口。在myResponseUnmarshaller的实现中，我们首先将实体解码为ByteString，然后使用其他解组器解组data字段的值。最后，我们在Main对象中使用MyResponse[String]类型的解组器来解组响应实体。

请注意，上述代码中的jsonUnmarshaller解组器是假设存在的，你需要根据具体的使用情况提供适当的解组器。