Java JwtBuilder.setExpiration方法代码示例

import io.jsonwebtoken.JwtBuilder; //导入方法依赖的package包/类
public static String Gerate(String issuer, int idSubject, int hours) {

        //The JWT signature algorithm we will be using to sign the token
        SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;
        
        //Hours to milliseconds
        long ttlMillis = hours * 3600000;
        String subject = String.valueOf(idSubject);
        
        long nowMillis = System.currentTimeMillis();
        Date now = new Date(nowMillis);
        
        //We will sign our JWT with our ApiKey secret
        byte[] apiKeySecretBytes = DatatypeConverter.parseBase64Binary(Parameters.TOKENKEY);
        Key signingKey = new SecretKeySpec(apiKeySecretBytes, signatureAlgorithm.getJcaName());

        //Let's set the JWT Claims
        JwtBuilder builder = Jwts.builder().setIssuedAt(now)
                                    .setSubject(subject)
                                    .setIssuer(issuer)
                                    .signWith(signatureAlgorithm, signingKey);

        //if it has been specified, let's add the expiration
        if (ttlMillis >= 0) {
        long expMillis = nowMillis + ttlMillis;
            Date exp = new Date(expMillis);
            builder.setExpiration(exp);
        }

        //Builds the JWT and serializes it to a compact, URL-safe string
        return builder.compact();
    }
 

import io.jsonwebtoken.JwtBuilder; //导入方法依赖的package包/类
@Override
public TokenDto generate(final String username, final String password) {
    if (StringUtils.isBlank(username) || StringUtils.isBlank(password)) {
        throw new BadCredentialsException("Input data can't be empty.");
    }
    final User user = userService.findByUsername(username);

    validateInputPassword(user.getPassword(), password);

    final Map<String, Object> tokenData = new HashMap<>();
    tokenData.put("username", user.getUsername());
    tokenData.put("password", user.getPassword());
    tokenData.put("create_date", LocalDateTime.now());
    final JwtBuilder jwtBuilder = Jwts.builder();
    jwtBuilder.setClaims(tokenData);
    final Calendar calendar = Calendar.getInstance();
    calendar.add(Calendar.MINUTE, expirationTime);
    jwtBuilder.setExpiration(calendar.getTime());
    final String token = jwtBuilder.signWith(SignatureAlgorithm.HS512, secretKey).compact();
    return new TokenDto(token, mapper.map(user, UserDto.class));
}
 

import io.jsonwebtoken.JwtBuilder; //导入方法依赖的package包/类
/**
 * 创建jwt
 * @param id
 * @param subject
 * @param ttlMillis
 * @return
 * @throws Exception
 */
public String createJWT(String id, String subject, long ttlMillis) throws Exception {

    SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS512;
    long nowMillis = System.currentTimeMillis();
    Date now = new Date(nowMillis);
    SecretKey key = generalKey();
    JwtBuilder builder = Jwts.builder()
            .setId(id)
            .setIssuedAt(now)
            .setSubject(subject)
            .signWith(signatureAlgorithm, key);
    if (ttlMillis >= 0) {
        long expMillis = nowMillis + ttlMillis;
        Date exp = new Date(expMillis);
        builder.setExpiration(exp);
    }
    return builder.compact();
}
 

import io.jsonwebtoken.JwtBuilder; //导入方法依赖的package包/类
public String createJWT(String id, String subject, long ttlMillis) {
    SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;
    long nowMillis = System.currentTimeMillis();
    Date now = new Date(nowMillis);
    SecretKey key = jwtConfig.generalKey();
    JwtBuilder builder = Jwts.builder()
            .setId(id)
            .setIssuedAt(now)
            .setSubject(subject)
            .signWith(signatureAlgorithm, key);
    if (ttlMillis >= 0) {
        long expMillis = nowMillis + ttlMillis;
        Date exp = new Date(expMillis);
        builder.setExpiration(exp);
    }
    return builder.compact();
}
 

import io.jsonwebtoken.JwtBuilder; //导入方法依赖的package包/类
@Path("login")
@POST
@Produces(MediaType.APPLICATION_JSON + ";charset=utf-8")
public String login(@FormParam(value = "id") String id) throws IOException {
	SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;
	 
    long nowMillis = System.currentTimeMillis();
    Date now = new Date(nowMillis);
 
    byte[] apiKeySecretBytes = DatatypeConverter.parseBase64Binary(SECRECT);
    Key signingKey = new SecretKeySpec(apiKeySecretBytes, signatureAlgorithm.getJcaName());
 
    JwtBuilder builder = Jwts.builder()
                                .setIssuedAt(now)
                                .setIssuer(id)
                                .signWith(signatureAlgorithm, signingKey);
 
    long expMillis = nowMillis + EXPIRE	;
       Date exp = new Date(expMillis);
       builder.setExpiration(exp);
     
    return builder.compact();
}
 

import io.jsonwebtoken.JwtBuilder; //导入方法依赖的package包/类
/**
 * Creates the jwt for the given dawg credentials
 * @param dawgCreds The credentials to encode
 * @return
 */
public String createUserJWT(DawgCreds dawgCreds) {

    long nowMillis = System.currentTimeMillis();
    Date now = new Date(nowMillis);
    Key signingKey = new SecretKeySpec(jwtSecret.getBytes(), SIGNATURE_ALG.getJcaName());
    Map<String, Object> claims = new HashMap<String, Object>();
    claims.put(DawgJwt.JWT_FIELD_CREDS, dawgCreds);

    JwtBuilder builder = Jwts.builder()
            .setClaims(claims)
            .setId(UUID.randomUUID().toString())
            .setIssuedAt(now) 
            .setSubject(JWT_SUBJECT)
            .setIssuer(this.jwtIssuer)
            .signWith(SIGNATURE_ALG, signingKey);

    if (this.ttlMillis >= 0) {
        long expMillis = nowMillis + this.ttlMillis;
        Date exp = new Date(expMillis);
        builder.setExpiration(exp);
    }

    return builder.compact();
}
 

