springboot项目编写发送异常日志到企微工具包的操作方法

目录

• 1.创建基础Bean
• 2.创建配置类
• 3.pom依赖
• 4.主工程引入工具包 pom依赖
• 5.主工程logback-spring.XML引入配置
• 6.nacos配置

1.创建基础Bean

public final class ThreadFactory implements Java.util.concurrent.ThreadFactory {
    private static final AtomicInteger poolNumber = new AtomicInteger(1);
    private final ThreadGroup group;
    private final AtomicInteger threadNumber = new AtomicInteger(1);
    private final String namePrefix;
    public ThreadFactory(String groupFlag, String functionName) {
        SecurityManager s = System.getSecurityManager();
        this.group = s != null ? s.getThreadGroup() : Thread.currentThread().getThreadGroup();
        this.namePrefix = this.buildPrefix(groupFlag, functionName, poolNumber);
    }
    private String buildPrefix(String vendorFlag, String functionName, final AtomicInteger poolNumber) {
        StringBuffer sb = (new StringBuffer("pool-")).append(poolNumber.getAndIncrement()).append("-thread-");
        String connChar = "-";
        if (null != vendorFlag && !"".equals(vendorFlag)) {
            sb.append(vendorFlag).append(connChar);
        }
        if (null != functionName && !"".equals(functionName)) {
            sb.append(functionName).append(connChar);
        }
        return sb.toString();
    }
    public Thread newThread(Runnable r) {
        String threadName = this.namePrefix + this.threadNumber.getAndIncrement();
        Thread t = new Thread(this.group, r, threadName, 0L);
        if (t.isDaemon()) {
            t.setDaemon(false);
        }
        if (t.getPriority() != 5) {
            t.setPriority(5);
        }
        return t;
    }
}

public class QiWeiMarkDownMessage<T> {
    private String msgtype;
    private T markdown;
    public QiWeiMarkDownMessage() {
    }
    public String getMsgtype() {
        return this.msgtype;
    }
    public T getMarkdown() {
        return this.markdown;
    }
    public void setMsgtype(final String msgtype) {
        this.msgtype = msgtype;
    }
    public void setMarkdown(final T markdown) {
        this.markdown = markdown;
    }
    public boolean equals(final Object o) {
        if (o == this) {
            return true;
        } else if (!(o instanceof QiWeiMarkDownMessage)) {
            return false;
        } else {
            QiWeiMarkDownMessage<?> other = (QiWeiMarkDownMessage)o;
            if (!other.canEqual(this)) {
                return false;
            } else {
                Object this$msgtype = this.getMsgtype();
                Object other$msgtype = other.getMsgtype();
                if (this$msgtype == null) {
                    if (other$msgtype != null) {
                        return false;
                    }
                } else if (!this$msgtype.equals(other$msgtype)) {
                    return false;
                }
                Object this$markdown = this.getMarkdown();
                Object other$markdown = other.getMarkdown();
                if (this$markdown == null) {
                    if (other$markdown != null) {
                        return false;
                    }
                } else if (!this$markdown.equals(other$markdown)) {
                    return false;
                }
                return true;
            }
        }
    }
    protected boolean canEqual(final Object other) {
        return other instanceof QiWeiMarkDownMessage;
    }
    public int hashCode() {
        int result = 1;
        Object $msgtype = this.getMsgtype();
        result = result * 59 + ($msgtype == null ? 43 : $msgtype.hashCode());
        Object $markdown = this.getMarkdown();
        result = result * 59 + ($markdown == null ? 43 : $markdown.hashCode());
        return result;
    }
    public String toString() {
        return "QiWeiMarkDownMessage(msgtype=" + this.getMsgtype() + ", markdown=" + this.getMarkdown() + ")";
    }
}

