Оптимизация времени запуска Spring Boot

@Component
public class StartupTimeLogger implements ApplicationListener<ContextRefreshedEvent> {
    private final Logger logger = LoggerFactory.getLogger(getClass());
 
    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        ConfigurableApplicationContext context = (ConfigurableApplicationContext) event.getApplicationContext();
        Map<String, Object> beansMap = context.getBeansOfType(Object.class);
        
        logger.info("=== Beans initialization times ===");
        Map<String, Long> beanCreationTimes = context.getBeanFactory()
                .getBeanNamesIterator()
                .forEachRemaining(name -> {
                    long startTime = System.nanoTime();
                    context.getBean(name);
                    long endTime = System.nanoTime();
                    logger.info("Bean '{}' initialization time: {} ms", 
                                name, (endTime - startTime) / 1_000_000.0);
                });
    }
}

@SpringBootApplication
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication application = new SpringApplication(MyApplication.class);
        application.addListeners(new ApplicationStartupTimeMetricsListener());
        application.run(args);
    }
}

public class ApplicationStartupTimeMetricsListener implements ApplicationListener<ApplicationReadyEvent> {
    private static final Logger logger = LoggerFactory.getLogger(ApplicationStartupTimeMetricsListener.class);
    private final long startTime = System.currentTimeMillis();
    
    @Override
    public void onApplicationEvent(ApplicationReadyEvent event) {
        long totalTime = System.currentTimeMillis() - startTime;
        ApplicationContext context = event.getApplicationContext();
        
        // Анализируем время на создание бинов
        if (context instanceof ConfigurableApplicationContext) {
            ConfigurableApplicationContext cac = (ConfigurableApplicationContext) context;
            Map<String, Object> slowBeans = findSlowInitializingBeans(cac);
            
            logger.info("Application startup completed in {} ms", totalTime);
            logger.info("Slowest beans to initialize:");
            slowBeans.forEach((name, time) -> 
                logger.info("  {} : {} ms", name, time));
        }
    }
    
    private Map<String, Object> findSlowInitializingBeans(ConfigurableApplicationContext context) {
        // Логика замера времени инициализации бинов
        // ...
        return result;
    }
}

@Component
public class StartupEventListener {
    private final Logger logger = LoggerFactory.getLogger(getClass());
    private final Map<String, Long> eventTimes = new HashMap<>();
    private final long startTime = System.currentTimeMillis();
 
    @EventListener
    public void handleContextRefreshEvent(ContextRefreshedEvent event) {
        logEventTime("ContextRefreshed");
    }
 
    @EventListener
    public void handlePreparedEvent(ApplicationPreparedEvent event) {
        logEventTime("ApplicationPrepared");
    }
 
    @EventListener
    public void handleStartedEvent(ApplicationStartedEvent event) {
        logEventTime("ApplicationStarted");
    }
 
    @EventListener
    public void handleReadyEvent(ApplicationReadyEvent event) {
        logEventTime("ApplicationReady");
        // Проанализировать и вывести отчёт о разнице между событиями
        eventTimes.forEach((eventName, timestamp) -> {
            long delta = timestamp - startTime;
            logger.info("Event {} occurred at {} ms from start", eventName, delta);
        });
    }
 
    private void logEventTime(String eventName) {
        eventTimes.put(eventName, System.currentTimeMillis());
        logger.info("Event {} occurred", eventName);
    }
}

@Component
public class BeanInitializationProfiler implements BeanPostProcessor {
    private static final Logger log = LoggerFactory.getLogger(BeanInitializationProfiler.class);
    private final Map<String, Long> startTimes = new ConcurrentHashMap<>();
 
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        startTimes.put(beanName, System.nanoTime());
        return bean;
    }
 
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        Long startTime = startTimes.remove(beanName);
        if (startTime != null) {
            long elapsedTime = System.nanoTime() - startTime;
            if (elapsedTime > 1_000_000) { // Фильтр: показываем только бины, занимающие > 1мс
                log.info("Bean '{}' of type [{}] initialized in {} ms", 
                        beanName, bean.getClass().getName(), elapsedTime / 1_000_000.0);
            }
        }
        return bean;
    }
}

