[JAVA] Erforderliche Schritte zum Ausgeben von asynchronen Spring Boot-Ereignissen

Das Spring Framework bietet einen Mechanismus, mit dem Sie die Ausführung einer Instanz unter Spring Management als "Ereignis" registrieren und die Ausführung durch Ausgabe eines Ereignisses steuern können. Es ist einfach zu bedienen und Spring Boot ermöglicht die asynchrone Verarbeitung. Dieses Mal beschreiben wir ein Beispiel für die Implementierung einer asynchronen Verarbeitung mithilfe asynchroner Ereignisse in Spring Boot.

Betriebsumgebung

• Java 11
• SpringBoot 2.3.1

Was ist für die ereignisgesteuerte Verarbeitung erforderlich?

Die folgenden 3 Kreationen sind erforderlich

• Ereignisklasse, die Parameter übergibt, die für die Verarbeitung der Ausführung erforderlich sind
• Publisher-Klasse, die ein Ereignis auslöst
• Listener-Klasse, die ein Ereignis erkennt und mit der Verarbeitung beginnt

Implementierungsbeispiel

Diesmal zu erstellendes Ereignis: Empfängt eine Zeichenfolge von der aufrufenden Klasse und gibt sie an das Protokoll aus

Die Klasse, die die vom Ereignis übergebene Zeichenfolge speichert, verwendet Folgendes.

SampleMessage.java

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.ToString;

@AllArgsConstructor @Getter @ToString
public class SampleMessage {
	private String message;

	public static SampleMessage of(String message) {
		return new SampleMessage(message);
	}
}

Event

Erbt org.springframework.context.ApplicationEvent.

PrimaryEvent.java

@Getter
public class PrimaryEvent extends ApplicationEvent {

	private final SampleMessage sampleMessage;

	public PrimaryEvent(Object source,  SampleMessage sampleMessage) {
		super(source);
		this.sampleMessage = sampleMessage;
	}

}

Erstes Argument des Konstruktors: Die Objektquelle ist eine erforderliche Implementierung.

Publisher

Erstellen Sie eine Java-Klasse, die die von Spring verwaltete org.springframework.context.ApplicationEventPublisher-Instanz verwendet. Daher ist es einfach, "@ Component" oder "@ Service" hinzuzufügen, um es zu einer Klasse zu machen, die in Spring Management [^ 1] platziert ist.

PrimaryEventPublisher.java

import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Component;

import lombok.AllArgsConstructor;
import lombok.extern.log4j.Log4j2;

@Component
@AllArgsConstructor
public class PrimaryEventPublisher {

	private final ApplicationEventPublisher applicationEventPublisher;

	public void ignite(String message) {
		SampleMessage sampleMessage = SampleMessage.of(message);
		
		//Erstellen Sie ein Ereignis
		PrimaryEvent event = new PrimaryEvent(this, sampleMessage);

		//Eventausgabe!
		applicationEventPublisher.publishEvent(event);
	}
}

Listener

Platzieren Sie es unter Spring Management [^ 2] und implementieren Sie die Schnittstelle org.springframework.context.ApplicationListener. Am einfachsten ist es, "@ Component" anzugeben.

import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

import lombok.extern.log4j.Log4j2;

@Component
public class PrimaryEventListener implements ApplicationListener<PrimaryEvent>{

	@Override
	public void onApplicationEvent(PrimaryEvent event) {
		SampleMessage sampleMessage = event.getSampleMessage();
		
		//Nachbearbeitung nach Erhalt einer Nachricht ↓......
	}

}

Damit ist die Vorbereitung für die Ereignisausführung abgeschlossen.

Ausführungsbeispiel von Spring MVC Controller

Dies ist ein Beispiel für das Empfangen einer Anforderung in Controller, das Ausführen eines Ereignisses und das anschließende Anzeigen des Bildschirms.

DisplayController.java

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

import lombok.AllArgsConstructor;

@RequestMapping("/display")
@Controller
@AllArgsConstructor
public class DisplayController {

	private final PrimaryEventPublisher publisher;

	@GetMapping
	public ModelAndView display(ModelAndView mnv) {

		publisher.ignite("Eine Nachricht schicken");

		mnv.setViewName("display");
		return mnv;
	}
}

Dies unterscheidet sich nicht von der Implementierung mit Spring MVC, und der Controller zeigt den Bildschirm an, nachdem das Ereignis ausgeführt und beendet wurde.

Asynchrone Verarbeitung

Um die asynchrone Verarbeitung mit SpringBoot zu verwenden, geben Sie der SpringBoot-Startklasse "@ EnableAsync" und fügen Sie der Klasse, die Sie asynchron verarbeiten möchten, "@ Async" hinzu.

SpringEventSampleApplication.java

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableAsync;

@SpringBootApplication
@EnableAsync
public class SpringEventSampleApplication {

	public static void main(String[] args) {
		SpringApplication.run(SpringEventSampleApplication.class, args);
	}

}

Was Sie beispielsweise asynchron arbeiten möchten, ist die folgende Zündmethode im Controller.

DisplayController.java

public class DisplayController {

	private final PrimaryEventPublisher publisher;

	@GetMapping
	public ModelAndView display(ModelAndView mnv) {
		//Ich möchte es getrennt von der Bildschirmanzeige verarbeiten
		publisher.ignite("Eine Nachricht schicken");

		mnv.setViewName("display");
		return mnv;
	}
}

Ich möchte PrimaryEventPublisher asynchron ausführen, also füge einfach "@ Async" hinzu.

PrimaryEventPublisher.java

import org.springframework.context.ApplicationEventPublisher;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

import lombok.AllArgsConstructor;

@Component
@AllArgsConstructor
@Async
public class PrimaryEventPublisher {

	private final ApplicationEventPublisher applicationEventPublisher;

	public void ignite(String message) {
		SampleMessage sampleMessage = SampleMessage.of(message);

		PrimaryEvent event = new PrimaryEvent(this, sampleMessage);
		applicationEventPublisher.publishEvent(event);
	}
}

Es ist sehr einfach, d (・ ω ・ ・ Da es möglich ist, mit @ Repository für die Verarbeitung, die ausgeführt werden kann, an die Datenquelle auszugeben, kann es auch zum Senden einer Benachrichtigung über den Abschluss der Verarbeitung an das interne Chat-Tool oder die E-Mail verwendet werden.

[^ 1]: Tatsächlich kann es aus Spring's ApplicationContext abgerufen werden, daher ist es nicht unbedingt erforderlich, Anmerkungen wie "@ Component" hinzuzufügen, um es unter die Spring-Verwaltung zu stellen. "Spring Managed = in ApplicationContext registrierte Klasse". In Spring Boot muss sich die ComponentScan-Funktion, die das Vorhandensein von Klassen mit den Spring-Annotationen "@ Controller", "@ Service", "@ Repository" und "@ Component" erkennt, in einem gültigen Paket befinden. Es ist eine Voraussetzung.

[^ 2]: Weil es von ApplicationEventPublisher unter Spring Management ausgeführt wird. Wenn Sie es nicht in ApplicationContext registrieren, funktioniert es nicht (es wird übersehen)