This is an automated email from the ASF dual-hosted git repository. mattsicker pushed a commit to branch master in repository https://gitbox.apache.org/repos/asf/logging-log4j2.git
commit cdf5d01d11c10be8851ba63650f8e23b0b33c177 Author: Matt Sicker <[email protected]> AuthorDate: Sun Oct 6 17:18:00 2019 -0500 Remove return type of bind and inject methods This adds some docs as well. Signed-off-by: Matt Sicker <[email protected]> --- .../inject/PluginConfigurationInjector.java | 5 ++-- .../plugins/visitors/PluginAttributeVisitor.java | 29 ++++++++++++---------- .../visitors/PluginBuilderAttributeVisitor.java | 26 ++++++++++++------- .../plugins/visitors/PluginElementVisitor.java | 13 +++++----- .../config/plugins/visitors/PluginNodeVisitor.java | 11 +++++--- .../plugins/visitors/PluginValueVisitor.java | 4 +-- .../plugins/bind/AbstractConfigurationBinder.java | 12 ++++++--- .../log4j/plugins/bind/ConfigurationBinder.java | 22 ++++++++++++++-- .../log4j/plugins/bind/FactoryMethodBinder.java | 3 +-- .../plugins/bind/FieldConfigurationBinder.java | 23 ++++++++--------- .../plugins/bind/MethodConfigurationBinder.java | 7 +++--- .../plugins/inject/ConfigurationInjector.java | 10 +++++++- .../plugins/inject/PluginAttributeInjector.java | 29 ++++++++++++---------- .../inject/PluginBuilderAttributeInjector.java | 26 ++++++++++++------- .../plugins/inject/PluginElementInjector.java | 13 +++++----- .../log4j/plugins/inject/PluginNodeInjector.java | 5 ++-- .../log4j/plugins/inject/PluginValueInjector.java | 4 +-- 17 files changed, 149 insertions(+), 93 deletions(-) diff --git a/log4j-core/src/main/java/org/apache/logging/log4j/core/config/plugins/inject/PluginConfigurationInjector.java b/log4j-core/src/main/java/org/apache/logging/log4j/core/config/plugins/inject/PluginConfigurationInjector.java index e16f998..f7bbf34 100644 --- a/log4j-core/src/main/java/org/apache/logging/log4j/core/config/plugins/inject/PluginConfigurationInjector.java +++ b/log4j-core/src/main/java/org/apache/logging/log4j/core/config/plugins/inject/PluginConfigurationInjector.java @@ -24,17 +24,16 @@ import org.apache.logging.log4j.plugins.inject.AbstractConfigurationInjector; public class PluginConfigurationInjector extends AbstractConfigurationInjector<PluginConfiguration, Configuration> { @Override - public Object inject(final Object target) { + public void inject(final Object factory) { if (TypeUtil.isAssignable(conversionType, configuration.getClass())) { debugLog.append("Configuration"); if (configuration.getName() != null) { debugLog.append('(').append(configuration.getName()).append(')'); } - return configurationBinder.bindObject(target, configuration); + configurationBinder.bindObject(factory, configuration); } else { LOGGER.warn("Element with type {} annotated with @PluginConfiguration is not compatible with type {}.", conversionType, configuration.getClass()); - return target; } } } diff --git a/log4j-core/src/main/java/org/apache/logging/log4j/core/config/plugins/visitors/PluginAttributeVisitor.java b/log4j-core/src/main/java/org/apache/logging/log4j/core/config/plugins/visitors/PluginAttributeVisitor.java index 538ab74..76e9c31 100644 --- a/log4j-core/src/main/java/org/apache/logging/log4j/core/config/plugins/visitors/PluginAttributeVisitor.java +++ b/log4j-core/src/main/java/org/apache/logging/log4j/core/config/plugins/visitors/PluginAttributeVisitor.java @@ -26,6 +26,7 @@ import org.apache.logging.log4j.util.Strings; import java.lang.reflect.Type; import java.util.Collections; import java.util.Map; +import java.util.Optional; import java.util.concurrent.ConcurrentHashMap; import java.util.function.Function; @@ -60,26 +61,28 @@ public class PluginAttributeVisitor extends AbstractConfigurationInjector<Plugin } @Override - public Object inject(final Object target) { - return findAndRemoveNodeAttribute() - .map(stringSubstitutionStrategy) - .map(value -> configurationBinder.bindString(target, value)) - .orElseGet(() -> injectDefaultValue(target)); + public void inject(final Object factory) { + final Optional<String> value = findAndRemoveNodeAttribute().map(stringSubstitutionStrategy); + if (value.isPresent()) { + configurationBinder.bindString(factory, value.get()); + } else { + injectDefaultValue(factory); + } } - private Object injectDefaultValue(final Object target) { + private void injectDefaultValue(final Object factory) { final Function<PluginAttribute, Object> extractor = DEFAULT_VALUE_EXTRACTORS.get(conversionType); if (extractor != null) { final Object value = extractor.apply(annotation); debugLog(value); - return configurationBinder.bindObject(target, value); - } - final String value = stringSubstitutionStrategy.apply(annotation.defaultString()); - if (Strings.isNotBlank(value)) { - debugLog(value); - return configurationBinder.bindString(target, value); + configurationBinder.bindObject(factory, value); + } else { + final String value = stringSubstitutionStrategy.apply(annotation.defaultString()); + if (Strings.isNotBlank(value)) { + debugLog(value); + configurationBinder.bindString(factory, value); + } } - return target; } private void debugLog(final Object value) { diff --git a/log4j-core/src/main/java/org/apache/logging/log4j/core/config/plugins/visitors/PluginBuilderAttributeVisitor.java b/log4j-core/src/main/java/org/apache/logging/log4j/core/config/plugins/visitors/PluginBuilderAttributeVisitor.java index 533745c..dc3aa06 100644 --- a/log4j-core/src/main/java/org/apache/logging/log4j/core/config/plugins/visitors/PluginBuilderAttributeVisitor.java +++ b/log4j-core/src/main/java/org/apache/logging/log4j/core/config/plugins/visitors/PluginBuilderAttributeVisitor.java @@ -23,20 +23,28 @@ import org.apache.logging.log4j.plugins.inject.AbstractConfigurationInjector; import org.apache.logging.log4j.util.NameUtil; import org.apache.logging.log4j.util.StringBuilders; +import java.util.Optional; + /** * @deprecated Provided for support for PluginBuilderAttribute. */ // copy of PluginBuilderAttributeInjector public class PluginBuilderAttributeVisitor extends AbstractConfigurationInjector<PluginBuilderAttribute, Configuration> { @Override - public Object inject(final Object target) { - return findAndRemoveNodeAttribute() - .map(stringSubstitutionStrategy) - .map(value -> { - String debugValue = annotation.sensitive() ? NameUtil.md5(value + getClass().getName()) : value; - StringBuilders.appendKeyDqValue(debugLog, name, debugValue); - return configurationBinder.bindString(target, value); - }) - .orElseGet(() -> configurationBinder.bindObject(target, null)); + public void inject(final Object factory) { + final Optional<String> value = findAndRemoveNodeAttribute().map(stringSubstitutionStrategy); + if (value.isPresent()) { + final String str = value.get(); + debugLog(str); + configurationBinder.bindString(factory, str); + } else { + debugLog.append(name).append("=null"); + configurationBinder.bindObject(factory, null); + } + } + + private void debugLog(final Object value) { + final Object debugValue = annotation.sensitive() ? NameUtil.md5(value + getClass().getName()) : value; + StringBuilders.appendKeyDqValue(debugLog, name, debugValue); } } \ No newline at end of file diff --git a/log4j-core/src/main/java/org/apache/logging/log4j/core/config/plugins/visitors/PluginElementVisitor.java b/log4j-core/src/main/java/org/apache/logging/log4j/core/config/plugins/visitors/PluginElementVisitor.java index 8e8d2ef..90dc00e 100644 --- a/log4j-core/src/main/java/org/apache/logging/log4j/core/config/plugins/visitors/PluginElementVisitor.java +++ b/log4j-core/src/main/java/org/apache/logging/log4j/core/config/plugins/visitors/PluginElementVisitor.java @@ -38,7 +38,7 @@ import java.util.Optional; // copy of PluginElementInjector public class PluginElementVisitor extends AbstractConfigurationInjector<PluginElement, Configuration> { @Override - public Object inject(final Object target) { + public void inject(final Object factory) { final Optional<Class<?>> componentType = getComponentType(conversionType); if (componentType.isPresent()) { final Class<?> compType = componentType.get(); @@ -61,7 +61,8 @@ public class PluginElementVisitor extends AbstractConfigurationInjector<PluginEl Object[] children = (Object[]) childObject; debugLog.append(Arrays.toString(children)).append('}'); node.getChildren().removeAll(used); - return configurationBinder.bindObject(target, children); + configurationBinder.bindObject(factory, children); + return; } else { debugLog.append(child.toString()); values.add(childObject); @@ -71,7 +72,7 @@ public class PluginElementVisitor extends AbstractConfigurationInjector<PluginEl debugLog.append('}'); if (!values.isEmpty() && !TypeUtil.isAssignable(compType, values.get(0).getClass())) { LOGGER.error("Cannot assign element {} a list of {} as it is incompatible with {}", name, values.get(0).getClass(), compType); - return null; + return; } node.getChildren().removeAll(used); // using List::toArray here would cause type mismatch later on @@ -79,17 +80,17 @@ public class PluginElementVisitor extends AbstractConfigurationInjector<PluginEl for (int i = 0; i < vals.length; i++) { vals[i] = values.get(i); } - return configurationBinder.bindObject(target, vals); + configurationBinder.bindObject(factory, vals); } else { final Optional<Node> matchingChild = node.getChildren().stream().filter(this::isRequestedNode).findAny(); if (matchingChild.isPresent()) { final Node child = matchingChild.get(); debugLog.append(child.getName()).append('(').append(child.toString()).append(')'); node.getChildren().remove(child); - return configurationBinder.bindObject(target, child.getObject()); + configurationBinder.bindObject(factory, child.getObject()); } else { debugLog.append(name).append("=null"); - return configurationBinder.bindObject(target, null); + configurationBinder.bindObject(factory, null); } } } diff --git a/log4j-core/src/main/java/org/apache/logging/log4j/core/config/plugins/visitors/PluginNodeVisitor.java b/log4j-core/src/main/java/org/apache/logging/log4j/core/config/plugins/visitors/PluginNodeVisitor.java index 3bfb7ce..f2f25f0 100644 --- a/log4j-core/src/main/java/org/apache/logging/log4j/core/config/plugins/visitors/PluginNodeVisitor.java +++ b/log4j-core/src/main/java/org/apache/logging/log4j/core/config/plugins/visitors/PluginNodeVisitor.java @@ -20,6 +20,7 @@ package org.apache.logging.log4j.core.config.plugins.visitors; import org.apache.logging.log4j.core.config.Configuration; import org.apache.logging.log4j.core.config.plugins.PluginNode; import org.apache.logging.log4j.plugins.inject.AbstractConfigurationInjector; +import org.apache.logging.log4j.plugins.util.TypeUtil; /** * @deprecated Provided to support legacy plugins. @@ -27,8 +28,12 @@ import org.apache.logging.log4j.plugins.inject.AbstractConfigurationInjector; // copy of PluginNodeInjector public class PluginNodeVisitor extends AbstractConfigurationInjector<PluginNode, Configuration> { @Override - public Object inject(final Object target) { - debugLog.append("Node=").append(node.getName()); - return configurationBinder.bindObject(target, node); + public void inject(final Object factory) { + if (TypeUtil.isAssignable(conversionType, node.getClass())) { + debugLog.append("Node=").append(node.getName()); + configurationBinder.bindObject(factory, node); + } else { + LOGGER.error("Element with type {} annotated with @PluginNode not compatible with type {}.", conversionType, node.getClass()); + } } } diff --git a/log4j-core/src/main/java/org/apache/logging/log4j/core/config/plugins/visitors/PluginValueVisitor.java b/log4j-core/src/main/java/org/apache/logging/log4j/core/config/plugins/visitors/PluginValueVisitor.java index bd7dad9..c2ba2ab 100644 --- a/log4j-core/src/main/java/org/apache/logging/log4j/core/config/plugins/visitors/PluginValueVisitor.java +++ b/log4j-core/src/main/java/org/apache/logging/log4j/core/config/plugins/visitors/PluginValueVisitor.java @@ -29,7 +29,7 @@ import org.apache.logging.log4j.util.Strings; // copy of PluginValueInjector public class PluginValueVisitor extends AbstractConfigurationInjector<PluginValue, Configuration> { @Override - public Object inject(final Object target) { + public void inject(final Object factory) { final String elementValue = node.getValue(); final String attributeValue = node.getAttributes().get(name); String rawValue = null; // if neither is specified, return null (LOG4J2-1313) @@ -45,6 +45,6 @@ public class PluginValueVisitor extends AbstractConfigurationInjector<PluginValu } final String value = stringSubstitutionStrategy.apply(rawValue); StringBuilders.appendKeyDqValue(debugLog, name, value); - return configurationBinder.bindString(target, value); + configurationBinder.bindString(factory, value); } } diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/bind/AbstractConfigurationBinder.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/bind/AbstractConfigurationBinder.java index ff0f9b7..e2a9cfc 100644 --- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/bind/AbstractConfigurationBinder.java +++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/bind/AbstractConfigurationBinder.java @@ -31,6 +31,12 @@ import java.util.Collection; import java.util.Objects; import java.util.function.Function; +/** + * Generic configuration binder for an {@link AnnotatedElement}. This provides automatic + * {@linkplain TypeConverter string conversion} and {@linkplain ConstraintValidator constraint validation} support. + * + * @param <E> element type being bound + */ public abstract class AbstractConfigurationBinder<E extends AnnotatedElement> implements ConfigurationBinder { protected static final Logger LOGGER = StatusLogger.getLogger(); @@ -48,17 +54,17 @@ public abstract class AbstractConfigurationBinder<E extends AnnotatedElement> im } @Override - public Object bindString(final Object target, final String value) { + public void bindString(final Object factory, final String value) { Object convertedValue = null; if (value != null) { final TypeConverter<?> converter = TypeConverterRegistry.getInstance().findCompatibleConverter(injectionType); try { convertedValue = converter.convert(value); } catch (final Exception e) { - LOGGER.error("Cannot convert string '{}' to type {} in option named {}. {}", value, injectionType, name, e); + throw new ConfigurationBindingException(name, value, e); } } - return bindObject(target, convertedValue); + bindObject(factory, convertedValue); } void validate(final Object value) { diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/bind/ConfigurationBinder.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/bind/ConfigurationBinder.java index bf2165d..d97075c 100644 --- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/bind/ConfigurationBinder.java +++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/bind/ConfigurationBinder.java @@ -17,8 +17,26 @@ package org.apache.logging.log4j.plugins.bind; +/** + * Strategy to bind and validate an {@linkplain org.apache.logging.log4j.plugins.inject.ConfigurationInjector injected + * configuration value} to a {@linkplain org.apache.logging.log4j.plugins.PluginFactory plugin factory}. + */ public interface ConfigurationBinder { - Object bindString(final Object target, final String value); + /** + * Binds an unparsed string value to the given factory. + * + * @param factory injection factory to bind value to + * @param value string representation of configuration value + * @throws ConfigurationBindingException if the given value is invalid + */ + void bindString(final Object factory, final String value); - Object bindObject(final Object target, final Object value); + /** + * Binds an object to the given factory. + * + * @param factory injection factory to bind value to + * @param value configuration value to bind + * @throws ConfigurationBindingException if the given value is invalid + */ + void bindObject(final Object factory, final Object value); } diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/bind/FactoryMethodBinder.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/bind/FactoryMethodBinder.java index b4ff49a..7548871 100644 --- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/bind/FactoryMethodBinder.java +++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/bind/FactoryMethodBinder.java @@ -64,12 +64,11 @@ public class FactoryMethodBinder { } @Override - public Object bindObject(final Object target, final Object value) { + public void bindObject(final Object factory, final Object value) { validate(value); if (value != null) { boundParameters.put(element, value); } - return target; } } } diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/bind/FieldConfigurationBinder.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/bind/FieldConfigurationBinder.java index bd260cc..112d759 100644 --- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/bind/FieldConfigurationBinder.java +++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/bind/FieldConfigurationBinder.java @@ -27,26 +27,25 @@ public class FieldConfigurationBinder extends AbstractConfigurationBinder<Field> } @Override - public Object bindObject(final Object target, final Object value) { - Objects.requireNonNull(target); + public void bindObject(final Object factory, final Object value) { + Objects.requireNonNull(factory); // FIXME: if we specify a default field value, @PluginAttribute's defaultType will override that if (value == null) { try { - Object defaultValue = element.get(target); + Object defaultValue = element.get(factory); validate(defaultValue); LOGGER.trace("Using default value {} for option {}", defaultValue, name); } catch (final IllegalAccessException e) { throw new ConfigurationBindingException("Unable to validate option " + name, e); } - return target; - } - validate(value); - try { - element.set(target, value); - LOGGER.trace("Using value {} for option {}", value, name); - return target; - } catch (final IllegalAccessException e) { - throw new ConfigurationBindingException(name, value, e); + } else { + validate(value); + try { + element.set(factory, value); + LOGGER.trace("Using value {} for option {}", value, name); + } catch (final IllegalAccessException e) { + throw new ConfigurationBindingException(name, value, e); + } } } diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/bind/MethodConfigurationBinder.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/bind/MethodConfigurationBinder.java index 0c3d609..0ef7f0f 100644 --- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/bind/MethodConfigurationBinder.java +++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/bind/MethodConfigurationBinder.java @@ -28,16 +28,15 @@ public class MethodConfigurationBinder extends AbstractConfigurationBinder<Metho } @Override - public Object bindObject(final Object target, final Object value) { - Objects.requireNonNull(target); + public void bindObject(final Object factory, final Object value) { + Objects.requireNonNull(factory); validate(value); try { - element.invoke(target, value); + element.invoke(factory, value); } catch (final IllegalAccessException e) { throw new ConfigurationBindingException(name, value, e); } catch (final InvocationTargetException e) { throw new ConfigurationBindingException(name, value, e.getCause()); } - return target; } } diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/inject/ConfigurationInjector.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/inject/ConfigurationInjector.java index 53daef5..f0db24d 100644 --- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/inject/ConfigurationInjector.java +++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/inject/ConfigurationInjector.java @@ -27,6 +27,14 @@ import java.lang.reflect.Type; import java.util.Optional; import java.util.function.Function; +/** + * Strategy builder for injecting configuration data into an {@link AnnotatedElement}. Configuration injection consists + * of {@linkplain ConfigurationBinder binding} a {@link Node} and configuration to an annotated element of a + * {@linkplain org.apache.logging.log4j.plugins.PluginFactory plugin factory}. + * + * @param <Ann> plugin annotation this injector uses + * @param <Cfg> configuration class + */ public interface ConfigurationInjector<Ann extends Annotation, Cfg> { static <Cfg> Optional<ConfigurationInjector<Annotation, Cfg>> forAnnotatedElement(final AnnotatedElement element) { @@ -61,5 +69,5 @@ public interface ConfigurationInjector<Ann extends Annotation, Cfg> { ConfigurationInjector<Ann, Cfg> withNode(final Node node); - Object inject(final Object target); + void inject(final Object factory); } diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/inject/PluginAttributeInjector.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/inject/PluginAttributeInjector.java index 55bcb75..af1144f 100644 --- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/inject/PluginAttributeInjector.java +++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/inject/PluginAttributeInjector.java @@ -25,6 +25,7 @@ import org.apache.logging.log4j.util.Strings; import java.lang.reflect.Type; import java.util.Collections; import java.util.Map; +import java.util.Optional; import java.util.concurrent.ConcurrentHashMap; import java.util.function.Function; @@ -55,26 +56,28 @@ public class PluginAttributeInjector extends AbstractConfigurationInjector<Plugi } @Override - public Object inject(final Object target) { - return findAndRemoveNodeAttribute() - .map(stringSubstitutionStrategy) - .map(value -> configurationBinder.bindString(target, value)) - .orElseGet(() -> injectDefaultValue(target)); + public void inject(final Object factory) { + final Optional<String> value = findAndRemoveNodeAttribute().map(stringSubstitutionStrategy); + if (value.isPresent()) { + configurationBinder.bindString(factory, value.get()); + } else { + injectDefaultValue(factory); + } } - private Object injectDefaultValue(final Object target) { + private void injectDefaultValue(final Object factory) { final Function<PluginAttribute, Object> extractor = DEFAULT_VALUE_EXTRACTORS.get(conversionType); if (extractor != null) { final Object value = extractor.apply(annotation); debugLog(value); - return configurationBinder.bindObject(target, value); - } - final String value = stringSubstitutionStrategy.apply(annotation.defaultString()); - if (Strings.isNotBlank(value)) { - debugLog(value); - return configurationBinder.bindString(target, value); + configurationBinder.bindObject(factory, value); + } else { + final String value = stringSubstitutionStrategy.apply(annotation.defaultString()); + if (Strings.isNotBlank(value)) { + debugLog(value); + configurationBinder.bindString(factory, value); + } } - return target; } private void debugLog(final Object value) { diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/inject/PluginBuilderAttributeInjector.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/inject/PluginBuilderAttributeInjector.java index 229f07d..f1d734d 100644 --- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/inject/PluginBuilderAttributeInjector.java +++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/inject/PluginBuilderAttributeInjector.java @@ -21,16 +21,24 @@ import org.apache.logging.log4j.plugins.PluginBuilderAttribute; import org.apache.logging.log4j.util.NameUtil; import org.apache.logging.log4j.util.StringBuilders; +import java.util.Optional; + public class PluginBuilderAttributeInjector extends AbstractConfigurationInjector<PluginBuilderAttribute, Object> { @Override - public Object inject(final Object target) { - return findAndRemoveNodeAttribute() - .map(stringSubstitutionStrategy) - .map(value -> { - String debugValue = annotation.sensitive() ? NameUtil.md5(value + getClass().getName()) : value; - StringBuilders.appendKeyDqValue(debugLog, name, debugValue); - return configurationBinder.bindString(target, value); - }) - .orElseGet(() -> configurationBinder.bindObject(target, null)); + public void inject(final Object factory) { + final Optional<String> value = findAndRemoveNodeAttribute().map(stringSubstitutionStrategy); + if (value.isPresent()) { + final String str = value.get(); + debugLog(str); + configurationBinder.bindString(factory, str); + } else { + debugLog.append(name).append("=null"); + configurationBinder.bindObject(factory, null); + } + } + + private void debugLog(final Object value) { + final Object debugValue = annotation.sensitive() ? NameUtil.md5(value + getClass().getName()) : value; + StringBuilders.appendKeyDqValue(debugLog, name, debugValue); } } diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/inject/PluginElementInjector.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/inject/PluginElementInjector.java index 7ad17b0..21c74be 100644 --- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/inject/PluginElementInjector.java +++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/inject/PluginElementInjector.java @@ -32,7 +32,7 @@ import java.util.Optional; public class PluginElementInjector extends AbstractConfigurationInjector<PluginElement, Object> { @Override - public Object inject(final Object target) { + public void inject(final Object factory) { final Optional<Class<?>> componentType = getComponentType(conversionType); if (componentType.isPresent()) { final Class<?> compType = componentType.get(); @@ -55,7 +55,8 @@ public class PluginElementInjector extends AbstractConfigurationInjector<PluginE Object[] children = (Object[]) childObject; debugLog.append(Arrays.toString(children)).append('}'); node.getChildren().removeAll(used); - return configurationBinder.bindObject(target, children); + configurationBinder.bindObject(factory, children); + return; } else { debugLog.append(child.toString()); values.add(childObject); @@ -65,7 +66,7 @@ public class PluginElementInjector extends AbstractConfigurationInjector<PluginE debugLog.append('}'); if (!values.isEmpty() && !TypeUtil.isAssignable(compType, values.get(0).getClass())) { LOGGER.error("Cannot assign element {} a list of {} as it is incompatible with {}", name, values.get(0).getClass(), compType); - return null; + return; } node.getChildren().removeAll(used); // using List::toArray here would cause type mismatch later on @@ -73,17 +74,17 @@ public class PluginElementInjector extends AbstractConfigurationInjector<PluginE for (int i = 0; i < vals.length; i++) { vals[i] = values.get(i); } - return configurationBinder.bindObject(target, vals); + configurationBinder.bindObject(factory, vals); } else { final Optional<Node> matchingChild = node.getChildren().stream().filter(this::isRequestedNode).findAny(); if (matchingChild.isPresent()) { final Node child = matchingChild.get(); debugLog.append(child.getName()).append('(').append(child.toString()).append(')'); node.getChildren().remove(child); - return configurationBinder.bindObject(target, child.getObject()); + configurationBinder.bindObject(factory, child.getObject()); } else { debugLog.append(name).append("=null"); - return configurationBinder.bindObject(target, null); + configurationBinder.bindObject(factory, null); } } } diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/inject/PluginNodeInjector.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/inject/PluginNodeInjector.java index b18949e..23d19ff 100644 --- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/inject/PluginNodeInjector.java +++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/inject/PluginNodeInjector.java @@ -22,13 +22,12 @@ import org.apache.logging.log4j.plugins.util.TypeUtil; public class PluginNodeInjector extends AbstractConfigurationInjector<PluginNode, Object> { @Override - public Object inject(final Object target) { + public void inject(final Object factory) { if (TypeUtil.isAssignable(conversionType, node.getClass())) { debugLog.append("Node=").append(node.getName()); - return configurationBinder.bindObject(target, node); + configurationBinder.bindObject(factory, node); } else { LOGGER.error("Element with type {} annotated with @PluginNode not compatible with type {}.", conversionType, node.getClass()); - return target; } } } diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/inject/PluginValueInjector.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/inject/PluginValueInjector.java index 31d89c0..8d4cade 100644 --- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/inject/PluginValueInjector.java +++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/inject/PluginValueInjector.java @@ -23,7 +23,7 @@ import org.apache.logging.log4j.util.Strings; public class PluginValueInjector extends AbstractConfigurationInjector<PluginValue, Object> { @Override - public Object inject(final Object target) { + public void inject(final Object factory) { final String elementValue = node.getValue(); final String attributeValue = node.getAttributes().get(name); String rawValue = null; // if neither is specified, return null (LOG4J2-1313) @@ -39,6 +39,6 @@ public class PluginValueInjector extends AbstractConfigurationInjector<PluginVal } final String value = stringSubstitutionStrategy.apply(rawValue); StringBuilders.appendKeyDqValue(debugLog, name, value); - return configurationBinder.bindString(target, value); + configurationBinder.bindString(factory, value); } }