public class QiWeiMessageContext {
    private String content;
    private String mentioned_list;
    private String mentioned_mobile_list;
    public QiWeiMessageContext() {
    }
    public String getContent() {
        return this.content;
    }
    public String getMentioned_list() {
        return this.mentioned_list;
    }
    public String getMentioned_mobile_list() {
        return this.mentioned_mobile_list;
    }
    public void setContent(final String content) {
        this.content = content;
    }
    public void setMentioned_list(final String mentioned_list) {
        this.mentioned_list = mentioned_list;
    }
    public void setMentioned_mobile_list(final String mentioned_mobile_list) {
        this.mentioned_mobile_list = mentioned_mobile_list;
    }
    public boolean equals(final Object o) {
        if (o == this) {
            return true;
        } else if (!(o instanceof QiWeiMessageContext)) {
            return false;
        } else {
            QiWeiMessageContext other = (QiWeiMessageContext)o;
            if (!other.canEqual(this)) {
                return false;
            } else {
                label47: {
                    Object this$content = this.getContent();
                    Object other$content = other.getContent();
                    if (this$content == null) {
                        if (other$content == null) {
                   qHMlsxnA         break label47;
                        }
                    } else if (this$content.equals(other$content)) {
                        break label47;
                    }
                    return false;
                }
                Object this$mentioned_list = this.getMentioned_list();
                Object other$mentioned_list = other.getMentioned_list();
                if (this$mentioned_list == null) {
                    if (other$mentioned_list != null) {
                        return false;
                    }
                } else if (!this$mentioned_list.equals(other$mentioned_list)) {
                    return false;
                }
                Object this$mentioned_mobile_list = this.getMentioned_mobile_list();
                Object other$mentioned_mobile_list = other.getMentioned_mobile_list();
                if (this$mentioned_mobile_list == null) {
                    if (other$mentioned_mobile_list != null) {
                        return false;
                    }
                } else if (!this$mentioned_mobile_list.equals(other$mentioned_mobile_list)) {
                    return false;
                }
                return true;
            }
        }
    }
    protected boolean canEqual(final Object other) {
        return other instanceof QiWeiMessageContext;
    }
    public int hashCode() {
        int result = 1;
        Object $content = this.getContent();
        result = result * 59 + ($content == null ? 43 : $content.hashCode());
        Object $mentioned_list = this.getMentioned_list();
        result = result * 59 + ($mentioned_list == null ? 43 : $mentioned_list.hashCode());
        Object $mentioned_mobile_list = this.getMentioned_mobile_list();
        result = result * 59 + ($mentioned_mobile_list == null ? 43 : $mentioned_mobile_list.hashCode());
        return result;
    }
    public String toString() {
        return "QiWeiMessageContext(content=" + this.getContent() + ", mentioned_list=" + this.getMentioned_list() + ", mentioned_mobile_list=" + this.getMentioned_mobile_list() + ")";
    }
}

public class MAChineUtils {
    public MachineUtils() {
    }
    public static String getHostIpFromdockerContainer() {
        String ip = null;
        try {
            Enumeration networkInterfa编程ces = NetworkInterface.getNetworkInterfaces();
            while(networkInterfaces.hasMoreElements()) {
                NetworkInterface networkInterface = (NetworkInterface)networkInterfaces.nextElement();
                if (!"docker0".equals(networkInterface.getDisplayName()) && !"lo".equals(networkInterface.getDisplayName())) {
                    Enumeration<InetAddress> inetAddresses = networkInterface.getInetAddresses();
                    StringJoiner ipJoiner = new StringJoiner("/", "(", ")");
                    while(inetAddresses.hasMoreElements()) {
                        InetAddress inetAddress = (InetAddress)inetAddresses.nextElement();
                        ipJoiner.add(inetAddress.getHostAddress());
                    }
                    ip = ipJoiner.toString();
                    break;
                }
            }
        } catch (Exception var6) {
            System.out.println("获取容器ip信息失败:" + var6);
            ip = "未获取到容器对应宿主机ip信息";
        }
        return ip;
    }
    public static MachineUtils.Machine getMachineInfo() {
        MachineUtils.Machine machine = new MachineUtils.Machine();
        try {
            InetAddress address = getLocalHostLANAddress();
            String ip = address.getHostAddress();
            String hostName = address.getHostName();
            machine.ip = ip;
            machine.hostName = hostName;
        } catch (Exception var4) {
            machine.hostName = "localhost";
            machine.ip = "127.0.0.1";
        }
        return machine;
    }
    private static InetAddress getLocalHostLANAddress() throws UnknownHostException {
        try {
            InetAddress candidateAddress = null;
            Enumeration ifaces = NetworkInterface.getNetworkInterfaces();
            while(ifaces.hasMoreElements()) {
                NetworkInterface iface = (NetworkInterface)ifaces.nextElement();
                Enumeration inetAddrs = iface.getInetAddresses();
                while(inetAddrs.hasMoreElements()) {
                    InetAddress inetAddr = (InetAddress)inetAddrs.nextElement();
                    if (!inetAddr.isLoopbackAddress()) {
                        if (inetAddr.isSiteLocalAddress()) {
                            return inetAddr;
                        }
                        if (candidateAddress == null) {
                            candidateAddress = inetAddr;
                        }
                    }
                }
            }
            if (candidateAddress != null) {
                return candidateAddress;
            } else {
                InetAddress jdkSuppliedAddress = InetAddress.getLocalHost();
                if (jdkSuppliedAddress == null) {
                    throw new UnknownHostException("The JDK InetAddress.getLocalHost() method unexpectedly returned null.");
                } else {
                    return jdkSuppliedAddress;
                }
            }
        } catch (Exception var5) {
            UnknownHostException unknownHostException = new UnknownHostException("Failed to determine LAN address: " + var5);
            unknownHostException.initCause(var5);
            throw unknownHostException;
        }
    }
    public static class Machine {
        public String ip = "";
        public String hostName = "";
        public Machine() {
        }
    }
}

