Akka HTTP Scala JWT认证报错：decode/isValid方法重载不匹配

我正在给Akka HTTP Scala应用的API加JWT认证，已经引入了jwt-circe和jwt-core依赖，但调用Jwt.isValid和Jwt.decode时出现类型错误，提示没有匹配的重载方法。以下是相关代码、SBT配置和完整错误信息。

案例类代码 #

final case class Account(name: String, age: Int, country: String, roles: List[String])

object JsonFormats {
import DefaultJsonProtocol._

implicit val accountFormat: RootJsonFormat[Account] = jsonFormat4(Account.apply)
}

JWT认证代码 #

import pdi.jwt.{ Jwt, JwtAlgorithm, JwtClaim, JwtCirce }

private val expiresIn = 1 * 24 * 60 * 60
implicit val clock: Clock = Clock.systemUTC
private val secretKey = "vp-akka-http-jwt"

def authenticated: Directive1[Account] =
  optionalHeaderValueByName("Authorization").flatMap {
    case Some(jwtToken) if Jwt.isValid(jwtToken, secretKey, Seq(JwtAlgorithm.HS256)) =>
         getClaims(jwtToken) match {
           case Some(account) => provide(account)
           case None => reject(AuthorizationFailedRejection).toDirective[Tuple1[Account]]
         }
    case t => println(t.get)
           complete(StatusCodes.Unauthorized)
}
      
private def getClaims(jwtToken: String): Option[Account] = {
    onComplete(Jwt.decode(jwtToken, secretKey, Seq(JwtAlgorithm.HS256))){
       case Success(value) => 
            Some(value.content.parseJson.convertTo[Account])
       case Failure(ex) => None
    }            
}

SBT配置 #

lazy val akkaHttpVersion = "10.6.3"
lazy val akkaVersion    = "2.9.4"

resolvers += "Akka library repository".at("https://repo.akka.io/maven")

fork := true

lazy val root = (project in file(".")).
  settings(
    inThisBuild(List(
      organization    := "com.example",
      scalaVersion    := "3.3.3"
    )),
    name := "eskimi-bidding-agent",
    libraryDependencies ++= Seq(
      // ....
      ("com.github.jwt-scala"     %% "jwt-circe"             % "10.0.1")
         .exclude("io.circe", "circe-parser_3")
         .exclude("io.circe", "circe-core_3")
         .exclude("org.typelevel", "cats-kernel_3")
         .exclude("org.typelevel", "cats-core_3")
         .exclude("io.circe", "circe-numbers_3")
         .exclude("org.typelevel", "jawn-parser_3")
         .exclude("io.circe", "circe-jawn_3"),
      "com.github.jwt-scala"     %% "jwt-core"             % "10.0.1",
      // ....
    )
  )

完整错误信息 #

类型错误：
case Some(jwtToken) if Jwt.isValid(jwtToken, secretKey, Seq(JwtAlgorithm.HS256)) 
JwtCore trait中的isValid方法没有匹配的重载版本，可选类型包括：

(token: String, key: java.security.PublicKey): Boolean
(token: String, key: java.security.PublicKey, options: pdi.jwt.JwtOptions): Boolean
(token: String, key: java.security.PublicKey, algorithms: Seq[pdi.jwt.algorithms.JwtAsymmetricAlgorithm]): Boolean
(token: String, key: java.security.PublicKey, algorithms: Seq[pdi.jwt.algorithms.JwtAsymmetricAlgorithm], options: pdi.jwt.JwtOptions): Boolean
(token: String, key: javax.crypto.SecretKey): Boolean
(token: String, key: javax.crypto.SecretKey, options: pdi.jwt.JwtOptions): Boolean
(token: String, key: javax.crypto.SecretKey, algorithms: Seq[pdi.jwt.algorithms.JwtHmacAlgorithm]): Boolean
(token: String, key: javax.crypto.SecretKey, algorithms: Seq[pdi.jwt.algorithms.JwtHmacAlgorithm], options: pdi.jwt.JwtOptions): Boolean
(token: String, key: String, algorithms: => Seq[pdi.jwt.algorithms.JwtAsymmetricAlgorithm]): Boolean
(token: String, key: String, algorithms: => Seq[pdi.jwt.algorithms.JwtAsymmetricAlgorithm], options: pdi.jwt.JwtOptions): Boolean
(token: String, key: String, algorithms: Seq[pdi.jwt.algorithms.JwtHmacAlgorithm]): Boolean
(token: String, key: String, algorithms: Seq[pdi.jwt.algorithms.JwtHmacAlgorithm], options: pdi.jwt.JwtOptions): Boolean
(token: String): Boolean
(token: String, options: pdi.jwt.JwtOptions): Boolean 
无法匹配参数：((jwtToken : String), (com.example.WebServer.secretKey : String), scala.collection.Seq[pdi.jwt.JwtAlgorithm.HS256.type])

解决方案 #

问题核心 #

1. 算法类型不匹配：JwtAlgorithm.HS256属于JwtHmacAlgorithm类型，但代码中传入的序列类型是Seq[JwtAlgorithm.HS256.type]，编译器无法匹配到对应String密钥的重载方法。
2. 异步逻辑错误：getClaims方法中使用Akka HTTP的onComplete指令，但方法返回类型是Option[Account]，违反了Directive的异步流程规则。

修复步骤 #

1. 明确指定HMAC算法类型

直接导入JwtHmacAlgorithm并使用其下的HS256，让编译器明确算法类型：

import pdi.jwt.algorithms.JwtHmacAlgorithm
private val hmacAlgorithm = JwtHmacAlgorithm.HS256

调用isValid和decode时，传入Seq(hmacAlgorithm)即可匹配正确的重载方法。

2. 修正异步逻辑

将getClaims改为返回Future[Option[Account]]，并在Directive中通过异步方式处理结果：

private def getClaims(jwtToken: String): Future[Option[Account]] = {
  Jwt.decode(jwtToken, secretKey, Seq(hmacAlgorithm))
    .map { claim =>
      import io.circe.generic.auto._
      import io.circe.parser._
      // 用circe解析claim内容到Account实例
      decode[Account](claim.content).toOption
    }
    .recover { case _ => None } // 捕获解码异常，返回None
}

然后在authenticated Directive中通过onSuccess处理Future结果：

def authenticated: Directive1[Account] =
  optionalHeaderValueByName("Authorization").flatMap {
    case Some(jwtToken) if Jwt.isValid(jwtToken, secretKey, Seq(hmacAlgorithm)) =>
      onSuccess(getClaims(jwtToken)).flatMap {
        case Some(account) => provide(account)
        case None => reject(AuthorizationFailedRejection)
      }
    case _ => complete(StatusCodes.Unauthorized)
  }

3. 简化依赖配置（可选）

如果项目中已经依赖circe相关库，无需手动排除jwt-circe的依赖项，直接引入即可避免冲突：

"com.github.jwt-scala" %% "jwt-circe" % "10.0.1",
"com.github.jwt-scala" %% "jwt-core" % "10.0.1"

关键说明 #

• jwt-scala库将算法分为两类：HMAC系列（HS256/HS384/HS512）对应JwtHmacAlgorithm，非对称加密系列（RSA/ECDSA）对应JwtAsymmetricAlgorithm，调用方法时必须匹配密钥类型和算法类型。
• Akka HTTP的Directive基于异步流设计，所有IO操作（如JWT解码）需返回Future，再通过onSuccess/flatMap整合到Directive流程中，不能在普通方法中使用onComplete指令。

内容的提问来源于stack exchange，提问作者Vakindu