Add Yaml bean support

annot/src/main/java/com/predic8/membrane/annot/MCChildElement.java

@@ -31,4 +31,6 @@
      * Allows the child to come from a schema other than Membrane core. Used for spring beans, e.g. ref to ssl bean
      */
 	boolean allowForeign() default false;
+
+    boolean excludeFromJson() default false;  // excludes from JSON Schema (YAML)
 }

annot/src/main/java/com/predic8/membrane/annot/MCElement.java

@@ -27,10 +27,15 @@
 
     boolean mixed() default false;
 
+    /**
+     * Whether the element can be defined at the top-level of the config.
+     */
+    boolean topLevel() default false;
+
     /**
      * Whether the element can be a separate bean in the XML schema, or a separate document in YAML/JSON.
      */
-    boolean topLevel() default true;
+    boolean component() default true;
 
     String configPackage() default "";
 
@@ -54,4 +59,9 @@
      * This does not have any effect on the XML grammar.
      */
     boolean noEnvelope() default false;
+
+    /**
+     * Whether the element should be configurable as part of the interceptor flow
+     */
+    boolean excludeFromFlow() default false;
 }

annot/src/main/java/com/predic8/membrane/annot/SpringConfigurationXSDGeneratingAnnotationProcessor.java

@@ -215,12 +215,10 @@ public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment
 
                     scan(main, ii);
 
-                    if (ii.getAnnotation().topLevel())
-                        main.getTopLevels().put(ii.getAnnotation().name(), ii);
+                    if (ii.getAnnotation().component())
+                        main.getComponents().put(ii.getAnnotation().name(), ii);
 
                     if (ii.getAnnotation().noEnvelope()) {
-                        if (ii.getAnnotation().topLevel())
-                            throw new ProcessingException("@MCElement(..., noEnvelope=true, topLevel=true) is invalid.", ii.getElement());
                         if (ii.getAnnotation().mixed())
                             throw new ProcessingException("@MCElement(..., noEnvelope=true, mixed=true) is invalid.", ii.getElement());
                         if (ii.getChildElementSpecs().size() != 1)
@@ -254,8 +252,8 @@ public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment
                             for (Entry<TypeElement, ElementInfo> e : main.getElements().entrySet()) {
                                 if (!processingEnv.getTypeUtils().isAssignable(e.getKey().asType(), f.getKey().asType()))
                                     continue;
-                                if (targetIsObject && !isTopLevelMCElement(e.getKey()))
-                                    continue; // only allow topLevel MCElements for Object
+                                if (targetIsObject && !isComponent(e.getKey()))
+                                    continue; // only allow component MCElements for Object
                                 cedi.getElementInfo().add(e.getValue());
                             }
                         }
@@ -272,9 +270,9 @@ public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment
 
                 for (MainInfo main : m.getMains()) {
                     for (Entry<TypeElement, ElementInfo> f : main.getElements().entrySet()) {
-                        ElementInfo ei2 = main.getTopLevels().get(f.getKey().getAnnotation(MCElement.class).name());
-                        if (ei2 != null && f.getValue() != ei2 && f.getValue().getAnnotation().topLevel())
-                            throw new ProcessingException("Duplicate top-level @MCElement name. Make at least one @MCElement(topLevel=false,...) .", f.getKey(), ei2.getElement());
+                        ElementInfo ei2 = main.getComponents().get(f.getKey().getAnnotation(MCElement.class).name());
+                        if (ei2 != null && f.getValue() != ei2 && f.getValue().getAnnotation().component())
+                            throw new ProcessingException("Duplicate component @MCElement name. Make at least one @MCElement(component=false,...) .", f.getKey(), ei2.getElement());
 
                         List<String> uniquenessErrors = getUniquenessError(f.getValue(), main);
                         if (!uniquenessErrors.isEmpty())
@@ -299,9 +297,9 @@ public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment
         }
     }
 
