io.jsonwebtoken.lang.Assert#notNull ( )源码实例Demo

/**
 * Generates a new secure-random key pair of sufficient strength for the specified Elliptic Curve {@link
 * SignatureAlgorithm} (must be one of {@code ES256}, {@code ES384} or {@code ES512}) using the specified {@link
 * SecureRandom} random number generator via the specified JCA provider and algorithm name.
 *
 * @param jcaAlgorithmName the JCA name of the algorithm to use for key pair generation, for example, {@code
 *                         ECDSA}.
 * @param jcaProviderName  the JCA provider name of the algorithm implementation (for example {@code "BC"} for
 *                         BouncyCastle) or {@code null} if the default provider should be used.
 * @param alg              alg the algorithm indicating strength, must be one of {@code ES256}, {@code ES384} or
 *                         {@code ES512}
 * @param random           the SecureRandom generator to use during key generation.
 * @return a new secure-randomly generated key pair of sufficient strength for the specified Elliptic Curve {@link
 * SignatureAlgorithm} (must be one of {@code ES256}, {@code ES384} or {@code ES512}) using the specified {@link
 * SecureRandom} random number generator via the specified JCA provider and algorithm name.
 * @see #generateKeyPair()
 * @see #generateKeyPair(SignatureAlgorithm)
 * @see #generateKeyPair(SignatureAlgorithm, SecureRandom)
 */
public static KeyPair generateKeyPair(String jcaAlgorithmName, String jcaProviderName, SignatureAlgorithm alg,
                                      SecureRandom random) {
    Assert.notNull(alg, "SignatureAlgorithm argument cannot be null.");
    Assert.isTrue(alg.isEllipticCurve(), "SignatureAlgorithm argument must represent an Elliptic Curve algorithm.");
    try {
        KeyPairGenerator g;

        if (Strings.hasText(jcaProviderName)) {
            g = KeyPairGenerator.getInstance(jcaAlgorithmName, jcaProviderName);
        } else {
            g = KeyPairGenerator.getInstance(jcaAlgorithmName);
        }

        String paramSpecCurveName = EC_CURVE_NAMES.get(alg);
        ECGenParameterSpec spec = new ECGenParameterSpec(paramSpecCurveName);
        g.initialize(spec, random);
        return g.generateKeyPair();
    } catch (Exception e) {
        throw new IllegalStateException("Unable to generate Elliptic Curve KeyPair: " + e.getMessage(), e);
    }
}
 

@SuppressWarnings("unchecked")
@Override
public Object deserialize(byte[] bytes) throws DeserializationException {

    Assert.notNull(bytes, "JSON byte array cannot be null");

    if (bytes.length == 0) {
        throw new DeserializationException("Invalid JSON: zero length byte array.");
    }

    try {
        String s = new String(bytes, Strings.UTF_8);
        return parse(s);
    } catch (Exception e) {
        String msg = "Invalid JSON: " + e.getMessage();
        throw new DeserializationException(msg, e);
    }
}
 

public void setSecrets(Map<String, String> secrets) {
    Assert.notNull(secrets);
    Assert.hasText(secrets.get(SignatureAlgorithm.HS256.getValue()));
    Assert.hasText(secrets.get(SignatureAlgorithm.HS384.getValue()));
    Assert.hasText(secrets.get(SignatureAlgorithm.HS512.getValue()));

    this.secrets = secrets;
}
 

@Override
public JwtBuilder signWith(Key key, SignatureAlgorithm alg) throws InvalidKeyException {
    Assert.notNull(key, "Key argument cannot be null.");
    Assert.notNull(alg, "SignatureAlgorithm cannot be null.");
    alg.assertValidSigningKey(key); //since 0.10.0 for https://github.com/jwtk/jjwt/issues/334
    this.algorithm = alg;
    this.key = key;
    return this;
}
 

/**
 * Asserts that payload is not null and calls {@link #doCompress(byte[]) doCompress}
 *
 * @param payload bytes to compress
 * @return compressed bytes
 * @throws CompressionException if {@link #doCompress(byte[]) doCompress} throws an IOException
 */
@Override
public final byte[] compress(byte[] payload) {
    Assert.notNull(payload, "payload cannot be null.");

    try {
        return doCompress(payload);
    } catch (IOException e) {
        throw new CompressionException("Unable to compress payload.", e);
    }
}
 

