You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@juneau.apache.org by ja...@apache.org on 2026/05/07 19:10:25 UTC
(juneau) branch master updated: refactor: rename BeanCreator2 to BeanInstantiator, add BeanStore.createBeanFromMethod() API
This is an automated email from the ASF dual-hosted git repository.
jamesbognar pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/juneau.git
The following commit(s) were added to refs/heads/master by this push:
new 3f9ad97f0a refactor: rename BeanCreator2 to BeanInstantiator, add BeanStore.createBeanFromMethod() API
3f9ad97f0a is described below
commit 3f9ad97f0a1aaffe0df31065081445ad0f7318a5
Author: James Bognar <ja...@jamesbog-ltmjqf2.internal.salesforce.com>
AuthorDate: Thu May 7 15:10:14 2026 -0400
refactor: rename BeanCreator2 to BeanInstantiator, add BeanStore.createBeanFromMethod() API
---
.../juneau/commons/inject/BasicBeanStore2.java | 40 +++++++++
.../commons/inject/BeanCreationException.java | 62 ++++++++++++++
.../{BeanCreator2.java => BeanInstantiator.java} | 92 ++++++++++-----------
.../apache/juneau/commons/inject/BeanStore.java | 76 ++++++++++++++++-
.../juneau/commons/inject/CreatableBeanStore.java | 50 +++++------
.../java/org/apache/juneau/cp/BeanCreator.java | 5 +-
...eator2_Test.java => BeanInstantiator_Test.java} | 96 +++++++++++-----------
todo/TODO-14-move-svl-to-commons.md | 2 +-
todo/TODO-15-replace-basicbeanstore-with-v2.md | 70 +++++++++++-----
todo/TODO-23-commons-inject-framework-roadmap.md | 2 +-
todo/TODO-24-jsr330-and-spring-lite-support.md | 4 +-
11 files changed, 353 insertions(+), 146 deletions(-)
diff --git a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/inject/BasicBeanStore2.java b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/inject/BasicBeanStore2.java
index 1c5fed3531..b82e548e39 100644
--- a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/inject/BasicBeanStore2.java
+++ b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/inject/BasicBeanStore2.java
@@ -16,6 +16,7 @@
*/
package org.apache.juneau.commons.inject;
+import static org.apache.juneau.commons.reflect.ReflectionUtils.*;
import static org.apache.juneau.commons.utils.CollectionUtils.*;
import static org.apache.juneau.commons.utils.Utils.*;
@@ -24,6 +25,7 @@ import java.util.concurrent.*;
import java.util.function.*;
import org.apache.juneau.commons.collections.*;
+import org.apache.juneau.commons.reflect.*;
/**
* Basic implementation of {@link WritableBeanStore}.
@@ -428,6 +430,44 @@ public class BasicBeanStore2 implements WritableBeanStore {
return resolve(beanType, name);
}
+ /**
+ * Finds and invokes a factory method that produces a bean of type <c>beanType</c>.
+ *
+ * <p>
+ * If <c>onClassOrObject</c> is a {@link Class}, only static methods are eligible.
+ * Otherwise, both instance and static methods on the object's class are eligible.
+ * A <jk>null</jk> <c>filter</c> accepts any qualifying method.
+ *
+ * @param <T> The bean type.
+ * @param beanType The type of bean to create. Must not be <jk>null</jk>.
+ * @param onClassOrObject The object instance or {@link Class} whose public methods are searched.
+ * Must not be <jk>null</jk>.
+ * @param filter Optional predicate restricting which methods are eligible. Can be <jk>null</jk>.
+ * @param extraBeans Optional bean instances visible to parameter resolution for this call only.
+ * @return The created bean wrapped in an {@link Optional}, or {@link Optional#empty()} if no matching
+ * factory method was found.
+ * @throws BeanCreationException If a matching method was found but threw an exception during invocation.
+ */
+ @Override
+ public <T> Optional<T> createBeanFromMethod(Class<T> beanType, Object onClassOrObject, Predicate<MethodInfo> filter, Object... extraBeans) {
+ Object resource = onClassOrObject instanceof Class ? null : onClassOrObject;
+ Class<?> resourceClass = onClassOrObject instanceof Class<?> c ? c : onClassOrObject.getClass();
+ return info(resourceClass)
+ .getPublicMethod(m ->
+ m.isNotDeprecated()
+ && m.hasReturnType(beanType)
+ && (filter == null || filter.test(m))
+ && (m.isStatic() || nn(resource))
+ && m.canResolveAllParameters(this, extraBeans))
+ .map(m -> {
+ try {
+ return m.<T>inject(this, resource, extraBeans);
+ } catch (Exception e) {
+ throw new BeanCreationException("Failed to create bean of type [" + beanType.getSimpleName() + "] via method [" + m.getName() + "]", e);
+ }
+ });
+ }
+
@Override /* Overridden from Object */
public String toString() {
return r(properties());
diff --git a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/inject/BeanCreationException.java b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/inject/BeanCreationException.java
new file mode 100644
index 0000000000..d1e3d31bd4
--- /dev/null
+++ b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/inject/BeanCreationException.java
@@ -0,0 +1,62 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.juneau.commons.inject;
+
+/**
+ * Unchecked exception thrown when a bean creator method is found but its invocation fails.
+ *
+ * <p>
+ * Thrown by {@link BeanStore#createBeanFromMethod(Class, Object, java.util.function.Predicate, Object[])} when a matching
+ * factory method is located but throws an exception during invocation. Wrapping in an unchecked type makes
+ * the exception compatible with {@link java.util.Optional} chaining and lambda contexts.
+ *
+ * <h5 class='section'>See Also:</h5><ul>
+ * <li class='jm'>{@link BeanStore#createBeanFromMethod(Class, Object, java.util.function.Predicate, Object[])}
+ * </ul>
+ */
+public class BeanCreationException extends RuntimeException {
+
+ private static final long serialVersionUID = 1L;
+
+ /**
+ * Constructor.
+ *
+ * @param message The detail message.
+ */
+ public BeanCreationException(String message) {
+ super(message);
+ }
+
+ /**
+ * Constructor.
+ *
+ * @param message The detail message.
+ * @param cause The cause.
+ */
+ public BeanCreationException(String message, Throwable cause) {
+ super(message, cause);
+ }
+
+ /**
+ * Constructor.
+ *
+ * @param cause The cause.
+ */
+ public BeanCreationException(Throwable cause) {
+ super(cause);
+ }
+}
diff --git a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/inject/BeanCreator2.java b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/inject/BeanInstantiator.java
similarity index 95%
rename from juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/inject/BeanCreator2.java
rename to juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/inject/BeanInstantiator.java
index a260c2eecf..0bae47ad75 100644
--- a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/inject/BeanCreator2.java
+++ b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/inject/BeanInstantiator.java
@@ -43,7 +43,7 @@ import org.apache.juneau.commons.reflect.*;
* <p>
* This class is instantiated through the following method:
* <ul class='javatree'>
- * <li class='jm'>{@link BeanCreator2#of(Class)}
+ * <li class='jm'>{@link BeanInstantiator#of(Class)}
* </ul>
*
* <h5 class='section'>Example:</h5>
@@ -99,8 +99,8 @@ import org.apache.juneau.commons.reflect.*;
* }
* }
*
- * <jc>// Create bean using BeanCreator2</jc>
- * MyBean <jv>bean</jv> = BeanCreator2
+ * <jc>// Create bean using BeanInstantiator</jc>
+ * MyBean <jv>bean</jv> = BeanInstantiator
* .<jsm>of</jsm>(MyBean.<jk>class</jk>, <jv>myBeanStore</jv>)
* .run();
* </p>
@@ -186,7 +186,7 @@ import org.apache.juneau.commons.reflect.*;
@SuppressWarnings({
"java:S115" // Constants use UPPER_snakeCase convention
})
-public class BeanCreator2<T> {
+public class BeanInstantiator<T> {
private static final String CLASSNAME_Autowired = "Autowired";
private static final String CLASSNAME_Inject = "Inject";
@@ -219,8 +219,8 @@ public class BeanCreator2<T> {
* @param beanType The bean type to create.
* @return A new bean creator.
*/
- public static <T> BeanCreator2<T> of(Class<T> beanType) {
- return new BeanCreator2<>(beanType, null, null, null);
+ public static <T> BeanInstantiator<T> of(Class<T> beanType) {
+ return new BeanInstantiator<>(beanType, null, null, null);
}
/**
@@ -231,8 +231,8 @@ public class BeanCreator2<T> {
* @param parentStore The parent bean store to use for resolving dependencies. Can be <jk>null</jk>.
* @return A new bean creator.
*/
- public static <T> BeanCreator2<T> of(Class<T> beanType, BeanStore parentStore) {
- return new BeanCreator2<>(beanType, parentStore, null, null);
+ public static <T> BeanInstantiator<T> of(Class<T> beanType, BeanStore parentStore) {
+ return new BeanInstantiator<>(beanType, parentStore, null, null);
}
/**
@@ -245,8 +245,8 @@ public class BeanCreator2<T> {
* @param enclosingInstance The enclosing instance object. Can be <jk>null</jk>.
* @return A new bean creator.
*/
- public static <T> BeanCreator2<T> of(Class<T> beanType, BeanStore parentStore, String name, Object enclosingInstance) {
- return new BeanCreator2<>(beanType, parentStore, name, enclosingInstance);
+ public static <T> BeanInstantiator<T> of(Class<T> beanType, BeanStore parentStore, String name, Object enclosingInstance) {
+ return new BeanInstantiator<>(beanType, parentStore, name, enclosingInstance);
}
private final BeanStore parentStore;
@@ -254,7 +254,7 @@ public class BeanCreator2<T> {
private final ClassInfoTyped<T> beanType;
private final SimpleReadWriteLock lock = new SimpleReadWriteLock();
private final NullableReference<List<String>> debug = NullableReference.empty();
- private static final Logger logger = Logger.getLogger(BeanCreator2.class);
+ private static final Logger logger = Logger.getLogger(BeanInstantiator.class);
private ClassInfoTyped<? extends T> beanSubType;
private ClassInfo explicitBuilderType = null;
@@ -284,7 +284,7 @@ public class BeanCreator2<T> {
* @param name The bean name. Can be <jk>null</jk>.
* @param enclosingInstance The enclosing instance object. Can be <jk>null</jk>.
*/
- protected BeanCreator2(Class<T> beanType, BeanStore parentStore, String name, Object enclosingInstance) {
+ protected BeanInstantiator(Class<T> beanType, BeanStore parentStore, String name, Object enclosingInstance) {
this.beanType = info(assertArgNotNull(ARG_beanType, beanType));
this.beanSubType = this.beanType;
this.parentStore = parentStore;
@@ -317,7 +317,7 @@ public class BeanCreator2<T> {
* @param bean The bean instance.
* @return This object.
*/
- public <T2> BeanCreator2<T> addBean(Class<T2> type, T2 bean) {
+ public <T2> BeanInstantiator<T> addBean(Class<T2> type, T2 bean) {
try (var writeLock = lock.write()) {
store.add(type, bean);
reset();
@@ -334,7 +334,7 @@ public class BeanCreator2<T> {
* @param name The bean name. Can be <jk>null</jk> for unnamed beans.
* @return This object.
*/
- public <T2> BeanCreator2<T> addBean(Class<T2> type, T2 bean, String name) {
+ public <T2> BeanInstantiator<T> addBean(Class<T2> type, T2 bean, String name) {
try (var writeLock = lock.write()) {
store.add(type, bean, name);
reset();
@@ -369,20 +369,20 @@ public class BeanCreator2<T> {
* <h5 class='section'>Example:</h5>
* <p class='bjava'>
* <jc>// Try to create, use default if it fails</jc>
- * MyBean <jv>bean</jv> = BeanCreator2
+ * MyBean <jv>bean</jv> = BeanInstantiator
* .<jsm>of</jsm>(MyBean.<jk>class</jk>, <jv>myBeanStore</jv>)
* .asOptional()
* .orElse(<jk>new</jk> DefaultMyBean());
*
* <jc>// Chain multiple creation attempts</jc>
- * MyService <jv>service</jv> = BeanCreator2.<jsm>of</jsm>(AdvancedService.<jk>class</jk>, <jv>store</jv>)
+ * MyService <jv>service</jv> = BeanInstantiator.<jsm>of</jsm>(AdvancedService.<jk>class</jk>, <jv>store</jv>)
* .asOptional()
- * .or(() -> BeanCreator2.<jsm>of</jsm>(BasicService.<jk>class</jk>, <jv>store</jv>)
+ * .or(() -> BeanInstantiator.<jsm>of</jsm>(BasicService.<jk>class</jk>, <jv>store</jv>)
* .asOptional())
* .orElseGet(() -> <jk>new</jk> FallbackService());
*
* <jc>// Check if optional feature is available</jc>
- * Optional<OptionalFeature> <jv>feature</jv> = BeanCreator2
+ * Optional<OptionalFeature> <jv>feature</jv> = BeanInstantiator
* .<jsm>of</jsm>(OptionalFeature.<jk>class</jk>, <jv>store</jv>)
* .asOptional();
* <jk>if</jk> (<jv>feature</jv>.isPresent()) {
@@ -425,7 +425,7 @@ public class BeanCreator2<T> {
* BeanStore <jv>store</jv> = <jk>new</jk> BasicBeanStore2(<jk>null</jk>);
* <jv>store</jv>.addBean(String.<jk>class</jk>, <js>"initial"</js>);
*
- * Memoizer<MyBean> <jv>supplier</jv> = BeanCreator2
+ * Memoizer<MyBean> <jv>supplier</jv> = BeanInstantiator
* .<jsm>of</jsm>(MyBean.<jk>class</jk>, <jv>store</jv>)
* .asMemoizer();
*
@@ -471,7 +471,7 @@ public class BeanCreator2<T> {
* @return This object.
* @throws IllegalArgumentException If value is not a subclass of {@code beanType}.
*/
- public BeanCreator2<T> beanSubType(Class<? extends T> value) {
+ public BeanInstantiator<T> beanSubType(Class<? extends T> value) {
assertArgNotNull(ARG_value, value);
try (var writeLock = lock.write()) {
beanSubType = info(value);
@@ -508,7 +508,7 @@ public class BeanCreator2<T> {
* @return This object.
* @throws IllegalArgumentException If the builder type is invalid (does not have a valid build/create/get method).
*/
- public BeanCreator2<T> builder(Class<?> value) {
+ public BeanInstantiator<T> builder(Class<?> value) {
try (var writeLock = lock.write()) {
explicitBuilderType = info(assertArgNotNull(ARG_value, value));
builderType.set(explicitBuilderType);
@@ -546,7 +546,7 @@ public class BeanCreator2<T> {
* @return This object.
* @throws IllegalArgumentException If the builder instance's class is invalid (does not have a valid build/create/get method).
*/
- public BeanCreator2<T> builder(Object value) {
+ public BeanInstantiator<T> builder(Object value) {
try (var writeLock = lock.write()) {
builder(value.getClass());
explicitBuilder = assertArgNotNull(ARG_value, value);
@@ -559,7 +559,7 @@ public class BeanCreator2<T> {
* Specifies custom class names to look for when auto-detecting builder inner classes.
*
* <p>
- * By default, {@code BeanCreator2} looks for inner classes named {@code "Builder"}.
+ * By default, {@code BeanInstantiator} looks for inner classes named {@code "Builder"}.
* This method allows you to specify alternative class names.
*
* <h5 class='section'>Notes:</h5><ul>
@@ -574,7 +574,7 @@ public class BeanCreator2<T> {
* <h5 class='section'>Example:</h5>
* <p class='bjava'>
* <jc>// Support alternative builder class naming conventions</jc>
- * MyBean <jv>bean</jv> = BeanCreator2
+ * MyBean <jv>bean</jv> = BeanInstantiator
* .<jsm>of</jsm>(MyBean.<jk>class</jk>, <jv>myBeanStore</jv>)
* .builderClassNames(<js>"BuilderImpl"</js>, <js>"Factory"</js>)
* .run();
@@ -583,7 +583,7 @@ public class BeanCreator2<T> {
* @param names The builder class names to look for. Cannot be <jk>null</jk> or contain <jk>null</jk> elements.
* @return This object.
*/
- public BeanCreator2<T> builderClassNames(String... names) {
+ public BeanInstantiator<T> builderClassNames(String... names) {
try (var writeLock = lock.write()) {
builderClassNames = set(assertArgNoNulls(ARG_names, names));
reset();
@@ -595,7 +595,7 @@ public class BeanCreator2<T> {
* Specifies custom method names to look for when auto-detecting builder factory methods.
*
* <p>
- * By default, {@code BeanCreator2} looks for static methods named {@code "create"} or {@code "builder"}
+ * By default, {@code BeanInstantiator} looks for static methods named {@code "create"} or {@code "builder"}
* that return a builder type. This method allows you to specify alternative method names.
*
* <h5 class='section'>Notes:</h5><ul>
@@ -610,7 +610,7 @@ public class BeanCreator2<T> {
* <h5 class='section'>Example:</h5>
* <p class='bjava'>
* <jc>// Support alternative builder factory method naming conventions</jc>
- * MyBean <jv>bean</jv> = BeanCreator2
+ * MyBean <jv>bean</jv> = BeanInstantiator
* .<jsm>of</jsm>(MyBean.<jk>class</jk>)
* .builderMethodNames(<js>"newBuilder"</js>, <js>"instance"</js>)
.run();
@@ -619,7 +619,7 @@ public class BeanCreator2<T> {
* @param names The builder factory method names to look for. Cannot be <jk>null</jk> or contain <jk>null</jk> elements.
* @return This object.
*/
- public BeanCreator2<T> builderMethodNames(String... names) {
+ public BeanInstantiator<T> builderMethodNames(String... names) {
try (var writeLock = lock.write()) {
builderMethodNames = set(assertArgNoNulls(ARG_names, names));
reset();
@@ -631,7 +631,7 @@ public class BeanCreator2<T> {
* Specifies custom method names to look for when calling build methods on builder instances.
*
* <p>
- * By default, {@code BeanCreator2} looks for instance methods named {@code "build"}, {@code "create"}, or {@code "get"}
+ * By default, {@code BeanInstantiator} looks for instance methods named {@code "build"}, {@code "create"}, or {@code "get"}
* on the builder that return the bean type. This method allows you to specify alternative method names.
*
* <h5 class='section'>Notes:</h5><ul>
@@ -645,7 +645,7 @@ public class BeanCreator2<T> {
* <h5 class='section'>Example:</h5>
* <p class='bjava'>
* <jc>// Support alternative build method naming conventions</jc>
- * MyBean <jv>bean</jv> = BeanCreator2
+ * MyBean <jv>bean</jv> = BeanInstantiator
* .<jsm>of</jsm>(MyBean.<jk>class</jk>)
* .buildMethodNames(<js>"execute"</js>, <js>"make"</js>)
.run();
@@ -654,7 +654,7 @@ public class BeanCreator2<T> {
* @param names The build method names to look for. Cannot be <jk>null</jk> or contain <jk>null</jk> elements.
* @return This object.
*/
- public BeanCreator2<T> buildMethodNames(String... names) {
+ public BeanInstantiator<T> buildMethodNames(String... names) {
try (var writeLock = lock.write()) {
buildMethodNames = set(assertArgNoNulls(ARG_names, names));
reset();
@@ -677,7 +677,7 @@ public class BeanCreator2<T> {
* <h5 class='section'>Example:</h5>
* <p class='bjava'>
* <jc>// Enable caching mode - same instance returned on each run()</jc>
- * <jk>var</jk> <jv>creator</jv> = BeanCreator2
+ * <jk>var</jk> <jv>creator</jv> = BeanInstantiator
* .<jsm>of</jsm>(MyBean.<jk>class</jk>)
* .<jsm>cached</jsm>();
* MyBean <jv>bean1</jv> = <jv>creator</jv>.<jsm>run</jsm>();
@@ -687,7 +687,7 @@ public class BeanCreator2<T> {
*
* @return This object.
*/
- public BeanCreator2<T> cached() {
+ public BeanInstantiator<T> cached() {
try (var writeLock = lock.write()) {
cached = true;
}
@@ -749,7 +749,7 @@ public class BeanCreator2<T> {
* <h5 class='section'>Example:</h5>
* <p class='bjava'>
* <jc>// Enable debug mode</jc>
- * <jk>var</jk> <jv>creator</jv> = BeanCreator2
+ * <jk>var</jk> <jv>creator</jv> = BeanInstantiator
* .<jsm>of</jsm>(MyBean.<jk>class</jk>, <jv>store</jv>)
* .debug();
*
@@ -761,7 +761,7 @@ public class BeanCreator2<T> {
*
* @return This object.
*/
- public BeanCreator2<T> debug() {
+ public BeanInstantiator<T> debug() {
try (var writeLock = lock.write()) {
debug.set(synchronizedList(new ArrayList<>()));
}
@@ -773,7 +773,7 @@ public class BeanCreator2<T> {
* Specifies custom static factory method names to look for when creating the bean.
*
* <p>
- * By default, {@link BeanCreator2} looks for a static {@code getInstance()} method when attempting
+ * By default, {@link BeanInstantiator} looks for a static {@code getInstance()} method when attempting
* to create beans without a builder. This method allows you to specify alternative
* factory method names to support non-standard naming conventions.
*
@@ -789,7 +789,7 @@ public class BeanCreator2<T> {
* <h5 class='section'>Example:</h5>
* <p class='bjava'>
* <jc>// Support multiple factory method naming conventions</jc>
- * MyBean <jv>bean</jv> = BeanCreator2
+ * MyBean <jv>bean</jv> = BeanInstantiator
* .<jsm>of</jsm>(MyBean.<jk>class</jk>, <jv>myBeanStore</jv>)
* .factoryMethodNames(<js>"of"</js>, <js>"from"</js>, <js>"create"</js>, <js>"newInstance"</js>)
* .run();
@@ -798,7 +798,7 @@ public class BeanCreator2<T> {
* @param names The factory method names to look for. Cannot be <jk>null</jk> or contain <jk>null</jk> elements.
* @return This object.
*/
- public BeanCreator2<T> factoryMethodNames(String... names) {
+ public BeanInstantiator<T> factoryMethodNames(String... names) {
try (var writeLock = lock.write()) {
factoryMethodNames = set(assertArgNoNulls(ARG_names, names));
reset();
@@ -833,14 +833,14 @@ public class BeanCreator2<T> {
* <h5 class='section'>Example:</h5>
* <p class='bjava'>
* <jc>// Provide a default instance if creation fails</jc>
- * MyService <jv>service</jv> = BeanCreator2
+ * MyService <jv>service</jv> = BeanInstantiator
* .<jsm>of</jsm>(MyService.<jk>class</jk>, <jv>myBeanStore</jv>)
* .fallback(() -> <jk>new</jk> DefaultMyService())
* .run();
*
* <jc>// Use a pre-created instance as fallback</jc>
* MyService <jv>defaultService</jv> = <jk>new</jk> DefaultMyService();
- * MyService <jv>service2</jv> = BeanCreator2
+ * MyService <jv>service2</jv> = BeanInstantiator
* .<jsm>of</jsm>(MyService.<jk>class</jk>, <jv>myBeanStore</jv>)
* .fallback(() -> <jv>defaultService</jv>)
* .run();
@@ -849,7 +849,7 @@ public class BeanCreator2<T> {
* @param fallback The fallback supplier. Cannot be <jk>null</jk>.
* @return This object.
*/
- public BeanCreator2<T> fallback(Supplier<? extends T> fallback) {
+ public BeanInstantiator<T> fallback(Supplier<? extends T> fallback) {
assertArgNotNull(ARG_fallback, fallback);
try (var writeLock = lock.write()) {
this.fallbackSupplier = fallback;
@@ -987,7 +987,7 @@ public class BeanCreator2<T> {
*
* <h5 class='section'>Example:</h5>
* <p class='bjava'>
- * <jk>var</jk> <jv>creator</jv> = BeanCreator2.<jsm>of</jsm>(MyBean.<jk>class</jk>, <jv>store</jv>)
+ * <jk>var</jk> <jv>creator</jv> = BeanInstantiator.<jsm>of</jsm>(MyBean.<jk>class</jk>, <jv>store</jv>)
* .debug();
*
* <jk>try</jk> {
@@ -1020,7 +1020,7 @@ public class BeanCreator2<T> {
* @param value The bean implementation instance.
* @return This object.
*/
- public BeanCreator2<T> implementation(T value) {
+ public BeanInstantiator<T> implementation(T value) {
try (var writeLock = lock.write()) {
this.explicitImplementation = value;
}
@@ -1051,7 +1051,7 @@ public class BeanCreator2<T> {
* <h5 class='section'>Example:</h5>
* <p class='bjava'>
* <jc>// Register multiple post-creation hooks</jc>
- * MyService <jv>service</jv> = BeanCreator2
+ * MyService <jv>service</jv> = BeanInstantiator
* .<jsm>of</jsm>(MyService.<jk>class</jk>, <jv>myBeanStore</jv>)
* .postCreateHook(<jv>s</jv> -> <jv>s</jv>.initialize())
* .postCreateHook(<jv>s</jv> -> <jv>s</jv>.loadConfiguration())
@@ -1062,7 +1062,7 @@ public class BeanCreator2<T> {
* @param hook The post-creation hook to run after bean creation. Cannot be <jk>null</jk>.
* @return This object.
*/
- public BeanCreator2<T> postCreateHook(Consumer<T> hook) {
+ public BeanInstantiator<T> postCreateHook(Consumer<T> hook) {
assertArgNotNull(ARG_hook, hook);
try (var writeLock = lock.write()) {
postCreateHooks.add(hook);
@@ -1087,7 +1087,7 @@ public class BeanCreator2<T> {
*
* @return This object.
*/
- public BeanCreator2<T> reset() {
+ public BeanInstantiator<T> reset() {
try (var writeLock = lock.write()) {
// Only reset builder if no explicit builder instance was set
// Explicit builder instances should be preserved across resets
diff --git a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/inject/BeanStore.java b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/inject/BeanStore.java
index 1ab1109051..200857126d 100644
--- a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/inject/BeanStore.java
+++ b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/inject/BeanStore.java
@@ -17,7 +17,9 @@
package org.apache.juneau.commons.inject;
import java.util.*;
-import java.util.function.Supplier;
+import java.util.function.*;
+
+import org.apache.juneau.commons.reflect.*;
/**
* Spring-bean-like interface for looking up beans by type and name.
@@ -134,5 +136,77 @@ public interface BeanStore {
* @return The supplier, or {@link Optional#empty()} if no supplier of the specified type and name exists.
*/
<T> Optional<Supplier<T>> getBeanSupplier(Class<T> beanType, String name);
+
+ /**
+ * Finds and invokes a factory method that produces a bean of type <c>beanType</c>.
+ *
+ * <p>
+ * Scans all public methods of the resource class identified by <c>onClassOrObject</c>:
+ * <ul>
+ * <li>If <c>onClassOrObject</c> is a {@link Class}, only <jk>static</jk> methods are eligible and
+ * the instance parameter passed to the invoked method is <jk>null</jk>.
+ * <li>If <c>onClassOrObject</c> is any other object, both instance and static methods on its class are
+ * eligible, and the object itself is passed as the receiver.
+ * </ul>
+ *
+ * <p>
+ * The first method satisfying all of the following is invoked:
+ * <ol>
+ * <li>Not deprecated.
+ * <li>Return type is assignment-compatible with <c>beanType</c>.
+ * <li>Accepted by <c>filter</c> (if non-<jk>null</jk>; otherwise any method qualifies).
+ * <li>All parameters can be resolved from this store plus any <c>extraBeans</c>.
+ * </ol>
+ *
+ * <p>
+ * The default implementation returns {@link Optional#empty()}.
+ * Override in concrete stores (see {@link BasicBeanStore2}) to enable factory-method scanning.
+ *
+ * <h5 class='section'>Example:</h5>
+ * <p class='bjava'>
+ * <jc>// Filter only</jc>
+ * <jv>beanStore</jv>.createBeanFromMethod(CallLogger.<jk>class</jk>, <jv>resource</jv>,
+ * RestContext::isRestInjectMethod)
+ * .ifPresent(<jv>creator</jv>::impl);
+ *
+ * <jc>// Filter + extra bean not yet in the store</jc>
+ * <jv>beanStore</jv>.createBeanFromMethod(EncoderSet.<jk>class</jk>, <jv>resource</jv>,
+ * RestContext::isRestInjectMethod, <jv>builder</jv>)
+ * .ifPresent(<jv>x</jv> -> <jv>builder</jv>.impl(<jv>x</jv>));
+ *
+ * <jc>// No filter, no extra beans</jc>
+ * <jv>beanStore</jv>.createBeanFromMethod(CallLogger.<jk>class</jk>, <jv>resource</jv>);
+ * </p>
+ *
+ * @param <T> The bean type.
+ * @param beanType The type of bean to create. Must not be <jk>null</jk>.
+ * @param onClassOrObject The object instance or {@link Class} whose public methods are searched.
+ * Must not be <jk>null</jk>.
+ * @param filter Optional predicate restricting which methods are eligible. Can be <jk>null</jk>.
+ * @param extraBeans Optional bean instances visible to parameter resolution for this call only.
+ * These are <em>not</em> registered in the store.
+ * @return The created bean wrapped in an {@link Optional}, or {@link Optional#empty()} if no matching
+ * factory method was found.
+ * @throws BeanCreationException If a matching method was found but threw an exception during invocation.
+ * @see BeanInstantiator BeanInstantiator — for instantiating a bean from its own constructors, builders, or factory methods
+ */
+ default <T> Optional<T> createBeanFromMethod(Class<T> beanType, Object onClassOrObject, Predicate<MethodInfo> filter, Object... extraBeans) {
+ return Optional.empty();
+ }
+
+ /**
+ * Convenience overload of {@link #createBeanFromMethod(Class, Object, Predicate, Object...)} with no filter and no extra beans.
+ *
+ * @param <T> The bean type.
+ * @param beanType The type of bean to create. Must not be <jk>null</jk>.
+ * @param onClassOrObject The object instance or {@link Class} whose public methods are searched.
+ * Must not be <jk>null</jk>.
+ * @return The created bean wrapped in an {@link Optional}, or {@link Optional#empty()} if no matching
+ * factory method was found.
+ * @throws BeanCreationException If a matching method was found but threw an exception during invocation.
+ */
+ default <T> Optional<T> createBeanFromMethod(Class<T> beanType, Object onClassOrObject) {
+ return createBeanFromMethod(beanType, onClassOrObject, null);
+ }
}
diff --git a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/inject/CreatableBeanStore.java b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/inject/CreatableBeanStore.java
index 2dfef5aca3..fee680e5e6 100644
--- a/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/inject/CreatableBeanStore.java
+++ b/juneau-core/juneau-commons/src/main/java/org/apache/juneau/commons/inject/CreatableBeanStore.java
@@ -24,10 +24,10 @@ import java.util.concurrent.*;
import java.util.function.*;
/**
- * A bean store that provides convenient access to {@link BeanCreator2} instances for creating beans.
+ * A bean store that provides convenient access to {@link BeanInstantiator} instances for creating beans.
*
* <p>
- * This class extends {@link BasicBeanStore2} and adds methods to manage {@link BeanCreator2} instances
+ * This class extends {@link BasicBeanStore2} and adds methods to manage {@link BeanInstantiator} instances
* for different bean types. Creators are lazily created and cached for efficient reuse.
*
* <h5 class='section'>Example:</h5>
@@ -36,7 +36,7 @@ import java.util.function.*;
* CreatableBeanStore <jv>store</jv> = <jk>new</jk> CreatableBeanStore(<jk>null</jk>);
*
* <jc>// Get or create a creator for MyBean</jc>
- * BeanCreator2<MyBean> <jv>creator</jv> = <jv>store</jv>.getCreator(MyBean.<jk>class</jk>);
+ * BeanInstantiator<MyBean> <jv>creator</jv> = <jv>store</jv>.getCreator(MyBean.<jk>class</jk>);
*
* <jc>// Use the creator to create a bean</jc>
* MyBean <jv>bean</jv> = <jv>creator</jv>.create();
@@ -47,7 +47,7 @@ import java.util.function.*;
*
* <h5 class='section'>See Also:</h5><ul>
* <li class='jc'>{@link BasicBeanStore2}
- * <li class='jc'>{@link BeanCreator2}
+ * <li class='jc'>{@link BeanInstantiator}
* </ul>
*/
@SuppressWarnings({
@@ -58,7 +58,7 @@ public class CreatableBeanStore extends BasicBeanStore2 {
// Argument name constants for assertArgNotNull
private static final String ARG_beanType = "beanType";
- private final ConcurrentHashMap<Class<?>, BeanCreator2<?>> creators = new ConcurrentHashMap<>();
+ private final ConcurrentHashMap<Class<?>, BeanInstantiator<?>> creators = new ConcurrentHashMap<>();
private final Object enclosingInstance;
/**
@@ -79,9 +79,9 @@ public class CreatableBeanStore extends BasicBeanStore2 {
* @param beanType The bean type to create a creator for. Cannot be <jk>null</jk>.
* @return The creator that was created and stored.
*/
- public <T> BeanCreator2<T> add(Class<T> beanType) {
+ public <T> BeanInstantiator<T> add(Class<T> beanType) {
assertArgNotNull(ARG_beanType, beanType);
- var creator = BeanCreator2.of(beanType, this, null, enclosingInstance);
+ var creator = BeanInstantiator.of(beanType, this, null, enclosingInstance);
creators.put(beanType, creator);
return creator;
}
@@ -94,15 +94,15 @@ public class CreatableBeanStore extends BasicBeanStore2 {
* @param name The bean name. Can be <jk>null</jk>.
* @return The creator that was created and stored.
*/
- public <T> BeanCreator2<T> add(Class<T> beanType, String name) {
+ public <T> BeanInstantiator<T> add(Class<T> beanType, String name) {
assertArgNotNull(ARG_beanType, beanType);
- var creator = BeanCreator2.of(beanType, this, name, enclosingInstance);
+ var creator = BeanInstantiator.of(beanType, this, name, enclosingInstance);
creators.put(beanType, creator);
return creator;
}
/**
- * Creates and stores a {@link BeanCreator2} for the specified bean type.
+ * Creates and stores a {@link BeanInstantiator} for the specified bean type.
*
* <p>
* If a creator for this type already exists, it is replaced with a new one.
@@ -113,7 +113,7 @@ public class CreatableBeanStore extends BasicBeanStore2 {
* <jv>store</jv>.addCreator(MyBean.<jk>class</jk>);
*
* <jc>// Get the creator</jc>
- * BeanCreator2<MyBean> <jv>creator</jv> = <jv>store</jv>.getCreator(MyBean.<jk>class</jk>);
+ * BeanInstantiator<MyBean> <jv>creator</jv> = <jv>store</jv>.getCreator(MyBean.<jk>class</jk>);
* </p>
*
* @param <T> The bean type.
@@ -122,13 +122,13 @@ public class CreatableBeanStore extends BasicBeanStore2 {
*/
public <T> CreatableBeanStore addCreator(Class<T> beanType) {
assertArgNotNull(ARG_beanType, beanType);
- var creator = BeanCreator2.of(beanType, this, null, enclosingInstance);
+ var creator = BeanInstantiator.of(beanType, this, null, enclosingInstance);
creators.put(beanType, creator);
return this;
}
/**
- * Creates and stores a {@link BeanCreator2} for the specified bean type with a name.
+ * Creates and stores a {@link BeanInstantiator} for the specified bean type with a name.
*
* <p>
* If a creator for this type already exists, it is replaced with a new one.
@@ -139,7 +139,7 @@ public class CreatableBeanStore extends BasicBeanStore2 {
* <jv>store</jv>.addCreator(MyBean.<jk>class</jk>, <js>"myBean"</js>);
*
* <jc>// Get the creator</jc>
- * BeanCreator2<MyBean> <jv>creator</jv> = <jv>store</jv>.getCreator(MyBean.<jk>class</jk>, <js>"myBean"</js>);
+ * BeanInstantiator<MyBean> <jv>creator</jv> = <jv>store</jv>.getCreator(MyBean.<jk>class</jk>, <js>"myBean"</js>);
* </p>
*
* @param <T> The bean type.
@@ -149,13 +149,13 @@ public class CreatableBeanStore extends BasicBeanStore2 {
*/
public <T> CreatableBeanStore addCreator(Class<T> beanType, String name) {
assertArgNotNull(ARG_beanType, beanType);
- var creator = BeanCreator2.of(beanType, this, name, enclosingInstance);
+ var creator = BeanInstantiator.of(beanType, this, name, enclosingInstance);
creators.put(beanType, creator);
return this;
}
/**
- * Returns the {@link BeanCreator2} for the specified bean type, creating it if it doesn't exist.
+ * Returns the {@link BeanInstantiator} for the specified bean type, creating it if it doesn't exist.
*
* <p>
* If a creator for this type doesn't exist, a new one is created with this bean store configured
@@ -164,7 +164,7 @@ public class CreatableBeanStore extends BasicBeanStore2 {
* <h5 class='section'>Example:</h5>
* <p class='bjava'>
* <jc>// Get or create a creator</jc>
- * BeanCreator2<MyBean> <jv>creator</jv> = <jv>store</jv>.getCreator(MyBean.<jk>class</jk>);
+ * BeanInstantiator<MyBean> <jv>creator</jv> = <jv>store</jv>.getCreator(MyBean.<jk>class</jk>);
*
* <jc>// Use the creator to create a bean</jc>
* MyBean <jv>bean</jv> = <jv>creator</jv>.create();
@@ -175,15 +175,15 @@ public class CreatableBeanStore extends BasicBeanStore2 {
* @return The creator for the specified bean type. Never <jk>null</jk>.
*/
@SuppressWarnings({
- "unchecked" // Type erasure requires cast to BeanCreator2<T>
+ "unchecked" // Type erasure requires cast to BeanInstantiator<T>
})
- public <T> BeanCreator2<T> getCreator(Class<T> beanType) {
+ public <T> BeanInstantiator<T> getCreator(Class<T> beanType) {
assertArgNotNull(ARG_beanType, beanType);
- return (BeanCreator2<T>)creators.computeIfAbsent(beanType, k -> BeanCreator2.of((Class<T>)k, this, null, enclosingInstance));
+ return (BeanInstantiator<T>)creators.computeIfAbsent(beanType, k -> BeanInstantiator.of((Class<T>)k, this, null, enclosingInstance));
}
/**
- * Returns the {@link BeanCreator2} for the specified bean type with a name, creating it if it doesn't exist.
+ * Returns the {@link BeanInstantiator} for the specified bean type with a name, creating it if it doesn't exist.
*
* <p>
* If a creator for this type doesn't exist, a new one is created with this bean store configured
@@ -192,7 +192,7 @@ public class CreatableBeanStore extends BasicBeanStore2 {
* <h5 class='section'>Example:</h5>
* <p class='bjava'>
* <jc>// Get or create a creator with a name</jc>
- * BeanCreator2<MyBean> <jv>creator</jv> = <jv>store</jv>.getCreator(MyBean.<jk>class</jk>, <js>"myBean"</js>);
+ * BeanInstantiator<MyBean> <jv>creator</jv> = <jv>store</jv>.getCreator(MyBean.<jk>class</jk>, <js>"myBean"</js>);
*
* <jc>// Use the creator to create a bean</jc>
* MyBean <jv>bean</jv> = <jv>creator</jv>.create();
@@ -204,11 +204,11 @@ public class CreatableBeanStore extends BasicBeanStore2 {
* @return The creator for the specified bean type. Never <jk>null</jk>.
*/
@SuppressWarnings({
- "unchecked" // Type erasure requires cast to BeanCreator2<T>
+ "unchecked" // Type erasure requires cast to BeanInstantiator<T>
})
- public <T> BeanCreator2<T> getCreator(Class<T> beanType, String name) {
+ public <T> BeanInstantiator<T> getCreator(Class<T> beanType, String name) {
assertArgNotNull(ARG_beanType, beanType);
- return (BeanCreator2<T>)creators.computeIfAbsent(beanType, k -> BeanCreator2.of((Class<T>)k, this, name, enclosingInstance));
+ return (BeanInstantiator<T>)creators.computeIfAbsent(beanType, k -> BeanInstantiator.of((Class<T>)k, this, name, enclosingInstance));
}
/**
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/cp/BeanCreator.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/cp/BeanCreator.java
index 7467f8462f..a214543b03 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/cp/BeanCreator.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/cp/BeanCreator.java
@@ -268,7 +268,8 @@ public class BeanCreator<T> {
* @throws ExecutableException if bean could not be created and {@link #silent()} was not enabled.
*/
@SuppressWarnings({
- "java:S3776" // Cognitive complexity acceptable for bean creation with multiple creation strategies
+ "java:S3776", // Cognitive complexity acceptable for bean creation with multiple creation strategies
+ "java:S6541" // Brain Method: bean creation logic requires handling multiple strategies in sequence
})
public T run() {
@@ -343,7 +344,7 @@ public class BeanCreator<T> {
// Look for public constructor.
var constructorMatch = new Match<ConstructorInfo>();
- type.getPublicConstructors().stream().forEach(x -> {
+ type.getPublicConstructors().forEach(x -> {
found.setIfEmpty("PUBLIC_CONSTRUCTOR");
if (hasAllParams(x))
constructorMatch.add(x);
diff --git a/juneau-utest/src/test/java/org/apache/juneau/commons/inject/BeanCreator2_Test.java b/juneau-utest/src/test/java/org/apache/juneau/commons/inject/BeanInstantiator_Test.java
similarity index 97%
rename from juneau-utest/src/test/java/org/apache/juneau/commons/inject/BeanCreator2_Test.java
rename to juneau-utest/src/test/java/org/apache/juneau/commons/inject/BeanInstantiator_Test.java
index be703ce8c1..ce13e39fb0 100644
--- a/juneau-utest/src/test/java/org/apache/juneau/commons/inject/BeanCreator2_Test.java
+++ b/juneau-utest/src/test/java/org/apache/juneau/commons/inject/BeanInstantiator_Test.java
@@ -38,7 +38,7 @@ import java.util.logging.Level;
"java:S1172", // Unused parameters in tests are intentional
"java:S1186" // Empty test method intentional for framework testing
})
-class BeanCreator2_Test extends TestBase {
+class BeanInstantiator_Test extends TestBase {
private BasicBeanStore2 beanStore;
@@ -48,11 +48,11 @@ class BeanCreator2_Test extends TestBase {
}
/**
- * Helper method to create a BeanCreator2 instance with the test's beanStore.
- * Reduces repetition of BeanCreator2.of(Class, beanStore) pattern.
+ * Helper method to create a BeanInstantiator instance with the test's beanStore.
+ * Reduces repetition of BeanInstantiator.of(Class, beanStore) pattern.
*/
- private <T> BeanCreator2<T> bc(Class<T> c) {
- return BeanCreator2.of(c, beanStore);
+ private <T> BeanInstantiator<T> bc(Class<T> c) {
+ return BeanInstantiator.of(c, beanStore);
}
//====================================================================================================
@@ -950,7 +950,7 @@ class BeanCreator2_Test extends TestBase {
/**
* Tests creating a bean using builder pattern with auto-detected builder.
- * Verifies that BeanCreator2 can automatically detect and use an inner Builder class
+ * Verifies that BeanInstantiator can automatically detect and use an inner Builder class
* when no explicit builder is specified. The builder is found via the static create()
* method that returns a Builder instance, demonstrating the default builder detection mechanism.
*/
@@ -967,7 +967,7 @@ class BeanCreator2_Test extends TestBase {
/**
* Tests creating a bean using an explicitly provided builder instance.
* Verifies that when a builder instance is explicitly provided via builder(),
- * BeanCreator2 uses that instance instead of creating a new one. This allows
+ * BeanInstantiator uses that instance instead of creating a new one. This allows
* pre-configuring the builder with specific values before bean creation.
*/
@Test
@@ -987,7 +987,7 @@ class BeanCreator2_Test extends TestBase {
/**
* Tests creating a bean using builder pattern with @Builder annotation.
* Verifies that when a bean class is annotated with @Builder specifying a builder type,
- * BeanCreator2 uses that builder type instead of auto-detection. This provides explicit
+ * BeanInstantiator uses that builder type instead of auto-detection. This provides explicit
* control over which builder class to use for bean creation.
*/
@Test
@@ -1096,7 +1096,7 @@ class BeanCreator2_Test extends TestBase {
/**
* Tests creating a bean using builder with protected constructor.
- * Verifies that builders with protected constructors can be instantiated by BeanCreator2.
+ * Verifies that builders with protected constructors can be instantiated by BeanInstantiator.
* This tests the fallback mechanism that searches for protected constructors when no public
* constructor is available, enabling encapsulation while still allowing bean creation.
*/
@@ -1181,7 +1181,7 @@ class BeanCreator2_Test extends TestBase {
/**
* Tests creating a child bean using child's own builder that extends parent's builder.
* Verifies that when a child class has its own @Builder annotation pointing to a builder
- * that extends the parent's builder, BeanCreator2 uses the child's builder annotation
+ * that extends the parent's builder, BeanInstantiator uses the child's builder annotation
* (which overrides the parent's). The child's builder must override build() to return
* the child type, ensuring type safety.
*/
@@ -1274,7 +1274,7 @@ class BeanCreator2_Test extends TestBase {
/**
* Tests creating a child bean using child's own builder that extends parent's inner Builder class.
* Verifies that when a child class has its own builder that extends the parent's inner Builder class,
- * BeanCreator2 uses the child's builder. The child's builder must override build() to return the
+ * BeanInstantiator uses the child's builder. The child's builder must override build() to return the
* child type, ensuring type safety. The builder is discovered through the child class's static create() method.
*/
@Test
@@ -1329,7 +1329,7 @@ class BeanCreator2_Test extends TestBase {
/**
* Tests creating a bean using builder pattern with static builder() method (instead of create()).
- * Verifies that BeanCreator2 recognizes "builder" as a valid builder factory method name alongside
+ * Verifies that BeanInstantiator recognizes "builder" as a valid builder factory method name alongside
* the default "create" method. This supports alternative naming conventions where classes use
* builder() instead of create() to return builder instances.
*/
@@ -1405,7 +1405,7 @@ class BeanCreator2_Test extends TestBase {
/**
* Tests creating a bean using builder with create() method instead of build().
* Verifies that builders can use "create" as an alternative to "build" for the method that
- * constructs the bean. BeanCreator2 searches for build(), create(), or get() methods on builders,
+ * constructs the bean. BeanInstantiator searches for build(), create(), or get() methods on builders,
* providing flexibility in builder method naming conventions.
*/
@Test
@@ -1486,7 +1486,7 @@ class BeanCreator2_Test extends TestBase {
/**
* Tests creating a bean using builder with build() method that has parameters resolved from bean store.
- * Verifies that when a builder's build() method requires parameters, BeanCreator2 resolves them from
+ * Verifies that when a builder's build() method requires parameters, BeanInstantiator resolves them from
* the bean store via dependency injection. This enables builders to accept additional dependencies
* beyond what's stored in builder fields, providing more flexible bean construction.
*/
@@ -1533,7 +1533,7 @@ class BeanCreator2_Test extends TestBase {
/**
* Tests that deprecated constructors are ignored in favor of non-deprecated ones.
- * Verifies that when multiple constructors are available, BeanCreator2 skips deprecated ones
+ * Verifies that when multiple constructors are available, BeanInstantiator skips deprecated ones
* and prefers non-deprecated alternatives. This ensures that deprecated APIs don't interfere
* with bean creation, allowing graceful deprecation of old constructor signatures.
*/
@@ -1568,7 +1568,7 @@ class BeanCreator2_Test extends TestBase {
/**
* Tests that constructors with unresolvable parameters are ignored, falling back to no-arg constructor.
- * Verifies that BeanCreator2 skips constructors whose parameters cannot be resolved from the bean store,
+ * Verifies that BeanInstantiator skips constructors whose parameters cannot be resolved from the bean store,
* preferring constructors with resolvable or no parameters. This ensures robust bean creation even when
* some constructor signatures cannot be satisfied.
*/
@@ -1599,7 +1599,7 @@ class BeanCreator2_Test extends TestBase {
/**
* Tests creating a bean via static factory method that accepts builder when builder has no build() method.
- * Verifies that when a builder lacks build/create/get methods, BeanCreator2 falls back to static factory
+ * Verifies that when a builder lacks build/create/get methods, BeanInstantiator falls back to static factory
* methods on the bean class that accept the builder. Factory methods are preferred over constructors,
* demonstrating the priority order: builder methods > factory methods > constructors.
*/
@@ -1748,7 +1748,7 @@ class BeanCreator2_Test extends TestBase {
/**
* Tests creating a bean using builder with custom method name when no build/create/get method exists and no constructor accepts builder.
- * Verifies the final fallback mechanism where BeanCreator2 searches for any method on the builder that returns
+ * Verifies the final fallback mechanism where BeanInstantiator searches for any method on the builder that returns
* the bean type. When standard builder methods and constructors aren't available, this "anything" method search
* provides a last-resort mechanism for bean creation, demonstrating maximum flexibility in builder patterns.
*/
@@ -1806,7 +1806,7 @@ class BeanCreator2_Test extends TestBase {
/**
* Tests that invalid builders (no valid build method, no constructor accepting builder) fail validation and fall back to constructor.
* Verifies that when a builder candidate doesn't meet validation criteria (no valid build method returning bean type,
- * no constructor accepting builder), BeanCreator2 rejects it and falls back to direct constructor-based creation.
+ * no constructor accepting builder), BeanInstantiator rejects it and falls back to direct constructor-based creation.
* This ensures that invalid builder configurations don't prevent bean creation, maintaining robustness.
*/
@Test
@@ -1856,7 +1856,7 @@ class BeanCreator2_Test extends TestBase {
/**
* Tests that ExecutableException is thrown when builder fails to create bean and no fallback is provided.
* Verifies that when a builder's build() method requires unresolvable parameters and no alternative creation
- * path exists (no factory methods, no valid constructors), BeanCreator2 throws an ExecutableException.
+ * path exists (no factory methods, no valid constructors), BeanInstantiator throws an ExecutableException.
* This ensures that unresolvable builder configurations result in clear error reporting rather than silent failures.
*/
@Test
@@ -1997,11 +1997,11 @@ class BeanCreator2_Test extends TestBase {
*/
@Test
void f01_createInnerBean() {
- var outerInstance = new BeanCreator2_Test();
+ var outerInstance = new BeanInstantiator_Test();
var value = "test";
beanStore.add(String.class, value);
- var bean = BeanCreator2.of(InnerBean.class, beanStore, null, outerInstance)
+ var bean = BeanInstantiator.of(InnerBean.class, beanStore, null, outerInstance)
.run();
assertEquals(value, bean.getValue());
@@ -2178,7 +2178,7 @@ class BeanCreator2_Test extends TestBase {
}
/**
- * Tests converting BeanCreator2 to Supplier interfaces:
+ * Tests converting BeanInstantiator to Supplier interfaces:
* - asSupplier() conversion
* - asMemoizer() with caching
* - Optional-like methods on suppliers
@@ -2187,7 +2187,7 @@ class BeanCreator2_Test extends TestBase {
@Nested class H_supplierConversion extends TestBase {
/**
- * Tests converting BeanCreator2 to a Supplier.
+ * Tests converting BeanInstantiator to a Supplier.
*/
@Test
void h01_asSupplier() {
@@ -2212,7 +2212,7 @@ class BeanCreator2_Test extends TestBase {
}
/**
- * Tests converting BeanCreator2 to a Memoizer.
+ * Tests converting BeanInstantiator to a Memoizer.
*/
@Test
void h03_asMemoizer() {
@@ -2326,7 +2326,7 @@ class BeanCreator2_Test extends TestBase {
*/
@Test
void i02_beanSubTypeReturnsThis() {
- var creator = BeanCreator2.of(ParentBean.class);
+ var creator = BeanInstantiator.of(ParentBean.class);
var result = creator.beanSubType(ChildBean.class);
assertSame(creator, result);
}
@@ -2336,7 +2336,7 @@ class BeanCreator2_Test extends TestBase {
*/
@Test
void i03_addBeanReturnsThis() {
- var creator = BeanCreator2.of(SimpleBean.class);
+ var creator = BeanInstantiator.of(SimpleBean.class);
var result = creator.addBean(TestService.class, new TestService("test"));
assertSame(creator, result);
}
@@ -2346,7 +2346,7 @@ class BeanCreator2_Test extends TestBase {
*/
@Test
void i05_builderReturnsThis() {
- var creator = BeanCreator2.of(BeanWithBuilder.class);
+ var creator = BeanInstantiator.of(BeanWithBuilder.class);
var result = creator.builder(BeanWithBuilder.create());
assertSame(creator, result);
}
@@ -2356,8 +2356,8 @@ class BeanCreator2_Test extends TestBase {
*/
@Test
void i06_enclosingInstanceCanBeSetViaConstructor() {
- var outerInstance = new BeanCreator2_Test();
- var creator = BeanCreator2.of(InnerBean.class, null, null, outerInstance);
+ var outerInstance = new BeanInstantiator_Test();
+ var creator = BeanInstantiator.of(InnerBean.class, null, null, outerInstance);
// Verify creator was created successfully
assertNotNull(creator);
}
@@ -2368,7 +2368,7 @@ class BeanCreator2_Test extends TestBase {
@Test
void i07_addMethodReturnsBean() {
var service = new TestService("test");
- var creator = BeanCreator2.of(BeanWithDependencies.class);
+ var creator = BeanInstantiator.of(BeanWithDependencies.class);
var result = creator.add(TestService.class, service);
@@ -3356,7 +3356,7 @@ class BeanCreator2_Test extends TestBase {
*/
@Test
void n12_beanSubTypeNullThrows() {
- var creator = BeanCreator2.of(SimpleBean.class);
+ var creator = BeanInstantiator.of(SimpleBean.class);
assertThrows(IllegalArgumentException.class, () -> creator.beanSubType(null));
}
}
@@ -3381,7 +3381,7 @@ class BeanCreator2_Test extends TestBase {
}
/**
- * Tests that BeanCreator2.of(Class, BeanStore) can resolve dependencies from parent bean store.
+ * Tests that BeanInstantiator.of(Class, BeanStore) can resolve dependencies from parent bean store.
*/
@Test
void o02_ofWithParentStore() {
@@ -3389,7 +3389,7 @@ class BeanCreator2_Test extends TestBase {
var testService = new TestService("parent-service");
parentStore.addBean(TestService.class, testService);
- var bean = BeanCreator2.of(BeanWithDependencies.class, parentStore)
+ var bean = BeanInstantiator.of(BeanWithDependencies.class, parentStore)
.addBean(AnotherService.class, new AnotherService(42))
.run();
@@ -3398,11 +3398,11 @@ class BeanCreator2_Test extends TestBase {
}
/**
- * Tests that BeanCreator2.of(Class, null) works when no parent bean store is provided.
+ * Tests that BeanInstantiator.of(Class, null) works when no parent bean store is provided.
*/
@Test
void o03_ofWithParentStoreNull() {
- var bean = BeanCreator2.of(SimpleBean.class, null).run();
+ var bean = BeanInstantiator.of(SimpleBean.class, null).run();
assertInstanceOf(SimpleBean.class, bean);
}
@@ -3417,7 +3417,7 @@ class BeanCreator2_Test extends TestBase {
parentStore.addBean(TestService.class, parentService);
var localService = new TestService("local");
- var bean = BeanCreator2.of(BeanWithDependencies.class, parentStore)
+ var bean = BeanInstantiator.of(BeanWithDependencies.class, parentStore)
.addBean(TestService.class, localService) // Local overrides parent
.addBean(AnotherService.class, new AnotherService(42))
.run();
@@ -3465,7 +3465,7 @@ class BeanCreator2_Test extends TestBase {
*/
@Test
void p03_getNameReturnsNullWhenNotSet() {
- var creator = BeanCreator2.of(SimpleBean.class);
+ var creator = BeanInstantiator.of(SimpleBean.class);
var name = creator.getName();
assertNull(name, "getName() should return null when no name is set");
@@ -3476,7 +3476,7 @@ class BeanCreator2_Test extends TestBase {
*/
@Test
void p04_getNameReturnsSetName() {
- var creator = BeanCreator2.of(SimpleBean.class, beanStore, "myBean", null);
+ var creator = BeanInstantiator.of(SimpleBean.class, beanStore, "myBean", null);
var name = creator.getName();
assertEquals("myBean", name);
@@ -3487,7 +3487,7 @@ class BeanCreator2_Test extends TestBase {
*/
@Test
void p05_getNameReturnsNullWhenSetToNull() {
- var creator = BeanCreator2.of(SimpleBean.class, beanStore, null, null);
+ var creator = BeanInstantiator.of(SimpleBean.class, beanStore, null, null);
var name = creator.getName();
assertNull(name, "getName() should return null when name is set to null");
@@ -3645,7 +3645,7 @@ class BeanCreator2_Test extends TestBase {
*/
@Test
void p17_nameCanBeSetViaConstructor() {
- var creator = BeanCreator2.of(SimpleBean.class, null, "testBean", null);
+ var creator = BeanInstantiator.of(SimpleBean.class, null, "testBean", null);
assertEquals("testBean", creator.getName());
}
@@ -3655,7 +3655,7 @@ class BeanCreator2_Test extends TestBase {
*/
@Test
void p18_nameCanBeSetToNull() {
- var creator = BeanCreator2.of(SimpleBean.class, beanStore, null, null);
+ var creator = BeanInstantiator.of(SimpleBean.class, beanStore, null, null);
assertNull(creator.getName(), "name should allow null value");
}
@@ -3664,7 +3664,7 @@ class BeanCreator2_Test extends TestBase {
*/
@Test
void p19_nameCanBeSetViaConstructor() {
- var creator = BeanCreator2.of(SimpleBean.class, beanStore, "final", null);
+ var creator = BeanInstantiator.of(SimpleBean.class, beanStore, "final", null);
assertEquals("final", creator.getName());
}
@@ -3736,9 +3736,9 @@ class BeanCreator2_Test extends TestBase {
*/
@Test
void q01_loggingOnSimpleBeanCreation() {
- // Get the logger instance using the same method as BeanCreator2 static field
+ // Get the logger instance using the same method as BeanInstantiator static field
// This ensures we get the same cached instance
- var logger = Logger.getLogger(BeanCreator2.class);
+ var logger = Logger.getLogger(BeanInstantiator.class);
logger.setLevel(Level.FINE); // Enable FINE level logging
try (var capture = logger.captureEvents()) {
@@ -3767,7 +3767,7 @@ class BeanCreator2_Test extends TestBase {
*/
@Test
void q02_loggingOnBuilderBeanCreation() {
- var logger = Logger.getLogger(BeanCreator2.class);
+ var logger = Logger.getLogger(BeanInstantiator.class);
logger.setLevel(Level.FINE); // Enable FINE level logging
try (var capture = logger.captureEvents()) {
var bean = bc(Q02_BeanWithBuilder.class).run();
@@ -3789,7 +3789,7 @@ class BeanCreator2_Test extends TestBase {
*/
@Test
void q03_logMessagesIncludeBeanTypePrefix() {
- var logger = Logger.getLogger(BeanCreator2.class);
+ var logger = Logger.getLogger(BeanInstantiator.class);
logger.setLevel(Level.FINE); // Enable FINE level logging
try (var capture = logger.captureEvents()) {
var bean = bc(SimpleBean.class).run();
@@ -3814,7 +3814,7 @@ class BeanCreator2_Test extends TestBase {
*/
@Test
void q04_logMessagesWithFormatArguments() {
- var logger = Logger.getLogger(BeanCreator2.class);
+ var logger = Logger.getLogger(BeanInstantiator.class);
try (var capture = logger.captureEvents()) {
// Create a bean that will trigger logging with format arguments
var bean = bc(Q02_BeanWithBuilder.class).run();
diff --git a/todo/TODO-14-move-svl-to-commons.md b/todo/TODO-14-move-svl-to-commons.md
index 3e440bd426..ec1133463c 100644
--- a/todo/TODO-14-move-svl-to-commons.md
+++ b/todo/TODO-14-move-svl-to-commons.md
@@ -20,7 +20,7 @@ Relocate `org.apache.juneau.svl` (Simple Variable Language) from `juneau-marshal
- Both expose an `Optional<String>`-returning API — callers perform any type conversion themselves via `Optional.map(...)`.
- **Hard break on the package rename.** No deprecated shim classes left in `org.apache.juneau.svl.*`; callers update their imports. Acceptable because 9.5 is the designated "simple breaking changes" release.
- Marshall-side `collections.Args` and `utils.ManifestFile` are **deleted** in 9.5 — callers move to `org.apache.juneau.commons.runtime.Args` / `ManifestFile`. (No deprecation cycle; 9.5 allows the break.)
-- SVL engine (`VarResolver` / `VarResolverSession`) retargets the commons bean-store stack **after** TODO-15 renames the `*2` classes to their final names. TODO-14 never references `BasicBeanStore2` / `BeanCreator2` directly.
+- SVL engine (`VarResolver` / `VarResolverSession`) retargets the commons bean-store stack **after** TODO-15 renames the `*2` classes to their final names. TODO-14 never references `BasicBeanStore2` / `BeanInstantiator` directly.
---
diff --git a/todo/TODO-15-replace-basicbeanstore-with-v2.md b/todo/TODO-15-replace-basicbeanstore-with-v2.md
index 3e411268e9..c7bb018fa0 100644
--- a/todo/TODO-15-replace-basicbeanstore-with-v2.md
+++ b/todo/TODO-15-replace-basicbeanstore-with-v2.md
@@ -1,15 +1,26 @@
# Replace `BasicBeanStore` / `BeanCreator` with v2 equivalents
-Eliminate the legacy injection stack in `org.apache.juneau.cp` (`BasicBeanStore`, `BeanCreator`, `BeanBuilder`, `BeanCreateMethodFinder`, `ContextBeanCreator`) in favor of the rewritten classes already present in `org.apache.juneau.commons.inject` (`BasicBeanStore2`, `BeanCreator2`, `BeanStore`, `CreatableBeanStore`, etc.). Once the replacement lands, the `2` suffix is dropped and the legacy classes are removed.
+Eliminate the legacy injection stack in `org.apache.juneau.cp` (`BasicBeanStore`, `BeanCreator`, `BeanBuilder`, `BeanCreateMethodFinder`, `ContextBeanCreator`) in favor of the rewritten classes already present in `org.apache.juneau.commons.inject` (`BasicBeanStore2`, `BeanInstantiator`, `BeanStore`, `CreatableBeanStore`, etc.). Once the replacement lands, the `2` suffix is dropped from `BasicBeanStore2` (→ `BasicBeanStore`) and the legacy classes are removed. `BeanInstantiator` already h [...]
**Target release:** **9.5.0** — semi-major release permitting simple breaking changes. Hard-break migration (no deprecation cycle on the final rename).
**Sequencing:**
- **Lands before TODO-14.** TODO-14 (SVL → commons) consumes the final, un-suffixed class names produced by this TODO, so this work must complete first.
-- TODO-1 (REST server API → `BeanStore2`) — prerequisite consumer migration, folded into Phase 3 below.
+- ~~TODO-1 (REST server API → `BeanStore2`)~~ — **DONE.** `RestContext` and all rest-server memoizers now use `BasicBeanStore2` / `WritableBeanStore` directly. No `cp.BasicBeanStore` imports remain in `juneau-rest-server` source files. Legacy references in `RestInject.java` / `RestInit.java` are **Javadoc-only**.
-**Related 9.5 work that shrinks this migration's footprint:**
-- **TODO-16** — replaces `RestContext.Builder` configuration with memoized/resettable fields on `RestContext` (reference pattern: `RestContext.allowedParserOptions`). Many of the `BeanBuilder<T>` / `BasicBeanStore` consumers currently living under `juneau-rest-server` will disappear as part of that refactor, independent of this TODO. **Consumer inventory (Phase 2 below) must run after TODO-16 Phase 1–2 lands** so we aren't migrating builders that are about to be deleted.
+**Current remaining footprint (as of 2026-05-07):**
+
+| Location | Legacy symbol | Nature |
+|---|---|---|
+| `RestContext.java` | `BeanCreateMethodFinder` | 33 live call sites — the dominant remaining work |
+| `RestOpContext.java` | `BeanCreateMethodFinder` | 16 live call sites |
+| `RestInject.java`, `RestInit.java` | `cp.BasicBeanStore` | Javadoc only — trivial update |
+| `McpPage.java`, `McpTypedHandlers.java` | `cp.BasicBeanStore` | live usage in rest-server-mcp module |
+| `Name.java`, `Named.java` | `cp.BasicBeanStore` | Javadoc / annotation `@see` only |
+| `HttpPartParser.java`, `HttpPartSerializer.java` | `BeanCreateMethodFinder` | 1 reference each — likely Javadoc |
+| `BeanStore_Test.java` | `BeanCreateMethodFinder` | 2 test references |
+
+**The v2 replacement API (`BeanStore.createBeanFromMethod`) is implemented. The critical path is now migrating the 49 `BeanCreateMethodFinder` call sites in `RestContext` and `RestOpContext` to use it.**
---
@@ -23,7 +34,7 @@ Low-risk, independent of the rest of this plan. Can land in an earlier release t
- `org.apache.juneau.cp.BeanBuilder` *(consumer class `org.apache.juneau.BeanBuilder` — re-evaluate)*
- `org.apache.juneau.cp.BeanCreateMethodFinder`
- `org.apache.juneau.cp.ContextBeanCreator`
-- [ ] Do **not** use `forRemoval = true` yet — too many internal consumers still wired to these. Deletion happens in Phase 4.
+- [ ] Do **not** use `forRemoval = true` yet — remaining internal consumers still wired to these. Deletion happens in Phase 4.
---
@@ -49,29 +60,48 @@ Net new v2 surface from this decision: none. The `Builder` class simply goes awa
- [ ] **`BasicBeanStore.Void.class`** — used as an annotation-default sentinel in `@Rest.beanStore()` and `RestAnnotation`. Either:
- port a `BasicBeanStore2.Void` sentinel class, or
- redesign those annotations (e.g., treat `BasicBeanStore2.class` itself as the sentinel and interpret "equal to default" as "unset").
-- [ ] **Executable-resolution helpers** — `getMissingParams(ExecutableInfo, Object)`, `getParams(ExecutableInfo, Object)`, `hasAllParams(ExecutableInfo, Object)`. v2 provides the same capability via `MethodInfo.canResolveAllParameters(store, extras)` and `ClassInfo.inject(bean, store)`. Plan: **migrate callers to the new API** rather than adding compat methods to the store. Verify no external API exposes these three legacy methods.
+- ~~**`BeanCreateMethodFinder` → v2 equivalent**~~ — **DONE.** Replaced by `BeanStore.createBeanFromMethod(Class<T>, Object, Predicate<MethodInfo>, Object...)`. The legacy DSL pattern:
+ ```java
+ new BeanCreateMethodFinder<>(Type.class, resource, beanStore)
+ .addBean(...)
+ .find(RestContext::isRestInjectMethod)
+ .run(result -> ...);
+ ```
+ migrates to:
+ ```java
+ beanStore.createBeanFromMethod(Type.class, resource,
+ RestContext::isRestInjectMethod, extraBean)
+ .ifPresent(result -> ...);
+ ```
+ Also introduced `BeanCreationException` (unchecked) and renamed `BeanCreator2` → `BeanInstantiator` to disambiguate the two APIs.
+- [ ] **Executable-resolution helpers** — `getMissingParams(ExecutableInfo, Object)`, `getParams(ExecutableInfo, Object)`, `hasAllParams(ExecutableInfo, Object)`. Still used in `RestContext` init path. Plan: **migrate callers to the new API** rather than adding compat methods to the store. Verify no external API exposes these three legacy methods.
### Still to survey
- [ ] **`BasicBeanStore.Entry<T>`** (public/extendable entry record, exposed via protected `createEntry(...)`) — confirm no external subclassers before deleting.
-- [ ] Diff `cp.BeanCreator` vs `commons.inject.BeanCreator2` — note any legacy-only methods / behaviors that need to be ported.
-- [ ] Diff `cp.BeanCreateMethodFinder` and `cp.ContextBeanCreator` against `BeanCreator2` — confirm their functionality is subsumed; list any callers that need rewriting rather than a rename.
+- [ ] Diff `cp.BeanCreator` vs `commons.inject.BeanInstantiator` — note any legacy-only methods / behaviors that need to be ported.
+- [ ] Diff `cp.BeanCreateMethodFinder` and `cp.ContextBeanCreator` against `BeanInstantiator` — confirm their functionality is subsumed; list any callers that need rewriting rather than a rename.
- [ ] Verify SVL's needs (`VarResolver(.Builder)` / `VarResolverSession`): constructor-based `Var` instantiation, optional session bean lookup, bean-store copy semantics. Cover any gaps here before TODO-14 starts.
- [ ] Document any residual deltas (missing methods, renamed methods, behavior differences) in this file before proceeding to Phase 2.
## Phase 2 — Consumer inventory
-- [ ] Enumerate direct callers of each legacy class across all modules (`juneau-marshall`, `juneau-rest-*`, `juneau-microservice-*`, `juneau-config`, `juneau-utest`).
-- [ ] Classify each caller as:
- - **mechanical** — straightforward switch to the `*2` equivalent
- - **non-trivial** — needs an interface/adapter change (likely callers holding `BasicBeanStore` in public API)
-- [ ] List the public API surfaces that expose `BasicBeanStore` / `BeanCreator` directly (these are the hardest part — every such method is a breaking change when renamed).
+**Much of Phase 2 is already resolved.** The REST server `BasicBeanStore` migration (TODO-1) has landed, leaving only the items in the table above.
+
+Remaining inventory work:
+- [ ] Confirm the `BeanCreateMethodFinder` callers in `RestContext` (33) and `RestOpContext` (16) are all mechanical once the v2 finder API is settled.
+- [ ] Check `McpPage.java` / `McpTypedHandlers.java` in `rest-server-mcp` — likely mechanical.
+- [ ] Enumerate direct callers in `juneau-microservice-*` and `juneau-config` (not yet surveyed).
+- [ ] List any public API surfaces in `juneau-marshall` that still expose `BasicBeanStore` / `BeanCreator` (these are the hard breaking changes). `Name.java` / `Named.java` Javadoc refs are trivial.
## Phase 3 — Migrate consumers to `*2`
-- [ ] Migrate internal consumers first (no public API change, no compat risk).
-- [ ] Migrate each public API surface. Since 9.5 allows simple breaking changes, the old overloads can be **replaced** rather than overloaded — pick whichever path yields the cleaner API per case. Document any breaking signature change in the 9.5 release notes.
-- [ ] Include TODO-1 (REST server) as part of or prior to this phase.
+- ~~Settle and implement the `BeanCreateMethodFinder` → v2 replacement API~~ — **DONE.** `BeanStore.createBeanFromMethod()` is live.
+- [ ] Migrate `RestContext` and `RestOpContext` (49 `BeanCreateMethodFinder` call sites) — now mechanical.
+- [ ] Migrate `McpPage` / `McpTypedHandlers` in `rest-server-mcp`.
+- [ ] Migrate remaining `juneau-microservice-*` / `juneau-config` consumers (if any).
+- [ ] Update Javadoc-only references in `RestInject.java`, `RestInit.java`, `Name.java`, `Named.java`, `HttpPartParser.java`, `HttpPartSerializer.java`.
+- [ ] Migrate each public API surface in `juneau-marshall`. Since 9.5 allows simple breaking changes, replace rather than overload — document each signature change in the 9.5 release notes.
## Phase 4 — Cutover rename
@@ -80,9 +110,9 @@ Once nothing still references the legacy classes:
- [ ] Delete `org.apache.juneau.cp.BasicBeanStore`, `BeanCreator`, `BeanBuilder`, `BeanCreateMethodFinder`, `ContextBeanCreator`.
- [ ] Rename the commons classes in place (drop the `2` suffix):
- `BasicBeanStore2` → `BasicBeanStore`
- - `BeanCreator2` → `BeanCreator`
+ - `BeanInstantiator` — **no rename needed** (already has its final name; was `BeanCreator2`)
- (update any other `*2`-suffixed types and their references)
-- [ ] Repo-wide find/replace of remaining `BasicBeanStore2` / `BeanCreator2` references.
+- [ ] Repo-wide find/replace of remaining `BasicBeanStore2` / `BeanInstantiator` references.
- [ ] Re-run `./scripts/test.py -f`.
## Phase 5 — Cleanup
@@ -121,9 +151,9 @@ Answer these before (or early in) Phase 1. They drive the shape of the v2 classe
- b) Delete it and rewrite each surviving domain builder to hold a plain `BeanStore` reference.
- c) Replace with a minimal commons equivalent (`org.apache.juneau.commons.inject.BeanBuilder`) with a trimmed surface.
-2. **`BeanCreateMethodFinder` replacement.** Used by rest-server / context builders to locate `static Optional<T> createX(...)` factory methods. Does `BeanCreator2`'s existing method discovery cover this, or do we port a dedicated finder?
+2. ~~**`BeanCreateMethodFinder` replacement.**~~ **RESOLVED.** `BeanStore.createBeanFromMethod(Class<T>, Object, Predicate<MethodInfo>, Object...)` is the v2 equivalent. `BeanInstantiator` handles self-instantiation; `createBeanFromMethod` handles external factory-method discovery.
-3. **`ContextBeanCreator` replacement.** Thin wrapper used during `Context.Builder` initialization. Is it subsumed by `BeanCreator2`, or does it need to be ported (possibly renamed)?
+3. **`ContextBeanCreator` replacement.** Thin wrapper used during `Context.Builder` initialization. Is it subsumed by `BeanInstantiator`, or does it need to be ported (possibly renamed)?
4. **`BasicBeanStore.Void` sentinel.** Pick one of the two paths listed in Phase 1 (port `Void` vs. redesign `@Rest.beanStore()` default). Affects `@Rest` annotation processing code in rest-server.
diff --git a/todo/TODO-23-commons-inject-framework-roadmap.md b/todo/TODO-23-commons-inject-framework-roadmap.md
index 4922479b90..a1127205b1 100644
--- a/todo/TODO-23-commons-inject-framework-roadmap.md
+++ b/todo/TODO-23-commons-inject-framework-roadmap.md
@@ -14,7 +14,7 @@ Grow **`org.apache.juneau.commons.inject`** into a **small, predictable** compos
## Current baseline (inventory)
-Today the package is primarily the **bean store** stack (e.g. `BeanStore`, `WritableBeanStore`, `CreatableBeanStore`, `BasicBeanStore2`, `BeanCreator2`). Treat this document as a **wishlist / decision log**: each subsection needs a **yes/no** and **scope** before implementation.
+Today the package is primarily the **bean store** stack (e.g. `BeanStore`, `WritableBeanStore`, `CreatableBeanStore`, `BasicBeanStore2`, `BeanInstantiator`). Treat this document as a **wishlist / decision log**: each subsection needs a **yes/no** and **scope** before implementation.
---
diff --git a/todo/TODO-24-jsr330-and-spring-lite-support.md b/todo/TODO-24-jsr330-and-spring-lite-support.md
index 34c10ca28a..ecc5036df8 100644
--- a/todo/TODO-24-jsr330-and-spring-lite-support.md
+++ b/todo/TODO-24-jsr330-and-spring-lite-support.md
@@ -36,7 +36,7 @@ Make **`org.apache.juneau.commons.inject`** present a story we can summarize as:
| JSR-330 element | Juneau plan | Notes |
|------------------|------------|-------|
-| **`@Inject`** (constructor / method / field) | Provide **`org.apache.juneau.commons.inject.Inject`** with same targets and runtime retention; treat **`jakarta.inject.Inject`** / **`javax.inject.Inject`** as equivalent in lookup code. **Expose `@Inject` as a user-facing annotation** on REST resources — fields and methods on `@Rest` resources annotated `@Inject` are populated from the resource's `BeanStore` at initialization time. | Constructor injection is the primary pattern Juneau alr [...]
+| **`@Inject`** (constructor / method / field) | Provide **`org.apache.juneau.commons.inject.Inject`** with same targets and runtime retention; treat **`jakarta.inject.Inject`** / **`javax.inject.Inject`** as equivalent in lookup code. **Expose `@Inject` as a user-facing annotation** on REST resources — fields and methods on `@Rest` resources annotated `@Inject` are populated from the resource's `BeanStore` at initialization time. | Constructor injection is the primary pattern Juneau alr [...]
| **`@Named`** | Keep / move Juneau **`@Named`**; recognize **`jakarta.inject.Named`** / **`javax.inject.Named`** for both **resolution** and as **qualifier** info. | `ParameterInfo.findQualifierInternal()` is the existing template — generalize to any FQN ending in `Named` from these two packages. |
| **`@Qualifier`** (meta-annotation) | Add **`org.apache.juneau.commons.inject.Qualifier`** as a meta-annotation marker; treat **any** annotation that is itself meta-annotated with **Juneau `@Qualifier`** OR **`jakarta.inject.Qualifier`** OR **`javax.inject.Qualifier`** as a qualifier on a parameter / field. | Lookup keys: `(type, qualifier-set)`. Start by supporting **string-valued qualifiers** (mirror `@Named`) and exact-match annotation-type qualifiers; defer qualifier *attribute* equ [...]
| **`@Scope` + `@Singleton`** | Add **`org.apache.juneau.commons.inject.Singleton`** as a scope marker; recognize JSR-330 `Singleton` by FQN. | Semantics in our model: a singleton is **registered once in a `BeanStore`** and reused; no proxying, no JVM-wide singleton. Custom `@Scope` annotations are **out of scope** for v1. |
@@ -89,7 +89,7 @@ Explicitly **declined** for v1 (revisit only with a real consumer):
- `org.apache.juneau.commons.inject.Named` (and current `org.apache.juneau.annotation.Named` until/if moved)
- `jakarta.inject.Named`, `javax.inject.Named`
- any annotation meta-annotated with one of the recognized `@Qualifier` annotations.
-- [ ] Update bean-creation paths (`BeanCreator2` and equivalents) to honor `@Inject` on constructors / methods using the same FQN list.
+- [ ] Update bean-creation paths (`BeanInstantiator` and equivalents) to honor `@Inject` on constructors / methods using the same FQN list.
### Phase 4 — `Provider<T>` injection support