import io.jsonwebtoken.JwtBuilder; //导入方法依赖的package包/类
private JwtToken createJWT(String id,
                           String issuer,
                           String subject,
                           String privileges,
                           long ttlMillis) {

    // The JWT signature algorithm we will be using to sign the token
    final SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.RS256;

    final long nowMillis = System.currentTimeMillis();
    final Date now = new Date(nowMillis);

    // We will sign our JWT with our ApiKey secret
    final Key signingKey = EncryptionUtil.getPrivateKey(
        env.getProperty("service.jwt.secret"));

    final Map<String, Object> claims = new HashMap<>();
    claims.put("privileges", privileges);

    // Let's set the JWT Claims
    final JwtBuilder builder = Jwts.builder()
        .setClaims(claims)
        .setId(id)
        .setIssuer(issuer)
        .setIssuedAt(now)
        .setSubject(subject)
        .signWith(signatureAlgorithm, signingKey);

    // If it has been specified, let's add the expiration
    if (ttlMillis >= 0) {
        long expMillis = nowMillis + ttlMillis;
        Date exp = new Date(expMillis);
        builder.setExpiration(exp);
    }

    // Builds the JWT and serializes it to a compact, URL-safe string
    return new JwtToken(builder.compact());
}
 

import io.jsonwebtoken.JwtBuilder; //导入方法依赖的package包/类
/**
 * Creates a new JWT for the specified principal. Token is signed using
 * the SecretKey with an HMAC 256 algorithm.
 *
 * @param principal the Principal to create the token for
 * @return a String representation of the generated token
 * @since 1.0.0
 */
public String createToken(Principal principal) {
    final Date today = new Date();
    final JwtBuilder jwtBuilder = Jwts.builder();
    jwtBuilder.setSubject(principal.getName());
    jwtBuilder.setIssuer("Alpine");
    jwtBuilder.setIssuedAt(today);
    jwtBuilder.setExpiration(addDays(today, 7));
    return jwtBuilder.signWith(SignatureAlgorithm.HS256, key).compact();
}
 

import io.jsonwebtoken.JwtBuilder; //导入方法依赖的package包/类
@Override
public String getToken(final String username, final String password) {
    if (username == null || password == null) {
        return null;
    }
    final User user = (User) userDetailsService.loadUserByUsername(username);
    Map<String, Object> tokenData = new HashMap<>();
    if (password.equals(user.getPassword())) {
        tokenData.put("clientType", "user");
        tokenData.put("userID", user.getId());
        tokenData.put("username", user.getUsername());
        tokenData.put("token_create_date", LocalDateTime.now());
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.MINUTE, tokenExpirationTime);
        tokenData.put("token_expiration_date", calendar.getTime());
        JwtBuilder jwtBuilder = Jwts.builder();
        jwtBuilder.setExpiration(calendar.getTime());
        jwtBuilder.setClaims(tokenData);
        return jwtBuilder.signWith(SignatureAlgorithm.HS512, tokenKey).compact();

    } else {
        throw new ServiceException("Authentication error", this.getClass().getName());
    }
}
 

import io.jsonwebtoken.JwtBuilder; //导入方法依赖的package包/类
protected JwtBuilder jwtBuilder(long exp, Map<String, Object> ext){
    JwtBuilder jwt = Jwts.builder()
            .claim("user_id","43FE6476-CD7B-493B-8044-C7E3149D0876")
            .claim("scope","perm")
            .claim("client_id","console")
            .claim("username","admin");
    if(ext != null){
        for (Entry<String, Object> entry : ext.entrySet()){
            jwt.claim(entry.getKey(),entry.getValue());
        }
    }
    jwt.setExpiration(new Date(exp));
    return jwt;
}
 

import io.jsonwebtoken.JwtBuilder; //导入方法依赖的package包/类
private static JwtBuilder createJWT(String id, String subject, String issuer, long timeToLiveMs) {

		long nowMs = System.currentTimeMillis();
		Date now = new Date(nowMs);

		JwtBuilder builder = Jwts.builder();
		builder.setIssuedAt(now);

		if (id != null) {
			builder.setId(id);
		}

		if (subject != null) {
			builder.setSubject(subject);
		}

		if (issuer != null) {
			builder.setIssuer(issuer);
		}

		if (timeToLiveMs >= 0) {
			long expireMs = nowMs + timeToLiveMs;
			builder.setExpiration(new Date(expireMs));
		}

		return builder;

	}
 

import io.jsonwebtoken.JwtBuilder; //导入方法依赖的package包/类
private String modifyTokenExpirationTime(final String token) {
    final Jws<Claims> tokenData = Jwts.parser().setSigningKey(secretKey).parseClaimsJws(token);
    final JwtBuilder jwtBuilder = Jwts.builder();
    final Calendar calendar = Calendar.getInstance();

    jwtBuilder.setClaims(tokenData.getBody());
    calendar.add(Calendar.MILLISECOND, 1);
    jwtBuilder.setExpiration(calendar.getTime());
    return jwtBuilder.signWith(SignatureAlgorithm.HS512, secretKey).compact();
}
 

import io.jsonwebtoken.JwtBuilder; //导入方法依赖的package包/类
private void prepareJwtBuilder(final JwtBuilder jwtBuilder) {
    final Calendar calendar = Calendar.getInstance();
    jwtBuilder.setExpiration(calendar.getTime());
}