Håndtering af brugersessioner
Implementer avanceret håndtering af brugersessioner i WebSockets ved at knytte HTTP-sessioner til WebSocket-sessioner.
Håndtering af brugersessioner er en gratis WebSockets og realtidssystemer med Spring-lektion på CoddyKit. Dette er lektion 3 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i WebSockets og realtidssystemer med Spring, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. WebSockets og realtidssystemer med Spring-kurset indeholder 4 lektioner i alt.
Forstå brugersessioner
I webapplikationer hjælper en "session" serveren med at huske en bruger på tværs af flere forespørgsler. Det fungerer som en midlertidig hukommelse for hver bruger.
I traditionel HTTP håndteres sessioner ofte med cookies. De gør det muligt at gemme brugerspecifikke data, f.eks. loginstatus eller varer i en indkøbskurv, mellem sideindlæsninger.
WebSockets: Udfordringer med sessioner
I modsætning til HTTP opretter WebSockets en vedvarende, fulddupleksforbindelse. Denne forbindelse indeholder ikke automatisk den samme sessionskontekst som en HTTP-forespørgsel.
Det betyder, at hvis en bruger logger ind via HTTP og derefter åbner en WebSocket, ved WebSocket-forbindelsen ikke automatisk, hvem brugeren er, uden en specifik opsætning.
- HTTP-session: Kortvarig, forespørgsel-svar.
- WebSocket-session: Langvarig, vedvarende forbindelse.
Forbind HTTP- og WebSocket-sessioner
For at bygge avancerede realtidsapplikationer har du ofte brug for, at WebSocket-forbindelsen kender brugerens HTTP-sessionskontekst.
Du kan f.eks. have brug for at vide, om en bruger er godkendt, brugerens bruger-id eller andre profildetaljer, der blev etableret under det oprindelige HTTP-login.
Spring leverer mekanismer til at "bygge bro" over dette hul under WebSocket-håndtrykket.
Håndtryksinterceptoren
Springs primære værktøj til at forbinde HTTP- og WebSocket-sessioner er HttpSessionHandshakeInterceptor.
Denne interceptor kører under WebSocket-håndtrykket, som er den indledende HTTP-forespørgsel, der opgraderes til en WebSocket-forbindelse. Den kan kopiere attributter fra den aktuelle HTTP-session til WebSocket-sessionen.
- Hvad den gør: Kopierer HTTP-sessionsattributter.
- Hvornår den kører: Under WebSocket-håndtrykket.
Konfiguration af sessionsinterceptoren
For at bruge HttpSessionHandshakeInterceptor skal du registrere den i din WebSocket-konfiguration. Det fortæller Spring, at interceptoren skal anvendes, når en WebSocket-forbindelse oprettes.
Den tilføjes typisk i din implementering af WebSocketMessageBrokerConfigurer:
public class WebSocketConfig extends AbstractWebSocketMessageBrokerConfigurer {
@Override
public void registerStompEndpoints(StompEndpointRegistry registry) {
registry.addEndpoint("/ws")
.addInterceptors(new HttpSessionHandshakeInterceptor())
.withSockJS();
}
}Adgang til forbundne sessionsdata
Når HttpSessionHandshakeInterceptor har udført sit arbejde, kan du få adgang til de kopierede HTTP-sessionsattributter i dine WebSocket-meddelelseshåndterere.
Du vil typisk have brug for at få adgang til Principal (som repræsenterer den godkendte bruger) eller andre tilpassede attributter, du har gemt i HTTP-sessionen.
@Controller
public class MyWebSocketController {
@MessageMapping("/hello")
public void handleMessage(@Payload String message, Principal principal) {
String username = principal.getName();
System.out.println("Message from " + username + ": " + message);
// ... use username for user-specific logic
}
}WebSocket-specifikke data
Ud over at kopiere HTTP-sessionsdata kan du også gemme oplysninger direkte i selve WebSocketSession. Disse data er specifikke for den pågældende WebSocket-forbindelse.
Det er nyttigt til håndtering af forbindelsesspecifikke tilstande, f.eks. en brugers aktuelle chatrum, meddelelsesindstillinger for denne forbindelse eller andre midlertidige data.
@EventListener
public void handleSessionConnect(SessionConnectedEvent event) {
StompHeaderAccessor accessor = StompHeaderAccessor.wrap(event.getMessage());
WebSocketSession session = (WebSocketSession) accessor.getSessionAttributes().get("webSocketSession");
if (session != null) {
session.getAttributes().put("customKey", "customValue");
}
System.out.println("User connected: " + accessor.getUser().getName());
}Håndtering af sessionens livscyklus
Spring giver dig mulighed for at lytte efter hændelser i WebSocket-sessionens livscyklus. Det er afgørende, når ressourcer skal ryddes op, eller brugerstatus skal opdateres, når forbindelser oprettes eller lukkes.
Du kan bruge @EventListener sammen med SessionConnectedEvent og SessionDisconnectEvent til at reagere på disse ændringer.
SessionConnectedEvent: Udløses, når en ny STOMP-session er oprettet.SessionDisconnectEvent: Udløses, når en STOMP-session lukkes.
Kørbar: Håndtryksinterceptor
Dette Spring Boot-eksempel konfigurerer et WebSocket-slutpunkt med HttpSessionHandshakeInterceptor. Når en klient opretter forbindelse, hjælper interceptoren med at forbinde HTTP-sessionen (hvis der er en) med WebSocket-sessionen.
Vi demonstrerer en enkel meddelelseshåndterer, som kunne få adgang til den godkendte brugers Principal. Hvis Spring Security var aktiveret, ville principal.getName() returnere brugernavnet på den bruger, der er logget ind.
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.handler.annotation.MessageMapping;
import org.springframework.messaging.simp.config.MessageBrokerRegistry;
import org.springframework.stereotype.Controller;
import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
import org.springframework.web.socket.config.annotation.StompEndpointRegistry;
import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer;
import org.springframework.web.socket.server.support.HttpSessionHandshakeInterceptor;
import java.security.Principal;
@SpringBootApplication
@EnableWebSocketMessageBroker
public class WebSocketSessionApp {
public static void main(String[] args) {
SpringApplication.run(WebSocketSessionApp.class, args);
}
@Configuration
public static class WebSocketConfig implements WebSocketMessageBrokerConfigurer {
@Override
public void configureMessageBroker(MessageBrokerRegistry config) {
config.enableSimpleBroker("/topic");
config.setApplicationDestinationPrefixes("/app");
}
@Override
public void registerStompEndpoints(StompEndpointRegistry registry) {
registry.addEndpoint("/ws")
.addInterceptors(new HttpSessionHandshakeInterceptor())
.withSockJS();
}
}
@Controller
public static class WebSocketGreetingController {
@MessageMapping("/hello")
public void greeting(Principal principal) {
if (principal != null) {
System.out.println("Message from authenticated user: " + principal.getName());
} else {
System.out.println("Message from unauthenticated user (Principal is null).");
}
}
}
}Hurtig test: Håndtryksinterceptor
Test din forståelse af HttpSessionHandshakeInterceptor.
Opsummering: Sessionshåndtering
Vi har undersøgt, hvordan du håndterer brugersessioner i Spring WebSocket-applikationer, især hvordan du forbinder HTTP-sessionskontekst med WebSocket-sessioner.
HttpSessionHandshakeInterceptorer afgørende for at kopiere HTTP-sessionsattributter under håndtrykket.- Du kan få adgang til oplysninger om godkendte brugere (
Principal) i WebSocket-håndterere. @EventListenerhjælper med at håndtere hændelser ved oprettelse og afbrydelse af forbindelser.
Korrekt sessionshåndtering sikrer, at dine realtidsfunktioner er personaliserede og sikre for hver bruger.
Lær WebSockets og realtidssystemer med Spring med en AI-underviser — gratis
Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.
- Kurser
- 12
- Lektioner
- 48
Ofte stillede spørgsmål
Er lektionen “Håndtering af brugersessioner” gratis?
Ja — hele teksten til “Håndtering af brugersessioner” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af WebSockets og realtidssystemer med Spring-kurset, skal du opgradere til CoddyKit PRO. WebSockets og realtidssystemer med Spring-kurset indeholder 4 lektioner i alt.
Hvad lærer jeg i “Håndtering af brugersessioner”?
Implementer avanceret håndtering af brugersessioner i WebSockets ved at knytte HTTP-sessioner til WebSocket-sessioner. Du øver dig i WebSockets og realtidssystemer med Spring med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.
Skal jeg have erfaring for at begynde på WebSockets og realtidssystemer med Spring?
Der kræves ingen tidligere erfaring. WebSockets og realtidssystemer med Spring på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 3 af 4.
Hvor lang tid tager lektionen “Håndtering af brugersessioner”?
De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.
Kan jeg skrive og køre kode i denne WebSockets og realtidssystemer med Spring-lektion?
Ja. Alle WebSockets og realtidssystemer med Spring-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.
Alle lektioner i dette kursus
- WebSocket-interceptorer
- Tilpasning af meddelelseskonvertere
- Håndtering af brugersessioner
- Målrettede meddelelser til bestemte brugere