@Component
public class DependencyAwareBeanProfiler implements BeanPostProcessor, ApplicationContextAware {
    private ConfigurableApplicationContext context;
    private final ThreadLocal<Stack<String>> beanCreationStack = ThreadLocal.withInitial(Stack::new);
    
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) {
        this.context = (ConfigurableApplicationContext) applicationContext;
    }
    
    // Логика отслеживания цепочек зависимостей...
}

public class FileAccessTracker {
    static {
        // Перехват и логирование файловых операций через Java Instrumentation API
    }
}

@Component
@Lazy(false)
public class CriticalComponent {
    // Этот компонент всегда инициализируется при запуске
}
 
@Component
@Lazy
public class NonCriticalComponent {
    // Этот компонент инициализируется только при первом обращении
}

@Configuration
public class LazyLoadingConfig {
    @Bean
    @Lazy(value = "${app.lazy-init.report-generators:true}")
    public ReportGenerator reportGenerator() {
        return new ReportGenerator();
    }
}

@Component
public class AsyncInitializer implements ApplicationListener<ApplicationReadyEvent> {
    
    private final List<DeferredInitializer> initializers;
    private final ExecutorService executorService;
    
    public AsyncInitializer(List<DeferredInitializer> initializers) {
        this.initializers = initializers;
        this.executorService = Executors.newFixedThreadPool(
            Math.max(2, Runtime.getRuntime().availableProcessors() / 2)
        );
    }
    
    @Override
    public void onApplicationEvent(ApplicationReadyEvent event) {
        initializers.forEach(initializer -> 
            executorService.submit(initializer::initialize)
        );
    }
    
    // Не забываем освобождать ресурсы
    @PreDestroy
    public void shutdown() {
        executorService.shutdown();
    }
}
 
public interface DeferredInitializer {
    void initialize();
}
 
@Component
public class CacheWarmer implements DeferredInitializer {
    @Override
    public void initialize() {
        // Прогрев кэшей в отдельном потоке
    }
}

@Configuration
@ConditionalOnProperty(name = "app.feature.heavy-analytics", havingValue = "true", matchIfMissing = false)
public class AnalyticsConfiguration {
    // Конфигурация тяжелых аналитических компонентов
}

@SpringBootApplication
@ComponentScan(basePackages = {"com.mycompany.core", "com.mycompany.api"})
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

@SpringBootApplication
@Import({
    CoreConfiguration.class,
    ApiConfiguration.class,
    // Только необходимые конфигурации
})
public class MyApplication {
    // ...
}

@Configuration
public class DataSourceConfig {
    
    @Bean
    @Primary
    public DataSource lazyDataSource(
            @Qualifier("actualDataSource") DataSource actualDataSource) {
        return new LazyConnectionDataSourceProxy(actualDataSource);
    }
    
    @Bean
    public DataSource actualDataSource() {
        HikariConfig config = new HikariConfig();
        // Конфигурация
        return new HikariDataSource(config);
    }
}

@Configuration
@Profile("dev")
public class DevConfiguration {
    @Bean
    public DataSource devDataSource() {
        return new EmbeddedDatabaseBuilder()
            .setType(EmbeddedDatabaseType.H2)
            .build();
    }
}
 
@Configuration
@Profile("prod")
public class ProdConfiguration {
    @Bean
    public DataSource prodDataSource() {
        // Полноценный пул соединений для продакшена
    }
}

// Модуль ядра
@Configuration
@ComponentScan("com.mycompany.core")
public class CoreModule {
    // Базовые сервисы
}
 
// Модуль API
@Configuration
@ComponentScan("com.mycompany.api")
@Import(CoreModule.class)
public class ApiModule {
    // Компоненты API, зависящие от ядра
}
 
