Finjustering av Spring WebSocket-inställningar
Optimera Spring WebSocket-konfigurationer för miljöer med hög genomströmning och låg fördröjning.
Finjustering av Spring WebSocket-inställningar är en gratis lektion i WebSockets och realtidssystem med Spring på CoddyKit. Detta är lektion 3 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för WebSockets och realtidssystem med Spring, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i WebSockets och realtidssystem med Spring innehåller totalt 4 lektioner.
Varför finjustera WebSocket?
Dina realtidsapplikationer måste vara snabba och tillförlitliga! Spring WebSocket har rimliga standardinställningar, men i scenarier med hög trafik eller låg svarstid behöver du finjustera dem.
I den här lektionen får du lära dig hur du optimerar konfigurationen av Spring WebSocket för maximal prestanda och en bättre användarupplevelse.
Mål för genomströmning och svarstid
När vi talar om prestandajustering fokuserar vi ofta på två viktiga mätvärden:
- Genomströmning: Hur många meddelanden eller operationer kan systemet hantera per sekund? Högre är vanligtvis bättre.
- Svarstid: Hur lång tid tar det för ett meddelande att färdas från avsändare till mottagare? Lägre är alltid bättre.
Genom att optimera dessa får du en smidig och responsiv realtidsapplikation.
WebSocket-buffertstorlekar
Den underliggande WebSocket-containern i Spring har gränser för storleken på enskilda meddelanden. Om applikationen skickar eller tar emot mycket stora meddelanden kan standardvärdena vara för begränsade, vilket gör att meddelanden avvisas.
- Textmeddelandebuffert: För textbaserade meddelanden, till exempel JSON-strängar.
- Binär meddelandebuffert: För binära data, till exempel bilder och filer.
Du kan öka dessa gränser för att tillåta större nyttolaster.
Exempel: Ange buffertgränser
Du kan konfigurera den maximala buffertstorleken för text- och binärmeddelanden genom att definiera en bean av typen ServletServerContainerFactoryBean i konfigurationen. Då kan den underliggande WebSocket-containern hantera större meddelanden.
import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.config.annotation.EnableWebSocket;
import org.springframework.web.socket.config.annotation.WebSocketConfigurer;
import org.springframework.web.socket.config.annotation.WebSocketHandlerRegistry;
import org.springframework.web.socket.server.standard.ServletServerContainerFactoryBean;
import org.springframework.context.annotation.Bean;
@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {
@Override
public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
// Handlers would be registered here, e.g., registry.addHandler(myHandler(), "/my-websocket");
}
@Bean
public ServletServerContainerFactoryBean createWebSocketContainer() {
ServletServerContainerFactoryBean container = new ServletServerContainerFactoryBean();
container.setMaxTextMessageBufferSize(16384); // Double the default (8192)
container.setMaxBinaryMessageBufferSize(16384); // Double the default
System.out.println("WebSocket container buffer sizes set to 16KB.");
return container;
}
public static void main(String[] args) {
// This config class is loaded by Spring Boot, not run directly.
// We simulate its effect for demonstration.
System.out.println("To apply these settings, run a Spring Boot app with this config.");
}
}Storleksgränser för STOMP-ramar
Om du använder STOMP över WebSocket för strukturerad meddelandehantering finns det ytterligare buffertgränser som styr den maximala storleken på STOMP-ramar. Dessa skiljer sig från de vanliga WebSocket-buffertstorlekarna.
- Sändbuffertgräns: Maximal storlek för utgående STOMP-ramar från servern.
- Mottagningsbuffertgräns: Maximal storlek för inkommande STOMP-ramar till servern.
Dessa gränser konfigureras på själva STOMP-slutpunkten.
Exempel: Justera STOMP-buffertar
Du kan ange STOMP-specifika buffertgränser direkt i slutpunktsregistret. Då säkerställs att stora STOMP-meddelanden, som innehåller huvuden och brödtext, inte överskrider de önskade gränserna. Det förebygger potentiella minnesproblem eller överbelastningsattacker.
import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.simp.config.MessageBrokerRegistry;
import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
import org.springframework.web.socket.config.annotation.StompEndpointRegistry;
import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer;
@Configuration
@EnableWebSocketMessageBroker
public class StompWebSocketConfig implements WebSocketMessageBrokerConfigurer {
@Override
public void configureMessageBroker(MessageBrokerRegistry config) {
config.enableSimpleBroker("/topic");
config.setApplicationDestinationPrefixes("/app");
}
@Override
public void registerStompEndpoints(StompEndpointRegistry registry) {
registry.addEndpoint("/ws")
.setAllowedOrigins("*")
.setSendBufferLimit(512 * 1024) // 512KB for outgoing STOMP frames
.setReceiveBufferLimit(512 * 1024); // 512KB for incoming STOMP frames
System.out.println("STOMP endpoint buffer limits set to 512KB.");
}
public static void main(String[] args) {
System.out.println("STOMP WebSocket config with buffer limits prepared.");
}
}Håll anslutningar vid liv (heartbeats)
WebSocket-anslutningar kan ibland bli inaktiva utan aktivitet, särskilt när de passerar genom nätverksproxyservrar eller lastbalanserare. STOMP-heartbeats är viktiga för att upprätthålla anslutningarnas tillstånd.
- De skickar små ”ping”-meddelanden med jämna mellanrum.
- Det förhindrar att inaktiva anslutningar stängs utan förvarning.
- De hjälper till att snabbt upptäcka klienter eller servrar som inte svarar.
Du konfigurerar serverns intervall för både sändning och mottagning av heartbeats.
Exempel: Ange STOMP-heartbeats
För att aktivera och konfigurera heartbeats använder du metoden setHeartbeatValue i konfigurationen av meddelandemäklaren. Arrayen representerar [server-send-interval, server-receive-interval] i millisekunder.
import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.simp.config.MessageBrokerRegistry;
import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
import org.springframework.web.socket.config.annotation.StompEndpointRegistry;
import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer;
@Configuration
@EnableWebSocketMessageBroker
public class StompHeartbeatConfig implements WebSocketMessageBrokerConfigurer {
@Override
public void configureMessageBroker(MessageBrokerRegistry config) {
config.enableSimpleBroker("/topic")
.setHeartbeatValue(new long[]{10000, 10000}); // Server sends every 10s, expects client every 10s
config.setApplicationDestinationPrefixes("/app");
System.out.println("STOMP broker heartbeat set to 10 seconds.");
}
@Override
public void registerStompEndpoints(StompEndpointRegistry registry) {
registry.addEndpoint("/ws").setAllowedOrigins("*");
}
public static void main(String[] args) {
System.out.println("STOMP WebSocket config with heartbeat values prepared.");
}
}Trådpool för meddelandehantering
När Spring-servern tar emot STOMP-meddelanden behandlas de av en trådpool. Som standard tillhandahåller Spring en enkel sådan, men för applikationer med hög belastning får du betydligt bättre prestanda genom att konfigurera en dedikerad ThreadPoolTaskExecutor.
- Poolens kärnstorlek: Det minsta antalet trådar som alltid körs.
- Poolens maximala storlek: Det högsta antalet trådar som tillåts i poolen.
- Kökapacitet: Hur många uppgifter som kan vänta när alla trådar är upptagna.
Det är viktigt att dimensionera denna exekverare korrekt för att hantera samtidiga meddelanden effektivt.
Exempel: Anpassad uppgiftsexekverare
Du kan definiera en anpassad ThreadPoolTaskExecutor och tilldela den till klientens inkommande kanal. Det ger dig detaljerad kontroll över hur många samtidiga meddelanden applikationen kan behandla.
import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.simp.config.MessageBrokerRegistry;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
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.context.annotation.Bean;
import org.springframework.messaging.simp.config.ChannelRegistration;
@Configuration
@EnableWebSocketMessageBroker
public class CustomExecutorConfig implements WebSocketMessageBrokerConfigurer {
@Override
public void configureMessageBroker(MessageBrokerRegistry config) {
config.enableSimpleBroker("/topic");
config.setApplicationDestinationPrefixes("/app");
}
@Override
public void registerStompEndpoints(StompEndpointRegistry registry) {
registry.addEndpoint("/ws").setAllowedOrigins("*");
}
@Override
public void configureClientInboundChannel(ChannelRegistration registration) {
registration.taskExecutor(clientInboundExecutor());
System.out.println("Custom client inbound task executor configured.");
}
@Bean
public ThreadPoolTaskExecutor clientInboundExecutor() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
executor.setCorePoolSize(8); // Start with 8 threads
executor.setMaxPoolSize(16); // Allow up to 16 threads
executor.setQueueCapacity(512); // Queue up to 512 tasks
executor.setThreadNamePrefix("StompInbound-");
executor.initialize();
return executor;
}
public static void main(String[] args) {
System.out.println("STOMP WebSocket config with custom task executor prepared.");
}
}Snabbtest: Alternativ för finjustering
Vilka av följande konfigurationsinställningar för Spring WebSocket kan direkt påverka realtidsapplikationens prestanda, det vill säga genomströmning och/eller svarstid?
Sammanfattning: Optimera dina WebSocket-anslutningar
Bra jobbat! Du har lärt dig att finjustera Spring WebSocket-applikationer för bättre prestanda.
- Vi justerade WebSocket-buffertstorlekar för större meddelanden.
- Vi konfigurerade STOMP-ramgränser för strukturerade data.
- Vi konfigurerade heartbeats för att upprätthålla anslutningarnas tillstånd.
- Vi anpassade trådpoolen för meddelandehantering för samtidig bearbetning.
Att tillämpa dessa inställningar är avgörande för att bygga robusta, skalbara och högpresterande realtidssystem!
Lär dig WebSockets och realtidssystem med Spring med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 12
- Lektioner
- 48
Vanliga frågor
Är lektionen ”Finjustering av Spring WebSocket-inställningar” gratis?
Ja – hela texten till ”Finjustering av Spring WebSocket-inställningar” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i WebSockets och realtidssystem med Spring, kan Ni uppgradera till CoddyKit PRO. Kursen i WebSockets och realtidssystem med Spring innehåller totalt 4 lektioner.
Vad lär jag mig i ”Finjustering av Spring WebSocket-inställningar”?
Optimera Spring WebSocket-konfigurationer för miljöer med hög genomströmning och låg fördröjning. Ni övar på WebSockets och realtidssystem med Spring med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig WebSockets och realtidssystem med Spring?
Du behöver inga förkunskaper. Utbildningen i WebSockets och realtidssystem med Spring på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.
Hur lång tid tar lektionen ”Finjustering av Spring WebSocket-inställningar”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här WebSockets och realtidssystem med Spring-lektionen?
Ja. Varje WebSockets och realtidssystem med Spring-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Prestandamätning av WebSockets
- Övervakning av WebSocket-anslutningar
- Finjustering av Spring WebSocket-inställningar
- Minska bandbredden med meddelandekomprimering