Java事件监听

监听

• 先定义消息事件对象

/**
  * Description: 消息事件对象
  * @Author: lwh
  * @Date: 2023/7/14 10:14
  **/
public class BpmMessageEvent extends ApplicationEvent {

    private final BpmMessageEventDTO data;

    public BpmMessageEventDTO getData(){
        return this.data;
    }

    public BpmMessageEvent(BpmMessageEventDTO source) {
        super(source);
        this.data = source;
    }
    
    

• 触发事件

 /**
 * Description: 消息中心事件触发
 * @Author: lwh
 * @Date: 2023/7/19 09:49
 * @param instId
 * @param instCaseNodeInfo
 * @param nodeTimeTip 预警或超时状态
 * @return:
 **/
private void publishFormEvent(Integer nodeTimeTip,String instId,InstCaseNodeInfo instCaseNodeInfo) {
    try {
        BpmMessageEventDTO bpmMessageEventDTO = new BpmMessageEventDTO();
        bpmMessageEventDTO.setInstId(instId);
        bpmMessageEventDTO.setNodeTimeTip(nodeTimeTip);
        bpmMessageEventDTO.setInstCaseNodeInfo(instCaseNodeInfo);
        BpmMessageEvent event = new BpmMessageEvent(bpmMessageEventDTO);
        applicationContext.publishEvent(event);
    }
    catch (Exception e){
        throw new BusinessException(String.format("消息中心[%s]-%s事件触发出错：%s",instId,nodeTimeTip,e.getMessage()));
    }
}    

• 调用触发事件

   this.publishFormEvent(nodeTimeTip,instCaseNodeInfo.getInstId(),instCaseNodeInfo);

• 消息中心监听

/**
 * 消息中心监听
 *
 * @author 梁伟浩
 * @date 2023/7/19 8:52
 * @study 星期三
 */
@Service
public class MessageEventListener {

    @Resource
    private IMessageService messageService;
    @Resource
    private ICaseNodeService caseNodeService;

   @EventListener
    @Async
    public void doAsyncMessageEvent(BpmMessageEvent event) throws InterruptedException {
        messageService.saveTemplateInfo(event.getData().getEventType(),event.getData().getInstId(),event.getData().getMessageCenterDTO());
    }
}

条件监听

• 先定义消息事件对象

public class BpmCaseEvent extends ApplicationEvent {
    private final BpmCaseEventDTO data;

    public BpmCaseEventDTO getData(){
        return this.data;
    }

    public BpmCaseEvent(BpmCaseEventDTO source) {
        super(source);
        this.data=source;
    }

• 编写触发方法

  public void publishCaseEvent(String instId,String key,String nodeId,Map<String,Object> variables,CaseEventType eventType) {
       try {
           BpmCaseEventDTO caseEventDTO = new BpmCaseEventDTO();
           caseEventDTO.setInstId(instId);
           caseEventDTO.setKey(key);
           caseEventDTO.setNodeId(nodeId);
           InstBusinessInfo businessInfo = businessService.getBusinessInfo(instId, true);
           caseEventDTO.setSolId(businessInfo.getSolId());
           caseEventDTO.setWfKey(businessInfo.getWfKey());
           caseEventDTO.setVariables(variables);
           caseEventDTO.setEventType(eventType.name());
           BpmCaseEvent event = new BpmCaseEvent(caseEventDTO);
           applicationContext.publishEvent(event);
       } catch (Exception ex) {
           throw new BusinessException(String.format("工作流[%s]-%s事件触发出错：%s", instId, eventType.name(), ex.getMessage()));
       }
   }

• 调用触发方法，传进对应类型

this.publishCaseEvent(instCaseNodeInfo.getInstId(),instCaseNodeInfo.getKey(),instCaseNodeInfo.getNodeId(),vars, CaseEventType.NodeCreate);

• 对应监听类型监听编写对应业务

  /**
      * Description: 监听业务实例节点创建
      * @Author: lwh
      * @Date: 2023/7/20 14:55
      * @param event
      * @return:
    **/
    @EventListener(condition = "#event.data.eventType=='NodeCreate'")
    @Async
    public void doAsyncCaseNodeCreateEvent(BpmCaseEvent event){
        String instId=event.getData().getInstId();
        String key=event.getData().getKey();
        //查询对应节点数据节点信息
        LambdaQueryWrapper<InstCaseNodeInfo> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(InstCaseNodeInfo::getInstId,instId)
                .eq(InstCaseNodeInfo::getKey,key);
        InstCaseNodeInfo caseNodeInfo = instCaseNodeInfoMapper.selectOne(wrapper);
        Integer actionType = caseNodeInfo.getActionType();
        //封装参数
        MessageCenterDTO messageCenter = new MessageCenterDTO();
        messageCenter.setSender(caseNodeInfo.getSendUser());
        messageCenter.setReceiver(caseNodeInfo.getDoingUser());
        messageCenter.setKey(caseNodeInfo.getKey());
        messageCenter.setSendTime(caseNodeInfo.getSendDate());
        messageCenter.setReceiveTime(caseNodeInfo.getDoneDate());
        //根据ActionTypeEnum类型，触发对应消息中心事件，发送信息到消息中心
        switch (actionType) {
            case 1:
                triggerMessageEvent.publishMessageEvent(MessageTypeEnum.DOING,instId,messageCenter);
                break;
            case 2:
                triggerMessageEvent.publishMessageEvent(MessageTypeEnum.SPSEND,instId,messageCenter);
                break;
            case 4:
                triggerMessageEvent.publishMessageEvent(MessageTypeEnum.BACK,instId,messageCenter);
                break;
            case 6:
                triggerMessageEvent.publishMessageEvent(MessageTypeEnum.CHANGEUSER,instId,messageCenter);
                break;
            default:
                break;
        }
    }

监听的好处，削峰、异步、解耦、利于扩展