Java 添加弹簧执行器'；s healthcheck不带引导和@EnableAutoConfiguration

我想将执行器添加到我的Spring应用程序中（不是Spring启动）。 确切地说，我需要使用HealthCheck，这样我就能够创建不同健康指标的bean，它们将在/health上创建完整的HealthCheck

---

起初我试图将

@EndpointAutoConfiguration

添加到我的

@Configuration

类中，但存在bean冲突，因为我有我真正需要的自定义bean，因此，除了

HealthIndicator配置之外，无需其他配置
可能的解决方案是创建带有关键字段的自定义HealthIndicator和HealthIndicator Collector。还添加了一个servlet：

contextHandler.addServlet(new ServletHolder(platformHealthCheckServlet), "/healthcheck");

从上下文收集所有自定义HealthIndicators，并在/healthcheck端点处创建漂亮的状态json：

@Autowired
public CustomHealthCheckServlet(Map<String, CustomHealthIndicator> healthIndicatorMap, ObjectMapper objectMapper) {
    this.healthIndicatorMap = Collections.unmodifiableMap(healthIndicatorMap);
    this.mapper = objectMapper;
}

CustomAbstractHealthIndicator覆盖AbstractHealthIndicator中的doHealthCheck方法，向其生成器添加关键细节并创建自己的抽象方法doCheck：

还有另一个自定义类，它聚合健康bean，根据每个健康的关键状态计算整个应用程序的状态，忽略不重要但可能对监视有用的指标：

public class CustomHealthAggregator implements HealthAggregator {

    private List<String> statusOrder;

    public CustomHealthAggregator() {
        setStatusOrder(Status.DOWN, Status.OUT_OF_SERVICE, Status.UP, 
Status.UNKNOWN);
    }

    public void setStatusOrder(Status... statusOrder) {
        String[] order = new String[statusOrder.length];
        for (int i = 0; i < statusOrder.length; i++) {
            order[i] = statusOrder[i].getCode();
         }
    setStatusOrder(Arrays.asList(order));
    }

    public void setStatusOrder(List<String> statusOrder) {
        Assert.notNull(statusOrder, "StatusOrder must not be null");
        this.statusOrder = statusOrder;
    }

    protected Status aggregateStatus(List<Status> candidates) {
        // Only sort those status instances that we know about
        List<Status> filteredCandidates = new ArrayList<Status>();
        for (Status candidate : candidates) {
            if (this.statusOrder.contains(candidate.getCode())) {
                filteredCandidates.add(candidate);
            }
        }
        // If no status is given return UP
        if (filteredCandidates.isEmpty()) {
            return Status.UP;
        }
        // Sort given Status instances by configured order
        Collections.sort(filteredCandidates, 
        new StatusComparator(this.statusOrder));
        return filteredCandidates.get(0);
    }

    @Override
    public Health aggregate(Map<String, Health> healths) {
        List<Status> statusCandidates = healths.entrySet()
                .stream()
                .filter(healthEntry -> 
              healthEntry.getValue().getDetails().get("critical").equals(true))
                .map(e -> e.getValue().getStatus())
                .collect(Collectors.toList());

        Status status = aggregateStatus(statusCandidates);
        Map<String, Object> details = new LinkedMap();
        details.put("version", AppVersionUtil.getAppVersion());
        details.putAll(aggregateDetails(healths));
        return new Health.Builder(status, details).build();
    }

    protected Map<String, Object> aggregateDetails(Map<String, Health> healths) 
    {
        return new LinkedHashMap<String, Object>(healths);
    }

    private class StatusComparator implements Comparator<Status> {

        private final List<String> statusOrder;

        StatusComparator(List<String> statusOrder) {
            this.statusOrder = statusOrder;
        }

        @Override
        public int compare(Status s1, Status s2) {
            int i1 = this.statusOrder.indexOf(s1.getCode());
            int i2 = this.statusOrder.indexOf(s2.getCode());
            return (i1 < i2 ? -1 : (i1 == i2 ? s1.getCode().compareTo(s2.getCode()) : 1));
        }

    }
}

