Java PersistentRememberMeToken类代码示例

import org.springframework.security.web.authentication.rememberme.PersistentRememberMeToken; //导入依赖的package包/类
protected void onLoginSuccess(HttpServletRequest request, HttpServletResponse response,
		Authentication successfulAuthentication) {

	LoginUser user = (LoginUser) successfulAuthentication.getPrincipal();

	logger.debug("Creating new persistent login for user " + user.getUsername());

	PersistentRememberMeToken persistentToken = new PersistentRememberMeToken(user.getUserId(),
			generateSeriesData(), generateTokenData(), new Date());
	try {
		tokenRepository.createNewToken(persistentToken);
		addCookie(persistentToken, request, response);
	} catch (Exception e) {
		logger.error("Failed to save persistent token ", e);
	}
}
 

import org.springframework.security.web.authentication.rememberme.PersistentRememberMeToken; //导入依赖的package包/类
@Override
public PersistentRememberMeToken getTokenForSeries(String seriesId) {
    try {
        return getJdbcTemplate().queryForObject(sqlSelect, new RowMapper<PersistentRememberMeToken>() {
            public PersistentRememberMeToken mapRow(ResultSet rs, int rowNum) throws SQLException {
                //String username, String series, String tokenValue, Date date
                return new PersistentRememberMeToken(rs.getString(3),
                        rs.getString(1),
                        rs.getString(2),
                        rs.getTimestamp(4));
            }
        }, seriesId);
    } catch (EmptyResultDataAccessException zeroResults) {
        if (logger.isInfoEnabled()) {
            logger.info("Querying token for series '" + seriesId + "' returned no results.", zeroResults);
        }
    } catch (IncorrectResultSizeDataAccessException moreThanOne) {
        logger.error("Querying token for series '" + seriesId + "' returned more than one value. Series" +
                " should be unique");
    } catch (DataAccessException e) {
        logger.error("Failed to load token for series " + seriesId, e);
    }

    return null;
}
 

import org.springframework.security.web.authentication.rememberme.PersistentRememberMeToken; //导入依赖的package包/类
@Override
public void createNewToken(PersistentRememberMeToken token) {
	logger.info("Creating Token for user : {}", token.getUsername());
	UserSessions userSession = new UserSessions();
	userSession.setUserEmail(token.getUsername());
	userSession.setSeries(token.getSeries());
	userSession.setSessionToken(token.getTokenValue());
	userSession.setLastLogin(token.getDate());
	persist(userSession);

}
 

import org.springframework.security.web.authentication.rememberme.PersistentRememberMeToken; //导入依赖的package包/类
@Override
public PersistentRememberMeToken getTokenForSeries(String seriesId) {
	logger.info("Fetch Token if any for seriesId : {}", seriesId);
	try {
		Criteria crit = createEntityCriteria();
		crit.add(Restrictions.eq("series", seriesId));
		UserSessions userSession = (UserSessions) crit.uniqueResult();

		return new PersistentRememberMeToken(userSession.getUserEmail(), userSession.getSeries(),
				userSession.getSessionToken(), userSession.getLastLogin());
	} catch (Exception e) {
		logger.info("Token not found...");
		return null;
	}
}
 

import org.springframework.security.web.authentication.rememberme.PersistentRememberMeToken; //导入依赖的package包/类
@Override
public PersistentRememberMeToken getTokenForSeries(String seriesId) {
  Long sessionId = Long.valueOf(seriesId);
  return sessionService
      .findSession(sessionId)
      .map(this::toPersistentRememberMeToken)
      .orElse(null);
}
 

import org.springframework.security.web.authentication.rememberme.PersistentRememberMeToken; //导入依赖的package包/类
private PersistentRememberMeToken toPersistentRememberMeToken(Session session) {
  String username = String.valueOf(session.getUserId());
  String series = String.valueOf(session.getId());
  LocalDateTime lastUsedAt =
      Optional.ofNullable(session.getLastUsedAt()).orElseGet(session::getIssuedAt);
  return new PersistentRememberMeToken(
      username, series, session.getToken(), toDate(lastUsedAt));
}
 

import org.springframework.security.web.authentication.rememberme.PersistentRememberMeToken; //导入依赖的package包/类
@Override
public void createNewToken(PersistentRememberMeToken token) {
    logger.info("Creating Token for user : {}", token.getUsername());
    PersistentLogin persistentLogin = new PersistentLogin();
    persistentLogin.setUsername(token.getUsername());
    persistentLogin.setSeries(token.getSeries());
    persistentLogin.setToken(token.getTokenValue());
    persistentLogin.setLast_used(token.getDate());
    persist(persistentLogin);

}
 