public class ThrowableUtils {
    public ThrowableUtils() {
    }
    public static String getThrowableStackTrace(Throwable t) {
        StringWriter sw = new StringWriter();
        t.printStackTrace(new PrintWriter(sw, true));
        String result = sw.getBuffer().toString();
        return result.length() > 3700 ? result.substring(0, 3700) + "\n..." : result;
    }
}

public class OKHttpUtil {
    private static final Logger log = LoggerFactory.getLogger(OKHttpUtil.class);
    private static volatile OkHttpClient okHttpClient = null;
    private static volatile Semaphore semaphore = null;
    private static final String CONTENT_TYPE = "Content-Type";
    private OKHttpUtil() {
        if (okHttpClient == null) {
            Class var1 = OKHttpUtil.class;
            synchronized(OKHttpUtil.class) {
                if (okHttpClient == null) {
                    TrustManager[] trustManagers = buildTrustManagers();
                    okHttpClient = (new Builder()).connectTimeout(15L, TimeUnit.SECONDS).writeTimeout(20L, TimeUnit.SECONDS).readTimeout(20L, TimeUnit.SECONDS).sslSocketFactory(createSSLSocketFactory(trustManagers), (X509TrustManager)trustManagers[0]).hostnameVerifier((hostName, session) -> {
                        return true;
                    }).retryOnConnectionFailure(true).build();
                }
            }
        }
    }
    public static OKHttpUtil builder() {
        return new OKHttpUtil();
    }
    private static Semaphore getSemaphoreInstance() {
        Class var0 = OKHttpUtil.class;
        synchronized(OKHttpUtil.class) {
            if (semaphore == null) {
                semaphore = new Semaphore(0);
            }
        }
        return semaphore;
    }
    private static okhttp3.Request.Builder addHeaders(Map<String, Object> headerMap, okhttp3.Request.Builder builder) {
        if (headerMap != null && !headerMap.isEmpty()) {
            headerMap.forEach((key, value) -> {
                builder.addHeader(key, String.valueOf(value));
            });
        }
        return builder;
    }
    private RequestBody setRequestBody(Map<String, Object> bodyParams, Map<String, Object> headerMap) throws Exception {
        if (headerMap != null && headerMap.containsKey("Content-Type")) {
            String contentType = String.valueOf(headerMap.get("Content-Type"));
            if ("application/www.devze.comx-www-form-urlencoded".equals(contentType)) {
                Map<String, String> strBodyParamMap = new HashMap();
                if (bodyParams != null && !bodyParams.isEmpty()) {
                    bodyParams.forEach((key, value) -> {
                        if (value != null) {
                            strBodyParamMap.put(key, (String)value);
                        }
                    });
                }
                return this.buildRequestBodyByMap(strBodyParamMap);
            } else {
                throw new RuntimeException("未知请求类型");
            }
        } else {
            throw new Exception("请求头信息配置中无 Content-Type配置，请先配置");
        }
    }
    private RequestBody buildRequestBodyByMap(Map<String, String> bodyParams) {
        RequestBody body = null;
        okhttp3.FormBody.Builder formEncodingBuilder = new okhttp3.FormBody.Builder();
        if (bodyParams != null) {
            Iterator<String> iterator = bodyParams.keySet().iterator();
            String key = "";
            while(iterator.hasNext()) {
                key = (String)iterator.next();
                formEncodingBuilder.add(key, (String)bodyParams.get(key));
                log.info("okClient post表单提交请求参数：{}，请求值：{} ", key, bodyParams.get(key));
            }
        }
        body = formEncodingBuilder.build();
        return body;
    }
    public String get(String url, Map<String, Object> headerMap) {
        String responseStr = null;
        try {
            okhttp3.Request.Builder builder = (new okhttp3.Request.Builder()).get().url(url);
            addHeaders(headerMap, builder);
            Request request = builder.build();
            Response response = okHttpClient.newCall(request).execute();
            responseStr = response.body().string();
        } catch (Exception var7) {
            log.error("httpUtil 请求出错:{}", var7.getMessage(), var7);
        }
        return responseStr;
    }
    public String postByjson(String url, String body, Map<String, Object> headerMap) {
        String responseStr = null;
        try {
            RequestBody requestBody = RequestBody.create(MediaType.parse("application/json; charset=utf-8"), body);
            okhttp3.Request.Builder requestBuilder = (new okhttp3.Request.Builder()).post(requestBody).url(url);
            addHeaders(headerMap, requestBuilder);
            Request request = requestBuilder.build();
            Call call = okHttpClient.newCall(request);
            Response response = call.execute();
            responseStr = response.body().string();
        } catch (Exception var10) {
            log.error("httpUtil 请求出错:{}", var10.getMessage(), var10);
        }
        return responseStr;
    }
    public String postByForm(String url, Map<String, Object> bodyMap, Map<String, Object> headerMap) {
        String responseStr = null;
        try {
            RequestBody body = this.setRequestBody(bodyMap, headerMap);
            okhttp3.Request.Builder requestBuilder = (new okhttp3.Request.Builder()).post(body).url(url);
            addHeaders(headerMap, requestBuilder);
            Request request = requestBuilder.build();
            Call call = okHttpClient.newCall(request);
            Response response = call.execute();
            responseStr = response.body().string();
        } catch (Exception var10) {
            log.error("httpUtil 请求出错:{}", var10.getMessage(), var10);
        }
        return responseStr;
    }
    public void postJsonAsync(String url, String json, final OKHttpUtil.MyNetCall myNetCall) throws IOException {
        RequestBody body = RequestBody.create(MediaType.parse("application/json; charset=utf-8"), json);
        okhttp3.Request.Builder requestBuilder = new okhttp3.Request.Builder();
        Request request = requestBuilder.post(body).url(url).build();
        Call call = okHttpClient.newCall(request);
        call.enqueue(new Callback() {
            public void onFailure(Call call, IOException e) {
                myNetCall.failed(call, e);
            }
            public void onResponse(Call call, Response response) throws IOException {
                myNetCall.success(call, response);
                OKHttpUtil.getSemaphoreInstance().release();
            }
        });
        try {
            getSemaphoreInstance().acquire();
        } catch (InterruptedException var9) {
            var9.printStackTrace();
        }
    }
    private static SSLSocketFactory createSSLSocketFactory(TrustManager[] trustAllCerts) {
        SSLSocketFactory ssfFactory = null;
        try {
            SSLContext sc = SSLContext.getInstance("TLS");
            sc.ini编程客栈t((KeyManager[])null, trustAllCerts, new SecureRandom());
            ssfFactory = sc.getSocketFactory();
        } catch (Exception var3) {
            var3.printStackTrace();
        }
        return ssfFactory;
    }
    private static TrustManager[] buildTrustManagers() {
        return new TrustManager[]{new X509TrustManager() {
            public void checkClientTrusted(X509Certificate[] chain, String authType) {
            }
            public void checkServerTrusted(X509Certificate[] chain, String authType) {
            }
            public X509Certificate[] getAcceptedIssuers() {
                return new X509Certificate[0];
            }
        }};
    }
    public interface MyNetCall {
        void success(Call call, Response response) throws IOException;
        void failed(Call call, IOException e);
    }
}