公共类CustomHealthAggregator实现HealthAggregator{
私有列表状态顺序；
公共自定义聚合器（）{
设置状态顺序（Status.DOWN、Status.OUT\u OF\u SERVICE、Status.UP、，
身份（未知）；
}
公共无效设置状态订单（状态…状态订单）{
字符串[]顺序=新字符串[statusOrder.length]；
对于（int i=0；i
healthEntry.getValue（）.getDetails（）.get（“临界”）.equals（true））
.map（e->e.getValue（）.getStatus（））
.collect（Collectors.toList（））；
状态状态=聚合状态（状态候选）；
映射详细信息=新建LinkedMap（）；
details.put（“version”，AppVersionUtil.getAppVersion（））；
详细信息。putAll（聚合详细信息（健康））；
返回新的Health.Builder（状态、详细信息）.build（）；
}
受保护的地图聚合详细信息（地图运行状况）
{
返回新的LinkedHashMap（healths）；
}
私有类StatusComparator实现Comparator{
私有最终列表状态顺序；
StatusComparator（列表状态顺序）{
this.statusOrder=statusOrder；
}
@凌驾
公共整数比较（状态s1、状态s2）{
int i1=this.statusOrder.indexOf（s1.getCode（））；
int i2=this.statusOrder.indexOf（s2.getCode（））；
返回（i1
可能的解决方案是创建带有关键字段的自定义HealthIndicator和HealthIndicatorCollector。还添加了一个servlet：

contextHandler.addServlet(new ServletHolder(platformHealthCheckServlet), "/healthcheck");

从上下文收集所有自定义HealthIndicators，并在/healthcheck端点处创建漂亮的状态json：

@Autowired
public CustomHealthCheckServlet(Map<String, CustomHealthIndicator> healthIndicatorMap, ObjectMapper objectMapper) {
    this.healthIndicatorMap = Collections.unmodifiableMap(healthIndicatorMap);
    this.mapper = objectMapper;
}

CustomAbstractHealthIndicator覆盖AbstractHealthIndicator中的doHealthCheck方法，向其生成器添加关键细节并创建自己的抽象方法doCheck：

还有另一个自定义类，它聚合健康bean，根据每个健康的关键状态计算整个应用程序的状态，忽略不重要但可能对监视有用的指标：

public class CustomHealthAggregator implements HealthAggregator {

    private List<String> statusOrder;

    public CustomHealthAggregator() {
        setStatusOrder(Status.DOWN, Status.OUT_OF_SERVICE, Status.UP, 
Status.UNKNOWN);
    }

    public void setStatusOrder(Status... statusOrder) {
        String[] order = new String[statusOrder.length];
        for (int i = 0; i < statusOrder.length; i++) {
            order[i] = statusOrder[i].getCode();
         }
    setStatusOrder(Arrays.asList(order));
    }

    public void setStatusOrder(List<String> statusOrder) {
        Assert.notNull(statusOrder, "StatusOrder must not be null");
        this.statusOrder = statusOrder;
    }

    protected Status aggregateStatus(List<Status> candidates) {
        // Only sort those status instances that we know about
        List<Status> filteredCandidates = new ArrayList<Status>();
        for (Status candidate : candidates) {
            if (this.statusOrder.contains(candidate.getCode())) {
                filteredCandidates.add(candidate);
            }
        }
        // If no status is given return UP
        if (filteredCandidates.isEmpty()) {
            return Status.UP;
        }
        // Sort given Status instances by configured order
        Collections.sort(filteredCandidates, 
        new StatusComparator(this.statusOrder));
        return filteredCandidates.get(0);
    }

    @Override
    public Health aggregate(Map<String, Health> healths) {
        List<Status> statusCandidates = healths.entrySet()
                .stream()
                .filter(healthEntry -> 
              healthEntry.getValue().getDetails().get("critical").equals(true))
                .map(e -> e.getValue().getStatus())
                .collect(Collectors.toList());

        Status status = aggregateStatus(statusCandidates);
        Map<String, Object> details = new LinkedMap();
        details.put("version", AppVersionUtil.getAppVersion());
        details.putAll(aggregateDetails(healths));
        return new Health.Builder(status, details).build();
    }

    protected Map<String, Object> aggregateDetails(Map<String, Health> healths) 
    {
        return new LinkedHashMap<String, Object>(healths);
    }

    private class StatusComparator implements Comparator<Status> {

        private final List<String> statusOrder;

        StatusComparator(List<String> statusOrder) {
            this.statusOrder = statusOrder;
        }

        @Override
        public int compare(Status s1, Status s2) {
            int i1 = this.statusOrder.indexOf(s1.getCode());
            int i2 = this.statusOrder.indexOf(s2.getCode());
            return (i1 < i2 ? -1 : (i1 == i2 ? s1.getCode().compareTo(s2.getCode()) : 1));
        }

    }
}

公共类CustomHealthAggregator实现HealthAggregator{
私有列表状态顺序；
公共自定义聚合器（）{
设置状态顺序（Status.DOWN、Status.OUT\u OF\u SERVICE、Status.UP、，
身份（未知）；
}
公共无效设置状态订单（状态…状态订单）{
字符串[]顺序=新字符串[statusOrder.length]；
对于（int i=0；i