// Модуль обработки данных
@Configuration
@ComponentScan("com.mycompany.processing")
@Import(CoreModule.class)
public class ProcessingModule {
    // Обработка данных, зависит от ядра, но не от API
}

@Configuration
public class DynamicConfigLoader {
    private final Map<String, Object> cachedConfigs = new ConcurrentHashMap<>();
    
    @Autowired
    private ConfigurationService configService;
    
    public <T> T getConfig(String key, Class<T> type) {
        return (T) cachedConfigs.computeIfAbsent(key, 
            k -> configService.loadConfig(k, type));
    }
}

@Order(10)
@Component
public class CoreServicesInitializer implements InitializingBean {
    @Override
    public void afterPropertiesSet() {
        // Инициализация критически важных сервисов
    }
}

// Проблема: динамическая загрузка классов
Class.forName("com.myapp.dynamic.SomeClass");
 
// Решение: явная регистрация для GraalVM
@TypeHint(types = {
    com.myapp.dynamic.SomeClass.class,
    com.myapp.dynamic.AnotherClass.class
})

// Автоматически сгенерированный код
public class BeanFactoryInitializationCode {
    public static void registerBeans(DefaultListableBeanFactory beanFactory) {
        // Регистрация бинов без рефлексии
        beanFactory.registerBeanDefinition("userService", 
            BeanDefinitionBuilder.genericBeanDefinition(UserService.class).getBeanDefinition());
        // ...
    }
}

@Configuration
public class AotProxyConfiguration {
    @Bean
    public AotProxyProcessor aotProxyProcessor() {
        return new AotProxyProcessor();
    }
}
 
public class AotProxyProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        // Pre-генерация прокси для @Transactional и других аспектов
    }
}

@Component
public class MetadataCacheManager {
    private static final String CACHE_FILE = "metadata-cache.bin";
    
    public void saveCache(Object metadata) {
        try (ObjectOutputStream oos = new ObjectOutputStream(
                new FileOutputStream(CACHE_FILE))) {
            oos.writeObject(metadata);
        } catch (IOException e) {
            // Обработка ошибок
        }
    }
    
    public Object loadCache() {
        if (new File(CACHE_FILE).exists()) {
            try (ObjectInputStream ois = new ObjectInputStream(
                    new FileInputStream(CACHE_FILE))) {
                return ois.readObject();
            } catch (Exception e) {
                // Обработка ошибок
            }
        }
        return null;
    }
}

@Configuration
public class SerializationConfig {
    @Bean
    public ObjectMapper fastObjectMapper() {
        ObjectMapper mapper = new ObjectMapper();
        // Отключение ненужных функций
        mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
        mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
        // Использование более быстрых модулей
        mapper.registerModule(new AfterburnerModule());
        return mapper;
    }
    
    @Bean
    public Gson fastGson() {
        return new GsonBuilder()
            .disableHtmlEscaping()
            .disableInnerClassSerialization()
            .create();
    }
}

public class LazyResourceLoader<T> {
    private final Supplier<T> resourceSupplier;
    private volatile T resource;
    
    public LazyResourceLoader(Supplier<T> resourceSupplier) {
        this.resourceSupplier = resourceSupplier;
    }
    
    public T getResource() {
        if (resource == null) {
            synchronized (this) {
                if (resource == null) {
                    resource = resourceSupplier.get();
                }
            }
        }
        return resource;
    }
}
 
// Использование
@Component
public class HeavyService {
    private final LazyResourceLoader<ExpensiveResource> resourceLoader;
    
    public HeavyService() {
        this.resourceLoader = new LazyResourceLoader<>(ExpensiveResource::new);
    }
    
    public void processData() {
        ExpensiveResource resource = resourceLoader.getResource();
        // Использование ресурса
    }
}

