management:
  endpoints:
    web:
      exposure:
        include: '*'
  endpoint:
    health:
      probes:
        enabled: true
      show-details: always
  health:
    # /actuator/health/liveness
    livenessState:
      enabled: true
    # /actuator/health/readiness
    readinessState:
      enabled: true

@Configuration(proxyBeanMethods = false)
public class ApplicationAvailabilityAutoConfiguration {
    @Bean
    public ApplicationAvailabilityBean applicationAvailability() {
        return new ApplicationAvailabilityBean();
    }
}

public class ApplicationAvailabilityBean
        implements ApplicationAvailability, ApplicationListener<AvailabilityChangeEvent<?>> {
    private final Map<Class<? extends AvailabilityState>, AvailabilityChangeEvent<?>> events = new HashMap<>();
    @Override
    public <S extends AvailabilityState> S getState(Class<S> stateType, S defaultState) {
        Assert.notNull(stateType, "StateType must not be null");
        Assert.notNull(defaultState, "DefaultState must not be null");
        S state = getState(stateType);
        return (state != null) ? state : defaultState;
    }
    @Override
    public <S extends AvailabilityState> S getState(Class<S> stateType) {
        AvailabilityChangeEvent<S> event = getLastChangeEvent(stateType);
        return (event != null) ? event.getState() : null;
    }
    @Override
    @SuppressWarnings("unchecked")
    public <S extends AvailabilityState> AvailabilityChangeEvent<S> getLastChangeEvent(Class<S> stateType) {
        return (AvailabilityChangeEvent<S>) this.events.get(stateType);
    }
    @Override
    public void onApplicationEvent(AvailabilityChangeEvent<?> event) {
        Class<? extends AvailabilityState> stateType = getStateType(event.getState());
        this.events.put(stateType, event);
    }
    @SuppressWarnings("unchecked")
    private Class<? extends AvailabilityState> getStateType(AvailabilityState state) {
        if (state instanceof Enum) {
            return (Class<? extends AvailabilityState>) ((Enum<?>) state).getDeclaringClass();
        }
        return state.getClass();
    }
}

public class AvailabilityChangeEvent<S extends AvailabilityState> extends PayloadApplicationEvent<S> {
    /**
     * Create a new {@link AvailabilityChangeEvent} instance.
     * @param source the source of the event
     * @param state the availability state (never {@code null})
     */
    public AvailabilityChangeEvent(Object source, S state) {
        super(source, state);
    }
    /**
     * Return the changed availability state.
     * @return the availability state
     */
    public S getState() {
        return getPayload();
    }
    @Override
    public ResolvableType getResolvableType() {
        return ResolvableType.forClassWithGenerics(getClass(), getStateType());
    }
    private Class<?> getStateType() {
        S state = getState();
        if (state instanceof Enum) {
            return ((Enum<?>) state).getDeclaringClass();
        }
        return state.getClass();
    }
    /**
     * Convenience method that can be used to publish an {@link AvailabilityChangeEvent}
     * to the given application context.
     * @param <S> the availability state type
     * @param context the context used to publish the event
     * @param state the changed availability state
     */
    public static <S extends AvailabilityState> void publish(ApplicationContext context, S state) {
        Assert.notNull(context, "Context must not be null");
        publish(context, context, state);
    }
    /**
     * Convenience method that can be used to publish an {@link AvailabilityChangeEvent}
     * to the given application context.
     * @param <S> the availability state type
     * @param publisher the publisher used to publish the event
     * @param source the source of the event
     * @param state the changed availability state
     */
    public static <S extends AvailabilityState> void publish(ApplicationEventPublisher publisher, Object source,
            S state) {
        Assert.notNull(publisher, "Publisher must not be null");
        publisher.publishEvent(new AvailabilityChangeEvent<>(source, state));
    }
}

@Configuration(proxyBeanMethods = false)
@AutoConfigureAfter(ApplicationAvailabilityAutoConfiguration.class)
public class AvailabilityHealthContributorAutoConfiguration {
    @Bean
    @ConditionalOnMissingBean(name = "livenessStateHealthIndicator")
    @ConditionalOnProperty(prefix = "management.health.livenessstate", name = "enabled", havingValue = "true")
    public LivenessStateHealthIndicator livenessStateHealthIndicator(ApplicationAvailability applicationAvailability) {
        return new LivenessStateHealthIndicator(applicationAvailability);
    }
    @Bean
    @ConditionalOnMissingBean(name = "readinessStateHealthIndicator")
    @ConditionalOnProperty(prefix = "management.health.readinessstate", name = "enabled", havingValue = "true")
    public ReadinessStateHealthIndicator readinessStateHealthIndicator(
            ApplicationAvailability applicationAvailability) {
        return new ReadinessStateHealthIndicator(applicationAvailability);
    }
}

