发布于 

java发送飞书通知

单纯做工具类

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
import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.nio.client.CloseableHttpAsyncClient;
import org.apache.http.impl.nio.client.HttpAsyncClients;
import org.apache.http.util.EntityUtils;
import org.apache.http.HttpResponse;

import java.nio.charset.StandardCharsets;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Future;

public class FeishuNotifier {
    private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
    private static final CloseableHttpAsyncClient HTTP_CLIENT = HttpAsyncClients.createDefault();

    private static final String proWebhookUrl = "https://open.feishu.cn/open-apis/bot/v2/hook/xxx";
    private static final String devWebhookUrl = "https://open.feishu.cn/open-apis/bot/v2/hook/xxx";

    static {
        HTTP_CLIENT.start(); // 启动异步 HTTP 客户端
    }

    public static void sendMessageAsync(String title, String content) {
        String env = System.getenv("ENV");
        if ("prod".equalsIgnoreCase(env)) {
            sendMessage(proWebhookUrl, title, content);
        }
        sendMessage(devWebhookUrl, title, content);
    }

    private static void sendMessage(String webhookUrl, String title, String content) {
        String message = "【" + title + "】\n" + content;
        String jsonPayload = createJsonPayload(message);

        try {
            // 创建 HttpPost 请求
            HttpPost httpPost = new HttpPost(webhookUrl);
            httpPost.setHeader("Content-Type", "application/json");
            httpPost.setEntity(new StringEntity(jsonPayload, StandardCharsets.UTF_8));

            // 异步发送请求
            Future<HttpResponse> futureResponse = HTTP_CLIENT.execute(httpPost, null);

            // 异步获取响应
            CompletableFuture.supplyAsync(() -> {
                try {
                    return futureResponse.get();  // 阻塞等待响应，但在 CompletableFuture 线程池中执行
                } catch (Exception e) {
                    throw new RuntimeException(">>> 发送飞书通知失败: " + e.getMessage(), e);
                }
            }).thenAcceptAsync(response -> {
                try {
                    // 打印飞书响应
                    String responseBody = EntityUtils.toString(response.getEntity(), StandardCharsets.UTF_8);
                    System.out.println(">>> 飞书响应: " + responseBody);
                } catch (Exception e) {
                    System.err.println(">>> 解析飞书响应失败: " + e.getMessage());
                }
            });
        } catch (Exception e) {
            System.err.println(">>> 发送飞书通知异常: " + e.getMessage());
        }
    }

    private static String createJsonPayload(String message) {
        try {
            return OBJECT_MAPPER.writeValueAsString(new FeishuMessage("text", new FeishuContent(message)));
        } catch (Exception e) {
            throw new RuntimeException("JSON 序列化失败", e);
        }
    }

    private static class FeishuMessage {
        public String msg_type;
        public FeishuContent content;

        public FeishuMessage(String msg_type, FeishuContent content) {
            this.msg_type = msg_type;
            this.content = content;
        }
    }

    private static class FeishuContent {
        public String text;

        public FeishuContent(String text) {
            this.text = text;
        }
    }
}

按配置开关

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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
package com.touchsmail.util;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ObjectUtil;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.touchsmail.model.entity.SystemConfig;
import com.touchsmail.service.system.SystemConfigService;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.nio.client.CloseableHttpAsyncClient;
import org.apache.http.impl.nio.client.HttpAsyncClients;
import org.apache.http.util.EntityUtils;
import org.apache.http.HttpResponse;
import org.springframework.stereotype.Component;
import org.springframework.beans.factory.annotation.Autowired;

import javax.annotation.PostConstruct;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

@Component
public class FeishuNotifier {
    private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
    private static final CloseableHttpAsyncClient HTTP_CLIENT = HttpAsyncClients.createDefault();

    @Autowired
    private SystemConfigService systemConfigService;

    private static boolean notifierSwitch = false;

    private static List<String> robotList = new ArrayList<>();