@Configuration
public class AsyncResourceConfig {
    @Bean
    public AsyncResourceInitializer asyncDatabaseInitializer(DataSource dataSource) {
        return new AsyncResourceInitializer(() -> {
            try (Connection conn = dataSource.getConnection()) {
                // Проверка подключения
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        });
    }
}
 
public class AsyncResourceInitializer {
    private final CompletableFuture<Void> initializationFuture;
    
    public AsyncResourceInitializer(Runnable initializationTask) {
        this.initializationFuture = CompletableFuture.runAsync(initializationTask);
    }
    
    public void await() {
        try {
            initializationFuture.get();
        } catch (Exception e) {
            throw new RuntimeException("Failed to initialize resource", e);
        }
    }
}

@SpringBootApplication
public class PartialStartApplication {
    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(PartialStartApplication.class);
        
        // Отключаем некритичные автоконфигурации
        app.setAdditionalProfiles("core-only");
        
        // Регистрируем слушатель для отложенной инициализации
        app.addListeners(new DelayedInitializationListener());
        
        app.run(args);
    }
}
 
class DelayedInitializationListener implements ApplicationListener<ApplicationReadyEvent> {
    @Override
    public void onApplicationEvent(ApplicationReadyEvent event) {
        ApplicationContext context = event.getApplicationContext();
        // Запускаем отложенную инициализацию в отдельном потоке
        Thread initThread = new Thread(() -> {
            ConfigurableApplicationContext delayedContext = new SpringApplicationBuilder()
                .parent(context)
                .profiles("delayed-components")
                .run();
        });
        initThread.setDaemon(true);
        initThread.start();
    }
}

@SpringBootApplication
public class TwoPhaseApplication {
    public static void main(String[] args) {
        SpringApplicationBuilder builder = new SpringApplicationBuilder(TwoPhaseApplication.class)
            .web(WebApplicationType.NONE);
        
        // Фаза 1: минимально необходимый контекст
        ApplicationContext coreContext = builder.run(args);
        
        // Запускаем базовый веб-сервер для проверок работоспособности
        TomcatServer minimalServer = new TomcatServer(8080);
        minimalServer.addHealthEndpoint("/health", () -> "UP");
        minimalServer.start();
        
        // Фаза 2: полная инициализация в фоне
        Thread fullStartThread = new Thread(() -> {
            SpringApplicationBuilder fullAppBuilder = new SpringApplicationBuilder()
                .parent(coreContext)
                .sources(FullApplicationConfig.class);
            fullAppBuilder.run(args);
            
            // Переключаем на полноценный сервер
            minimalServer.stop();
        });
        fullStartThread.start();
    }
}

public interface ApplicationModule {
    String getName();
    void initialize(ApplicationContext parentContext);
    boolean isRequired();
}
 
@Component
public class ModuleRegistry {
    private final List<ApplicationModule> registeredModules = new ArrayList<>();
    private final Map<String, ApplicationContext> moduleContexts = new HashMap<>();
    
    public void registerModule(ApplicationModule module) {
        registeredModules.add(module);
    }
    
    public void initializeRequiredModules(ApplicationContext parentContext) {
        registeredModules.stream()
            .filter(ApplicationModule::isRequired)
            .forEach(module -> initializeModule(module, parentContext));
    }
    
    public void initializeModule(ApplicationModule module, ApplicationContext parentContext) {
        module.initialize(parentContext);
    }
    
    public <T> Optional<T> getModuleBean(String moduleName, Class<T> beanType) {
        ApplicationContext moduleContext = moduleContexts.get(moduleName);
        if (moduleContext != null && moduleContext.containsBean(beanType.getSimpleName())) {
            return Optional.of(moduleContext.getBean(beanType));
        }
        return Optional.empty();
    }
}

@Configuration
public class SpelOptimizationConfig {
    @Bean
    public SpelExpressionParser spelExpressionParser() {
        SpelParserConfiguration config = new SpelParserConfiguration(
            SpelCompilerMode.IMMEDIATE, // Компилировать сразу
            this.getClass().getClassLoader()
        );
        return new SpelExpressionParser(config);
    }
    
