如何在Quarkus Framework中实现JWT刷新令牌？

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;

import javax.annotation.Priority;
import javax.enterprise.context.RequestScoped;
import javax.inject.Inject;
import javax.ws.rs.*;
import javax.ws.rs.container.ContainerRequestContext;
import javax.ws.rs.container.ContainerRequestFilter;
import javax.ws.rs.core.Context;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.UriInfo;
import java.security.Key;
import java.time.Duration;
import java.time.Instant;
import java.util.Date;

@Path("/api")
@RequestScoped
public class MyResource {

    @Inject
    private KeyGenerator keyGenerator;

    @GET
    @Path("/protected")
    @Produces(MediaType.TEXT_PLAIN)
    @JWTTokenNeeded
    public String protectedResource() {
        return "This is a protected resource";
    }

    @POST
    @Path("/login")
    @Consumes(MediaType.APPLICATION_JSON)
    @Produces(MediaType.APPLICATION_JSON)
    public Response login(UserCredentials credentials) {
        // Check if the credentials are valid
        if (isValidCredentials(credentials)) {
            // Generate access token
            String accessToken = generateAccessToken(credentials.getUsername());
            // Generate refresh token
            String refreshToken = generateRefreshToken(credentials.getUsername());
            // Return the tokens as response
            return Response.ok(new TokenResponse(accessToken, refreshToken)).build();
        } else {
            return Response.status(Response.Status.UNAUTHORIZED).build();
        }
    }

    @POST
    @Path("/refresh")
    @Consumes(MediaType.APPLICATION_JSON)
    @Produces(MediaType.APPLICATION_JSON)
    public Response refresh(RefreshTokenRequest refreshTokenRequest) {
        // Check if the refresh token is valid
        if (isValidRefreshToken(refreshTokenRequest.getRefreshToken())) {
            // Generate new access token
            String accessToken = generateAccessToken(getUsernameFromRefreshToken(refreshTokenRequest.getRefreshToken()));
            // Return the new access token as response
            return Response.ok(new TokenResponse(accessToken)).build();
        } else {
            return Response.status(Response.Status.UNAUTHORIZED).build();
        }
    }

    private boolean isValidCredentials(UserCredentials credentials) {
        // TODO: Implement your own logic to validate the credentials
        return true;
    }

    private boolean isValidRefreshToken(String refreshToken) {
        // TODO: Implement your own logic to validate the refresh token
        return true;
    }

    private String getUsernameFromRefreshToken(String refreshToken) {
        // TODO: Implement your own logic to extract the username from the refresh token
        return "username";
    }

    private String generateAccessToken(String username) {
        Instant now = Instant.now();
        Instant expiration = now.plus(Duration.ofMinutes(15));
        return Jwts.builder()
                .setSubject(username)
                .setIssuedAt(Date.from(now))
                .setExpiration(Date.from(expiration))
                .signWith(keyGenerator.generateKey(), SignatureAlgorithm.HS256)
                .compact();
    }

    private String generateRefreshToken(String username) {
        Instant now = Instant.now();
        Instant expiration = now.plus(Duration.ofDays(30));
        return Jwts.builder()
                .setSubject(username)
                .setIssuedAt(Date.from(now))
                .setExpiration(Date.from(expiration))
                .signWith(keyGenerator.generateKey(), SignatureAlgorithm.HS256)
                .compact();
    }

    @Priority(Priorities.AUTHENTICATION)
    public static class JWTTokenNeededFilter implements ContainerRequestFilter {

        @Context
        private UriInfo uriInfo;

        @Override
        public void filter(ContainerRequestContext requestContext) {
            // Get the Authorization header from the request
            String authorizationHeader = requestContext.getHeaderString("Authorization");

            // Check if the Authorization header is present and formatted correctly
            if (authorizationHeader == null || !authorizationHeader.startsWith("Bearer ")) {
                requestContext.abortWith(Response.status(Response.Status.UNAUTHORIZED).build());
                return;
            }

            // Extract the JWT token from the Authorization header
            String token = authorizationHeader.substring("Bearer".length()).trim();

            try {
                // Validate the JWT token
                Claims claims = Jwts.parserBuilder()
                        .setSigningKey(keyGenerator.generateKey())
                        .build()
                        .parseClaimsJws(token)
                        .getBody();

                // Add the username to the request context for further processing
                requestContext.setProperty("username", claims.getSubject());

            } catch (Exception e) {
                requestContext.abortWith(Response.status(Response.Status.UNAUTHORIZED).build());
            }
        }
    }

    @NameBinding
    @Retention(RetentionPolicy.RUNTIME)
    @Target({ElementType.TYPE, ElementType.METHOD})
    public @interface JWTTokenNeeded {
    }

    public static class UserCredentials {
        private String username;
        private String password;

        // Getters and setters
    }

    public static class TokenResponse {
        private String accessToken;
        private String refreshToken;

        // Constructors, getters and setters
    }

    public static class RefreshTokenRequest {
        private String refreshToken;

        // Getters and setters
    }

    // Other classes and methods
}