import org.springframework.session.events.SessionDeletedEvent; //导入依赖的package包/类
@Test
public void deletedSessionTest() throws InterruptedException {
    S sessionToSave = repository.createSession();

    repository.save(sessionToSave);

    assertThat(registry.receivedEvent(sessionToSave.getId())).isTrue();
    assertThat((EventObject) registry.getEvent(sessionToSave.getId()))
            .isInstanceOf(SessionCreatedEvent.class);

    registry.clear();

    repository.delete(sessionToSave.getId());

    assertThat(registry.receivedEvent(sessionToSave.getId())).isTrue();
    assertThat((EventObject) registry.getEvent(sessionToSave.getId()))
            .isInstanceOf(SessionDeletedEvent.class);

    assertThat(repository.getSession(sessionToSave.getId())).isNull();
}
 

import org.springframework.session.events.SessionDeletedEvent; //导入依赖的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.events.SessionDeletedEvent; //导入依赖的package包/类
@Test
public void deletedSessionTest() throws InterruptedException {
	S sessionToSave = this.repository.createSession();

	this.repository.save(sessionToSave);

	assertThat(this.registry.receivedEvent(sessionToSave.getId())).isTrue();
	assertThat(this.registry.<SessionCreatedEvent>getEvent(sessionToSave.getId()))
			.isInstanceOf(SessionCreatedEvent.class);
	this.registry.clear();

	this.repository.deleteById(sessionToSave.getId());

	assertThat(this.registry.receivedEvent(sessionToSave.getId())).isTrue();
	assertThat(this.registry.<SessionDeletedEvent>getEvent(sessionToSave.getId()))
			.isInstanceOf(SessionDeletedEvent.class);

	assertThat(this.repository.findById(sessionToSave.getId())).isNull();
}
 

import org.springframework.session.events.SessionDeletedEvent; //导入依赖的package包/类
@Override
public void onApplicationEvent(AbstractSessionEvent event) {
    if (event instanceof SessionCreatedEvent) {
        sessionCreatedEvents++;
    }
    if (event instanceof SessionDeletedEvent) {
        sessionDeletedEvents++;
    }
    if (event instanceof SessionExpiredEvent) {
        sessionExpiredEvents++;
    }
}
 

import org.springframework.session.events.SessionDeletedEvent; //导入依赖的package包/类
/**
 * Deletes the {@link MongoSession} with the given {@link MongoSession#getId()} or does nothing
 * if the {@link MongoSession} is not found.
 *
 * @param id the {@link MongoSession#getId()} to delete
 */
@Override
public Mono<Void> deleteById(String id) {

	return findSession(id)
		.flatMap(document -> this.mongoOperations.remove(document, this.collectionName).then(Mono.just(document)))
		.map(document -> convertToSession(this.mongoSessionConverter, document))
		.map(mongoSession -> Mono.fromRunnable(() -> publishEvent(new SessionDeletedEvent(this, mongoSession))))
		.then();
}
 

import org.springframework.session.events.SessionDeletedEvent; //导入依赖的package包/类
@Override
public void deleteById(String id) {
	Optional.ofNullable(findSession(id))
		.ifPresent(document -> {
			publishEvent(new SessionDeletedEvent(this, convertToSession(this.mongoSessionConverter, document)));
			this.mongoOperations.remove(document, this.collectionName);
		});
}
 

import org.springframework.session.events.SessionDeletedEvent; //导入依赖的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.events.SessionDeletedEvent; //导入依赖的package包/类
@ClientCacheEntryRemoved
public void entryRemoved(ClientCacheEntryRemovedEvent<String> event) {
    if (logger.isDebugEnabled()) {
        logger.debug("Session expired with id: " + event.getKey());
    }
    eventPublisher.publishEvent(new SessionDeletedEvent(this, event.getKey()));
}
 

import org.springframework.session.events.SessionDeletedEvent; //导入依赖的package包/类
@Override
public void delete(String id) {
    CouchbaseSession session = getSession(id);
    if (session == null) {
        return;
    }
    deleteSession(session);
    eventPublisher.publishEvent(new SessionDeletedEvent(this, session));
}
 

import org.springframework.session.events.SessionDeletedEvent; //导入依赖的package包/类
@Before
public void setup() {
	String sessionId = "session-id";
	MapSession session = new MapSession(sessionId);

	this.attributes = new HashMap<>();
	SessionRepositoryMessageInterceptor.setSessionId(this.attributes, sessionId);

	given(this.wsSession.getAttributes()).willReturn(this.attributes);
	given(this.wsSession.getPrincipal()).willReturn(this.principal);
	given(this.wsSession.getId()).willReturn("wsSession-id");

	given(this.wsSession2.getAttributes()).willReturn(this.attributes);
	given(this.wsSession2.getPrincipal()).willReturn(this.principal);
	given(this.wsSession2.getId()).willReturn("wsSession-id2");

	Map<String, Object> headers = new HashMap<>();
	headers.put(SimpMessageHeaderAccessor.SESSION_ATTRIBUTES, this.attributes);
	given(this.message.getHeaders()).willReturn(new MessageHeaders(headers));

	this.listener = new WebSocketRegistryListener();
	this.connect = new SessionConnectEvent(this.listener, this.wsSession);
	this.connect2 = new SessionConnectEvent(this.listener, this.wsSession2);
	this.disconnect = new SessionDisconnectEvent(this.listener, this.message,
			this.wsSession.getId(), CloseStatus.NORMAL);
	this.deleted = new SessionDeletedEvent(this.listener, session);
	this.expired = new SessionExpiredEvent(this.listener, session);
}
 

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

import org.springframework.session.events.SessionDeletedEvent; //导入依赖的package包/类
@EventListener
public void onSessionDeleted(SessionDeletedEvent deletedEvent) {
    sessionDeleted = true;
}
 

import org.springframework.session.events.SessionDeletedEvent; //导入依赖的package包/类
private void handleDeleted(RedisSession session) {
	publishEvent(new SessionDeletedEvent(this, session));
}