fine tuning for the processEngine configuration

Author: s-yonkov-yonkov

multiapps-controller-process/src/main/java/org/cloudfoundry/multiapps/controller/process/flowable/FlowableFacade.java

@@ -30,8 +30,10 @@
 import org.flowable.variable.api.persistence.entity.VariableInstance;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.springframework.context.annotation.DependsOn;
 
 @Named
+@DependsOn("processEngine")
 public class FlowableFacade {
 
     private static final Logger LOGGER = LoggerFactory.getLogger(FlowableFacade.class);

multiapps-controller-process/src/main/java/org/cloudfoundry/multiapps/controller/process/jobs/LockOwnerReporter.java

@@ -15,9 +15,11 @@
 import org.flowable.engine.ProcessEngine;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.springframework.context.annotation.DependsOn;
 import org.springframework.scheduling.annotation.Scheduled;
 
 @Named
+@DependsOn("processEngine")
 public class LockOwnerReporter {
 
     private static final Logger LOGGER = LoggerFactory.getLogger(LockOwnerReporter.class);

multiapps-controller-process/src/main/java/org/cloudfoundry/multiapps/controller/process/util/LockOwnerReleaser.java

@@ -11,8 +11,10 @@
 import org.flowable.engine.impl.cmd.ClearProcessInstanceLockTimesCmd;
 import org.flowable.job.api.Job;
 import org.flowable.job.service.JobServiceConfiguration;
+import org.springframework.context.annotation.DependsOn;
 
 @Named("lockOwnerReleaser")
+@DependsOn("processEngine")
 public class LockOwnerReleaser {
 
     private final ProcessEngine processEngine;

multiapps-controller-web/src/main/java/org/cloudfoundry/multiapps/controller/web/configuration/FlowableConfiguration.java

@@ -9,9 +9,6 @@
 import org.flowable.common.engine.impl.AbstractEngineConfiguration;
 import org.flowable.common.engine.impl.async.DefaultAsyncTaskExecutor;
 import org.flowable.common.engine.impl.persistence.StrongUuidGenerator;
-import org.flowable.engine.HistoryService;
-import org.flowable.engine.ProcessEngine;
-import org.flowable.engine.RuntimeService;
 import org.flowable.job.service.impl.asyncexecutor.AsyncExecutor;
 import org.flowable.job.service.impl.asyncexecutor.DefaultAsyncJobExecutor;
 import org.flowable.job.service.impl.asyncexecutor.FailedJobCommandFactory;
@@ -41,6 +38,18 @@ public class FlowableConfiguration {
     protected Supplier<String> randomIdGenerator = () -> UUID.randomUUID()
                                                              .toString();
 
+    /**
+     * Creates the ProcessEngine bean via ProcessEngineFactoryBean.
+     *
+     * Important: We return ProcessEngineFactoryBean (which implements FactoryBean<ProcessEngine>)
+     * instead of calling getObject() directly. This allows Spring to properly manage the factory bean's
+     * lifecycle and ensures the ProcessEngine is created at the correct time during context initialization.
+     *
+     * This approach resolves intermittent circular dependency issues that can occur with Spring 6.2.15+
+     * when beans depending on ProcessEngine are initialized concurrently.
+     *
+     * @see FlowableServicesConfiguration for RuntimeService and HistoryService beans
+     */
     @Bean
     @DependsOn("liquibaseChangelog")
     public ProcessEngineFactoryBean processEngine(ApplicationContext applicationContext,

multiapps-controller-web/src/main/java/org/cloudfoundry/multiapps/controller/web/configuration/FlowableServicesConfiguration.java

@@ -1,28 +1,36 @@
 package org.cloudfoundry.multiapps.controller.web.configuration;
 
+import org.flowable.engine.HistoryService;
 import org.flowable.engine.ProcessEngine;
+import org.flowable.engine.RuntimeService;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.DependsOn;
-import org.springframework.context.annotation.Lazy;
 
+/**
+ * Configuration for Flowable engine service beans.
+ *
+ * These beans are extracted from FlowableConfiguration to ensure proper initialization order.
+ * The @DependsOn("processEngine") ensures that the ProcessEngineFactoryBean is fully initialized
+ * and the ProcessEngine is available before these service beans are created.
+ *
+ * Note: @Lazy is not used here because:
+ * 1. The ProcessEngine is properly managed via ProcessEngineFactoryBean, which handles lifecycle correctly
+ * 2. Components like FlowableHistoricDataCleaner need HistoryService at startup for scheduled jobs
+ * 3. Using @Lazy could cause unexpected initialization timing issues
+ */
 @Configuration
 public class FlowableServicesConfiguration {
 
-    // Mark as @Lazy and @DependsOn to ensure 'processEngine' is produced first,
-    // and service beans only resolve when actually needed.
-
     @Bean
-    @Lazy
     @DependsOn("processEngine")
-    public org.flowable.engine.RuntimeService runtimeService(ProcessEngine processEngine) {
+    public RuntimeService runtimeService(ProcessEngine processEngine) {
         return processEngine.getRuntimeService();
     }
 
     @Bean
-    @Lazy
     @DependsOn("processEngine")
-    public org.flowable.engine.HistoryService historyService(ProcessEngine processEngine) {
+    public HistoryService historyService(ProcessEngine processEngine) {
         return processEngine.getHistoryService();
     }
 }