feat(dependency-injection): add toOverriding and asAllInterfaces binding API improvements (#31)

deer · web-flow · commit a0fbb031d766 · 2026-04-13T14:04:02.000+02:00
diff --git a/dependency-injection/src/main/java/build/codemodel/injection/BindingBuilder.java b/dependency-injection/src/main/java/build/codemodel/injection/BindingBuilder.java
@@ -9,9 +9,9 @@
  * 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.
@@ -25,6 +25,7 @@
 import jakarta.inject.Qualifier;
 
 import java.lang.annotation.Annotation;
+import java.util.function.Predicate;
 import java.util.function.Supplier;
 
 /**
@@ -96,4 +97,69 @@ public interface BindingBuilder<T> {
      * @return this {@link BindingBuilder} to permit fluent-style method invocation
      */
     BindingBuilder<T> with(AnnotationTypeUsage qualifier);
+
+    /**
+     * Replaces an existing {@link Binding} for this type with the specified value, or registers a new
+     * {@link Binding} if none exists. Unlike {@link #to(Object)}, this does not throw
+     * {@link BindingAlreadyExistsException} when a binding is already registered.
+     *
+     * @param value the value
+     * @return the newly registered {@link Binding}
+     */
+    default Binding<T> toOverriding(final T value) {
+        throw new UnsupportedOperationException("toOverriding is not supported by this BindingBuilder");
+    }
+
+    /**
+     * Replaces an existing {@link Binding} for this type with an instance of the specified concrete
+     * {@link Class}, or registers a new {@link Binding} if none exists.
+     *
+     * @param implementationClass the concrete {@link Class} to bind
+     * @return the newly registered {@link Binding}
+     */
+    default Binding<T> toOverriding(final Class<? extends T> implementationClass) {
+        throw new UnsupportedOperationException("toOverriding is not supported by this BindingBuilder");
+    }
+
+    /**
+     * Replaces an existing {@link Binding} for this type with the specified {@link Supplier}, or registers
+     * a new {@link Binding} if none exists.
+     *
+     * @param supplier the {@link Supplier}
+     * @return the newly registered {@link Binding}
+     */
+    default Binding<T> toOverriding(final Supplier<T> supplier) {
+        throw new UnsupportedOperationException("toOverriding is not supported by this BindingBuilder");
+    }
+
+    /**
+     * Registers a {@link Binding} of the bound value to each non-{@code java.*} interface in its type
+     * hierarchy. Equivalent to calling {@link #asAllInterfaces(Predicate)} with a filter that excludes
+     * interfaces whose package name starts with {@code "java."}.
+     *
+     * <p>Example:
+     * <pre>{@code
+     * context.bind(myService).asAllInterfaces();
+     * // equivalent to registering bind(ServiceInterface.class).to(myService) for every user interface
+     * }</pre>
+     *
+     * @throws UnsupportedOperationException if called on a builder that was not created via
+     *                                       {@link Context#bind(Object)}
+     */
+    default void asAllInterfaces() {
+        throw new UnsupportedOperationException("asAllInterfaces is not supported by this BindingBuilder");
+    }
+
+    /**
+     * Registers a {@link Binding} of the bound value to each interface in its type hierarchy that matches
+     * the supplied {@link Predicate}.
+     *
+     * @param filter a {@link Predicate} applied to each interface {@link Class}; only matching interfaces
+     *               are bound
+     * @throws UnsupportedOperationException if called on a builder that was not created via
+     *                                       {@link Context#bind(Object)}
+     */
+    default void asAllInterfaces(final Predicate<Class<?>> filter) {
+        throw new UnsupportedOperationException("asAllInterfaces is not supported by this BindingBuilder");
+    }
 }
diff --git a/dependency-injection/src/main/java/build/codemodel/injection/Context.java b/dependency-injection/src/main/java/build/codemodel/injection/Context.java
@@ -9,9 +9,9 @@
  * 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.
@@ -25,6 +25,7 @@
 
 import java.util.function.BiFunction;
 import java.util.function.Function;
