Java ExpiringSession类代码示例

import org.springframework.session.ExpiringSession; //导入依赖的package包/类
@Override
public ExpiringSession getSession(final String id)
{
	final ExpiringSession saved = sessions.get(id);
	if (saved == null)
	{
		return null;
	}
	if (saved.isExpired())
	{
		final boolean expired = true;
		deleteAndFireEvent(saved.getId(), expired);
		return null;
	}

	return new MapSession(saved);
}
 

import org.springframework.session.ExpiringSession; //导入依赖的package包/类
private void deleteAndFireEvent(final String id, boolean expired)
{
	final ExpiringSession deletedSession = sessions.remove(id);

	// Fire event
	if (deletedSession != null)
	{
		if (expired)
		{
			applicationEventPublisher.publishEvent(new SessionExpiredEvent(this, id));
		}
		else
		{
			applicationEventPublisher.publishEvent(new SessionDeletedEvent(this, id));
		}
	}
}
 

import org.springframework.session.ExpiringSession; //导入依赖的package包/类
public void purgeExpiredSessions()
{
	final Stopwatch stopwatch = Stopwatch.createStarted();
	int countExpiredSessions = 0;

	final List<ExpiringSession> sessionsToCheck = new ArrayList<>(sessions.values());
	for (final ExpiringSession session : sessionsToCheck)
	{
		if (session.isExpired())
		{
			deleteAndFireEvent(session.getId(), true /* expired */);
			countExpiredSessions++;
		}
	}

	logger.debug("Purged {}/{} expired sessions in {}", countExpiredSessions, sessionsToCheck.size(), stopwatch);
}
 

import org.springframework.session.ExpiringSession; //导入依赖的package包/类
private HttpSessionEvent createHttpSessionEvent(AbstractSessionEvent event) {
	ExpiringSession session = event.getSession();
	HttpSession httpSession = new ExpiringSessionHttpSession<ExpiringSession>(session,
			this.context);
	HttpSessionEvent httpSessionEvent = new HttpSessionEvent(httpSession);
	return httpSessionEvent;
}
 

import org.springframework.session.ExpiringSession; //导入依赖的package包/类
@CacheEntryExpired
public void entryExpired(CacheEntryExpiredEvent<String, ExpiringSession> event) {
    if (logger.isDebugEnabled()) {
        logger.debug("Session expired with id: " + event.getValue().getId());
    }

    eventPublisher.publishEvent(new SessionExpiredEvent(this, event.getValue()));
}
 

import org.springframework.session.ExpiringSession; //导入依赖的package包/类
@CacheEntryRemoved
public void entryRemoved(CacheEntryRemovedEvent<String, ExpiringSession> event) {
    if (logger.isDebugEnabled()) {
        logger.debug("Session expired with id: " + event.getOldValue().getId());
    }
    eventPublisher.publishEvent(new SessionDeletedEvent(this, event.getOldValue()));
}
 

import org.springframework.session.ExpiringSession; //导入依赖的package包/类
@Override
public ExpiringSession put(String key, ExpiringSession value) {
    if (value == null) {
        return cache.put(key, value);
    }

    return cache.put(key, value, timeToLive, TimeUnit.MILLISECONDS, value.getMaxInactiveIntervalInSeconds(),
            TimeUnit.SECONDS);
}
 

import org.springframework.session.ExpiringSession; //导入依赖的package包/类
@Override
public ExpiringSession createSession()
{
	final ExpiringSession result = new MapSession();
	if (defaultMaxInactiveInterval != null)
	{
		result.setMaxInactiveIntervalInSeconds(defaultMaxInactiveInterval);
	}

	// Fire event
	applicationEventPublisher.publishEvent(new SessionCreatedEvent(this, result.getId()));

	return result;
}
 

import org.springframework.session.ExpiringSession; //导入依赖的package包/类
public InvalidClassExceptionSafeRepository(SessionRepository<S> repository,
                                           RedisTemplate<String, ExpiringSession> sessionRedisTemplate,
                                           CounterService counterService) {
    this.repository = repository;
    this.sessionRedisTemplate = sessionRedisTemplate;
    this.counterService = counterService;
}
 

import org.springframework.session.ExpiringSession; //导入依赖的package包/类
public SpringSessionBackedSessionInformation(ExpiringSession session, SessionRepository<? extends ExpiringSession> sessionRepository) {
    super(resolvePrincipal(session), session.getId(), new Date(session.getLastAccessedTime()));
    this.sessionRepository = sessionRepository;
    if (session.isExpired()) {
        super.expireNow();
    }
}
 

import org.springframework.session.ExpiringSession; //导入依赖的package包/类
@Override
public SessionInformation getSessionInformation(String sessionId) {
    ExpiringSession session = sessionRepository.getSession(sessionId);
    if (session != null) {
        return new SpringSessionBackedSessionInformation(session, sessionRepository);
    }
    return null;
}
 

import org.springframework.session.ExpiringSession; //导入依赖的package包/类
@RequestMapping("/")
String listSessions(Principal principal, HttpSession session, Model model) {
    Collection<? extends ExpiringSession> userSessions = sessions.findByIndexNameAndIndexValue(PRINCIPAL_NAME_INDEX_NAME, principal.getName()).values();
    model.addAttribute("sessions", userSessions);
    // this gives us the correct session ID, as the HttpSession is backed by Spring Session:
    model.addAttribute("currSessionId", session.getId());
    return "index";
}
 

import org.springframework.session.ExpiringSession; //导入依赖的package包/类
@Bean
public SessionRepository<ExpiringSession> sessionRepository(
		SessionProperties properties) {
	MapSessionRepository repository = new MapSessionRepository();
	Integer timeout = properties.getTimeout();
	if (timeout != null) {
		repository.setDefaultMaxInactiveInterval(timeout);
	}
	return repository;
}
 

import org.springframework.session.ExpiringSession; //导入依赖的package包/类
/**
 * SpringSession config
 * @return
 * @throws Exception
 */
@Bean
public RedisTemplate<String,ExpiringSession> redisTemplate() throws Exception {
    RedisTemplate<String, ExpiringSession> template = new RedisTemplate<>();
    template.setKeySerializer(new StringRedisSerializer());
    template.setHashKeySerializer(new StringRedisSerializer());
    template.setConnectionFactory(redisConnectionFactory);
    return template;
}
 

import org.springframework.session.ExpiringSession; //导入依赖的package包/类
@Bean
public SessionRepository<ExpiringSession> sessionRepository() {
	return new MapSessionRepository();
}