-    private boolean isTopLevelMCElement(TypeElement type) {
+    private boolean isComponent(TypeElement type) {
         MCElement mcElement = type.getAnnotation(MCElement.class);
-        return (mcElement != null) && mcElement.topLevel();
+        return (mcElement != null) && mcElement.component();
     }
 
     private List<String> getUniquenessError(ElementInfo ii, MainInfo main) {
@@ -512,6 +510,10 @@ private boolean isRequired(Element e2) {
     }
 
     public void process(Model m) throws IOException {
+        if (new ComponentClassGenerator(processingEnv).writeJava(m))
+            return; // we will be called again to handle the newly generated class.
+        if (new BeanClassGenerator(processingEnv).writeJava(m))
+            return; // we will be called again to handle the newly generated class.
         new Schemas(processingEnv).writeXSD(m);
         new KubernetesBootstrapper(processingEnv).boot(m);
         new JsonSchemaGenerator(processingEnv).write(m);

annot/src/main/java/com/predic8/membrane/annot/bean/BeanFactory.java

@@ -0,0 +1,252 @@
+/* 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.annot.bean;
+
+import com.fasterxml.jackson.databind.*;
+import com.predic8.membrane.annot.util.*;
+import com.predic8.membrane.annot.yaml.*;
+import org.jetbrains.annotations.*;
+
+import java.lang.reflect.*;
+import java.util.*;
+import java.util.stream.*;
+
+import static com.predic8.membrane.annot.util.ReflectionUtil.isWrapperOfPrimitive;
+
+/**
+ * Builds Java objects from a "bean" JSON node (YAML).
+ */
+public final class BeanFactory {
+
+    private final BeanRegistry registry;
+
+    public BeanFactory(BeanRegistry registry) {
+        this.registry = registry;
+    }
+
+    /**
+     * Creates an instance described by the given bean node.
+     */
+    public Object create(JsonNode beanBody) {
+        String className = getTextContent(beanBody, "class");
+
+        try {
+            Object instance = instantiate(
+                    loadBeanClass(className),
+                    parseConstructorArgList(beanBody.path("constructorArgs"))
+            );
+            applyProperties(instance, parsePropertyList(beanBody.path("properties")));
+            return instance;
+        } catch (Exception e) {
+            throw new RuntimeException("Could not create bean for class: " + className, e);
+        }
+    }
+
+    // TODO simplify this. 'normal' code should not be required to use classloader magic
+    private Class<?> loadBeanClass(String className) throws ClassNotFoundException {
+        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
+        if (classLoader != null) {
+            try {
+                return Class.forName(className, true, classLoader);
+            } catch (ClassNotFoundException ignored) {
+            }
+        }
+
+        classLoader = registry.getGrammar().getClass().getClassLoader();
+        if (classLoader != null) {
+            try {
+                return Class.forName(className, true, classLoader);
+            } catch (ClassNotFoundException ignored) {
+            }
+        }
+
+        classLoader = BeanFactory.class.getClassLoader();
+        if (classLoader != null) {
+            try {
+                return Class.forName(className, true, classLoader);
+            } catch (ClassNotFoundException ignored) {
+            }
+        }
+
+        return Class.forName(className);
+    }
+
+    private class ConstructorArg {
+        String value, ref;
+
+        public ConstructorArg(JsonNode node) {
+            var item = node.isObject() && node.has("constructorArg") ? node.get("constructorArg") : node;
+
+            value = getTextOrNull(item, "value");
+            ref = getTextOrNull(item, "ref");
+        }
+    }
+
+    private class Property {
+        String name, value, ref;
+
+        public Property(JsonNode node) {
+            var item = node.isObject() && node.has("property") ? node.get("property") : node;
+
+            name = getTextContent(item, "name");
+            value = getTextOrNull(item, "value");
+            ref = getTextOrNull(item, "ref");
+        }
+
+        public boolean isBlank() {
+            return name == null || name.isBlank();
+        }
+    }
+
+    private List<ConstructorArg> parseConstructorArgList(JsonNode arr) {
+        if (arr == null || !arr.isArray()) return List.of();
+
+        return StreamSupport.stream(arr.spliterator(), false)
+                .map(ConstructorArg::new)
+                .toList();
+    }
+
+    private List<Property> parsePropertyList(JsonNode arr) {
+        if (arr == null || !arr.isArray()) return List.of();
+
+        return StreamSupport.stream(arr.spliterator(), false)
+                .map(Property::new)
+                .toList();
+    }
+
+    private String getTextContent(JsonNode n, String key) {
+        JsonNode v = n.get(key);
+        if (v == null || !v.isTextual() || v.asText().isBlank())
+            throw new IllegalArgumentException("Missing/blank '" + key + "' in bean spec.");
+        return v.asText();
+    }
+
+    private String getTextOrNull(JsonNode n, String key) {
+        JsonNode v = n.get(key);
+        return v != null && v.isTextual() ? v.asText() : null;
+    }
+
+    private Object instantiate(Class<?> type, List<ConstructorArg> args) throws Exception {
+        int n = args == null ? 0 : args.size();
+
+        Set<Constructor<?>> constructors = new LinkedHashSet<>();
+        constructors.addAll(Arrays.asList(type.getConstructors()));
+        constructors.addAll(Arrays.asList(type.getDeclaredConstructors()));
+
+        Constructor<?> best = null;
+        Object[] bestArgs = null;
+
+        for (Constructor<?> c : constructors) {
+            if (c.getParameterCount() != n) continue;
+            Object[] resolved = tryResolveCtorArgs(c.getParameterTypes(), args);
+            if (resolved != null) {
+                best = c;
+                bestArgs = resolved;
+                break;
+            }
+        }
+
+        if (best == null) {
+            throw new IllegalArgumentException("No matching constructor found for %s with %d argument(s).".formatted(type.getName(), n));
+        }
+
+        best.setAccessible(true);
+        return best.newInstance(bestArgs);
+    }
+
+    private Object[] tryResolveCtorArgs(Class<?>[] paramTypes, List<ConstructorArg> args) {
+        try {
+            Object[] resolved = new Object[paramTypes.length];
+            for (int i = 0; i < paramTypes.length; i++) {
+                resolved[i] = resolveValueOrRef(paramTypes[i], args.get(i).value, args.get(i).ref);
+            }
+            return resolved;
+        } catch (Exception e) {
+            return null; // not compatible
+        }
+    }
+
+    private void applyProperties(Object target, List<Property> props) throws Exception {
+        for (Property p : props) {
+            if (p.isBlank())
+                throw new IllegalArgumentException("Property name must not be blank.");
+
+            Method setter = findSetter(target.getClass(), p.name);
+            if (setter != null) {
+                Class<?> pt = setter.getParameterTypes()[0];
+                setter.setAccessible(true);
+                setter.invoke(target, resolveValueOrRef(pt, p.value, p.ref));
+                continue;
+            }
+
+            Field f = findField(target.getClass(), p.name);
+            if (f != null) {
+                f.setAccessible(true);
+                f.set(target, resolveValueOrRef(f.getType(), p.value, p.ref));
+                continue;
+            }
+
+            throw new IllegalArgumentException("No setter/field found for property '%s' on %s".formatted(p.name, target.getClass().getName()));
+        }
+    }
+
+    private Method findSetter(Class<?> clazz, String prop) {
+        String setterName = getSetterName(prop);
+        for (Method method : clazz.getMethods()) {
+            if (matchesSetter(method, setterName)) return method;
+        }
+        for (Method method : clazz.getDeclaredMethods()) {
+            if (matchesSetter(method, setterName)) return method;
+        }
+        return null;
+    }
+
+    private static boolean matchesSetter(Method method, String setterName) {
+        return method.getName().equals(setterName) && method.getParameterCount() == 1;
+    }
+
+    // e.g. bar -> setBar
+    private static @NotNull String getSetterName(String prop) {
+        if (prop == null || prop.isEmpty()) {
+            throw new IllegalArgumentException("Property name cannot be null or empty");
+        }
+        return "set" + Character.toUpperCase(prop.charAt(0)) + prop.substring(1);
+    }
+
+    private Field findField(Class<?> clazz, String name) {
+        Class<?> c = clazz;
+        while (c != null && c != Object.class) {
+            try {
+                return c.getDeclaredField(name);
+            } catch (NoSuchFieldException ignored) {
+                c = c.getSuperclass();
+            }
+        }
+        return null;
+    }
+
+    private Object resolveValueOrRef(Class<?> targetType, String value, String ref) {
+        if (ref != null && !ref.isBlank()) {
+            Object o = registry.resolveReference(ref);
+            if (o != null && !targetType.isInstance(o)) {
+                if (!(targetType.isPrimitive() && isWrapperOfPrimitive(targetType, o.getClass()))) {
+                    throw new IllegalArgumentException("Ref '%s' is not assignable to %s".formatted(ref, targetType.getName()));
+                }
+            }
+            return o;
+        }
+        return ReflectionUtil.convert(value, targetType);
+    }
+}