Implementering af opdateringer i realtid
Udvikl subscription-resolvere i Spring Boot for at publicere hændelser og sende live-data til klienter.
Implementering af opdateringer i realtid er en gratis GraphQL-API'er med Spring Boot-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 GraphQL-API'er med Spring Boot, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. GraphQL-API'er med Spring Boot-kurset indeholder 4 lektioner i alt.
Forklaring af abonnementsresolvere
Abonnementer leverer opdateringer i realtid. I modsætning til forespørgsler, der returnerer data én gang, returnerer abonnementsresolvere en datastrøm, som løbende sender opdateringer til klienterne.
Vi lærer, hvordan du implementerer disse datastrømme i en Spring Boot GraphQL-applikation.
Brug af Reactor Flux
Spring GraphQL bruger Project Reactors Flux til at håndtere abonnementer. En Flux repræsenterer en asynkron, ikke-blokerende strøm med fra 0 til N elementer.
- Den er velegnet til løbende levering af data.
- Du kan udsende flere værdier over tid.
Schema til opdateringer i realtid
Først definerer vi vores abonnement i GraphQL Schema Definition Language (SDL). Dette eksempel viser et abonnement på nye meddelelser:
type Subscription {
messageAdded(channelId: ID!): Message
}
type Message {
id: ID!
text: String!
channelId: ID!
timestamp: String!
}Oprettelse af en abonnementsresolver
I Spring Boot er en abonnementsresolver en metode, der er annoteret med @SubscriptionMapping. Den skal returnere en Flux med den ønskede type.
Vi bruger en Sinks.Many til at administrere og udgive hændelser i denne strøm.
import org.springframework.graphql.data.method.annotation.SubscriptionMapping;
import org.springframework.stereotype.Controller;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Sinks;
@Controller
public class MessageSubscriptionController {
private final Sinks.Many<Message> messageSink =
Sinks.many().multicast().onBackpressureBuffer();
@SubscriptionMapping
public Flux<Message> messageAdded() {
return messageSink.asFlux();
}
}Udgivelse af hændelser med Sinks.Many
Instansen Sinks.Many fungerer som vores hændelsesudgiver. Når en hændelse indtræffer (f.eks. når der oprettes en ny meddelelse), bruger vi dens metode tryEmitNext() til at sende data ind i strømmen.
Disse data flyder derefter gennem Flux til alle tilsluttede GraphQL-abonnenter.
public class MessageService {
private final Sinks.Many<Message> messageSink;
public MessageService(Sinks.Many<Message> messageSink) {
this.messageSink = messageSink;
}
public Message createMessage(String text, String channelId) {
// ... save message to DB ...
Message newMessage = new Message("1", text, channelId, "now");
messageSink.tryEmitNext(newMessage); // Publish the new message
return newMessage;
}
}Komplet opsætning, der kan køres
Lad os bygge en komplet Spring Boot-applikation, der kan køres. Vi definerer en Message-record og en MessagePublisher-komponent til at administrere vores Sinks.Many.
record Message(String id, String text, String channelId, String timestamp) {}
import org.springframework.stereotype.Component;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Sinks;
@Component
public class MessagePublisher {
private final Sinks.Many<Message> messageSink =
Sinks.many().multicast().onBackpressureBuffer();
public Flux<Message> getMessageStream() {
return messageSink.asFlux();
}
public void publishMessage(Message message) {
messageSink.tryEmitNext(message);
}
}Hovedapplikation og resolver
Nu forbinder vi vores MessagePublisher med @SubscriptionMapping-resolveren. Klassen Main simulerer afsendelsen af en meddelelse efter en forsinkelse.
Kør dette eksempel for at se udgivelse fra serversiden i praksis!
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.graphql.data.method.annotation.SubscriptionMapping;
import org.springframework.stereotype.Controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.time.Duration;
@SpringBootApplication
public class Main implements CommandLineRunner {
@Autowired
private MessagePublisher messagePublisher;
public static void main(String[] args) {
SpringApplication.run(Main.class, args);
}
@Override
public void run(String... args) throws Exception {
// Simulate sending a message after 2 seconds
Mono.delay(Duration.ofSeconds(2))
.subscribe(l -> {
Message msg = new Message("2", "Hello from Spring!", "general", "now");
messagePublisher.publishMessage(msg);
System.out.println("Published: " + msg);
});
}
}
@Controller
class MessageSubscriptionController {
private final MessagePublisher messagePublisher;
public MessageSubscriptionController(MessagePublisher messagePublisher) {
this.messagePublisher = messagePublisher;
}
@SubscriptionMapping
public Flux<Message> messageAdded() {
return messagePublisher.getMessageStream();
}
}
record Message(String id, String text, String channelId, String timestamp) {}Filtrering af abonnementshændelser
Klienter har ofte brug for opdateringer, der matcher bestemte kriterier. Vi kan filtrere Flux baseret på argumenter, der sendes til abonnementet.
Her modtager klienterne kun meddelelser for et angivet channelId.
import org.springframework.graphql.data.method.annotation.Argument;
// ... other imports ...
@Controller
class MessageSubscriptionController {
private final MessagePublisher messagePublisher;
public MessageSubscriptionController(MessagePublisher messagePublisher) {
this.messagePublisher = messagePublisher;
}
@SubscriptionMapping
public Flux<Message> messageAdded(@Argument String channelId) {
return messagePublisher.getMessageStream()
.filter(msg -> msg.channelId().equals(channelId));
}
}Adskillelse af hændelsesudgivelse
For at opnå en bedre arkitektur er det god praksis at adskille hændelsesudgivelsen fra din centrale forretningslogik.
- Det holder dine tjenester rene og fokuserede.
- Det gør det muligt for flere uafhængige abonnenter at reagere på den samme hændelse uden tæt kobling.
- Overvej at bruge Spring's
ApplicationEventPublishereller en dedikeret hændelsesbus til dette.
Kontrol af abonnementsresolver
Du har lært, hvordan du implementerer abonnementsresolvere i Spring Boot. Lad os teste din forståelse!
Opsummering: Opdateringer i realtid
Du har med succes lært, hvordan du implementerer opdateringer i realtid ved hjælp af GraphQL-abonnementer i Spring Boot!
- Abonnementsresolvere returnerer en
Flux. Sinks.Manybruges til at udgive hændelser iFlux.- Du kan filtrere datastrømme baseret på abonnementsargumenter.
- Adskillelse af udgivelseslogikken gør vedligeholdelsen lettere.
Lær GraphQL-API'er med Spring Boot 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 “Implementering af opdateringer i realtid” gratis?
Ja — hele teksten til “Implementering af opdateringer i realtid” 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 GraphQL-API'er med Spring Boot-kurset, skal du opgradere til CoddyKit PRO. GraphQL-API'er med Spring Boot-kurset indeholder 4 lektioner i alt.
Hvad lærer jeg i “Implementering af opdateringer i realtid”?
Udvikl subscription-resolvere i Spring Boot for at publicere hændelser og sende live-data til klienter. Du øver dig i GraphQL-API'er med Spring Boot 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å GraphQL-API'er med Spring Boot?
Der kræves ingen tidligere erfaring. GraphQL-API'er med Spring Boot 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 “Implementering af opdateringer i realtid”?
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 GraphQL-API'er med Spring Boot-lektion?
Ja. Alle GraphQL-API'er med Spring Boot-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
- Forståelse af GraphQL-subscriptions
- Implementering af opdateringer i realtid
- Integration af WebSockets med Spring
- Filtrering og skalering af subscriptions