#415 #393 clean up and removal of spring from Embedded Java app (generator to follow)

Author: davetcc

.idea/misc.xml

@@ -0,0 +1,196 @@
+package com.thecoderscorner.embedcontrol.core.util;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.stream.Collectors;
+
+/**
+ * BaseMenuConfig is a base class for configuring menu settings and properties. It holds both the core configuration
+ * and also extra configuration added by plugins, it is assumed that the plugin based configuration does not have any
+ * dependencies outside of those that are declared in its parameters.
+ */
+public class BaseMenuConfig {
+    protected final Map<Class<?>, Object> componentMap = new ConcurrentHashMap<>();
+    protected final System.Logger logger = System.getLogger(getClass().getSimpleName());
+    protected final String environment;
+    protected final Properties resolvedProperties;
+    protected final String baseName;
+
+    /**
+     * this constructor ensures that the environment and properties are initialised. To configure the environment from
+     * system properties set `env` to `null` and set system property `tc.env` to the environment name.
+     * @param env the environment or null to evaluate from system properties.
+     */
+    public BaseMenuConfig(String baseAppName, String env) {
+        environment = (env != null) ? env : System.getProperty("tc.env", "dev");
+        logger.log(System.Logger.Level.INFO, "Starting app in environment " + environment);
+        baseName = baseAppName != null ? baseAppName : "application";
+        resolvedProperties = resolveProperties(environment);
+    }
+
+    /**
+     * Resolves properties based on the specified environment.
+     *
+     * @param environment the environment for which properties need to be resolved
+     * @return the resolved properties as a Properties object
+     */
+    protected Properties resolveProperties(String environment) {
+        Properties p = new Properties();
+        try(var envProps = getClass().getResourceAsStream(String.format("/%s_%s.properties", baseName, environment));
+            var globalProps = getClass().getResourceAsStream("/" + baseName + ".properties")) {
+            if(globalProps != null) {
+                logger.log(System.Logger.Level.INFO, "Reading global properties from " + globalProps);
+                p.load(globalProps);
+            }
+
+            if(envProps != null) {
+                logger.log(System.Logger.Level.INFO, "Reading env properties from " + envProps);
+                p.load(envProps);
+            }
+            logger.log(System.Logger.Level.INFO, "App Properties read finished");
+        } catch (Exception ex) {
+            logger.log(System.Logger.Level.ERROR, "Failed to read app property files", ex);
+        }
+        return p;
+    }
+
+    /**
+     * Scans for components annotated with {@code TcComponent} in the current class and stores them in the component map.
+     * If an annotated method fails to invoke, an error message will be logged. Further, you can add parameters that will
+     * be resolved, but this code cannot resolve circular dependencies, it will scan as long as at one component is built
+     * each time around the loop.
+     */
+    protected void scanForComponents() {
+        var toResolve = Arrays.stream(getClass().getDeclaredMethods()).filter(m -> m.isAnnotationPresent(TcComponent.class))
+                .collect(Collectors.toCollection(ArrayList::new));
+        while(!toResolve.isEmpty()) {
+            var resolvedThisTurn = new ArrayList<Method>();
+            for (var m : toResolve) {
+                m.setAccessible(true);
+                try {
+                    if (m.getParameters().length == 0) {
+                        logger.log(System.Logger.Level.DEBUG, "Found " + m.getName() + " to fulfill " + m.getReturnType().getSimpleName());
+                        componentMap.put(m.getReturnType(), m.invoke(this));
+                        resolvedThisTurn.add(m);
+                    } else {
+                        var params = resolveParametersOrFail(m);
+                        if(params == null) continue;
+                        logger.log(System.Logger.Level.DEBUG, "Found " + m.getName() + " parameterized to fulfill " + m.getReturnType().getSimpleName());
+                        componentMap.put(m.getReturnType(), m.invoke(this, params.toArray()));
+                        resolvedThisTurn.add(m);
+                    }
+                } catch (Exception e) {
+                    logger.log(System.Logger.Level.ERROR, "Skipping bean " + m.getName() + " because it failed", e);
+                }
+            }
+            if(resolvedThisTurn.isEmpty() && !toResolve.isEmpty()) {
+                throw new UnsupportedOperationException("Probably circular dependency in config, cannot resolve");
+            } else {
+                toResolve.removeAll(resolvedThisTurn);
+            }
+        }
+    }
+
+    private ArrayList<Object> resolveParametersOrFail(Method m) {
+        try {
+            var params = new ArrayList<>();
+            for (Parameter param : m.getParameters()) {
+                Class<?> paramType = param.getType();
+                Object resolvedParam = componentMap.get(paramType);
+                if (resolvedParam == null) {
+                    resolvedParam = componentMap.entrySet().stream()
+                            .filter(e -> paramType.isAssignableFrom(e.getKey()))
+                            .findFirst()
+                            .orElseThrow()
+                            .getValue();
+                }
+                params.add(resolvedParam);
+            }
+            return params;
+        } catch (Exception ex) {
+            logger.log(System.Logger.Level.DEBUG, "Can't resolve " + m.getName() + " yet, unresolved dependencies");
+            return null;
+        }
+    }
+
+    /**
+     * Retrieves the current environment.
+     *
+     * @return the current environment as a String
+     */
+    public String getEnvironment() {
+        return environment;
+    }
+
+    /**
+     * Retrieves the resolved properties.
+     *
+     * @return the resolved properties as a Properties object
+     */
+    public Properties getResolvedProperties() {
+        return resolvedProperties;
+    }
+
+    /**
+     * Gets the value of the specified property as an integer. If the property exists in the resolved properties,
+     * it will be parsed as an integer and returned. If the property does not exist, the default value will be returned.
+     *
+     * @param propName the name of the property to retrieve the value from
+     * @param def the default value to return if the property does not exist
+     * @return the value of the property as an integer, or the default value if the property does not exist
+     */
+    protected int propAsIntWithDefault(String propName, int def) {
+        if(resolvedProperties.containsKey(propName)) {
+            return Integer.parseInt(resolvedProperties.getProperty(propName));
+        }
+        return def;
+    }
+
+    /**
+     * Retrieves the value of the specified property and throws an exception if missing.
+     *
+     * @param propName the name of the property to retrieve
+     * @return the value of the property
+     * @throws IllegalArgumentException if the property is missing in the configuration
+     */
+    protected String mandatoryStringProp(String propName) {
+        if(!resolvedProperties.containsKey(propName)) {
+            throw new IllegalArgumentException("Missing property in configuration " + propName);
+        }
+        return resolvedProperties.getProperty(propName);
+    }
+
+    /**
+     * Retrieves an instance of the specified class from the component map. Fastest lookup is by direct class type.
+     * However, if the class is not found in the map, it searches for a compatible class that would fulfill the
+     * interface provided. If no compatible class is found, an exception is thrown.
+     *
+     * @param clazz the class to retrieve an instance of
+     * @param <T>   the generic type of the class, the function is T <= class T
+     * @return an instance of the specified class
+     * @throws NoSuchElementException if no compatible class is found in the component map
+     */
+    public <T> T getBean(Class<T> clazz) {
+        var cmp = componentMap.get(clazz);
+        if(cmp == null) {
+            cmp = componentMap.entrySet().stream().filter(e -> clazz.isAssignableFrom(e.getKey())).findFirst()
+                    .orElseThrow().getValue();
+        }
+        return (T) cmp;
+    }
+
+    /**
+     * Adds a bean to the component map and returns it.
+     *
+     * @param beanToAdd the bean to be added to the component map
+     * @param <T>       the type of the bean
+     * @return the added bean
+     */
+    public <T> T asBean(T beanToAdd) {
+        componentMap.put(beanToAdd.getClass(), beanToAdd);
+        return beanToAdd;
+    }
+
+}