+import java.util.function.Predicate;
 
 /**
  * An {@link Injector} that manages zero or more {@link Binding}s to be used for injection into {@link InjectionPoint}s.
@@ -51,6 +52,22 @@
 public interface Context
     extends Injector, Binder {
 
+    /**
+     * Creates a {@link BindingBuilder} pre-loaded with the specified instance value, enabling
+     * {@link BindingBuilder#asAllInterfaces()} and {@link BindingBuilder#asAllInterfaces(Predicate)} to
+     * register the value against every interface in its type hierarchy in a single call.
+     *
+     * <p>Example:
+     * <pre>{@code
+     * context.bind(myService).asAllInterfaces();
+     * }</pre>
+     *
+     * @param <T>   the type of the instance
+     * @param value the instance to bind
+     * @return a {@link BindingBuilder} loaded with the value
+     */
+    <T> BindingBuilder<T> bind(T value);
+
     /**
      * Creates an instance of the specified class by locating and injecting a constructor annotated
      * with {@link Inject} with values resolved from the {@link Context}.  Should an injectable
diff --git a/dependency-injection/src/main/java/build/codemodel/injection/InjectionContext.java b/dependency-injection/src/main/java/build/codemodel/injection/InjectionContext.java
@@ -32,13 +32,15 @@
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.IdentityHashMap;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.function.BiFunction;
+import java.util.function.Predicate;
 import java.util.function.Supplier;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
@@ -154,6 +156,36 @@ public Binding<T> to(final Supplier<T> supplier) {
 
                 return addBinding(dependency, new SupplierBinding<>(dependency, supplier));
             }
+
+            @Override
+            public Binding<T> toOverriding(final T value) {
+                final var dependency = IndependentDependency.of(
+                    typeUsage,
+                    this.injectionFramework::getQualifierAnnotationTypes);
+                return replaceBinding(dependency, SingletonValueBinding.of(dependency, value));
+            }
+
+            @Override
+            public Binding<T> toOverriding(final Class<? extends T> concreteClass) {
+                Objects.requireNonNull(concreteClass, "The Binding Value Class must not be null");
+                final var dependency = IndependentDependency.of(
+                    typeUsage,
+                    this.injectionFramework::getQualifierAnnotationTypes);
+                final var typeDescriptor = codeModel.getJDKTypeDescriptor(concreteClass)
+                    .orElseThrow(() -> new IllegalArgumentException(
+                        "Could not resolve a TypeDescriptor for " + concreteClass));
+                return replaceBinding(dependency, this.injectionFramework.isSingleton(typeDescriptor)
+                    ? new LazySingletonClassBinding<>(dependency, concreteClass)
+                    : new NonSingletonClassBinding<T>(dependency, concreteClass));
+            }
+
+            @Override
+            public Binding<T> toOverriding(final Supplier<T> supplier) {
+                final var dependency = IndependentDependency.of(
+                    typeUsage,
+                    this.injectionFramework::getQualifierAnnotationTypes);
+                return replaceBinding(dependency, new SupplierBinding<>(dependency, supplier));
+            }
         };
     }
 
@@ -175,6 +207,96 @@ private <T> Binding<T> addBinding(final Dependency dependency, final Binding<T>
         return binding;
     }
 
+    /**
+     * Replaces or adds the specified {@link Dependency} {@link Binding} without throwing when a binding
+     * already exists.
+     *
+     * @param dependency the {@link Dependency}
+     * @param binding    the {@link Binding}
+     * @return the {@link Binding} that was registered
+     */
+    private <T> Binding<T> replaceBinding(final Dependency dependency, final Binding<T> binding) {
+        this.bindingsByDependency.put(dependency, binding);
+        return binding;
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public <T> BindingBuilder<T> bind(final T value) {
+        Objects.requireNonNull(value, "The value must not be null");
+
+        final var codeModel = this.injectionFramework.codeModel();
+        final var type = (Class<T>) value.getClass();
+        final var typeUsage = codeModel.getTypeUsage(type);
+
+        return new AbstractBindingBuilder<>(this.injectionFramework, typeUsage) {
+            @Override
+            public Binding<T> to(final T v) {
+                final var dependency = IndependentDependency.of(
+                    typeUsage,
+                    this.injectionFramework::getQualifierAnnotationTypes);
+                return addBinding(dependency, SingletonValueBinding.of(dependency, v));
+            }
+
+            @Override
+            public Binding<T> to(final Class<? extends T> concreteClass) {
+                Objects.requireNonNull(concreteClass, "The Binding Value Class must not be null");
+                final var dependency = IndependentDependency.of(
+                    typeUsage,
+                    this.injectionFramework::getQualifierAnnotationTypes);
+                final var typeDescriptor = codeModel.getJDKTypeDescriptor(concreteClass)
+                    .orElseThrow(() -> new IllegalArgumentException(
+                        "Could not resolve a TypeDescriptor for " + concreteClass));
+                return addBinding(dependency, this.injectionFramework.isSingleton(typeDescriptor)
+                    ? new LazySingletonClassBinding<>(dependency, concreteClass)
+                    : new NonSingletonClassBinding<>(dependency, concreteClass));
+            }
+
+            @Override
+            public Binding<T> to(final Supplier<T> supplier) {
+                final var dependency = IndependentDependency.of(
+                    typeUsage,
+                    this.injectionFramework::getQualifierAnnotationTypes);
+                return addBinding(dependency, new SupplierBinding<>(dependency, supplier));
+            }
+
+            @Override
+            public void asAllInterfaces() {
+                asAllInterfaces(iface -> !iface.getPackageName().startsWith("java."));
+            }
+
+            @Override
+            @SuppressWarnings({"unchecked", "rawtypes"})
+            public void asAllInterfaces(final Predicate<Class<?>> filter) {
+                Objects.requireNonNull(filter, "The filter must not be null");
+                collectInterfaces(type, new LinkedHashSet<>())
+                    .stream()
+                    .filter(filter)
+                    .forEach(iface -> InjectionContext.this.bind((Class) iface).to(value));
+            }
+        };
+    }
+
+    /**
+     * Collects all interfaces from the type hierarchy of the given class, including inherited ones,
+     * into the provided accumulator set.
+     *
+     * @param type   the class to walk
+     * @param result the set to accumulate interfaces into
+     * @return the same set, populated
+     */
+    private static Set<Class<?>> collectInterfaces(final Class<?> type, final Set<Class<?>> result) {
+        if (type == null || type == Object.class) {
+            return result;
+        }
+        for (final Class<?> iface : type.getInterfaces()) {
+            result.add(iface);
+            collectInterfaces(iface, result);
+        }
+        collectInterfaces(type.getSuperclass(), result);
+        return result;
+    }
+
     @Override
     @SuppressWarnings("unchecked")
     public <T> MultiBinder<T> bindSet(final Class<T> type) {
diff --git a/dependency-injection/src/main/java/build/codemodel/injection/Modules.java b/dependency-injection/src/main/java/build/codemodel/injection/Modules.java
@@ -89,15 +89,9 @@ public <T> MultiBinder<T> bindSet(final Class<T> type) {
      *
      * @param <T> the type being bound
      */
-    private static class SuppressingBindingBuilder<T>
+    private record SuppressingBindingBuilder<T>(BindingBuilder<T> delegate)
         implements BindingBuilder<T> {
 
-        private final BindingBuilder<T> delegate;
-
-        SuppressingBindingBuilder(final BindingBuilder<T> delegate) {
-            this.delegate = delegate;
-        }
-
         @Override
         public Binding<T> to(final T value) {
             try {
@@ -125,6 +119,21 @@ public Binding<T> to(final Supplier<T> supplier) {
             }
         }
 
+        @Override
+        public Binding<T> toOverriding(final T value) {
+            return this.delegate.toOverriding(value);
+        }
+
+        @Override
+        public Binding<T> toOverriding(final Class<? extends T> implementationClass) {
+            return this.delegate.toOverriding(implementationClass);
+        }
+
+        @Override
+        public Binding<T> toOverriding(final Supplier<T> supplier) {
+            return this.delegate.toOverriding(supplier);
+        }
+
         @Override
         public BindingBuilder<T> as(final String name) {
             this.delegate.as(name);
diff --git a/dependency-injection/src/test/java/build/codemodel/injection/BindingApiImprovementTests.java b/dependency-injection/src/test/java/build/codemodel/injection/BindingApiImprovementTests.java