    @Bean
    public ExpressionCacheManager expressionCacheManager() {
        return new ExpressionCacheManager(spelExpressionParser());
    }
}
 
public class ExpressionCacheManager {
    private final SpelExpressionParser parser;
    private final ConcurrentMap<String, Expression> expressionCache = new ConcurrentHashMap<>();
    
    public ExpressionCacheManager(SpelExpressionParser parser) {
        this.parser = parser;
    }
    
    public Expression getOrCompileExpression(String expressionString) {
        return expressionCache.computeIfAbsent(expressionString, parser::parseExpression);
    }
}

public class BytecodeOptimizer {
    public static <T> Class<T> optimizeClass(Class<T> origClass) {
        try {
            ClassPool pool = ClassPool.getDefault();
            CtClass cc = pool.get(origClass.getName());
            
            // Интернализация часто используемых строк
            for (CtMethod method : cc.getDeclaredMethods()) {
                method.instrument(new ExprEditor() {
                    public void edit(MethodCall m) throws CannotCompileException {
                        if (m.getClassName().startsWith("java.lang.String") && 
                            m.getMethodName().equals("equals")) {
                            // Оптимизация сравнения строк
                        }
                    }
                });
            }
            
            // Создание оптимизированного класса
            return (Class<T>) cc.toClass();
        } catch (Exception e) {
            throw new RuntimeException("Failed to optimize class", e);
        }
    }
}

@Configuration
public class DistributedInitializationConfig {
    @Bean
    public InitializationCoordinator initCoordinator(
            @Value("${app.instance.id}") String instanceId,
            @Value("${app.cluster.size}") int clusterSize) {
        return new InitializationCoordinator(instanceId, clusterSize);
    }
}
 
public class InitializationCoordinator {
    private final String instanceId;
    private final int clusterSize;
    
    // Инициализация важных общих ресурсов распределяется между узлами кластера
    public boolean shouldInitializeResource(String resourceId) {
        int resourceHash = resourceId.hashCode();
        int targetNode = Math.abs(resourceHash % clusterSize);
        return Integer.valueOf(instanceId) == targetNode;
    }
}

@SpringBootApplication
public class FastStartupApplication {
    public static void main(String[] args) {
        // Отключаем баннер и логирование для ускорения
        SpringApplication app = new SpringApplication(FastStartupApplication.class);
        app.setBannerMode(Banner.Mode.OFF);
        app.setLogStartupInfo(false);
        
        // Устанавливаем минимальный веб-сервер первой фазы
        Map<String, Object> props = new HashMap<>();
        props.put("server.tomcat.max-threads", "2");
        props.put("server.tomcat.min-spare-threads", "1");
        app.setDefaultProperties(props);
        
        app.run(args);
        
        // Вторая фаза запускается асинхронно
    }
}

@Configuration
public class IntegrationConfig {
    
    @Bean
    public IntegrationPool integrationPool() {
        return new AsyncIntegrationPool(10); // 10 потоков
    }
}
 
public class AsyncIntegrationPool {
    private final ExecutorService executor;
    private final Map<String, CompletableFuture<IntegrationClient>> clientFutures = new ConcurrentHashMap<>();
    
    public AsyncIntegrationPool(int threadPoolSize) {
        this.executor = Executors.newFixedThreadPool(threadPoolSize);
    }
    
    public CompletableFuture<IntegrationClient> initializeClient(String clientId, Supplier<IntegrationClient> initializer) {
        return clientFutures.computeIfAbsent(clientId, 
            k -> CompletableFuture.supplyAsync(initializer, executor));
    }
    
    public IntegrationClient getClient(String clientId) throws Exception {
        CompletableFuture<IntegrationClient> future = clientFutures.get(clientId);
        if (future == null) {
            throw new IllegalStateException("Client not initialized: " + clientId);
        }
        return future.get(5, TimeUnit.SECONDS); // С таймаутом ожидания
    }
}