博客

实现一个用于监测 API 接口可用性的线程类，其作用是通过发送 HTTP 请求到指定的 API 接口，并监测接口的可用性。

代码中的

APIThread

类继承自

Thread

，意味着它可以在单独的线程中执行。

在

run

方法中，使用

HttpURLConnection

建立与 API 接口的连接，并发送 HTTP 请求。通过设置连接超时时间、请求方法和请求头部信息，可以根据需要自定义 API 请求的配置。

在获取到 API 接口的响应后，根据响应的 HTTP 状态码和返回的内容，判断 API 接口的可用性。如果响应的状态码为

HttpURLConnection.HTTP_OK

，表示 API 接口正常工作，根据返回的内容和预设的

returnMsg

进行比较，来确定 API 接口的返回状态。如果返回内容与预设的

returnMsg

一致，表示 API 接口返回正常，否则表示返回异常。根据判断结果，通过调用

monApiService

更新监控 API 接口的状态。

如果无法建立连接或出现其他异常情况，也会将监控 API 接口的状态更新为异常。

此线程在每次请求完成后会等待一段时间（这里是 5000 毫秒），然后再次发起请求。通过

running

变量控制线程的运行状态，当调用

stopThread

方法时，将设置

running

为

false

，从而终止线程的执行。

请注意，该代码片段中使用了一些自定义的类和接口，例如

IMonApiService

，这些类和接口在代码中没有给出具体实现。因此，要使代码正常运行，需要确保相关的类和接口已经正确实现，并且适配于你的应用程序环境

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

public class APIThread extends Thread{


    private volatile boolean running = true;
    private Long apiId;
    private String apiURL;
    private String method;
    private Integer timeout = 3000;
    private String header;

    private String returnMsg;

    private IMonApiService monApiService;

    private String status = "";

    private String checkStatus = "";

    public APIThread(Long apiId, String apiURL, String method,Integer timeout, String header,String returnMsg, IMonApiService monApiService){
        this.apiId = apiId;
        this.apiURL = apiURL;
        this.method = method;
        this.header = header;
        this.returnMsg = returnMsg;
        this.timeout = timeout;
        this.monApiService = monApiService;
    }

    public void stopThread() {
        running = false;
    }

    public void run() {
        while (running){
            try {
                URL url = new URL(apiURL);
                HttpURLConnection connection = (HttpURLConnection) url.openConnection();
                connection.setConnectTimeout(timeout);
                connection.setRequestMethod(method);
                if(StringUtils.isNotBlank(header)&&header.startsWith("token:")){
                    connection.setRequestProperty("token", header.replace("token:",""));
                }else{
                    connection.setRequestProperty("Authorization", "Bearer "+header);
                }
                // 创建一个 StringBuilder 对象，用于保存 HTTP 响应的内容
                StringBuilder response = new StringBuilder();

                // 获取 HTTP 响应输入流
                InputStream inputStream = connection.getInputStream();

                // 使用 BufferedReader 对象读取输入流中的数据，并将其添加到 StringBuilder 对象中
                try (BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream))) {
                    String line;
                    while ((line = reader.readLine()) != null) {
                        response.append(line);
                    }
                }

                // 输出 HTTP 响应内容
//                System.out.println(response.toString());
                String res = response.toString();
                int responseCode = connection.getResponseCode();
                if (responseCode == HttpURLConnection.HTTP_OK) {
//                    System.out.println("API is working fine");
                        if(StringUtils.isBlank(returnMsg)||"#".equals(returnMsg)){
                            if(!"open".equals(status)) {
                                monApiService.updateMonApiStatus(apiId, Status.OPEN);
                                status = "open";
                                checkStatus = "";
                            }
                        }else{
                            if(StringUtils.isNotBlank(res)&&res.equals(returnMsg)){
                                if(!"open".equals(checkStatus)) {
//                                    System.out.println("API return fine");
                                    monApiService.updateMonApiStatus(apiId, Status.OPEN);
                                    checkStatus = "open";
                                    status="";
                                }
                            }else{
                                if(!"close".equals(checkStatus)) {
//                                    System.out.println("API return error");
                                    monApiService.updateMonApiStatus(apiId, Status.CLOSE);
                                    checkStatus = "close";
                                    status="";
                                }
                            }
                        }

                } else {
//                    System.out.println("API is not working. Response code: " + responseCode);
                    if(!"close".equals(status)) {
                        monApiService.updateMonApiStatus(apiId, Status.CLOSE);
                        status = "close";
                        checkStatus = "";
                    }
                }
            } catch (Exception ex) {
//                ex.printStackTrace();
//                System.out.println("API is not working. Exception: " + ex.getMessage());
                if(!"close".equals(status)) {
                    monApiService.updateMonApiStatus(apiId, Status.CLOSE);
                    status = "close";
                    checkStatus = "";
                }
            }
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }

    }


}