This is an automated email from the ASF dual-hosted git repository. mattsicker pushed a commit to branch feature/3.x/name-alias-provider in repository https://gitbox.apache.org/repos/asf/logging-log4j2.git
commit 57081b68165a1c0e76061362c14cf1a3eec09428 Author: Matt Sicker <[email protected]> AuthorDate: Thu Aug 7 14:54:30 2025 -0500 Combine extension registration into single method --- .../apache/logging/log4j/core/LoggerContext.java | 2 +- .../log4j/core/config/AbstractConfiguration.java | 2 +- .../impl/Log4jModuleReflectionPostProcessor.java | 11 ++++-- .../plugins/di/ConfigurableInstanceFactory.java | 39 ++++++++------------ .../log4j/plugins/di/DefaultInstanceFactory.java | 42 +++++++++++++++------- .../log4j/plugins/di/resolver/package-info.java | 2 +- .../di/spi/FactoryResolversPostProcessor.java | 2 +- 7 files changed, 58 insertions(+), 42 deletions(-) diff --git a/log4j-core/src/main/java/org/apache/logging/log4j/core/LoggerContext.java b/log4j-core/src/main/java/org/apache/logging/log4j/core/LoggerContext.java index 4b5d3dd0ed..e0e53e7743 100644 --- a/log4j-core/src/main/java/org/apache/logging/log4j/core/LoggerContext.java +++ b/log4j-core/src/main/java/org/apache/logging/log4j/core/LoggerContext.java @@ -139,7 +139,7 @@ public class LoggerContext extends AbstractLifeCycle ConfigurableInstanceFactoryPostProcessor::getClass, OrderedComparator.INSTANCE)) .forEachOrdered(processor -> processor.postProcessFactory(instanceFactory)); - this.instanceFactory.registerInstancePostProcessor(new LoggerContextAwarePostProcessor(this)); + this.instanceFactory.registerExtension(new LoggerContextAwarePostProcessor(this)); if (externalContext != null) { externalMap.put(EXTERNAL_CONTEXT_KEY, externalContext); } diff --git a/log4j-core/src/main/java/org/apache/logging/log4j/core/config/AbstractConfiguration.java b/log4j-core/src/main/java/org/apache/logging/log4j/core/config/AbstractConfiguration.java index 3a6271fdcc..4c332e5239 100644 --- a/log4j-core/src/main/java/org/apache/logging/log4j/core/config/AbstractConfiguration.java +++ b/log4j-core/src/main/java/org/apache/logging/log4j/core/config/AbstractConfiguration.java @@ -202,7 +202,7 @@ public abstract class AbstractConfiguration extends AbstractFilterable implement ConfigurableInstanceFactoryPostProcessor::getClass, OrderedComparator.INSTANCE)) .forEachOrdered(processor -> processor.postProcessFactory(instanceFactory)); - instanceFactory.registerInstancePostProcessor(new ConfigurationAwarePostProcessor(Lazy.weak(this))); + instanceFactory.registerExtension(new ConfigurationAwarePostProcessor(Lazy.weak(this))); componentMap.put(Configuration.CONTEXT_PROPERTIES, properties); interpolatorFactory = instanceFactory.getInstance(InterpolatorFactory.class); tempLookup = interpolatorFactory.newInterpolator(new PropertiesLookup(properties)); diff --git a/log4j-core/src/main/java/org/apache/logging/log4j/core/impl/Log4jModuleReflectionPostProcessor.java b/log4j-core/src/main/java/org/apache/logging/log4j/core/impl/Log4jModuleReflectionPostProcessor.java index 679ca32373..d6dd107dfd 100644 --- a/log4j-core/src/main/java/org/apache/logging/log4j/core/impl/Log4jModuleReflectionPostProcessor.java +++ b/log4j-core/src/main/java/org/apache/logging/log4j/core/impl/Log4jModuleReflectionPostProcessor.java @@ -18,10 +18,12 @@ package org.apache.logging.log4j.core.impl; import aQute.bnd.annotation.Resolution; import aQute.bnd.annotation.spi.ServiceProvider; +import java.lang.reflect.AccessibleObject; import org.apache.logging.log4j.plugins.Ordered; import org.apache.logging.log4j.plugins.di.ConfigurableInstanceFactory; import org.apache.logging.log4j.plugins.di.spi.ConfigurableInstanceFactoryPostProcessor; import org.apache.logging.log4j.plugins.di.spi.ReflectionAgent; +import org.jspecify.annotations.NonNull; /** * Post-processor that registers a {@link ReflectionAgent} using {@code log4j-core} as the calling context. @@ -29,9 +31,14 @@ import org.apache.logging.log4j.plugins.di.spi.ReflectionAgent; */ @Ordered(Ordered.FIRST + 100) @ServiceProvider(value = ConfigurableInstanceFactoryPostProcessor.class, resolution = Resolution.OPTIONAL) -public class Log4jModuleReflectionPostProcessor implements ConfigurableInstanceFactoryPostProcessor { +public class Log4jModuleReflectionPostProcessor implements ConfigurableInstanceFactoryPostProcessor, ReflectionAgent { @Override public void postProcessFactory(final ConfigurableInstanceFactory factory) { - factory.setReflectionAgent(object -> object.setAccessible(true)); + factory.registerExtension(this); + } + + @Override + public void makeAccessible(@NonNull AccessibleObject object) { + object.setAccessible(true); } } diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/di/ConfigurableInstanceFactory.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/di/ConfigurableInstanceFactory.java index 77f150cf01..74f0084f65 100644 --- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/di/ConfigurableInstanceFactory.java +++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/di/ConfigurableInstanceFactory.java @@ -28,7 +28,8 @@ import org.apache.logging.log4j.plugins.di.spi.ReflectionAgent; import org.apache.logging.log4j.plugins.di.spi.Scope; import org.apache.logging.log4j.plugins.internal.util.AnnotatedAnnotation; import org.apache.logging.log4j.plugins.internal.util.AnnotationUtil; -import org.apache.logging.log4j.plugins.util.OrderedComparator; +import org.apache.logging.log4j.plugins.name.AnnotatedElementAliasesProvider; +import org.apache.logging.log4j.plugins.name.AnnotatedElementNameProvider; import org.apache.logging.log4j.plugins.validation.Constraint; import org.apache.logging.log4j.plugins.validation.ConstraintValidationException; import org.apache.logging.log4j.plugins.validation.ConstraintValidator; @@ -106,23 +107,22 @@ public interface ConfigurableInstanceFactory extends InstanceFactory { void removeBinding(final Key<?> key); /** - * Registers a factory resolver. Factory resolvers are additional strategies for resolving factories for - * a key using existing bindings or other factory resolvers. These are consulted in the order that they are - * registered. + * Registers extensions for dependency injection. * - * @param resolver factory resolver to add to this instance factory - */ - void registerFactoryResolver(final FactoryResolver<?> resolver); - - /** - * Registers an instance post-processor. Instance post-processors provide hooks into the lifecycle of instance - * initialization. When multiple processors are registered, then they are invoked in the order of their - * {@link Ordered} annotations and falls back to the rules in {@link OrderedComparator}. When creating a child - * instance factory, then the child factory is created with a copy of the current registered processors. + * @param extension instance of extension to register + * @see FactoryResolver + * @see InstancePostProcessor + * @see ReflectionAgent + * @see AnnotatedElementNameProvider + * @see AnnotatedElementAliasesProvider * - * @param instancePostProcessor processor to register + * @implNote Factory resolvers are shared between parent and child {@link InstanceFactory} objects. + * Child factories inherit copies of registered {@link InstancePostProcessor} objects (which are kept in + * {@link Ordered} order), but processors added to child factories are not copied to the parent. + * Use of a custom {@link ReflectionAgent} is specific to this factory and is inherited by child factories + * unless overridden. Name and alias providers are shared by all factories. */ - void registerInstancePostProcessor(final InstancePostProcessor instancePostProcessor); + void registerExtension(final Object extension); /** * Creates a new child instance factory from this factory which uses bindings from this factory as fallback @@ -141,15 +141,6 @@ public interface ConfigurableInstanceFactory extends InstanceFactory { ConfigurableInstanceFactory newChildInstanceFactory( Supplier<PropertyEnvironment> environment, Supplier<ClassLoader> loader); - /** - * Sets the {@link ReflectionAgent} used for invoking {@link java.lang.reflect.AccessibleObject#setAccessible(boolean)} - * from an appropriate caller class. Customizing this allows for changing the base module that other modules should - * open themselves to. - * - * @param accessor accessor to use - */ - void setReflectionAgent(final ReflectionAgent accessor); - /** * Injects dependencies into the members of the provided instance. Injectable fields are set, then injectable methods are * invoked (first those with parameters, then those without parameters). diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/di/DefaultInstanceFactory.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/di/DefaultInstanceFactory.java index 4762cf172e..f7e50d1171 100644 --- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/di/DefaultInstanceFactory.java +++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/di/DefaultInstanceFactory.java @@ -26,9 +26,11 @@ import java.util.Arrays; import java.util.Collection; import java.util.Comparator; import java.util.List; +import java.util.Map; import java.util.Optional; import java.util.Set; import java.util.SortedSet; +import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentSkipListSet; import java.util.function.Supplier; import java.util.stream.Collectors; @@ -51,6 +53,8 @@ import org.apache.logging.log4j.plugins.internal.util.AnnotationUtil; import org.apache.logging.log4j.plugins.internal.util.BeanUtils; import org.apache.logging.log4j.plugins.internal.util.BindingMap; import org.apache.logging.log4j.plugins.internal.util.HierarchicalMap; +import org.apache.logging.log4j.plugins.name.AnnotatedElementAliasesProvider; +import org.apache.logging.log4j.plugins.name.AnnotatedElementNameProvider; import org.apache.logging.log4j.plugins.util.OrderedComparator; import org.apache.logging.log4j.status.StatusLogger; import org.apache.logging.log4j.util.Cast; @@ -69,6 +73,8 @@ public class DefaultInstanceFactory implements ConfigurableInstanceFactory { private final List<FactoryResolver<?>> factoryResolvers; private final SortedSet<InstancePostProcessor> instancePostProcessors = new ConcurrentSkipListSet<>( Comparator.comparing(InstancePostProcessor::getClass, OrderedComparator.INSTANCE)); + private final Map<Class<? extends Annotation>, AnnotatedElementNameProvider<?>> nameProviders; + private final Map<Class<? extends Annotation>, AnnotatedElementAliasesProvider<?>> aliasProviders; private ReflectionAgent agent = object -> object.setAccessible(true); protected DefaultInstanceFactory() { @@ -77,6 +83,8 @@ public class DefaultInstanceFactory implements ConfigurableInstanceFactory { HierarchicalMap.newRootMap(), new ArrayList<>(), List.of(), + new ConcurrentHashMap<>(), + new ConcurrentHashMap<>(), PropertyEnvironment::getGlobal, LoaderUtil::getClassLoader); } @@ -90,6 +98,8 @@ public class DefaultInstanceFactory implements ConfigurableInstanceFactory { parent.scopes.newChildMap(), parent.factoryResolvers, parent.instancePostProcessors, + parent.nameProviders, + parent.aliasProviders, environment, loader); this.agent = parent.agent; @@ -100,12 +110,16 @@ public class DefaultInstanceFactory implements ConfigurableInstanceFactory { final HierarchicalMap<Class<? extends Annotation>, Scope> scopes, final List<FactoryResolver<?>> factoryResolvers, final Collection<InstancePostProcessor> instancePostProcessors, + final Map<Class<? extends Annotation>, AnnotatedElementNameProvider<?>> nameProviders, + final Map<Class<? extends Annotation>, AnnotatedElementAliasesProvider<?>> aliasProviders, final Supplier<PropertyEnvironment> environment, final Supplier<ClassLoader> loader) { this.bindings = bindings; this.scopes = scopes; this.factoryResolvers = factoryResolvers; this.instancePostProcessors.addAll(instancePostProcessors); + this.nameProviders = nameProviders; + this.aliasProviders = aliasProviders; this.bindings.put(InjectionPoint.CURRENT_INJECTION_POINT, currentInjectionPoint::get); this.bindings.put(Key.forClass(ConfigurableInstanceFactory.class), () -> this); this.bindings.put(Key.forClass(InstanceFactory.class), () -> this); @@ -337,13 +351,22 @@ public class DefaultInstanceFactory implements ConfigurableInstanceFactory { } @Override - public void registerFactoryResolver(final FactoryResolver<?> resolver) { - factoryResolvers.add(resolver); - } - - @Override - public void registerInstancePostProcessor(final InstancePostProcessor instancePostProcessor) { - instancePostProcessors.add(instancePostProcessor); + public void registerExtension(final Object extension) { + if (extension instanceof FactoryResolver<?> factoryResolver) { + factoryResolvers.add(factoryResolver); + } + if (extension instanceof InstancePostProcessor instancePostProcessor) { + instancePostProcessors.add(instancePostProcessor); + } + if (extension instanceof ReflectionAgent reflectionAgent) { + agent = reflectionAgent; + } + if (extension instanceof AnnotatedElementNameProvider<?> nameProvider) { + nameProviders.put(nameProvider.annotationType(), nameProvider); + } + if (extension instanceof AnnotatedElementAliasesProvider<?> aliasProvider) { + aliasProviders.put(aliasProvider.annotationType(), aliasProvider); + } } @Override @@ -360,11 +383,6 @@ public class DefaultInstanceFactory implements ConfigurableInstanceFactory { return new DefaultInstanceFactory(this, environment, loader); } - @Override - public void setReflectionAgent(final ReflectionAgent accessor) { - this.agent = accessor; - } - @Override public void injectMembers(final Object instance) { injectMembers(Key.forClass(instance.getClass()), instance, DependencyChain.empty()); diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/di/resolver/package-info.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/di/resolver/package-info.java index 2de238b120..9dc2066a6b 100644 --- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/di/resolver/package-info.java +++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/di/resolver/package-info.java @@ -20,7 +20,7 @@ * org.apache.logging.log4j.plugins.di.spi.FactoryResolver#supportsKey(org.apache.logging.log4j.plugins.di.Key) * supported keys} from {@linkplain org.apache.logging.log4j.plugins.di.ConfigurableInstanceFactory existing instance * factories}. Resolvers should be - * {@linkplain org.apache.logging.log4j.plugins.di.ConfigurableInstanceFactory#registerFactoryResolver(org.apache.logging.log4j.plugins.di.spi.FactoryResolver)} + * {@linkplain org.apache.logging.log4j.plugins.di.ConfigurableInstanceFactory#registerExtension(java.lang.Object) * registered} via a {@link org.apache.logging.log4j.plugins.di.spi.ConfigurableInstanceFactoryPostProcessor * ConfigurableInstanceFactoryPostProcessor} service. */ diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/di/spi/FactoryResolversPostProcessor.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/di/spi/FactoryResolversPostProcessor.java index 7f16bfe947..cd23b3f719 100644 --- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/di/spi/FactoryResolversPostProcessor.java +++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/di/spi/FactoryResolversPostProcessor.java @@ -34,6 +34,6 @@ public abstract class FactoryResolversPostProcessor implements ConfigurableInsta @Override public final void postProcessFactory(final ConfigurableInstanceFactory factory) { - factoryResolvers.forEach(factory::registerFactoryResolver); + factoryResolvers.forEach(factory::registerExtension); } }
