Overvågning af WebSocket-forbindelser
Implementer overvågningsløsninger til at følge aktive forbindelser, meddelelseshastigheder og serverens tilstand.
Overvågning af WebSocket-forbindelser er en gratis WebSockets og realtidssystemer med Spring-lektion på CoddyKit. Dette er lektion 2 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.
Hvorfor overvåge WebSockets?
Realtidsapplikationer, der bruger WebSockets, kræver konstant opmærksomhed for at fungere problemfrit. I modsætning til traditionel HTTP opretholder WebSockets vedvarende forbindelser, så det er afgørende at holde øje med deres tilstand.
Overvågning hjælper os med at forstå ydeevnen, identificere flaskehalse og reagere hurtigt på problemer, før brugerne bliver påvirket. Det er afgørende for pålidelige realtidsoplevelser.
Vigtige WebSocket-målepunkter
Fokuser på disse vigtige områder, når du overvåger WebSockets:
- Aktive forbindelser: Hvor mange klienter er i øjeblikket forbundet?
- Meddelelsesfrekvens: Hvor mange meddelelser sendes eller modtages pr. sekund?
- Fejlfrekvens: Hvor ofte mislykkes forbindelser, eller opstår der fejl i meddelelser?
- Svartid: Hvor hurtigt behandles og leveres meddelelser?
Hvis du følger disse målepunkter, får du et klart billede af din applikations tilstand.
Grundlæggende overvågning med Actuator
Spring Boot Actuator tilbyder funktioner, der er klar til produktion, til overvågning og administration af din applikation. Det stiller forskellige endepunkter til rådighed, som giver indsigt i din applikations tilstand, målepunkter og miljø.
Actuator er ikke specifikt beregnet til WebSockets, men kan vise generelle JVM-målepunkter, målepunkter for HTTP-anmodninger og den overordnede applikationstilstand. Det er grundlaget for enhver overvågningsopsætning.
Actuators målepunktsendepunkt
For at komme i gang skal du tilføje Actuator-afhængigheden til din pom.xml. Derefter kan du få adgang til endepunkter som /actuator/health eller /actuator/metrics.
Endepunktet /actuator/metrics viser en liste over tilgængelige målepunkter, herunder nogle, der vedrører trådpuljer eller netværksaktivitet, og som indirekte kan afspejle WebSocket-belastningen.
<!-- pom.xml snippet -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>Micrometer til brugerdefinerede målepunkter
Til WebSocket-specifikke målepunkter bruger vi Micrometer, Spring Boots facade til målepunkter. Den giver dig mulighed for at instrumentere din kode med brugerdefinerede tællere, målere, tidsmålere og meget mere, som derefter kan eksporteres til forskellige overvågningssystemer.
Micrometer tilbyder en ensartet API, så du kan vælge din overvågningsbackend (f.eks. Prometheus eller Grafana) uden at ændre din kode.
Optælling af aktive WebSocket-sessioner
Hvis du vil følge antallet af aktive WebSocket-forbindelser, kan du bruge en AtomicInteger til at tælle sessioner. Micrometers Gauge kan derefter eksponere denne værdi.
En Gauge er velegnet til værdier, der varierer, f.eks. antallet af klienter, der er forbundet lige nu. I en rigtig applikation ville du opdatere denne tæller ved hændelser for oprettelse og afbrydelse af forbindelser.
import io.micrometer.core.instrument.Gauge;
import io.micrometer.core.instrument.MeterRegistry;
import io.micrometer.core.instrument.simple.SimpleMeterRegistry;
import java.util.concurrent.atomic.AtomicInteger;
public class SessionCounterDemo {
private final AtomicInteger activeSessions = new AtomicInteger(0);
private final MeterRegistry meterRegistry;
public SessionCounterDemo(MeterRegistry registry) {
this.meterRegistry = registry;
Gauge.builder("websocket.active.sessions", activeSessions, AtomicInteger::get)
.description("Number of active WebSocket sessions")
.register(meterRegistry);
}
public void connect() {
activeSessions.incrementAndGet();
}
public void disconnect() {
activeSessions.decrementAndGet();
}
public static void main(String[] args) {
MeterRegistry registry = new SimpleMeterRegistry();
SessionCounterDemo demo = new SessionCounterDemo(registry);
System.out.println("Initial sessions: " + demo.activeSessions.get());
demo.connect();
demo.connect();
System.out.println("After 2 connects: " + demo.activeSessions.get());
demo.disconnect();
System.out.println("After 1 disconnect: " + demo.activeSessions.get());
}
}Følg meddelelsesfrekvenser
Ud over forbindelser er det afgørende at følge meddelelsesfrekvenser. Du kan bruge en Micrometer-Counter, der øges, hver gang en meddelelse sendes eller modtages.
En Counter er et målepunkt med én værdi, som kun stiger. Den er velegnet til optælling af hændelser som behandlede meddelelser, håndterede anmodninger eller opståede fejl.
import io.micrometer.core.instrument.Counter;
import io.micrometer.core.instrument.MeterRegistry;
import io.micrometer.core.instrument.simple.SimpleMeterRegistry;
public class MessageCounterDemo {
private final Counter messagesReceived;
public MessageCounterDemo(MeterRegistry registry) {
this.messagesReceived = Counter.builder("websocket.messages.received")
.description("Number of WebSocket messages received")
.register(registry);
}
public void onMessageReceived(String message) {
messagesReceived.increment();
System.out.println("Received message: " + message);
}
public static void main(String[] args) {
MeterRegistry registry = new SimpleMeterRegistry();
MessageCounterDemo demo = new MessageCounterDemo(registry);
System.out.println("Initial messages: " + demo.messagesReceived.count());
demo.onMessageReceived("Hello");
demo.onMessageReceived("World");
System.out.println("Total messages: " + demo.messagesReceived.count());
}
}Registrering af WebSocket-fejl
Der kan opstå fejl på forskellige stadier: under forbindelseshåndtryk, fortolkning af meddelelser eller behandling af forretningslogik. Det er vigtigt at følge disse fejl for at bevare applikationens stabilitet.
Du kan bruge en Counter til bestemte fejltyper, eventuelt med tags, der skelner mellem forbindelsesfejl, fejl i meddelelsesformatet og fejl under serverbehandling.
import io.micrometer.core.instrument.Counter;
import io.micrometer.core.instrument.MeterRegistry;
import io.micrometer.core.instrument.simple.SimpleMeterRegistry;
public class ErrorCounterDemo {
private final Counter connectionErrors;
private final Counter messageProcessingErrors;
public ErrorCounterDemo(MeterRegistry registry) {
this.connectionErrors = Counter.builder("websocket.errors.total")
.tag("type", "connection")
.description("Total connection errors")
.register(registry);
this.messageProcessingErrors = Counter.builder("websocket.errors.total")
.tag("type", "message_processing")
.description("Total message processing errors")
.register(registry);
}
public void simulateConnectionError() {
connectionErrors.increment();
System.out.println("Connection error occurred.");
}
public void simulateMessageProcessingError() {
messageProcessingErrors.increment();
System.out.println("Message processing error occurred.");
}
public static void main(String[] args) {
MeterRegistry registry = new SimpleMeterRegistry();
ErrorCounterDemo demo = new ErrorCounterDemo(registry);
System.out.println("Initial connection errors: " + demo.connectionErrors.count());
demo.simulateConnectionError();
System.out.println("Connection errors after one: " + demo.connectionErrors.count());
demo.simulateMessageProcessingError();
System.out.println("Message processing errors: " + demo.messageProcessingErrors.count());
}
}Eksport af målepunkter til dashboards
Når du har instrumenteret din applikation med Micrometer, kan disse målepunkter eksporteres til forskellige overvågningssystemer som Prometheus, Grafana, Datadog eller New Relic.
Disse systemer giver dig derefter mulighed for at opbygge effektive dashboards, der visualiserer dine WebSocket-målepunkter i realtid. Det hjælper dig med at opdage tendenser, oprette alarmer og fejlfinde effektivt.
Tjek af Micrometer-målepunkter
Du vil følge antallet af aktuelt aktive brugere i en chatapplikation. Hvilken Micrometer-målepunktstype egner sig bedst til dette formål?
Opsummering af overvågning
Godt gået! Du har lært, hvor vigtigt det er at overvåge WebSocket-applikationer, og hvordan du implementerer det.
- Vi undersøgte vigtige WebSocket-målepunkter som aktive forbindelser og meddelelsesfrekvenser.
- Du så, hvordan Spring Boot Actuator tilbyder grundlæggende tilstandstjek.
- Vi brugte Micrometer til at oprette brugerdefinerede målepunkter af typen
GaugeogCounterfor WebSocket-sessioner og meddelelser.
Gå derefter videre til specifikke værktøjer som Prometheus og Grafana for at visualisere disse målepunkter og opbygge robuste dashboards!
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 “Overvågning af WebSocket-forbindelser” gratis?
Ja — hele teksten til “Overvågning af WebSocket-forbindelser” 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 “Overvågning af WebSocket-forbindelser”?
Implementer overvågningsløsninger til at følge aktive forbindelser, meddelelseshastigheder og serverens tilstand. 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 2 af 4.
Hvor lang tid tager lektionen “Overvågning af WebSocket-forbindelser”?
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
- Benchmarking af WebSocket-ydeevne
- Overvågning af WebSocket-forbindelser
- Finjustering af Spring WebSocket-indstillinger
- Reduktion af båndbredde med meddelelseskomprimering