embedCONTROLCore/src/main/java/com/thecoderscorner/embedcontrol/core/util/BaseMenuConfig.java

@@ -0,0 +1,15 @@
+package com.thecoderscorner.embedcontrol.core.util;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Methods within a MenuConfig annotated with this method will be called during construction and the returned result
+ * will be added to componentMap so as to be available with its getBean method.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.METHOD)
+public @interface TcComponent {
+}

embedCONTROLCore/src/main/java/com/thecoderscorner/embedcontrol/core/util/TcComponent.java

@@ -0,0 +1,57 @@
+package com.thecoderscorner.embedcontrol.core.util;
+
+import com.thecoderscorner.embedcontrol.core.controlmgr.color.ControlColor;
+import com.thecoderscorner.menu.domain.AnalogMenuItem;
+import com.thecoderscorner.menu.domain.AnalogMenuItemBuilder;
+import com.thecoderscorner.menu.domain.BooleanMenuItem;
+import com.thecoderscorner.menu.domain.BooleanMenuItemBuilder;
+import com.thecoderscorner.menu.persist.VersionInfo;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class BaseMenuConfigTest {
+    /**
+     * Test case for `resolveProperties` method when global properties and environment-specific properties are both present.
+     */
+    @Test
+    public void testResolveProperties_GlobalAndEnvPropsPresent() throws Exception {
+        TestMenuConfig config = new TestMenuConfig();
+        assertEquals("bool name", config.getBean(BooleanMenuItem.class).getName());
+        assertEquals(ControlColor.BLACK, config.getBean(ControlColor.class).getFg());
+        assertEquals(ControlColor.WHITE, config.getBean(ControlColor.class).getBg());
+        assertEquals("4.2.0", config.getBean(MenuAppVersion.class).getVersionInfo().toString());
+        assertEquals("bool name", config.getBean(DependentItem.class).dependee().getName());
+        assertEquals("12345", config.getBean(DependentItem.class).dependee2().getName());
+        assertEquals("12345", config.getBean(AnalogMenuItem.class).getName());
+    }
+
+    class TestMenuConfig extends BaseMenuConfig {
+        public TestMenuConfig() {
+            super("unittest_app", null);
+            asBean(new ControlColor(ControlColor.BLACK, ControlColor.WHITE));
+            asBean(new MenuAppVersion(VersionInfo.fromString("4.2.0"), "TS", "Group", "abc"));
+            scanForComponents();
+        }
+
+        @TcComponent
+        DependentItem dependentItem(BooleanMenuItem dependee, AnalogMenuItem dependee2) {
+            return new DependentItem(dependee, dependee2);
+        }
+
+        @TcComponent
+        AnalogMenuItem analogItem() {
+            return new AnalogMenuItemBuilder().withName(mandatoryStringProp("dev.only.config")).withId(102)
+                    .menuItem();
+        }
+
+        @TcComponent
+        BooleanMenuItem booleanItem() {
+            return BooleanMenuItemBuilder.aBooleanMenuItemBuilder().withId(100)
+                    .withName(mandatoryStringProp("bool.item.name")).menuItem();
+        }
+    }
+
+    public record DependentItem(BooleanMenuItem dependee, AnalogMenuItem dependee2) {
+    }
+}