public final class ThreadPoolFactory {
    private static final Logger LOGGER = LoggerFactory.getLogger(ThreadPoolFactory.class);
    private static int SEND_MESSAGE_CORESIZE = 1;
    private static int SEND_MESSAGE_MAXSIZE = 1;
    private static int SEND_MESSAGE_KEEPALIVE = 120;
    private static int SEND_MESSAGE_QUEUESIZE = 120;
    public static ExecutorService createExecutorService(int coreNum, int maxNum) {
        return new ThreadPoolExecutor(coreNum, maxNum, (long)SEND_MESSAGE_KEEPALIVE, TimeUnit.SECONDS, new ArrayblockingQueue(SEND_MESSAGE_QUEUESIZE), new ThreadFactory("robotMessage", "SendErrorMessage"), new DiscardOldestPolicy());
    }
    private ThreadPoolFactory() {
    }
    static class MonitorRejectedExecutionHandler implements RejectedExecutionHandler {
        MonitorRejectedExecutionHandler() {
        }
        public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
            if (!executor.isShutdown()) {
                try {
                    executor.getQueue().put(r);
                } catch (InterruptedException var4) {
                    ThreadPoolFactory.LOGGER.error("When task queue is full, some bad things happened! Message is {}", var4);
                }
            }
        }
    }
}

