So verwenden Sie ApplicationEvent und ApplicationListener in SpringBoot

In diesem Modell gibt es zwei wichtige Klassen, eine ist Ereignis und die andere ist Zuhören. Ereignisse müssen die ApplicationEvent-Klasse erben und die Überwachung muss die ApplicationListener-Schnittstelle implementieren.

1. ApplicationEvent entwickeln

Das Ereignis ist eigentlich der Nachrichtentext, den wir senden möchten. Dies muss im Allgemeinen entsprechend unserem tatsächlichen Geschäft gekapselt werden, welcher Typ verwendet werden soll und welche Felder hinzugefügt werden nach Bedarf. Geben wir einen Fall.

package com.lsqingfeng.springboot.applicationEvent;
 
import lombok.Getter;
import lombok.Setter;
import org.springframework.context.ApplicationEvent;
 
/**
 * @className: MyApplicationEvent
 * @description: 事件封装
 * @author: sh.Liu
 * @date: 2022-03-23 14:41
 */
@Getter
@Setter
@ToString
public class MyApplicationEvent extends ApplicationEvent {
 
    private Integer age;
 
    private String name;
 
    /**
     * 需要重写构造方法
     * @param source
     * @param name
     * @param age
     */
    public MyApplicationEvent(Object source, String name, Integer age) {
        super(source);
        this.name = name;
        this.age = age;
    }
}

2. Entwickeln Sie den Listener

Der Listener entspricht dem Verbraucher unseres MQ. Wenn Zeit zum Pushen ist, kann der Listener-Code ausgeführt werden. Hier legen wir unseren Ereignistyp durch Generika fest.

package com.lsqingfeng.springboot.applicationEvent;
 
import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;
 
/**
 * @className: MyApplicationEventListener
 * @description:事件监听器
 * @author: sh.Liu
 * @date: 2022-03-23 14:50
 */
@Component
public class MyApplicationEventListener implements ApplicationListener<MyApplicationEvent> {
 
    @Override
    public void onApplicationEvent(MyApplicationEvent event) {
        System.out.println("收到消息：" + event);
    }
}

3. Push-Ereignisse

Push-Ereignisse erfordern die Verwendung von ApplicationEventPublisher. Dieses Objekt befindet sich bereits im Container, wenn der Spring-Container geladen wird. Wir können es also direkt injizieren oder ApplicationContext verwenden, da ApplicationContext selbst ApplicationEventPublisher erbt. Lassen Sie es uns durch einen Controller überprüfen.

package com.lsqingfeng.springboot.controller;
 
import com.lsqingfeng.springboot.applicationEvent.MyApplicationEvent;
import com.lsqingfeng.springboot.base.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
 
/**
 * @className: ApplicationEventController
 * @description:
 * @author: sh.Liu
 * @date: 2022-03-23 15:21
 */
@RestController
@RequestMapping("event")
public class ApplicationEventController {
 
    @Autowired
    private ApplicationContext applicationContext;
 
    @RequestMapping("/push")
    public Result pushEvent(){
        MyApplicationEvent myApplicationEvent = new MyApplicationEvent(this,"zhangsan", 10);
        applicationContext.publishEvent(myApplicationEvent);
        return Result.success();
    }
 
    @RequestMapping("/push3")
    public Result pushEvent2(){
        applicationContext.publishEvent("大家好");
        return Result.success();
    }
}

Wir definieren zwei Push-Methoden. Eine Methode pusht unseren MyApplicationEvent-Typ und eine andere Methode pusht einen String.

Wenn wir die erste Methode aufrufen, kann die Konsole die von uns übertragenen Dateninformationen ausdrucken.

Beim Aufrufen der Push-Zeichenfolge wird unser Listener nicht ausgeführt, da unser Interceptor das generische MyApplicationEvent hinzugefügt hat, was bedeutet, dass er nur Nachrichten vom Typ MyApplicationEvent abhört. Andere Arten von Nachrichten werden nicht abgehört.

Was wird also der Effekt sein, wenn wir Generika entfernen? Versuchen wir es.

Bei jedem Push werden zwei Nachrichten gesendet (möglicherweise gibt es einen internen Mechanismus, das ist mir egal), aber beide werden gedruckt, was darauf hinweist, dass die Nachricht angezeigt wird, wenn Sie keine Generika hinzufügen, egal wer pusht hier erhalten.

4. Implementieren des Listeners durch Anmerkungen

Zusätzlich zur Entwicklung des Listeners durch Implementierung der oben genannten Schnittstelle können wir ihn auch durch Anmerkungen implementieren. Der spezifische Code lautet wie folgt.

package com.lsqingfeng.springboot.applicationEvent;
 
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;
 
/**
 * @className: MyApplicationEventListener2
 * @description: 注解实现监听器
 * @author: sh.Liu
 * @date: 2022-03-23 15:56
 */
@Component
public class MyApplicationEventListener2 {
 
    @EventListener
    public void onEvent(MyApplicationEvent event){
        System.out.println("收到消息2：" + event);
    }
}

Die Annotation @EventListener wird hier hinzugefügt, um darzustellen, dass es sich um einen Listener handelt. Der Methodenname ist beliebig und die Parameter in der Methode repräsentieren die zu überwachenden Ereignistypen.

Rufen Sie die Push-Methode erneut auf:

Es wurde festgestellt, dass die Daten beider Listener gedruckt werden. Jeder sollte auf diese Funktion achten.

Das obige ist der detaillierte Inhalt vonSo verwenden Sie ApplicationEvent und ApplicationListener in SpringBoot. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!