club.zhcs.lina.auth.jwt.AlgorithmicJWTGenerator Maven / Gradle / Ivy

Go to download
package club.zhcs.lina.auth.jwt;

import java.util.Map;
import java.util.concurrent.TimeUnit;

import org.nutz.lang.Strings;
import org.nutz.lang.Times;
import org.nutz.lang.util.NutMap;

import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTCreator.Builder;
import com.auth0.jwt.JWTVerifier;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.exceptions.JWTVerificationException;
import com.auth0.jwt.interfaces.Claim;

import lombok.AllArgsConstructor;
import lombok.Builder.Default;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;

/**
 * 
 * @author Kerbores([email protected])
 *
 */
@Data
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
public class AlgorithmicJWTGenerator implements JWTGenerator {

    /**
     * 有效期
     */
    @Default
    private long term = 1;
    /**
     * 有效期时间单位
     */
    @Default
    private TimeUnit unit = TimeUnit.DAYS;
    /**
     * 签发人
     */
    @Default
    private String issuer = "club.zhcs";

    /**
     * 签名算法
     */
    @Default
    private Algorithm algorithm = Algorithm.HMAC256("G00dl^ck");

    /**
     * @param subject
     * @param claims
     * @return
     * @see club.zhcs.auth.jwt.JWTGenerator#token(java.lang.String,
     *      java.util.Map)
     */
    @Override
    public String token(String subject, Map claims) {
        return token(subject, claims, term, unit);
    }

    @Override
    public String token(String subject, Map claims, long term, TimeUnit unit) {
        return JWT.create()
                  .withSubject(subject)
                  .withPayload(claims)
                  .withExpiresAt(Times.D(System.currentTimeMillis() + unit.toMillis(term)))
                  .withIssuedAt(Times.now())
                  .withIssuer(issuer)
                  .withNotBefore(Times.now())
                  .sign(algorithm);
    }

    /**
     * @param subject
     * @return
     * @see club.zhcs.auth.jwt.JWTGenerator#token(java.lang.String)
     */
    @Override
    public String token(String subject) {
        return token(subject, NutMap.NEW());
    }

    /**
     * @param subject
     * @param claims
     * @param jti
     * @param kid
     * @return
     * @see club.zhcs.auth.jwt.JWTGenerator#token(java.lang.String,
     *      java.util.Map, java.lang.String, java.lang.String)
     */
    @Override
    public String token(String subject, Map claims, String jti, String kid) {
        Builder builder = JWT.create()
                             .withSubject(subject)
                             .withPayload(claims)
                             .withExpiresAt(Times.D(System.currentTimeMillis() + unit.toMillis(term)))
                             .withIssuedAt(Times.now())
                             .withIssuer(issuer)
                             .withNotBefore(Times.now());
        if (Strings.isNotBlank(jti)) {
            builder.withJWTId(jti);
        }
        if (Strings.isNotBlank(kid)) {
            builder.withKeyId(kid);
        }
        return builder.sign(algorithm);
    }

    /**
     * @param token
     * @return
     * @see club.zhcs.auth.jwt.JWTGenerator#verify(java.lang.String)
     */
    @Override
    public boolean verify(String token) {
        JWTVerifier verifier = JWT.require(algorithm).build();
        try {
            verifier.verify(token);
            return true;
        }
        catch (JWTVerificationException e) {
            return false;
        }
    }

    /**
     * @param token
     * @return
     * @see club.zhcs.auth.jwt.JWTGenerator#subject(java.lang.String)
     */
    @Override
    public String subject(String token) {
        return JWT.decode(token).getSubject();
    }

    /**
     * @param token
     * @return
     * @see club.zhcs.auth.jwt.JWTGenerator#verifiedSubject(java.lang.String)
     */
    @Override
    public String verifiedSubject(String token) {
        if (Strings.isNotBlank(token) && verify(token)) {
            return subject(token);
        }
        return null;
    }

    /**
     * @param token
     * @param name
     * @return
     * @see club.zhcs.auth.jwt.JWTGenerator#claim(java.lang.String,
     *      java.lang.String)
     */
    @Override
    public Claim claim(String token, String name) {
        return JWT.decode(token).getClaim(name);
    }

    /**
     * @param subject
     * @return
     * @see club.zhcs.lina.auth.jwt.JWTGenerator#refreshToken(java.lang.String)
     */
    @Override
    public String refreshToken(String subject) {
        return JWT.create()
                  .withSubject(subject)
                  .withExpiresAt(Times.D(System.currentTimeMillis() + unit.toMillis(term) * 10))
                  .withIssuedAt(Times.now())
                  .withIssuer(issuer)
                  .withNotBefore(Times.now())
                  .sign(algorithm);
    }

    @Override
    public Map claims(String token) {
        return JWT.decode(token).getClaims();
    }

}