public abstract class AbstraceSendErrorMsgAppender extends UnsynchronizedAppenderBase<ILoggingEvent> {
    private String appName;
    private String messageChannel;
    private String env;
    private String sendEnabled;
    public AbstraceSendErrorMsgAppender() {
    }
    public void append(ILoggingEvent event) {
        if (event.getLevel() == Level.ERROR && "true".equals(this.sendEnabled)) {
            try {
                String userLogeErrorMessage = event.getFormattedMessage();
                String stackTraceInfo = "";
                IThrowableProxy proxy = event.getThrowableProxy();
                if (null != proxy) {
                    Throwable t = ((ThrowableProxy)proxy).getThrowable();
                    stackTraceInfo = ThrowableUtils.getThrowableStackTrace(t);
                }
                String ip = MachineUtils.getHostIpFromDockerContainer();
                if (stackTraceInfo.contains("OmsException") || stackTraceInfo.contains("WmsException") || stackTraceInfo.contains("BmsException")) {
                    return;
                }
                LocalDateTime dateTime = LocalDateTime.now();
                DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd-MM-yyyy HH:mm:ss");
                String mesText = "服务名称:<font color=\"warning\">[" + this.appName + "]</font>,发生错误异常\n>ip:[" + ip + "]\n>环境信息:[" + this.env + "]\n>异常信息:[" + userLogeErrorMessage + "]\n>time:[" + dateTime.format(formatter) + "]\n堆栈信息:[\n" + stackTraceInfo + "]";
                this.sendAlarmMessage("markdown", mesText);
            } catch (Exception var9) {
                System.out.println(String.format("日志报警异常，异常原因:{} last=%s", var9.getMessage()));
            }
        }
    }
    public String getAppName() {
        return this.appName;
    }
    public void setAppName(String appName) {
        this.appName = appName;
    }
    public String getMessageChannel() {
        return this.messageChannel;
    }
    public void setMessageChannel(String messageChannel) {
        this.messageChannel = messageChannel;
    }
    public String getEnv() {
        return this.env;
    }
    public void setEnv(String env) {
        this.env = env;
    }
    public String getSendEnabled() {
        return this.sendEnabled;
    }
    public void setSendEnabled(String sendEnabled) {
        this.sendEnabled = sendEnabled;
    }
    protected abstract void sendAlarmMessage(String messageType, String messageContent);
}