    private static final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);

    public void startScheduledTask() {
        scheduler.scheduleAtFixedRate(this::updateNotifierConfig, 0, 1, TimeUnit.MINUTES);  // 每分钟执行一次
    }

    public void updateNotifierConfig() {
        try {
            SystemConfig notifierSwitchConfig = systemConfigService.getConfigByType("FeishuNotifier");
            if (ObjectUtil.isNotEmpty(notifierSwitchConfig)) {
                String jsonConfig = notifierSwitchConfig.getDefaultConfigValue();

                ObjectMapper objectMapper = new ObjectMapper();
                JsonNode rootNode = objectMapper.readTree(jsonConfig);

                JsonNode feishuNode = rootNode.get("FeishuNotifier");

                if (feishuNode != null) {
                    if (feishuNode.has("notifierSwitch")) {
                        notifierSwitch = feishuNode.get("notifierSwitch").asBoolean();
                    }

                    robotList = new ArrayList<>();
                    JsonNode prodRobotNode = feishuNode.get("robots");
                    if (prodRobotNode != null && prodRobotNode.isArray()) {
                        for (JsonNode node : prodRobotNode) {
                            robotList.add(node.asText());
                        }
                    }
                }
            }
        } catch (Exception e) {
            System.err.println(">>> 读取 notifierSwitch 配置失败: " + e.getMessage());
        }
    }

    @PostConstruct
    public void init() {
        // 启动异步 HTTP 客户端
        HTTP_CLIENT.start();

        // 启动定时任务
        startScheduledTask();
    }

    public static void sendMessageAsync(String title, String content) {
        if (!notifierSwitch) {
            System.out.println(">>> 飞书消息通知没开");
            return;
        }

        if (CollUtil.isNotEmpty(robotList)) {
            for (String robot : robotList) {
                sendMessage(robot, title, content);
            }
        } else {
            System.out.println(">>> 飞书机器人为空");
        }
    }

    private static void sendMessage(String webhookUrl, String title, String content) {
        String message = "【" + title + "】\n" + content;
        String jsonPayload = createJsonPayload(message);

        try {
            // 创建 HttpPost 请求
            HttpPost httpPost = new HttpPost(webhookUrl);
            httpPost.setHeader("Content-Type", "application/json");
            httpPost.setEntity(new StringEntity(jsonPayload, StandardCharsets.UTF_8));

            // 异步发送请求
            Future<HttpResponse> futureResponse = HTTP_CLIENT.execute(httpPost, null);

            // 异步获取响应
            CompletableFuture.supplyAsync(() -> {
                try {
                    return futureResponse.get();  // 阻塞等待响应，但在 CompletableFuture 线程池中执行
                } catch (Exception e) {
                    throw new RuntimeException(">>> 发送飞书通知失败: " + e.getMessage(), e);
                }
            }).thenAcceptAsync(response -> {
                try {
                    // 打印飞书响应
                    String responseBody = EntityUtils.toString(response.getEntity(), StandardCharsets.UTF_8);
                    System.out.println(">>> 飞书响应: " + responseBody);
                } catch (Exception e) {
                    System.err.println(">>> 解析飞书响应失败: " + e.getMessage());
                }
            });
        } catch (Exception e) {
            System.err.println(">>> 发送飞书通知异常: " + e.getMessage());
        }
    }

    private static String createJsonPayload(String message) {
        try {
            return OBJECT_MAPPER.writeValueAsString(new FeishuMessage("text", new FeishuContent(message)));
        } catch (Exception e) {
            throw new RuntimeException("JSON 序列化失败", e);
        }
    }

    private static class FeishuMessage {
        public String msg_type;
        public FeishuContent content;

        public FeishuMessage(String msg_type, FeishuContent content) {
            this.msg_type = msg_type;
            this.content = content;
        }
    }

    private static class FeishuContent {
        public String text;

        public FeishuContent(String text) {
            this.text = text;
        }
    }
}

数据结构

1
2
3
4
5
6
7
8
{
  "FeishuNotifier": {
    "notifierSwitch": true,
    "robots": [
      "https://open.feishu.cn/open-apis/bot/v2/hook/xxx"
    ]
  }
}

调用

1
FeishuNotifier.sendMessageAsync("xxx", "xxx");
分享文章
快来参与讨论吧