@Override
public byte[] serialize(T t) throws SerializationException {
    Assert.notNull(t, "Object to serialize cannot be null.");
    try {
        return writeValueAsBytes(t);
    } catch (JsonProcessingException e) {
        String msg = "Unable to serialize object: " + e.getMessage();
        throw new SerializationException(msg, e);
    }
}
 

public JwsToUserDetailsConverter(Function<String, Claims> claimsExtractor,
                                 Function<Claims, User> claimsUserFactory,
                                 Function<Claims, Collection<? extends GrantedAuthority>> authoritiesResolver) {
    Assert.notNull(claimsExtractor, "claimsExtractor cannot be null.");
    Assert.notNull(claimsUserFactory, "claimsUserFactory cannot be null.");
    this.claimsExtractor = claimsExtractor;
    this.claimsUserFactory = claimsUserFactory;
    this.authoritiesResolver = authoritiesResolver;
}
 

/**
 * Asserts that payload is not null and calls {@link #doCompress(byte[]) doCompress}
 *
 * @param payload bytes to compress
 * @return compressed bytes
 * @throws CompressionException if {@link #doCompress(byte[]) doCompress} throws an IOException
 */
@Override
public final byte[] compress(byte[] payload) {
    Assert.notNull(payload, "payload cannot be null.");

    try {
        return doCompress(payload);
    } catch (IOException e) {
        throw new CompressionException("Unable to compress payload.", e);
    }
}
 

@Override
public JwtBuilder signWith(SignatureAlgorithm alg, byte[] secretKey) {
    Assert.notNull(alg, "SignatureAlgorithm cannot be null.");
    Assert.notEmpty(secretKey, "secret key byte array cannot be null or empty.");
    Assert.isTrue(alg.isHmac(), "Key bytes may only be specified for HMAC signatures.  If using RSA or Elliptic Curve, use the signWith(SignatureAlgorithm, Key) method instead.");
    this.algorithm = alg;
    this.keyBytes = secretKey;
    return this;
}
 

@Override
public JwtParser setCompressionCodecResolver(CompressionCodecResolver compressionCodecResolver) {
    Assert.notNull(compressionCodecResolver, "compressionCodecResolver cannot be null.");
    this.compressionCodecResolver = compressionCodecResolver;
    return this;
}
 

private GsonDeserializer(Gson gson, Class<T> returnType) {
    Assert.notNull(gson, "gson cannot be null.");
    Assert.notNull(returnType, "Return type cannot be null.");
    this.gson = gson;
    this.returnType = returnType;
}
 

public RequestHeaderUserFactory(String headerName, Function<String, User> headerValueToUserConverter) {
    Assert.hasText(headerName, "headerName argument cannot be null or empty.");
    Assert.notNull(headerValueToUserConverter, "headerValueToUserConverter function cannot be null.");
    this.headerName = headerName;
    this.headerValueToUser = headerValueToUserConverter;
}
 

@Override
public JwtParserBuilder setSigningKeyResolver(SigningKeyResolver signingKeyResolver) {
    Assert.notNull(signingKeyResolver, "SigningKeyResolver cannot be null.");
    this.signingKeyResolver = signingKeyResolver;
    return this;
}
 

@Override
public JwtParserBuilder setCompressionCodecResolver(CompressionCodecResolver compressionCodecResolver) {
    Assert.notNull(compressionCodecResolver, "compressionCodecResolver cannot be null.");
    this.compressionCodecResolver = compressionCodecResolver;
    return this;
}
 

ExceptionPropagatingDecoder(Decoder<T, R> decoder) {
    Assert.notNull(decoder, "Decoder cannot be null.");
    this.decoder = decoder;
}
 

public ClaimValueResolver(Function<Claims, ?> delegate, boolean resultRequired) {
    Assert.notNull(delegate, "delegate function cannot be null.");
    this.delegate = delegate;
    this.resultRequired = resultRequired;
}
 

@Override
public JwtParser setClock(Clock clock) {
    Assert.notNull(clock, "Clock instance cannot be null.");
    this.clock = clock;
    return this;
}
 

@Override
public JwtParser setSigningKeyResolver(SigningKeyResolver signingKeyResolver) {
    Assert.notNull(signingKeyResolver, "SigningKeyResolver cannot be null.");
    this.signingKeyResolver = signingKeyResolver;
    return this;
}
 

@Override
public byte[] decode(String s) throws DecodingException {
    Assert.notNull(s, "String argument cannot be null");
    return this.base64.decodeFast(s.toCharArray());
}
 

private String getAlgorithmFromHeader(Header header) {
    Assert.notNull(header, "header cannot be null.");

    return header.getCompressionAlgorithm();
}