import org.springframework.security.web.authentication.rememberme.PersistentRememberMeToken; //导入依赖的package包/类
@Override
public PersistentRememberMeToken getTokenForSeries(String seriesId) {
    logger.info("Fetch Token if any for seriesId : {}", seriesId);
    try {
        Criteria crit = createEntityCriteria();
        crit.add(Restrictions.eq("series", seriesId));
        PersistentLogin persistentLogin = (PersistentLogin) crit.uniqueResult();

        return new PersistentRememberMeToken(persistentLogin.getUsername(), persistentLogin.getSeries(),
                persistentLogin.getToken(), persistentLogin.getLast_used());
    } catch (Exception e) {
        logger.info("Token not found...");
        return null;
    }
}
 

import org.springframework.security.web.authentication.rememberme.PersistentRememberMeToken; //导入依赖的package包/类
/** {@inheritDoc} */
@Override
public PersistentRememberMeToken getTokenForSeries(String seriesId) {
	RememberMeToken token = this.rememberMeTokenRepository.findBySeries(seriesId);
	if (null == token) {
		return null;
	}
	return new PersistentRememberMeToken(token.getUsername(), token.getSeries(), token.getTokenValue(),
			token.getDate());
}
 

import org.springframework.security.web.authentication.rememberme.PersistentRememberMeToken; //导入依赖的package包/类
/**
 * <p>Constructor for RememberMeToken.</p>
 *
 * @param token a {@link org.springframework.security.web.authentication.rememberme.PersistentRememberMeToken} object.
 */
public RememberMeToken(PersistentRememberMeToken token) {
    this.series = token.getSeries();
    this.username = token.getUsername();
    this.tokenValue = token.getTokenValue();
    this.date = token.getDate();
}
 

import org.springframework.security.web.authentication.rememberme.PersistentRememberMeToken; //导入依赖的package包/类
/**
 * The method provides the functionality to store a new token in the token repository
 * @param token The token that will be stored in the token repository
 */
@Override
public synchronized void createNewToken(PersistentRememberMeToken token) {
    PersistentRememberMeToken current = this.seriesTokens.get(token.getSeries());
    if(current != null) {
        throw new DataIntegrityViolationException("Series Id \'" + token.getSeries() + "\' already exists!");
    } else {
        this.seriesTokens.put(token.getSeries(), token);
        saveTokens();
    }
}
 

import org.springframework.security.web.authentication.rememberme.PersistentRememberMeToken; //导入依赖的package包/类
/**
 * Updates a specific token with a new values to a specific token
 * @param series The token that will be updated
 * @param tokenValue The new token value
 * @param lastUsed Date for when it was last used
 */
@Override
public synchronized void updateToken(String series, String tokenValue, Date lastUsed) {
    PersistentRememberMeToken token = this.getTokenForSeries(series);
    PersistentRememberMeToken newToken = new PersistentRememberMeToken(token.getUsername(), series, tokenValue, new Date());
    this.seriesTokens.put(series, newToken);
    saveTokens();
}
 

import org.springframework.security.web.authentication.rememberme.PersistentRememberMeToken; //导入依赖的package包/类
/**
 * Remove a user token from the repository
 * @param username The token that matches this user name will be removed
 */
@Override
public synchronized void removeUserTokens(String username) {
    Iterator series = this.seriesTokens.keySet().iterator();

    while(series.hasNext()) {
        String seriesId = (String)series.next();
        PersistentRememberMeToken token = this.seriesTokens.get(seriesId);
        if(username.equals(token.getUsername())) {
            series.remove();
        }
    }
    saveTokens();
}
 

import org.springframework.security.web.authentication.rememberme.PersistentRememberMeToken; //导入依赖的package包/类
/**
 * Get all tokens in a token list
 * @return A list of tokens
 */
private SessionTokenList getTokens(){
    final SessionTokenList tokens = new SessionTokenList();
    for(PersistentRememberMeToken persistentRememberMeToken : seriesTokens.values()){
        final SessionToken token = new SessionToken(persistentRememberMeToken);
        tokens.add(token);
    }
    return tokens;
}
 

import org.springframework.security.web.authentication.rememberme.PersistentRememberMeToken; //导入依赖的package包/类
@Override
public void createNewToken(PersistentRememberMeToken token) {
    PersistentLoginEntity userPersistentToken = new PersistentLoginEntity();
    userPersistentToken.setSeries(token.getSeries());
    userPersistentToken.setUsername(token.getUsername());
    userPersistentToken.setToken(token.getTokenValue());
    userPersistentToken.setLastUsed(token.getDate());
    persistentLoginRepository.save(userPersistentToken);
}