public class SendQiWeiAlarmErrorMessageAppender extends AbstraceSendErrorMsgAppender {
    private static final Logger log = LoggerFactory.getLogger(SendQiWeiAlarmErrorMessageAppender.class);
    private String webhookUrl;
    private AlarmService alarmService;
    public SendQiWeiAlarmErrorMessageAppender() {
    }
    protected void sendAlarmMessage(String messageType, String messageContent) {
        Assert.hasText(this.webhookUrl, "机器人webHook地址不能为空");
        if (null == this.alarmService) {
            synchronized(this) {
                if (null == this.alarmService) {
                    this.alarmService = new WechatAlarmServiceImpl(this.webhookUrl);
                }
            }
        }
        this.alarmService.alarmHandler(messageType, messageContent);
    }
    public String getWebhookUrl() {
        return this.webhookUrl;
    }
    public void setWebhookUrl(String webhookUrl) {
        this.webhookUrl = webhookUrl;
    }
}

2.创建配置类

@ConfigurationProperties(
    prefix = "message.robot"
)
public class RobotMessageAlarmMessageProperties {
    private String enable;
    public RobotMessageAlarmMessageProperties() {
    }
    public String getEnable() {
        return this.enable;
    }
    public void setEnable(final String enable) {
        this.enable = enable;
    }
    public boolean equals(final Object o) {
        if (o == this) {
            return true;
        } else if (!(o instanceof RobotMessageAlarmMessageProperties)) {
            return false;
        } else {
            RobotMessageAlarmMessageProperties other = (RobotMessageAlarmMessageProperties)o;
            if (!other.canEqual(this)) {
                return false;
            } else {
                Object this$enable = this.getEnable();
                Object other$enable = other.getEnable();
                if (this$enable == null) {
                    if (other$enable != null) {
                        return false;
                    }
                } else if (!this$enable.equals(other$enable)) {
                    return false;
                }
                return true;
            }
        }
    }
    protected boolean canEqual(final Object other) {
        return other instanceof RobotMessageAlarmMessageProperties;
    }
    public int hashCode() {
        int result = 1;
        Object $enable = this.getEnable();
        result = result * 59 + ($enable == null ? 43 : $enable.hashCode());
        return result;
    }
    public String toString() {
        return "RobotMessageAlarmMessageProperties(enable=" + this.getEnable() + ")";
    }
}

@Configuration
@ConditionalOnProperty(
    prefix = "message.robot",
    name = {"enable"},
    havingValue = "true",
    matchIfMissing = false
)
@ConditionalOnClass(
    name = {"ch.qos.logback.classic.LoggerContext"}
)
@EnableConfigurationProperties({RobotMessageAlarmMessageProperties.class})
@ComponentScan({"com.xrtframework.logback.alarm"})
public class LogbackAlarmAutoConfiguration {
    private final RobotMessageAlarmMessageProperties robotMessageAlarmMessageProperties;
    public LogbackAlarmAutoConfiguration(RobotMessageAlarmMessageProperties robotMessageAlarmMessageProperties) {
        this.robotMessageAlarmMessageProperties = robotMessageAlarmMessageProperties;
    }
}

public interface AlarmService {
    void alarmHandler(String messageType, String messageContent);
}

public class WechatAlarmServiceImpl implements AlarmService {
    private static final Logger log = LoggerFactory.getLogger(WechatAlarmServiceImpl.class);
    private String webhookUrl;
    private ExecutorService executorService;
    private static final int coreThreadNum = 3;
    private static final int maxThreadNum = 10;
    private RateLimiter rateLimiter;
    private static final Double rateLimiterPermitsPerSecond = 0.2857D;
    public WechatAlarmServiceImpl(String webhookUrl) {
        this.webhookUrl = webhookUrl;
        this.executorService = ThreadPoolFactory.createExecutorService(3, 10);
        this.rateLimiter = RateLimiter.create(rateLimiterPermitsPerSecond);
    }
    public void alarmHandler(String messageType, String messageContent) {
        try {
            this.rateLimiter.acquire();
            this.executorService.execute(() -> {
                QiWeiMessageContext qiWeiMessage = new QiWeiMessageContext();
                qiWeiMessage.setContent(messageContent);
                qiWeiMessage.setMentioned_list("@all");
                QiWeiMarkDownMessage<QiWeiMessageContext> qiWeiMessageContextQiWeiMarkDownMessage = new QiWeiMarkDownMessage();
                qiWeiMessageContextQiWeiMarkDownMessage.setMsgtype(messageType);
                qiWeiMessageContextQiWeiMarkDownMessage.setMarkdown(qiWeiMessage);
                if (log.isDebugEnabled()) {
                    log.debug("【企业微信机器人告警】消息请求入参：{}", JSON.toJSONString(qiWeiMessageContextQiWeiMarkDownMessage));
                }
                String response = OKHttpUtil.builder().postByJson(this.webhookUrl, JSON.toJSONString(qiWeiMessageContextQiWeiMarkDownMessage), (Map)null);
                if (log.isDebugEnabled()) {
                    log.debug("【企业微信机器人告警】消息请出参：{}", response);
                }
            });
        } catch (Exception var4) {
            System.out.println(String.format("send wechat error last=%s", var4.getMessage()));
        }
    }
}

