新增可忽略的维修时间

xyc

2025-02-21 664db98c9e8595ce4dd636a27f480e3a08b81ff5

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
package com.zt.common.message.consumer;
 
import cn.hutool.core.map.MapUtil;
import com.alibaba.fastjson.JSON;
import com.zt.common.message.handler.MessageHandler;
import com.zt.common.message.model.Message;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;
 
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
 
/**
 * 抽象公共消息队列
 *
 * @author wacxhs
 */
public abstract class AbstractMessageQueue implements ApplicationListener<ContextRefreshedEvent> {
 
    private static final Logger LOGGER = LoggerFactory.getLogger(AbstractMessageQueue.class);
 
    private ApplicationContext applicationContext;
 
    /**
     * 注册消息处理器
     */
    private Map<String, MessageHandler> registerJmsHandler = Collections.emptyMap();
 
    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        if (event.getApplicationContext().getParent() == null) {
            LOGGER.debug("准备加载MessageHandler实现");
            this.applicationContext = event.getApplicationContext();
            Map<String, MessageHandler> jmsHandlerMap = applicationContext.getBeansOfType(MessageHandler.class);
            LOGGER.debug("加载MessageHandler实现共{}条", jmsHandlerMap.size());
 
            if (MapUtil.isNotEmpty(jmsHandlerMap)) {
                Collection<MessageHandler> jmsHandlers = jmsHandlerMap.values();
                this.registerJmsHandler = new HashMap<>(jmsHandlers.size(), 1);
                for (MessageHandler jmsHandler : jmsHandlers) {
                    this.registerJmsHandler.put(jmsHandler.getType().getKey(), jmsHandler);
                }
            }
            containerInitialCompleteAfter();
        }
    }
 
    /**
     * 容器初始化完成后
     */
    protected void containerInitialCompleteAfter() {
    }
 
    protected ApplicationContext getApplicationContext() {
        return applicationContext;
    }
 
    /**
     * 发送消息
     *
     * @param message
     *            消息传输对象
     */
    @SuppressWarnings("unchecked")
    public void handleMessage(Message<?> message) {
        MessageHandler handler = getJmsHandler(message.getType());
        if (handler == null) {
            LOGGER.warn("未找到({})消息处理器", message.getType());
            return;
        }
        try {
            handler.handlerMessage(message);
        } catch (Exception e) {
            LOGGER.error("处理消息({})出错, 参数入参：{}", message.getType(), JSON.toJSONString(message), e);
        }
    }
 
    /**
     * 获取消息处理实现
     *
     * @return 消息处理实现
     */
    protected MessageHandler getJmsHandler(String type) {
        return this.registerJmsHandler.get(type);
    }
}