Polish

commons/common-util/src/main/java/com/schbrain/common/util/InetUtils.java → commons/common-util/src/main/java/com/schbrain/common/util/HostInfoHolder.java

@@ -8,42 +8,33 @@ import java.net.Inet4Address;
 import java.net.InetAddress;
 import java.net.NetworkInterface;
 import java.net.UnknownHostException;
-import java.nio.ByteBuffer;
 import java.util.Enumeration;
 
 /**
- * Copy from SpringCloud
- *
  * @author liaozan
  * @since 2021/11/19
  */
 @Slf4j
-public class InetUtils {
+public class HostInfoHolder {
 
-    public static HostInfo findFirstNonLoopBackHostInfo() {
+    private static final HostInfo HOST_INFO = findFirstNonLoopBackHostInfo();
+
+    public static HostInfo getHostInfo() {
+        return HOST_INFO;
+    }
+
+    private static HostInfo findFirstNonLoopBackHostInfo() {
         InetAddress address = findFirstNonLoopBackAddress();
         if (address != null) {
             return convertAddress(address);
         }
+        log.warn("Cannot find first non-loopBack address, fallback to localhost");
         HostInfo hostInfo = new HostInfo();
         hostInfo.setHostname("localhost");
         hostInfo.setIpAddress("127.0.0.1");
         return hostInfo;
     }
 
-    public static int getIpAddressAsInt(HostInfo hostInfo) {
-        String host = hostInfo.getIpAddress();
-        if (host == null) {
-            host = hostInfo.getHostname();
-        }
-        try {
-            InetAddress inetAddress = InetAddress.getByName(host);
-            return ByteBuffer.wrap(inetAddress.getAddress()).getInt();
-        } catch (final UnknownHostException e) {
-            throw new IllegalArgumentException(e);
-        }
-    }
-
     private static InetAddress findFirstNonLoopBackAddress() {
         InetAddress result = null;
         try {

commons/web-common/src/main/java/com/schbrain/common/web/ObjectMapperConfiguration.java → commons/web-common/src/main/java/com/schbrain/common/web/ObjectMapperCustomizerConfiguration.java

@@ -11,10 +11,10 @@ import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
  * @since 2023/8/9
  */
 @ConditionalOnClass(Jackson2ObjectMapperBuilder.class)
-public class ObjectMapperConfiguration {
+public class ObjectMapperCustomizerConfiguration {
 
     @Bean
-    public Jackson2ObjectMapperBuilderCustomizer jacksonCustomizer() {
+    public Jackson2ObjectMapperBuilderCustomizer longToStringSerializerJacksonCustomizer() {
         return builder -> builder.serializerByType(Long.class, LongToStringSerializer.instance);
     }
 

commons/web-common/src/main/java/com/schbrain/common/web/WebCommonAutoConfiguration.java

@@ -30,7 +30,7 @@ import java.util.List;
         ExceptionHandingConfiguration.class,
         ServletComponentConfiguration.class,
         CorsFilterConfiguration.class,
-        ObjectMapperConfiguration.class
+        ObjectMapperCustomizerConfiguration.class
 })
 public class WebCommonAutoConfiguration {
 

starters/apollo-spring-boot-starter/src/main/java/com/schbrain/framework/autoconfigure/apollo/event/listener/ConfigLoadedEventListener.java

@@ -17,9 +17,4 @@ public interface ConfigLoadedEventListener extends ApplicationListener<ConfigLoa
         return Ordered.LOWEST_PRECEDENCE;
     }
 
-    @Override
-    default void initialize(ConfigurableApplicationContext applicationContext) {
-
-    }
-
 }

starters/apollo-spring-boot-starter/src/main/java/com/schbrain/framework/autoconfigure/apollo/event/listener/GenericConfigLoadedEventListener.java → starters/apollo-spring-boot-starter/src/main/java/com/schbrain/framework/autoconfigure/apollo/event/listener/ConfigLoadedEventListenerAdaptor.java

@@ -3,6 +3,7 @@ package com.schbrain.framework.autoconfigure.apollo.event.listener;
 import com.schbrain.common.util.support.ConfigurableProperties;
 import com.schbrain.framework.autoconfigure.apollo.event.ConfigLoadedEvent;
 import org.apache.commons.logging.Log;
+import org.springframework.context.ConfigurableApplicationContext;
 import org.springframework.core.ResolvableType;
 
 /**
@@ -10,25 +11,39 @@ import org.springframework.core.ResolvableType;
  * @since 2023-04-28
  */
 @SuppressWarnings("unchecked")
-public abstract class GenericConfigLoadedEventListener<T extends ConfigurableProperties> implements ConfigLoadedEventListener {
+public abstract class ConfigLoadedEventListenerAdaptor<T extends ConfigurableProperties> implements ConfigLoadedEventListener {
 
     protected final ResolvableType propertiesType;
-
     protected Log log;
+    private T properties;
 
-    public GenericConfigLoadedEventListener() {
+    public ConfigLoadedEventListenerAdaptor() {
         this.propertiesType = ResolvableType.forInstance(this).getSuperType().getGeneric(0);
     }
 
     @Override
     public void onApplicationEvent(ConfigLoadedEvent event) {
         event.getSpringApplication().addInitializers(this);
-        if (propertiesType.isInstance(event.getSource())) {
+        if (propertiesType.isInstance(event.getSource()) && properties == null) {
             this.log = event.getDeferredLogFactory().getLog(getClass());
-            this.onConfigLoaded(event, (T) event.getSource());
+            this.properties = (T) event.getSource();
+            this.onConfigLoaded(event, properties);
+        }
     }
+
+    @Override
+    public final void initialize(ConfigurableApplicationContext applicationContext) {
+        onApplicationContextInitialized(applicationContext, properties);
     }
 
+    /**
+     * callback when config loaded
+     */
     protected abstract void onConfigLoaded(ConfigLoadedEvent event, T configurableProperties);
 
+    /**
+     * callback when application context initialized
+     */
+    protected abstract void onApplicationContextInitialized(ConfigurableApplicationContext context, T properties);
+
 }

starters/dubbo-spring-boot-starter/src/main/java/com/schbrain/framework/autoconfigure/dubbo/initializer/DubboValidationInitializer.java

-package com.schbrain.framework.autoconfigure.dubbo.initializer;
-
-import com.schbrain.framework.autoconfigure.apollo.config.OrderedMapPropertySource;
-import org.springframework.util.ClassUtils;
-
-/**
- * 暂时以编程的方式配置参数校验。待所有服务都升级到指定版本时,再通过配置开启
- *
- * @author liaozan
- * @since 2023-07-04
- */
-public class DubboValidationInitializer {
-
-    private static final String VALIDATION_FILTER_CLASS_NAME = "org.apache.dubbo.validation.filter.ValidationFilter";
-
-    private static final String PROVIDER_VALIDATION_PROPERTY = "dubbo.provider.validation";
-
-    public static void initialize(OrderedMapPropertySource propertySource) {
-        if (ClassUtils.isPresent(VALIDATION_FILTER_CLASS_NAME, DubboValidationInitializer.class.getClassLoader())) {
-            if (!propertySource.containsProperty(PROVIDER_VALIDATION_PROPERTY)) {
-                propertySource.addProperty(PROVIDER_VALIDATION_PROPERTY, Boolean.TRUE.toString());
-            }
-        }
-    }
-
-}
\ No newline at end of file

starters/dubbo-spring-boot-starter/src/main/java/com/schbrain/framework/autoconfigure/dubbo/listener/DubboConfigLoadedEventListener.java

@@ -2,8 +2,7 @@ package com.schbrain.framework.autoconfigure.dubbo.listener;
 
 import com.schbrain.framework.autoconfigure.apollo.config.OrderedMapPropertySource;
 import com.schbrain.framework.autoconfigure.apollo.event.ConfigLoadedEvent;
-import com.schbrain.framework.autoconfigure.apollo.event.listener.GenericConfigLoadedEventListener;
-import com.schbrain.framework.autoconfigure.dubbo.initializer.DubboValidationInitializer;
+import com.schbrain.framework.autoconfigure.apollo.event.listener.ConfigLoadedEventListenerAdaptor;
 import com.schbrain.framework.autoconfigure.dubbo.properties.DubboProperties;
 import org.springframework.boot.SpringApplication;
 import org.springframework.context.ConfigurableApplicationContext;
@@ -16,7 +15,7 @@ import static org.apache.dubbo.config.ConfigKeys.DUBBO_SCAN_BASE_PACKAGES;
  * @author liaozan
  * @since 2023-04-28
  */
-public class DubboConfigLoadedEventListener extends GenericConfigLoadedEventListener<DubboProperties> {
+public class DubboConfigLoadedEventListener extends ConfigLoadedEventListenerAdaptor<DubboProperties> {
 
     @Override
     public int getOrder() {
@@ -24,14 +23,13 @@ public class DubboConfigLoadedEventListener extends GenericConfigLoadedEventList
     }
 
     @Override
-    public void initialize(ConfigurableApplicationContext applicationContext) {
-        applicationContext.addApplicationListener(new DubboConfigInitEventListener(applicationContext));
+    protected void onConfigLoaded(ConfigLoadedEvent event, DubboProperties properties) {
+        addRequiredProperties(event.getEnvironment(), event.getSpringApplication(), event.getPropertySource());
     }
 
     @Override
-    protected void onConfigLoaded(ConfigLoadedEvent event, DubboProperties properties) {
-        addRequiredProperties(event.getEnvironment(), event.getSpringApplication(), event.getPropertySource());
-        DubboValidationInitializer.initialize(event.getPropertySource());
+    protected void onApplicationContextInitialized(ConfigurableApplicationContext context, DubboProperties properties) {
+        context.addApplicationListener(new DubboConfigInitEventListener(context));
     }
 
     private void addRequiredProperties(ConfigurableEnvironment environment, SpringApplication application, OrderedMapPropertySource propertySource) {

starters/logger-spring-boot-starter/src/main/java/com/schbrain/framework/autoconfigure/logger/LoggerConfigurationInitializer.java → starters/logger-spring-boot-starter/src/main/java/com/schbrain/framework/autoconfigure/logger/JSONLoggingInitializer.java

@@ -12,9 +12,10 @@ import ch.qos.logback.core.rolling.TimeBasedRollingPolicy;
 import cn.hutool.json.JSONObject;
 import com.schbrain.common.util.ApplicationName;
 import com.schbrain.common.util.EnvUtils;
-import com.schbrain.common.util.InetUtils.HostInfo;
+import com.schbrain.common.util.HostInfoHolder;
+import com.schbrain.common.util.HostInfoHolder.HostInfo;
 import com.schbrain.framework.autoconfigure.logger.logstash.EnhancedLogstashEncoder;
-import com.schbrain.framework.autoconfigure.logger.properties.LoggerProperties;
+import com.schbrain.framework.autoconfigure.logger.properties.LoggingProperties;
 import lombok.extern.slf4j.Slf4j;
 import net.logstash.logback.appender.LogstashTcpSocketAppender;
 import net.logstash.logback.encoder.LogstashEncoder;
@@ -23,39 +24,42 @@ import org.apache.commons.collections4.IteratorUtils;
 import org.apache.commons.lang3.StringUtils;
 import org.slf4j.LoggerFactory;
 import org.springframework.boot.cloud.CloudPlatform;
-import org.springframework.core.env.ConfigurableEnvironment;
+import org.springframework.core.env.Environment;
 import org.springframework.util.CollectionUtils;
 
 import java.nio.file.Paths;
 import java.util.List;
 
 /**
- * Enable the json logging, will be auto active when the application is running in cloudPlatform
+ * Enable the json logging, will be auto active when the application is running in CloudPlatform
  *
  * @author liaozan
  * @see CloudPlatform
  * @since 2021/12/11
  */
 @Slf4j
-public class LoggerConfigurationInitializer {
+public class JSONLoggingInitializer {
 
-    private final ConfigurableEnvironment environment;
-    private final LoggerProperties properties;
-    private final HostInfo hostInfo;
     private final String applicationName;
+    private final Environment environment;
+    private final LoggingProperties loggingProperties;
 
     private volatile boolean initialized;
 
-    public LoggerConfigurationInitializer(ConfigurableEnvironment environment, LoggerProperties properties, HostInfo hostInfo) {
+    private JSONLoggingInitializer(Environment environment, LoggingProperties loggingProperties) {
         this.environment = environment;
-        this.properties = properties;
-        this.hostInfo = hostInfo;
+        this.loggingProperties = loggingProperties;
         this.applicationName = ApplicationName.get(environment);
     }
 
+    public static void init(Environment environment, LoggingProperties properties) {
+        JSONLoggingInitializer initializer = new JSONLoggingInitializer(environment, properties);
+        initializer.init();
+    }
+
     public void init() {
-        if (properties == null) {
-            log.warn("logger properties is null");
+        if (loggingProperties == null) {
+            log.warn("logging properties is null");
             return;
         }
         if (initialized) {
@@ -75,18 +79,18 @@ public class LoggerConfigurationInitializer {
             return;
         }
 
-        if (properties.isEnableJsonFileOutput()) {
+        if (loggingProperties.isEnableJsonFileOutput()) {
             Appender<ILoggingEvent> appender = buildFileAppender(context);
             logger.addAppender(appender);
         }
 
-        if (properties.isEnableJsonConsoleOutput()) {
+        if (loggingProperties.isEnableJsonConsoleOutput()) {
             Appender<ILoggingEvent> appender = buildConsoleAppender(context);
             logger.addAppender(appender);
         }
 
-        if (properties.isEnableJsonLogWriteToLogstash() || EnvUtils.runningOnCloudPlatform(environment)) {
-            if (StringUtils.isBlank(properties.getLogstashAddress())) {
+        if (loggingProperties.isEnableJsonLogWriteToLogstash() || EnvUtils.runningOnCloudPlatform(environment)) {
+            if (StringUtils.isBlank(loggingProperties.getLogstashAddress())) {
                 log.warn("logstash address is unset, will NOT write log to logstash");
                 return;
             }
@@ -98,7 +102,7 @@ public class LoggerConfigurationInitializer {
     private Appender<ILoggingEvent> buildLogstashAppender(LoggerContext context) {
         LogstashTcpSocketAppender appender = new LogstashTcpSocketAppender();
         appender.setContext(context);
-        appender.addDestination(properties.getLogstashAddress());
+        appender.addDestination(loggingProperties.getLogstashAddress());
         appender.setEncoder(createJsonEncoder(context));
         appender.start();
         return appender;
@@ -127,6 +131,7 @@ public class LoggerConfigurationInitializer {
     }
 
     private String getCustomFields() {
+        HostInfo hostInfo = HostInfoHolder.getHostInfo();
         JSONObject customFields = new JSONObject();
         customFields.set("appName", applicationName);
         customFields.set("hostName", hostInfo.getHostname());
@@ -145,12 +150,12 @@ public class LoggerConfigurationInitializer {
     }
 
     private String getPathLocation(String path) {
-        return Paths.get(properties.getLogPath(), path).toString();
+        return Paths.get(loggingProperties.getLogPath(), path).toString();
     }
 
     private TimeBasedRollingPolicy<ILoggingEvent> createRollingPolicy(Context context, FileAppender<ILoggingEvent> appender) {
         TimeBasedRollingPolicy<ILoggingEvent> rollingPolicy = new TimeBasedRollingPolicy<>();
-        rollingPolicy.setMaxHistory(properties.getMaxHistory());
+        rollingPolicy.setMaxHistory(loggingProperties.getMaxHistory());
         rollingPolicy.setFileNamePattern(getPathLocation("json/json-%d{yyyy-MM-dd}.log"));
         rollingPolicy.setContext(context);
         rollingPolicy.setParent(appender);

starters/logger-spring-boot-starter/src/main/java/com/schbrain/framework/autoconfigure/logger/LoggerAutoConfiguration.java → starters/logger-spring-boot-starter/src/main/java/com/schbrain/framework/autoconfigure/logger/LoggingAutoConfiguration.java

 package com.schbrain.framework.autoconfigure.logger;
 
-import com.schbrain.framework.autoconfigure.logger.apollo.DynamicLoggerConfiguration;
-import com.schbrain.framework.autoconfigure.logger.properties.LoggerProperties;
+import com.schbrain.framework.autoconfigure.logger.apollo.DynamicLoggingConfiguration;
+import com.schbrain.framework.autoconfigure.logger.properties.LoggingProperties;
 import org.springframework.boot.autoconfigure.AutoConfiguration;
 import org.springframework.boot.context.properties.EnableConfigurationProperties;
 import org.springframework.context.annotation.Import;
@@ -11,8 +11,8 @@ import org.springframework.context.annotation.Import;
  * @since 2021/11/19
  */
 @AutoConfiguration
-@Import(DynamicLoggerConfiguration.class)
-@EnableConfigurationProperties(LoggerProperties.class)
-public class LoggerAutoConfiguration {
+@Import(DynamicLoggingConfiguration.class)
+@EnableConfigurationProperties(LoggingProperties.class)
+public class LoggingAutoConfiguration {
 
 }

starters/logger-spring-boot-starter/src/main/java/com/schbrain/framework/autoconfigure/logger/apollo/DynamicLoggerConfiguration.java → starters/logger-spring-boot-starter/src/main/java/com/schbrain/framework/autoconfigure/logger/apollo/DynamicLoggingConfiguration.java

@@ -2,7 +2,7 @@ package com.schbrain.framework.autoconfigure.logger.apollo;
 
 import com.ctrip.framework.apollo.Config;
 import com.ctrip.framework.apollo.ConfigService;
-import com.schbrain.framework.autoconfigure.logger.properties.LoggerProperties;
+import com.schbrain.framework.autoconfigure.logger.properties.LoggingProperties;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.boot.logging.LoggingSystem;
@@ -14,22 +14,22 @@ import org.springframework.boot.logging.LoggingSystem;
  * @since 2021/11/19
  **/
 @Slf4j
-public class DynamicLoggerConfiguration {
+public class DynamicLoggingConfiguration {
 
-    public DynamicLoggerConfiguration(LoggingSystem loggingSystem, LoggerProperties loggerProperties) {
-        this.listenToLoggingLevelChange(loggingSystem, loggerProperties);
+    public DynamicLoggingConfiguration(LoggingSystem loggingSystem, LoggingProperties loggingProperties) {
+        this.listenToLoggingLevelChange(loggingSystem, loggingProperties);
     }
 
-    private void listenToLoggingLevelChange(LoggingSystem loggingSystem, LoggerProperties loggerProperties) {
-        String loggerNamespace = loggerProperties.getNamespace();
-        if (StringUtils.isBlank(loggerNamespace)) {
-            log.debug("logger level reload is disabled");
+    private void listenToLoggingLevelChange(LoggingSystem loggingSystem, LoggingProperties loggingProperties) {
+        String loggingNamespace = loggingProperties.getNamespace();
+        if (StringUtils.isBlank(loggingNamespace)) {
+            log.debug("logging level reload is disabled");
             return;
         }
 
-        log.debug("init logger level listener, logger namespace: {}", loggerNamespace);
+        log.debug("init logging level listener, logging namespace: {}", loggingNamespace);
 
-        Config config = ConfigService.getConfig(loggerNamespace);
+        Config config = ConfigService.getConfig(loggingNamespace);
         if (config == null) {
             return;
         }

starters/logger-spring-boot-starter/src/main/java/com/schbrain/framework/autoconfigure/logger/listener/LoggerConfigLoadedEventListener.java → starters/logger-spring-boot-starter/src/main/java/com/schbrain/framework/autoconfigure/logger/listener/LoggingConfigLoadedEventListener.java

@@ -6,12 +6,12 @@ import com.ctrip.framework.apollo.ConfigFile;
 import com.ctrip.framework.apollo.ConfigService;
 import com.ctrip.framework.apollo.core.enums.ConfigFileFormat;
 import com.google.common.collect.Maps;
-import com.schbrain.common.util.InetUtils;
-import com.schbrain.common.util.InetUtils.HostInfo;
+import com.schbrain.common.util.HostInfoHolder;
+import com.schbrain.common.util.HostInfoHolder.HostInfo;
 import com.schbrain.framework.autoconfigure.apollo.event.ConfigLoadedEvent;
-import com.schbrain.framework.autoconfigure.apollo.event.listener.GenericConfigLoadedEventListener;
-import com.schbrain.framework.autoconfigure.logger.LoggerConfigurationInitializer;
-import com.schbrain.framework.autoconfigure.logger.properties.LoggerProperties;
+import com.schbrain.framework.autoconfigure.apollo.event.listener.ConfigLoadedEventListenerAdaptor;
+import com.schbrain.framework.autoconfigure.logger.JSONLoggingInitializer;
+import com.schbrain.framework.autoconfigure.logger.properties.LoggingProperties;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.boot.context.logging.LoggingApplicationListener;
 import org.springframework.boot.logging.LogFile;
@@ -31,28 +31,24 @@ import static org.springframework.boot.context.logging.LoggingApplicationListene
  * @author liaozan
  * @since 2023-04-28
  */
-public class LoggerConfigLoadedEventListener extends GenericConfigLoadedEventListener<LoggerProperties> {
-
-    private LoggerConfigurationInitializer loggerInitializer;
+public class LoggingConfigLoadedEventListener extends ConfigLoadedEventListenerAdaptor<LoggingProperties> {
 
     @Override
-    public void initialize(ConfigurableApplicationContext applicationContext) {
-        loggerInitializer.init();
+    protected void onConfigLoaded(ConfigLoadedEvent event, LoggingProperties properties) {
+        event.getPropertySource().addProperties(buildHostInfoProperties());
+        configLoggingFileLocation(event.getEnvironment(), properties.getLogConfigNamespace());
     }
 
     @Override
-    protected void onConfigLoaded(ConfigLoadedEvent event, LoggerProperties properties) {
-        HostInfo hostInfo = InetUtils.findFirstNonLoopBackHostInfo();
-        Map<String, Object> hostInfoProperties = buildHostInfoProperties(hostInfo);
-        event.getPropertySource().addProperties(hostInfoProperties);
-        configLoggingFileLocation(event.getEnvironment(), properties.getLogConfigNamespace());
-        this.loggerInitializer = new LoggerConfigurationInitializer(event.getEnvironment(), properties, hostInfo);
+    protected void onApplicationContextInitialized(ConfigurableApplicationContext context, LoggingProperties properties) {
+        JSONLoggingInitializer.init(context.getEnvironment(), properties);
     }
 
     /**
-     * hostInfo properties, for logging pattern
+     * hostInfo properties, for logging pattern, used in logback-spring.xml
      */
-    private Map<String, Object> buildHostInfoProperties(HostInfo hostInfo) {
+    private Map<String, Object> buildHostInfoProperties() {
+        HostInfo hostInfo = HostInfoHolder.getHostInfo();
         Map<String, Object> properties = Maps.newHashMapWithExpectedSize(2);
         properties.put("application.hostname", hostInfo.getHostname());
         properties.put("application.ipAddress", hostInfo.getIpAddress());

starters/logger-spring-boot-starter/src/main/java/com/schbrain/framework/autoconfigure/logger/properties/LoggerProperties.java → starters/logger-spring-boot-starter/src/main/java/com/schbrain/framework/autoconfigure/logger/properties/LoggingProperties.java

@@ -13,7 +13,7 @@ import java.time.Duration;
  */
 @Data
 @ConfigurationProperties(prefix = "schbrain.logging.file")
-public class LoggerProperties implements ConfigurableProperties, PriorityOrdered {
+public class LoggingProperties implements ConfigurableProperties, PriorityOrdered {
 
     public static final String DEFAULT_LOG_PATH = "/data/logs";
 

starters/logger-spring-boot-starter/src/main/resources/META-INF/spring.factories

 org.springframework.context.ApplicationContextInitializer=\
   com.schbrain.framework.autoconfigure.logger.logback.LogbackTraceIdConfiguration
 org.springframework.context.ApplicationListener=\
-  com.schbrain.framework.autoconfigure.logger.listener.LoggerConfigLoadedEventListener
+  com.schbrain.framework.autoconfigure.logger.listener.LoggingConfigLoadedEventListener
 com.schbrain.common.util.support.ConfigurableProperties=\
-  com.schbrain.framework.autoconfigure.logger.properties.LoggerProperties
\ No newline at end of file
+  com.schbrain.framework.autoconfigure.logger.properties.LoggingProperties

starters/logger-spring-boot-starter/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports

-com.schbrain.framework.autoconfigure.logger.LoggerAutoConfiguration
\ No newline at end of file
+com.schbrain.framework.autoconfigure.logger.LoggingAutoConfiguration

starters/xxl-job-spring-boot-starter/src/main/java/com/schbrain/framework/autoconfigure/xxl/XxlJobAutoConfiguration.java

 package com.schbrain.framework.autoconfigure.xxl;
 
 import com.schbrain.common.util.ApplicationName;
-import com.schbrain.framework.autoconfigure.logger.properties.LoggerProperties;
+import com.schbrain.framework.autoconfigure.logger.properties.LoggingProperties;
 import com.schbrain.framework.autoconfigure.xxl.condition.XxlJobShouldAvailableCondition;
 import com.schbrain.framework.autoconfigure.xxl.properties.XxlJobProperties;
 import com.xxl.job.core.executor.XxlJobExecutor;
@@ -25,7 +25,7 @@ public class XxlJobAutoConfiguration {
 
     @Bean(initMethod = "start", destroyMethod = "destroy")
     @ConditionalOnMissingBean(XxlJobExecutor.class)
-    public XxlJobSpringExecutor xxlJobSpringExecutor(XxlJobProperties xxlJobProperties, LoggerProperties loggingProperties) {
+    public XxlJobSpringExecutor xxlJobSpringExecutor(XxlJobProperties xxlJobProperties, LoggingProperties loggingProperties) {
         XxlJobSpringExecutor executor = new XxlJobSpringExecutor();
         executor.setAdminAddresses(xxlJobProperties.getAdminAddresses());
         executor.setIp(xxlJobProperties.getIp());

starters/xxl-job-spring-boot-starter/src/main/java/com/schbrain/framework/autoconfigure/xxl/properties/XxlJobProperties.java

 package com.schbrain.framework.autoconfigure.xxl.properties;
 
-import com.schbrain.common.util.InetUtils;
+import com.schbrain.common.util.HostInfoHolder;
 import com.schbrain.common.util.support.ConfigurableProperties;
 import lombok.Data;
 import org.springframework.boot.context.properties.ConfigurationProperties;
@@ -15,7 +15,7 @@ public class XxlJobProperties implements ConfigurableProperties {
 
     private String adminAddresses;
 
-    private String ip = InetUtils.findFirstNonLoopBackHostInfo().getIpAddress();
+    private String ip = HostInfoHolder.getHostInfo().getIpAddress();
 
     private int port = -1;
 

support/schbrain-spring-support/src/main/java/com/schbrain/framework/support/spring/startup/BufferingApplicationStartupApplicationContextInitializer.java

-package com.schbrain.framework.support.spring.startup;
-
-import org.springframework.boot.context.metrics.buffering.BufferingApplicationStartup;
-import org.springframework.context.ApplicationContextInitializer;
-import org.springframework.context.ConfigurableApplicationContext;
-import org.springframework.core.metrics.ApplicationStartup;
-
-/**
- * @author liaozan
- * @since 2023-06-12
- */
-public class BufferingApplicationStartupApplicationContextInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {
-
-    @Override
-    public void initialize(ConfigurableApplicationContext applicationContext) {
-        if (applicationContext.getApplicationStartup() == ApplicationStartup.DEFAULT) {
-            applicationContext.setApplicationStartup(new BufferingApplicationStartup(Integer.MAX_VALUE));
-        }
-    }
-
-}
\ No newline at end of file

support/schbrain-spring-support/src/main/resources/META-INF/spring.factories

 org.springframework.boot.env.EnvironmentPostProcessor=com.schbrain.framework.support.spring.env.DefaultPropertiesEnvironmentPostProcessor
-org.springframework.context.ApplicationContextInitializer=com.schbrain.framework.support.spring.startup.BufferingApplicationStartupApplicationContextInitializer