pom.properties
version=1.0-SNAPSHOT
groupId=com.xxframework
artifactId=xxframe-logback-alarm

spring-configuration-metadata.json
{
  "groups": [
    {
      "name": "message.robot",
      "type": "com.xxframework.logback.alarm.config.RobotMessageAlarmMessageProperties",
      "sourceType": "com.xxframework.logback.alarm.config.RobotMessageAlarmMessageProperties"
    }
  ],
  "properties": [
    {
      "name": "message.robot.enable",
      "type": "java.lang.String",
      "sourceType": "com.xxframework.logback.alarm.config.RobotMessageAlarmMessageProperties"
    }
  ],
  "hints": []
}

3.pom依赖

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
            <exclusions>
                <exclusion>
                    <artifactId>spring-boot-starter-logging</artifactId>
                    <groupId>org.springframework.boot</groupId>
                </exclusion>
            &lpythont;/exclusions>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!--用来解决未配置spring boot 配置注解处理器IDEA告警-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>com.xrtframework</groupId>
            <artifactId>xrtframe-common-util</artifactId>
            <version>${project.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-logging</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
        </dependency>
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <scope>provided</scope>
        </dependency>
    </dependencies>
    <!--    <build>-->
    <!--        <plugins>-->
    <!--            <plugin>-->
    <!--                <groupId>org.springframework.boot</groupId>-->
    <!--                <artifactId>spring-boot-maven-plugin</artifactId>-->
    <!--            </plugin>-->
    <!--        </plugins>-->
    <!--        -->
    <!--    </build>-->
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <configuration>
                    <testFailureIgnore>true</testFailureIgnore>
                </configuration>
            </plugin>
        </plugins>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*</include>
                </includes>
            </resource>
        </resources>
    </build>

4.主工程引入工具包 pom依赖

<dependency>
            <groupId>com.xxframework</groupId>
            <artifactId>xxframe-logback-alarm</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <!--micrometer桥接prometheus-->
        <dependency>
            <groupId>io.micrometer</groupId>
            <artifactId>micrometer-registry-prometheus</artifactId>
        </dependency>

5.主工程logback-spring.xml引入配置

 <!--添加的内容-->
    <springProperty scope="context" name="robotMessageChannel" source="message.robot.channel" defaultValue="QI_WEI"/>
    <springProperty scope="context" name="robotMessageEnv" source="message.robot.env" defaultValue=""/>
    <springProperty scope="context" name="robotMessageWebHookUrl" source="message.robot.webhookUrl" defaultValue=""/>
 <!--添加的内容-->
    <appender name="sendErrorMsg" class="com.xrtframework.logback.alarm.core.SendQiWeiAlarmErrorMessageAppender">
        <!--使用该组件的应用名称 -->
        <appName>${springAppName}</appName>
        <messageChannel>${robotMessageChannel}</messageChannel>
        <env>${robotMessageEnv}</env>
        <webhookUrl>${robotMessageWebHookUrl}</webhookUrl>
    </appender>

6.nacos配置

#应用日志监控
message.robot.sendEnabled=true
message.robot.channel=QI_WEI
message.robot.env=测试环境
message.robot.webhookUrl=https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=XXX

到此这篇关于springboot项目编写发送异常日志到企微工具包的文章就介绍到这了,更多相关springboot发送异常日志到企微工具包内容请搜索编程客栈(www.devze.com)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程客栈(www.devze.com)！