embedCONTROLCore/src/test/java/com/thecoderscorner/embedcontrol/core/util/BaseMenuConfigTest.java

@@ -0,0 +1,2 @@
+bool.item.name=bool name
+dev.only.config=321

embedCONTROLCore/src/test/resources/unittest_app.properties

@@ -0,0 +1 @@
+dev.only.config=12345

embedCONTROLCore/src/test/resources/unittest_app_dev.properties

@@ -2,6 +2,7 @@
 
 import com.thecoderscorner.menu.mgr.MenuInMenu;
 import com.thecoderscorner.menu.mgr.MenuManagerServer;
+import com.thecoderscorner.menu.persist.MenuStateSerialiser;
 import com.thecoderscorner.menu.remote.ConnectMode;
 import com.thecoderscorner.menu.remote.LocalIdentifier;
 import com.thecoderscorner.menu.remote.MenuCommandProtocol;
@@ -23,15 +24,15 @@ public class EmbeddedJavaDemoApp {
 
     public EmbeddedJavaDemoApp() {
         context = new MenuConfig(null);
-        manager = context.getMenuManagerServer();
-        webServer = context.getWebServer();
+        manager = context.getBean(MenuManagerServer.class);
+        webServer = context.getBean(TcJettyWebServer.class);
     }
 
     public void start() {
-        var serializer = context.getMenuStateSerialiser();
+        var serializer = context.getBean(MenuStateSerialiser.class);
         serializer.loadMenuStatesAndApply();
         Runtime.getRuntime().addShutdownHook(new Thread(serializer::saveMenuStates));
-        manager.addMenuManagerListener(context.getMenuController());
+        manager.addMenuManagerListener(context.getBean(EmbeddedJavaDemoController.class));
         buildMenuInMenuComponents();
         JfxLocalAutoUI.setAppContext(context);
         manager.addConnectionManager(webServer);
@@ -43,9 +44,9 @@ public static void main(String[] args) {
     }
 
     public void buildMenuInMenuComponents() {
-        MenuManagerServer menuManager = context.getMenuManagerServer();
-        MenuCommandProtocol protocol = context.getWebServer().getProtocol();
-        ScheduledExecutorService executor = context.getScheduledExecutorService();
+        MenuManagerServer menuManager = context.getBean(MenuManagerServer.class);
+        MenuCommandProtocol protocol = context.getBean(MenuCommandProtocol.class);
+        ScheduledExecutorService executor = context.getBean(ScheduledExecutorService.class);
         LocalIdentifier localId = new LocalIdentifier(menuManager.getServerUuid(), menuManager.getServerName());
         var remMenuAvrBoardConnector = new SocketBasedConnector(localId, executor, Clock.systemUTC(), protocol, "192.168.0.96", 3333, ConnectMode.FULLY_AUTHENTICATED);
         var remMenuAvrBoard = new MenuInMenu(remMenuAvrBoardConnector, menuManager, menuManager.getManagedMenu().getMenuById(16).orElseThrow(), MenuInMenu.ReplicationMode.REPLICATE_ADD_STATUS_ITEM, 100000, 65000);

embeddedJavaExample/src/main/java/com/thecoderscorner/menuexample/tcmenu/EmbeddedJavaDemoApp.java

@@ -24,6 +24,14 @@
 
 import static java.lang.System.Logger.Level.INFO;
 
+/**
+ * This class represents the controller for the EmbeddedJavaDemoMenu. It implements the MenuManagerListener interface.
+ * The controller is responsible for creating instances of objects that are required around the application, you can
+ * get hold of these objects later using getBean, and you can add extra ones wrapping an object creation with asBean(..).
+ *
+ * Unless you delete this file it will not be recreated as you can edit it too.
+ * @see MenuManagerListener
+ */
 public class EmbeddedJavaDemoController implements MenuManagerListener {
     private final System.Logger logger = System.getLogger(getClass().getSimpleName());
     private final EmbeddedJavaDemoMenu  menuDef;