org.springframework.session.events.AbstractSessionEvent Java Examples

@Override
public void onApplicationEvent(AbstractSessionEvent event) {
	if (this.listeners.isEmpty()) {
		return;
	}

	HttpSessionEvent httpSessionEvent = createHttpSessionEvent(event);

	for (HttpSessionListener listener : this.listeners) {
		if (event instanceof SessionDestroyedEvent) {
			listener.sessionDestroyed(httpSessionEvent);
		}
		else if (event instanceof SessionCreatedEvent) {
			listener.sessionCreated(httpSessionEvent);
		}
	}
}
 

@Override
public void onApplicationEvent(AbstractSessionEvent event) {
    if (event instanceof SessionCreatedEvent) {
        sessionCreatedEvents++;
    }
    if (event instanceof SessionDeletedEvent) {
        sessionDeletedEvents++;
    }
    if (event instanceof SessionExpiredEvent) {
        sessionExpiredEvents++;
    }
}
 

@Override
public void onApplicationEvent(AbstractSessionEvent event) {
	String sessionId = event.getSessionId();
	this.events.put(sessionId, event);
	Object lock = getLock(sessionId);
	synchronized (lock) {
		lock.notifyAll();
	}
}
 

@SuppressWarnings("unchecked")
private <E extends AbstractSessionEvent> E waitForEvent(String sessionId) throws InterruptedException {
	Object lock = getLock(sessionId);
	synchronized (lock) {
		if (!this.events.containsKey(sessionId)) {
			lock.wait(10000);
		}
	}
	return (E) this.events.get(sessionId);
}
 

@Override
public void onApplicationEvent(AbstractSessionEvent event) {
	String sessionId = event.getSessionId();
	this.events.put(sessionId, event);
	Object lock = getLock(sessionId);
	synchronized (lock) {
		lock.notifyAll();
	}
}
 

@SuppressWarnings("unchecked")
private <E extends AbstractSessionEvent> E waitForEvent(String sessionId) throws InterruptedException {
	Object lock = getLock(sessionId);
	synchronized (lock) {
		if (!this.events.containsKey(sessionId)) {
			lock.wait(10000);
		}
	}
	return (E) this.events.get(sessionId);
}
 

@Test
public void sessionExpirationIsCorrect() {

	Session session = this.sessionRepository.createSession();

	assertThat(session).isNotNull();
	assertThat(session.getId()).isNotBlank();
	assertThat(session.isExpired()).isFalse();

	this.sessionRepository.save(session);

	Session savedSession = this.sessionRepository.findById(session.getId());

	assertThat(savedSession).isEqualTo(session);

	// Clear any existing Session event
	this.sessionEventListener.getSessionEvent();

	AbstractSessionEvent sessionEvent =
		this.sessionEventListener.waitForSessionEvent(TimeUnit.SECONDS.toMillis(2));

	assertThat(sessionEvent).isNotNull();
	assertThat(sessionEvent.getSessionId()).isEqualTo(savedSession.getId());
	assertThat(this.sessionRepository.findById(savedSession.getId())).isNull();
}
 

public void onApplicationEvent(AbstractSessionEvent event) {
	this.sessionEvent = event;
}
 

private HttpSessionEvent createHttpSessionEvent(AbstractSessionEvent event) {
	Session session = event.getSession();
	HttpSession httpSession = new HttpSessionAdapter<>(session, this.context);
	return new HttpSessionEvent(httpSession);
}
 

@SuppressWarnings("unchecked")
<E extends AbstractSessionEvent> E getEvent(String sessionId) throws InterruptedException {
	return (E) waitForEvent(sessionId);
}
 

@SuppressWarnings("unchecked")
public <E extends AbstractSessionEvent> E getEvent(String sessionId) throws InterruptedException {
	return (E) waitForEvent(sessionId);
}
 

@SuppressWarnings("unchecked")
public <T extends AbstractSessionEvent> T getSessionEvent() {

	T sessionEvent = (T) this.sessionEvent;

	this.sessionEvent = null;

	return sessionEvent;
}
 

public <T extends AbstractSessionEvent> T waitForSessionEvent(long duration) {

			waitOn(() -> SessionEventListener.this.sessionEvent != null, duration);

			return getSessionEvent();
		}