Router refactor to beanfactory (#2514)

* refactor: move globalInterceptor to beanFactory

* refactor: streamline exception messages, improve logging, and enhance Javadoc comments across classes

* feat: global interceptor support for YAML

* refactor: streamline imports, remove unused methods, and improve exception formatting in `Router`

* refactor: remove unused `setRouter` method from `Transport` and enhance Javadoc for `Router` settings

* refactor: remove unused imports, simplify package structure, and clean up redundant code in YAML integration

* refactor: remove unused imports, simplify package structure, and clean up redundant code in YAML integration

* refactor: extend and streamline BeanRegistry integration in Router, improve exception formatting, enhance concurrency handling

* refactor: streamline imports in `GenericYamlParserTest`, improve readability and maintainability

* refactor: simplify `registerIfAbsent` usage in `Router` and `BeanRegistry`, streamline bean registration logic

* refactor: simplify `registerIfAbsent` by removing `name` parameter, streamline bean registration

* refactor: remove duplicate `openPorts` field from `Router`

* refactor: enhance concurrency handling in `BeanRegistryImplementation`, improve logging and null checks, and streamline `activationRun` logic

* refactor: replace `Router.init` with `Router.initByXML`, improve thread-safety in `BeanContainer`, and streamline `BeanRegistry` handling

* refactor: remove redundant `Exception` declarations, simplify `tearDown` and `setUp` methods, and clean up `BeanContainer` by removing unused `setIfAbsent` method

* refactor: simplify Router lifecycle methods, streamline test setup/teardown logic, and remove unused classes

* refactor: streamline imports in test files and remove redundant `Exception` declarations

* refactor: improve thread-safety in `registerIfAbsent` by introducing dedicated lock

* refactor: update test lifecycle methods to use `@BeforeAll`/`@AfterAll`, remove redundant assertions, and improve object reuse

* refactor: refactor `Router` lifecycle methods, remove `openPorts` handling, improve proxy addition & initialization logic

* refactor: streamline imports, remove redundant declarations, and improve readability in test files

* refactor: improve Router lifecycle management, update test setup/teardown methods, and streamline imports across test cases

* refactor: replace `Router.initByXML` with `RouterBootstrap.initByXML`, improve HotDeployer lifecycle, and streamline `Router` initialization logic

* refactor: make `router` field `final` in `RuleReinitializer` to ensure immutability and improve thread-safety

* refactor: improve `Router` lifecycle methods, enhance thread-safety, and streamline `RuleReinitializer` logic

* refactor: remove unnecessary `Exception` declaration from `initOasi` method in test file

* refactor: enhance `Router` lifecycle handling, improve thread-safety, and update test setup/teardown methods

* refactor: add TODO for replacing `backgroundInitializer` with virtual threads in `Router` to align with modern threading practices

* refactor: replace `Router` with `HttpRouter` in test files and update initialization logic for consistency

* refactor: improve thread-safety in `DefaultHotDeployer`, enhance logging, and fix `BeanContainer` string formatting

* refactor: replace `Router` with `IRouter` for better abstraction and consistency across core components

* refactor: introduce `AbstractRouter` for shared functionality, replace `Router` with `IRouter` or specialized implementations, and align tests accordingly

* refactor: remove `IRouter` interface, replace with `DefaultRouter` or specialized implementations, and align related components and tests

* refactor: replace `router.getConfig()` with `router.getConfiguration()` for improved naming consistency across core components and tests

* refactor: replace `router.shutdown()` with `router.stop()` and introduce `DefaultMainComponents` to streamline router initialization and component management

* refactor: improve thread-safety and synchronization in `BeanRegistryImplementation`, enhance initialization/logging in routers, and remove unused/deprecated methods

* refactor: extend timeout in `MassivelyParallelTest` to improve test stability under high load

* improved synchronization

* doc

* small improvements

---------

Co-authored-by: Christian Gördes <118011644+christiangoerdes@users.noreply.github.com>
Co-authored-by: Tobias Polley <mail@tobias-polley.de>

Author: 3 people

annot/src/main/java/com/predic8/membrane/annot/beanregistry/BeanContainer.java

@@ -14,24 +14,52 @@
 
 package com.predic8.membrane.annot.beanregistry;
 
+import com.predic8.membrane.annot.Grammar;
+import com.predic8.membrane.annot.bean.BeanFactory;
+import com.predic8.membrane.annot.yaml.GenericYamlParser;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.concurrent.atomic.*;
+
 public class BeanContainer {
+    private static final Logger log = LoggerFactory.getLogger(BeanContainer.class);
+
     private final BeanDefinition definition;
     /**
      * Constructed bean after initialization.
      */
-    private volatile Object singleton;
+    private final AtomicReference<Object> singleton = new AtomicReference<>();
 
+    /**
+     * Creates a BeanDefinition where the bean has not yet been instantiated and initialized.
+     */
     public BeanContainer(BeanDefinition definition) {
         this.definition = definition;
     }
 
+    /**
+     * Creates a BeanDefinition where the bean has already been instantiated and initialized.
+     */
+    public BeanContainer(BeanDefinition definition, Object singleton) {
+        this.definition = definition;
+        this.singleton.set(singleton);
+    }
 
-    public Object getSingleton() {
-        return singleton;
+    /**
+     * Only to be used within this class.
+     * Use {@link #getOrCreate(BeanRegistryImplementation, Grammar)} instead.
+     */
+    private Object getSingleton() {
+        return singleton.get();
     }
 
-    public void setSingleton(Object singleton) {
-        this.singleton = singleton;
+    /**
+     * Only to be used within this class.
+     * Use {@link #getOrCreate(BeanRegistryImplementation, Grammar)} instead.
+     */
+    private void setSingleton(Object singleton) {
+        this.singleton.set(singleton);
     }
 
     public BeanDefinition getDefinition() {
@@ -40,6 +68,52 @@ public BeanDefinition getDefinition() {
 
     @Override
     public String toString() {
-        return "BeanContainer: %s of %s".formatted( definition.getName(),definition.getKind());
+        return "BeanContainer: %s of %s singleton: %s".formatted( definition.getName(),definition.getKind(),singleton.get());
+    }
+
+    private synchronized Object define(BeanRegistryImplementation registry, Grammar grammar) {
+        log.debug("defining bean: {}", definition.getNode());
+        try {
+            if ("bean".equals(definition.getKind())) {
+                return new BeanFactory(registry).create(definition.getNode().path("bean"));
+            }
+            return GenericYamlParser.readMembraneObject(definition.getKind(),
+                    grammar,
+                    definition.getNode(),
+                    registry);
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public Object getOrCreate(BeanRegistryImplementation registry, Grammar grammar) {
+        boolean prototype = isPrototypeScope(getDefinition());
+
+        // Prototypes are created anew every time.
+        if (prototype) {
+            return define(registry, grammar);
+        }
+
+        // Singleton: ensure define() runs at most once per BeanContainer.
+        synchronized (this) {
+            Object existing = getSingleton();
+            if (existing != null) {
+                return existing;
+            }
+
+            Object created = define(registry, grammar);
+            setSingleton(created);
+            return created;
+        }
+    }
+
+    private static boolean isPrototypeScope(BeanDefinition bd) {
+        if (!bd.isBean())
+            return bd.isPrototype();
+
+        return "PROTOTYPE".equalsIgnoreCase(
+                bd.getNode().path("bean").path("scope").asText("SINGLETON")
+        );
     }
+
 }

annot/src/main/java/com/predic8/membrane/annot/beanregistry/BeanDefinition.java

@@ -16,6 +16,9 @@
 import com.fasterxml.jackson.databind.*;
 import com.predic8.membrane.annot.yaml.*;
 
+/**
+ * Immutable.
+ */
 public class BeanDefinition {
 
     public static final String PROTOTYPE = "prototype";
@@ -76,6 +79,8 @@ public String getKind() {
     }
 
     public String getScope() {
+        if (node == null)
+            return null;
         JsonNode meta = node.get("metadata");
         if (meta == null)
             return null;

annot/src/main/java/com/predic8/membrane/annot/beanregistry/BeanRegistry.java

@@ -16,6 +16,7 @@
 import com.predic8.membrane.annot.*;
 
 import java.util.*;
+import java.util.function.*;
 
 public interface BeanRegistry {
 
@@ -44,4 +45,15 @@ public interface BeanRegistry {
      * @param bean   instance to register (must not be null)
      */
     void register(String beanName, Object bean);
+
+    /**
+     * Registers a bean of the specified type with the given name if it is not already registered.
+     * If a bean with the given name is already present, the existing instance is returned.
+     * Otherwise, the supplier is used to create and register a new instance.
+     * @param type the class type of the bean
+     * @param supplier a supplier that provides a new instance of the bean if not already registered
+     * @param <T> the generic type of the bean
+     * @return the existing or newly created and registered bean instance
+     */
+     <T> T registerIfAbsent(Class<T> type, Supplier<T> supplier);
 }

annot/src/main/java/com/predic8/membrane/annot/beanregistry/BeanRegistryImplementation.java

@@ -13,17 +13,29 @@
    limitations under the License. */
 package com.predic8.membrane.annot.beanregistry;
 
-import com.predic8.membrane.annot.Grammar;
-import com.predic8.membrane.annot.bean.BeanFactory;
-import com.predic8.membrane.annot.yaml.GenericYamlParser;
-import com.predic8.membrane.annot.yaml.WatchAction;
+import com.predic8.membrane.annot.*;
+import com.predic8.membrane.annot.bean.*;
+import com.predic8.membrane.annot.yaml.*;
 import org.jetbrains.annotations.*;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
+import org.slf4j.*;
 
+import javax.annotation.concurrent.*;
 import java.util.*;
-import java.util.concurrent.ConcurrentHashMap;
-
+import java.util.concurrent.*;
+import java.util.function.*;
+
+/**
+ * TODO:
+ * - More Tests
+ * - Document
+ * - For TB Unclear: Lifecycle activation/resolve
+ * - oldbean
+ *   - a.) Revert to second list (singletonBeans)
+ *   - b.) Give proxies an unique id
+ * <p>
+ * For K8S UUID and name is needed cause name is only unique within a namespace.
+ *
+ */
 public class BeanRegistryImplementation implements BeanRegistry, BeanCollector {
 
     private static final Logger log = LoggerFactory.getLogger(BeanRegistryImplementation.class);
@@ -36,31 +48,24 @@ public class BeanRegistryImplementation implements BeanRegistry, BeanCollector {
 
     // uid -> bean container
     private final Map<String, BeanContainer> bcs = new ConcurrentHashMap<>(); // Order is not critical. Order is determined by uidsToActivate
+
+    @GuardedBy("uidsToActivate")
     private final Set<UidAction> uidsToActivate = Collections.synchronizedSet(new LinkedHashSet<>()); // keeps order
 
-    record UidAction(String uid, WatchAction action) {}
+    /**
+     * Protects the initialization of beans, which are unique per class.
+     */
+    private final Object uniqueClassInitialization = new Object();
+
+    record UidAction(String uid, WatchAction action) {
+    }
 
     public BeanRegistryImplementation(BeanCacheObserver observer, BeanRegistryAware registryAware, Grammar grammar) {
         this.observer = observer;
         this.grammar = grammar;
         registryAware.setRegistry(this);
     }
 
-    private Object define(BeanDefinition bd)  {
-        log.debug("defining bean: {}", bd.getNode());
-        try {
-            if ("bean".equals(bd.getKind())) {
-                return new BeanFactory(this).create(bd.getNode().path("bean"));
-            }
-            return GenericYamlParser.readMembraneObject(bd.getKind(),
-                    grammar,
-                    bd.getNode(),
-                    this);
-        } catch (Exception e) {
-            throw new RuntimeException(e);
-        }
-    }
-
     @Override
     public void start() {
     }
@@ -89,10 +94,9 @@ private void activationRun() {
         for (UidAction uidAction : uidsToActivate) {
             BeanContainer bc = bcs.get(uidAction.uid);
             try {
-                Object bean = define(bc.getDefinition());
-                bc.setSingleton(bean);
+                Object bean = bc.getOrCreate(this, grammar);
 
-                // e.g. inform router about new proxy
+                // e.g., inform router about a new ApiProxy or GlobalInterceptor
                 observer.handleBeanEvent(new BeanDefinitionChanged(uidAction.action, bc.getDefinition()), bean, getOldBean(uidAction.action, bc.getDefinition()));
 
                 if (uidAction.action.isAdded() || uidAction.action.isModified())
@@ -121,19 +125,7 @@ private void activationRun() {
 
     @Override
     public Object resolve(String url) {
-        BeanContainer bc = getFirstByName(url).orElseThrow(() -> new RuntimeException("Reference %s not found".formatted(url)));
-
-        boolean prototype = isPrototypeScope(bc.getDefinition());
-
-        if (!prototype && bc.getSingleton() != null)
-            return bc.getSingleton();
-
-        Object instance = define(bc.getDefinition());
-
-        if (!prototype)
-            bc.setSingleton(instance);
-
-        return instance;
+        return getFirstByName(url).orElseThrow(() -> new RuntimeException("Reference %s not found".formatted(url))).getOrCreate(this, grammar);
     }
 
     private @NotNull Optional<BeanContainer> getFirstByName(String url) {
@@ -143,7 +135,7 @@ public Object resolve(String url) {
     @Override
     public List<Object> getBeans() {
         return bcs.values().stream().filter(bd -> !bd.getDefinition().isComponent())
-                .map(BeanContainer::getSingleton)
+                .map(bc -> bc.getOrCreate(this, grammar))
                 .filter(Objects::nonNull)
                 .toList();
     }
@@ -153,19 +145,10 @@ public Grammar getGrammar() {
         return grammar;
     }
 
-    private static boolean isPrototypeScope(BeanDefinition bd) {
-        if (!bd.isBean())
-            return bd.isPrototype();
-
-        return "PROTOTYPE".equalsIgnoreCase(
-                bd.getNode().path("bean").path("scope").asText("SINGLETON")
-        );
-    }
-
     @Override
     public <T> List<T> getBeans(Class<T> clazz) {
         return bcs.values().stream()
-                .map(BeanContainer::getSingleton)
+                .map(bc -> bc.getOrCreate(this, grammar))
                 .filter(Objects::nonNull)
                 .filter(clazz::isInstance)
                 .map(clazz::cast)
@@ -175,18 +158,44 @@ public <T> List<T> getBeans(Class<T> clazz) {
     public <T> Optional<T> getBean(Class<T> clazz) {
         var beans = getBeans(clazz);
         if (beans.size() > 1) {
-            var msg = "One bean was asked. But found %d beans of %s".formatted(beans.size(),clazz);
+            var msg = "One bean was asked. But found %d beans of %s".formatted(beans.size(), clazz);
             log.error(msg);
             throw new RuntimeException(msg);
         }
         return beans.size() == 1 ? Optional.of(beans.getFirst()) : Optional.empty();
     }
 
     public void register(String beanName, Object bean) {
+        if (bean == null)
+            throw new IllegalArgumentException("bean must not be null");
+
         var uuid = UUID.randomUUID().toString();
-        BeanContainer bc = new BeanContainer(new BeanDefinition("component", beanName,null, uuid, null));
-        bc.setSingleton(bean);
-        singletonBeans.put(uuid,bean);
-        bcs.put(uuid, bc);
+        bcs.put(uuid,
+                new BeanContainer(
+                    new BeanDefinition(
+                            "component",
+                            computeBeanName(beanName, uuid),
+                            null,
+                            uuid,
+                            null),
+                    bean));
+        singletonBeans.put(uuid, bean);
+        // the return value of 'put' is ignored, since bean registration with
+        // random keys should not yield duplicates anyway.
     }
+
+    public <T> T registerIfAbsent(Class<T> type, Supplier<T> supplier) {
+        synchronized (uniqueClassInitialization) {
+            return getBean(type).orElseGet(() -> getBean(type).orElseGet(() -> {
+                T created = supplier.get();
+                register(null, created);
+                return created;
+            }));
+        }
+    }
+
+    private static @NotNull String computeBeanName(String beanName, String uuid) {
+        return beanName != null ? beanName : "#" + uuid;
+    }
+
 }

core/src/main/java/com/predic8/membrane/core/AbstractRouter.java

@@ -0,0 +1,31 @@
+/* Copyright 2025 predic8 GmbH, www.predic8.com
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License. */
+
+package com.predic8.membrane.core;
+
+import com.predic8.membrane.core.proxies.*;
+import org.slf4j.*;
+
+public abstract class AbstractRouter implements Router, MainComponents {
+
+    private static final Logger log = LoggerFactory.getLogger(DefaultRouter.class);
+
+    protected void initProxies() {
+        log.debug("Initializing proxies.");
+        for (Proxy proxy : getRuleManager().getRules()) {
+            log.debug("Initializing proxy {}.", proxy.getName());
+            proxy.init(this);
+        }
+    }
+}

core/src/main/java/com/predic8/membrane/core/Configuration.java

@@ -37,7 +37,7 @@ public class Configuration {
 
     private boolean retryInit = false;
 
-    private String jmxRouterName;
+    private String jmxRouterName = "default";
 
     private URIFactory uriFactory = new URIFactory(false);
 

core/src/main/java/com/predic8/membrane/core/DefaultConfig.java

@@ -66,7 +66,7 @@ private void defineRouter(BeanDefinitionRegistry beanDefinitionRegistry) {
 		if (!beanDefinitionRegistry.containsBeanDefinition("router")) {
 			beanDefinitionRegistry.registerBeanDefinition(
 					"router",
-					root().clazz(Router.class).addRef("transport", "transport").addRef("exchangeStore", "memoryExchangeStore").build());
+					root().clazz(DefaultRouter.class).addRef("transport", "transport").addRef("exchangeStore", "memoryExchangeStore").build());
 		}
 	}