Comment utiliser ApplicationEvent et ApplicationListener dans SpringBoot

Dans ce modèle, il y a deux classes importantes, l'une est événementielle et l'autre est écoute. Les événements doivent hériter de la classe ApplicationEvent et la surveillance doit implémenter l'interface ApplicationListener.

1. Développer ApplicationEvent

L'événement est en fait le corps du message que nous voulons envoyer. Cela doit généralement être encapsulé en fonction de notre activité réelle, quel type de données est nécessaire, quel type utiliser et quels champs sont ajoutés. au besoin. Donnons un cas.

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. Développer l'écouteur

L'écouteur est équivalent au consommateur de notre MQ Quand il est temps de le pousser, le code de l'écouteur peut être exécuté. Ici, nous définissons notre type d'événement via des génériques.

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. Événements Push

Les événements Push nécessitent l'utilisation d'ApplicationEventPublisher. Cet objet est déjà dans le conteneur lorsque le conteneur Spring est chargé. Nous pouvons donc l'injecter directement ou utiliser ApplicationContext, car ApplicationContext lui-même hérite de ApplicationEventPublisher. Vérifions-le via un contrôleur.

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();
    }
}

Nous définissons deux méthodes push. L’une pousse notre type MyApplicationEvent et une autre méthode pousse une chaîne.

Lorsque nous appelons la première méthode, la console peut imprimer les informations sur les données que nous avons transmises.

Lors de l'appel de la chaîne push, notre écouteur ne s'exécutera pas car notre intercepteur a ajouté le générique MyApplicationEvent, ce qui signifie qu'il n'écoutera que les messages de type MyApplicationEvent. Les autres types de messages ne seront pas écoutés.

Alors, quel sera l’effet si nous supprimons les génériques ? Essayons.

Chaque push enverra deux messages (il peut y avoir un mécanisme interne, je m'en fiche), mais les deux sont imprimés, indiquant que si vous n'ajoutez pas de génériques, peu importe qui pousse, le message sera reçu ici.

4. Implémentation de l'écouteur via des annotations

En plus de développer l'écouteur en implémentant l'interface ci-dessus, nous pouvons également l'implémenter via des annotations.

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);
    }
}

L'annotation @EventListener est ajoutée ici pour représenter qu'il s'agit d'un auditeur. Le nom de la méthode est arbitraire et les paramètres de la méthode représentent les types d'événements à surveiller.

Appelez à nouveau la méthode push :

On constate que les données des deux auditeurs seront imprimées. Tout le monde devrait prêter attention à cette fonctionnalité.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!