public class AvailabilityStateHealthIndicator extends AbstractHealthIndicator {
    private final ApplicationAvailability applicationAvailability;
    private Class<? extends AvailabilityState> stateType;
    private final Map<AvailabilityState, Status> statusMappings = new HashMap<>();
    /**
     * Create a new {@link AvailabilityStateHealthIndicator} instance.
     * @param <S> the availability state type
     * @param applicationAvailability the application availability
     * @param stateType the availability state type
     * @param statusMappings consumer used to setup the status mappings
     */
    public <S extends AvailabilityState> AvailabilityStateHealthIndicator(
            ApplicationAvailability applicationAvailability, Class<S> stateType,
            Consumer<StatusMappings<S>> statusMappings) {
        Assert.notNull(applicationAvailability, "ApplicationAvailability must not be null");
        Assert.notNull(stateType, "StateType must not be null");
        Assert.notNull(statusMappings, "StatusMappings must not be null");
        this.applicationAvailability = applicationAvailability;
        this.stateType = stateType;
        statusMappings.accept(this.statusMappings::put);
        assertAllEnumsMapped(stateType);
    }
    @SuppressWarnings({ "unchecked", "rawtypes" })
    private <S extends AvailabilityState> void assertAllEnumsMapped(Class<S> stateType) {
        if (!this.statusMappings.containsKey(null) && Enum.class.isAssignableFrom(stateType)) {
            EnumSet elements = EnumSet.allOf((Class) stateType);
            for (Object element : elements) {
                Assert.isTrue(this.statusMappings.containsKey(element),
                        () -> "StatusMappings does not include " + element);
            }
        }
    }
    @Override
    protected void doHealthCheck(Builder builder) throws Exception {
        AvailabilityState state = getState(this.applicationAvailability);
        Status status = this.statusMappings.get(state);
        if (status == null) {
            status = this.statusMappings.get(null);
        }
        Assert.state(status != null, () -> "No mapping provided for " + state);
        builder.status(status);
    }
    /**
     * Return the current availability state. Subclasses can override this method if a
     * different retrieval mechanism is needed.
     * @param applicationAvailability the application availability
     * @return the current availability state
     */
    protected AvailabilityState getState(ApplicationAvailability applicationAvailability) {
        return applicationAvailability.getState(this.stateType);
    }
    /**
     * Callback used to add status mappings.
     *
     * @param <S> the availability state type
     */
    public interface StatusMappings<S extends AvailabilityState> {
        /**
         * Add the status that should be used if no explicit mapping is defined.
         * @param status the default status
         */
        default void addDefaultStatus(Status status) {
            add(null, status);
        }
        /**
         * Add a new status mapping .
         * @param availabilityState the availability state
         * @param status the mapped status
         */
        void add(S availabilityState, Status status);
    }
}

public class LivenessStateHealthIndicator extends AvailabilityStateHealthIndicator {

    public LivenessStateHealthIndicator(ApplicationAvailability availability) {
        super(availability, LivenessState.class, (statusMappings) -> {
            statusMappings.add(LivenessState.CORRECT, Status.UP);
            statusMappings.add(LivenessState.BROKEN, Status.DOWN);
        });
    }

    @Override
    protected AvailabilityState getState(ApplicationAvailability applicationAvailability) {
        return applicationAvailability.getLivenessState();
    }

}

public class ReadinessStateHealthIndicator extends AvailabilityStateHealthIndicator {

    public ReadinessStateHealthIndicator(ApplicationAvailability availability) {
        super(availability, ReadinessState.class, (statusMappings) -> {
            statusMappings.add(ReadinessState.ACCEPTING_TRAFFIC, Status.UP);
            statusMappings.add(ReadinessState.REFUSING_TRAFFIC, Status.OUT_OF_SERVICE);
        });
    }

    @Override
    protected AvailabilityState getState(ApplicationAvailability applicationAvailability) {
        return applicationAvailability.getReadinessState();
    }

}

public class EventPublishingRunListener implements SpringApplicationRunListener, Ordered {
    @Override
    public void started(ConfigurableApplicationContext context) {
        context.publishEvent(new ApplicationStartedEvent(this.application, this.args, context));
        AvailabilityChangeEvent.publish(context, LivenessState.CORRECT);
    }

    @Override
    public void running(ConfigurableApplicationContext context) {
        context.publishEvent(new ApplicationReadyEvent(this.application, this.args, context));
        AvailabilityChangeEvent.publish(context, ReadinessState.ACCEPTING_TRAFFIC);
    }
}

class SpringApplicationRunListeners {

    void started(ConfigurableApplicationContext context) {
        for (SpringApplicationRunListener listener : this.listeners) {
            listener.started(context);
        }
    }

    void running(ConfigurableApplicationContext context) {
        for (SpringApplicationRunListener listener : this.listeners) {
            listener.running(context);
        }
    }

    //......
}

public class ServletWebServerApplicationContext extends GenericWebApplicationContext
        implements ConfigurableWebServerApplicationContext {
    @Override
    protected void doClose() {
        if (isActive()) {
            AvailabilityChangeEvent.publish(this, ReadinessState.REFUSING_TRAFFIC);
        }
        super.doClose();
    }
    //......
}

public ConfigurableApplicationContext run(String... args) {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        ConfigurableApplicationContext context = null;
        Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
        configureHeadlessProperty();
        SpringApplicationRunListeners listeners = getRunListeners(args);
        listeners.starting();
        try {
            ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
            ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
            configureIgnoreBeanInfo(environment);
            Banner printedBanner = printBanner(environment);
            context = createApplicationContext();
            exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
                    new Class[] { ConfigurableApplicationContext.class }, context);
            prepareContext(context, environment, listeners, applicationArguments, printedBanner);
            refreshContext(context);
            afterRefresh(context, applicationArguments);
            stopWatch.stop();
            if (this.logStartupInfo) {
                new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
            }
            listeners.started(context);
            callRunners(context, applicationArguments);
        }
        catch (Throwable ex) {
            handleRunFailure(context, ex, exceptionReporters, listeners);
            throw new IllegalStateException(ex);
        }
        try {
            listeners.running(context);
        }
        catch (Throwable ex) {
            handleRunFailure(context, ex, exceptionReporters, null);
            throw new IllegalStateException(ex);
        }
        return context;
    }