Comment appliquer ApplicationEvent basé sur SpringBoot

1. Scénario de cas

1. Initiez une requête reposante et publiez différents événements en fonction des paramètres de la requête.

2. L'écouteur d'événement, après avoir écouté l'événement, effectue les opérations planifiées.

3. Cet exemple est un mécanisme de traitement synchrone d'événement, c'est-à-dire qu'une fois l'événement publié, l'événement sera surveillé de manière synchrone.

2. Utilisez la classe

org.springframework.context.ApplicationEvent, l'objet événement de Spring.

org.springframework.context.ApplicationListener, interface d'écoute d'événements.

org.springframework.context.ApplicationEventPublisher, interface éditeur d'événements.

3. Code

1. Objet événement

L'objet événement implémente ApplicationEvent.

1.1 SampleApplicationEvent

ExampleApplicationEvent, une classe abstraite. Héritez de ApplicationEvent et personnalisez et développez certaines propriétés requises dans les microservices.

public abstract class ExampleApplicationEvent extends ApplicationEvent {
  private static final String eventSource = "Example";
  private String eventType = null;
  private Object eventData = null;
  public ExampleApplicationEvent(Object eventData) {
      super(eventSource);
      this.eventData = eventData;
  }
  public ExampleApplicationEvent(Object eventData, String eventType) {
      super(eventSource);
      this.eventData = eventData;
      this.eventType = eventType;
  }
  public String getEventType() {
      return eventType;
  }
  public Object getEventData() {
      return eventData;
  }
}

1.2 SampleLocalApplicationEvent

ExampleLocalApplicationEvent est la classe d'implémentation de la classe abstraite SampleApplicationEvent, où vous pouvez développer les propriétés selon vos besoins.

public class ExampleLocalApplicationEvent extends ExampleApplicationEvent {
  public ExampleLocalApplicationEvent(Object eventData) {
      super(eventData);
  }
  public ExampleLocalApplicationEvent(Object eventData, String eventType) {
      super(eventData, eventType);
  }
}

1.3 EventTypeEnum

EventTypeEnum, énumération de types d'événements personnalisés, étendue à la demande.

public enum EventTypeEnum {
  CHANGE("change", "变更事件"),
  ADD("add", "新增事件");
  private String id;
  private String name;
  public String getId() {
   return id;
  }
  public String getName() {
   return name;
  }
  EventTypeEnum(String id, String name) {
   this.id = id;
   this.name = name;
  }
  public static EventTypeEnum getEventTypeEnum(String id) {
   for (EventTypeEnum var : EventTypeEnum.values()) {
       if (var.getId().equalsIgnoreCase(id)) {
           return var;
       }
   }
   return null;
  }
}

2. Écouteur d'événements

Les écouteurs d'événements incluent des interfaces et des classes abstraites.

2.1 IEventListener

IEventListener, une interface, hérite de l'interface ApplicationListener.

@SuppressWarnings("rawtypes")
public interface IEventListener extends ApplicationListener {
}

2.2 AbstractEventListener

AbstractEventListener, une classe abstraite, implémente l'interface IEventListener. Et fournissez des méthodes abstraites pour faciliter l’extension de classe et le découplage de code.

public abstract  class AbstractEventListener implements IEventListener {
 @Override
 public void onApplicationEvent(ApplicationEvent event){
  if(!(event instanceof ExampleApplicationEvent)){
    return;
  }
  ExampleApplicationEvent exEvent = (ExampleApplicationEvent) event;
  try{
    onExampleApplicationEvent(exEvent);
  }catch (Exception e){
    e.printStackTrace();
  }
 }
 protected abstract void onExampleApplicationEvent(ExampleApplicationEvent event);
}

2.3 OrderEventListener

OrderEventListener, implémente la classe abstraite AbstractEventListener. C'est une classe affaires pour écouter les événements et les traiter.

@Slf4j
@Component
public class OrderEventListener extends AbstractEventListener {
  @Override
  protected void onExampleApplicationEvent(ExampleApplicationEvent event) {
   log.info("OrderEventListener->onSpApplicationEvent,监听事件.");
   Object eventData = event.getEventData();
   log.info("事件类型: " + EventTypeEnum.getEventTypeEnum(event.getEventType()));
   log.info("事件数据: " + eventData.toString());
  }
}

3. Éditeur d'événements

Les écouteurs d'événements incluent des interfaces et des classes d'implémentation.

3.1 IEventPublisher

IEventPublisher, interface de publication d'événements personnalisée, pratique pour étendre les fonctions et les propriétés.

public interface IEventPublisher {
    boolean publish(ExampleApplicationEvent event);
}

3.2 LocalEventPublisher

LocalEventPublisher, classe d'implémentation de publication d'événements, cette classe utilise @Component, le conteneur IOC de Spring chargera cette classe. Cette classe appelle le applyEvent de ApplicationEventPublisher pour publier des événements.

@Slf4j
@Component("localEventPublisher")
public class LocalEventPublisher implements IEventPublisher {
  @Override
  public boolean publish(ExampleApplicationEvent event) {
    try{
      log.info("LocalEventPublisher->publish,发布事件.");
      log.info("事件类型: " + EventTypeEnum.getEventTypeEnum(event.getEventType()));
      log.info("事件数据: " + event.getEventData().toString());
      SpringUtil.getApplicationContext().publishEvent(event);
    }catch (Exception e){
      log.info("事件发布异常.");
      e.printStackTrace();
      return false;
    }
    return true;
  }
}

4.La requête Restful déclenche des événements

Utilisez les requêtes Restful pour déclencher des événements.

4.1 EventController

EventController, reçoit des requêtes Restful.

@Slf4j
@RestController
@RequestMapping("/event")
public class EventController {
  @Autowired
  private LocalEventPublisher eventPublisher;
  @PostMapping("/f1")
  public Object f1(@RequestBody Object obj) {
   log.info("EventController->f1,接收参数,obj = " + obj.toString());
   Map objMap = (Map) obj;
   OrderInfo orderInfo = new OrderInfo();
   orderInfo.setUserName((String) objMap.get("userName"));
   orderInfo.setTradeName((String) objMap.get("tradeName"));
   orderInfo.setReceiveTime(DateUtil.format(new Date(),
           "yyyy-MM-dd HH:mm:ss"));
   String flag = (String) objMap.get("flag");
   if (StringUtils.equals("change", flag)) {
       eventPublisher.publish(new ExampleLocalApplicationEvent(orderInfo,
               EventTypeEnum.CHANGE.getId()));
   } else if (StringUtils.equals("add", flag)) {
       eventPublisher.publish(new ExampleLocalApplicationEvent(orderInfo,
               EventTypeEnum.ADD.getId()));
   } else {
       eventPublisher.publish(new ExampleLocalApplicationEvent(orderInfo));
   }
   log.info("EventController->f1,返回.");
   return ResultObj.builder().code("200").message("成功").build();
  }
}

4.2 OrderInfo

OrderInfo, objet de données, est transmis dans l'objet événement.

@Data
@NoArgsConstructor
public class OrderInfo {
  private String userName;
  private String tradeName;
  private String receiveTime;
}

4.3 ResultObj

ResultObj, restful renvoie un objet commun.

@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class ResultObj {
    private String code;
    private String message;
}

5. Test

5.1 Demande d'informations

Demande d'URL : http://127.0.0.1:8080/server/event/f1

Paramètres d'entrée :

{
    "userName": "HangZhou",
    "tradeName": "Vue进阶教程",
    "flag": "add"
}

Valeur de retour :

{
    "code": "200",
    "message": "成功"
}

5.2 Log

Sortie Journal :

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!