使用Scala Play Framework和Silhouette验证失败时如何记录用户凭据

使用Scala Play Framework和Silhouette进行验证时，可以通过以下步骤记录用户凭据的验证失败：

首先，确保已经在项目中添加了Scala Play Framework和Silhouette的依赖。
创建一个自定义的验证失败处理器（FailureHandler），用于记录用户凭据的验证失败。可以继承Silhouette提供的DefaultFailureHandler，并重写handle方法。

import com.mohiva.play.silhouette.api.actions.SecuredErrorHandler
import com.mohiva.play.silhouette.api.{ Logger, RequestProvider }
import com.mohiva.play.silhouette.impl.exceptions.{ IdentityNotFoundException, InvalidPasswordException }
import com.mohiva.play.silhouette.impl.providers.CredentialsProvider
import play.api.mvc.{ RequestHeader, Result }

import scala.concurrent.Future

class CustomSecuredErrorHandler extends SecuredErrorHandler with Logger {

  override def onNotAuthenticated(implicit request: RequestHeader): Future[Result] = {
    // 记录用户凭据验证失败的日志
    logger.error(s"Authentication failed for ${request.remoteAddress}")
    Future.successful(Results.Unauthorized)
  }

  override def onNotAuthorized(implicit request: RequestHeader): Future[Result] = {
    // 记录用户凭据验证失败的日志
    logger.error(s"Authorization failed for ${request.remoteAddress}")
    Future.successful(Results.Forbidden)
  }
}

在应用程序的配置文件（application.conf）中配置自定义的验证失败处理器。

silhouette {
  errorHandler = "com.example.CustomSecuredErrorHandler"
}

确保在应用程序的路由文件（routes）中定义了登录和验证的路由。

GET     /login                  controllers.AuthenticationController.login
POST    /authenticate           controllers.AuthenticationController.authenticate

创建一个身份验证控制器（AuthenticationController），用于处理登录和验证请求。

import com.mohiva.play.silhouette.api.Silhouette
import com.mohiva.play.silhouette.api.util.Credentials
import com.mohiva.play.silhouette.impl.providers.CredentialsProvider
import javax.inject.Inject
import play.api.mvc.{ AbstractController, ControllerComponents }

import scala.concurrent.{ ExecutionContext, Future }

class AuthenticationController @Inject()(
  cc: ControllerComponents,
  silhouette: Silhouette[UserEnv],
  credentialsProvider: CredentialsProvider
)(implicit ec: ExecutionContext) extends AbstractController(cc) {

  def login = Action.async { implicit request =>
    Future.successful(Ok(views.html.login()))
  }

  def authenticate = Action.async { implicit request =>
    val credentials = Credentials(
      request.body.asFormUrlEncoded.get("email").head,
      request.body.asFormUrlEncoded.get("password").head
    )

    credentialsProvider.authenticate(credentials).flatMap { loginInfo =>
      silhouette.env.userService.retrieve(loginInfo).flatMap {
        case Some(user) => silhouette.env.authenticatorService.create(loginInfo).map {
          case authenticator if credentialsProvider.authenticatorIdleTimeout.isDefined =>
            authenticator.copy(
              idleTimeout = credentialsProvider.authenticatorIdleTimeout,
              expirationDateTime = credentialsProvider.authenticatorExpiry.toDateTime
            )
          case authenticator => authenticator
        }.flatMap { authenticator =>
          silhouette.env.eventBus.publish(LoginEvent(user, request))
          silhouette.env.authenticatorService.init(authenticator).flatMap { token =>
            silhouette.env.authenticatorService.embed(token, Ok("Authentication successful"))
          }
        }
        case None => Future.failed(new IdentityNotFoundException("Couldn't find user"))
      }
    }.recover {
      case _: InvalidPasswordException => Unauthorized("Invalid credentials")
    }
  }
}

通过以上步骤，当用户凭据验证失败时，会记录相应的日志信息。你可以根据实际需求自定义日志的格式和存储方式。