You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@logging.apache.org by ma...@apache.org on 2020/03/09 00:07:46 UTC
[logging-log4j2] 02/02: Simplify InjectionFactory into Injector
This is an automated email from the ASF dual-hosted git repository.
mattsicker pushed a commit to branch mean-bean-machine
in repository https://gitbox.apache.org/repos/asf/logging-log4j2.git
commit 37e122b9c33b0a085d45cdc888383a4764553fce
Author: Matt Sicker <bo...@gmail.com>
AuthorDate: Sun Mar 8 18:58:09 2020 -0500
Simplify InjectionFactory into Injector
Signed-off-by: Matt Sicker <bo...@gmail.com>
---
.../plugins/defaults/bean/AbstractProducer.java | 11 ++-
.../plugins/defaults/bean/DefaultBeanManager.java | 6 +-
.../defaults/bean/DefaultInjectionFactory.java | 92 ----------------------
.../defaults/bean/DefaultInjectionTarget.java | 18 ++---
.../bean/DefaultInjectionTargetFactory.java | 10 +--
.../plugins/defaults/bean/DefaultInjector.java | 82 +++++++++++++++++++
.../plugins/defaults/bean/MethodProducer.java | 5 +-
.../log4j/plugins/spi/bean/InjectionFactory.java | 47 -----------
.../logging/log4j/plugins/spi/bean/Injector.java | 43 ++++++++++
.../log4j/plugins/test/BeanJUnit4Runner.java | 12 +--
10 files changed, 155 insertions(+), 171 deletions(-)
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/AbstractProducer.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/AbstractProducer.java
index b7069fb..9882f9e 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/AbstractProducer.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/AbstractProducer.java
@@ -19,11 +19,11 @@ package org.apache.logging.log4j.plugins.defaults.bean;
import org.apache.logging.log4j.plugins.spi.bean.Bean;
import org.apache.logging.log4j.plugins.spi.bean.BeanManager;
-import org.apache.logging.log4j.plugins.spi.bean.InjectionFactory;
+import org.apache.logging.log4j.plugins.spi.bean.InitializationContext;
+import org.apache.logging.log4j.plugins.spi.bean.Injector;
import org.apache.logging.log4j.plugins.spi.bean.Producer;
import org.apache.logging.log4j.plugins.spi.model.InjectionPoint;
import org.apache.logging.log4j.plugins.spi.model.MetaMethod;
-import org.apache.logging.log4j.plugins.spi.bean.InitializationContext;
import java.lang.reflect.Type;
import java.util.Collection;
@@ -35,7 +35,7 @@ abstract class AbstractProducer<D, T> implements Producer<T> {
private final Bean<D> declaringBean;
private final MetaMethod<D, ?> disposerMethod;
private final Collection<InjectionPoint<?>> disposerInjectionPoints;
- final InjectionFactory injectionFactory;
+ final Injector injector;
AbstractProducer(final BeanManager beanManager, final Bean<D> declaringBean, final MetaMethod<D, ?> disposerMethod,
final Collection<InjectionPoint<?>> disposerInjectionPoints) {
@@ -43,7 +43,7 @@ abstract class AbstractProducer<D, T> implements Producer<T> {
this.declaringBean = declaringBean;
this.disposerMethod = disposerMethod;
this.disposerInjectionPoints = Objects.requireNonNull(disposerInjectionPoints);
- this.injectionFactory = new DefaultInjectionFactory(beanManager);
+ this.injector = new DefaultInjector(beanManager);
}
// context is managed separately as the declaring instance is only used for producing the object and is not a dependent of the bean
@@ -68,8 +68,7 @@ abstract class AbstractProducer<D, T> implements Producer<T> {
// as producer and disposer bean is unrelated to this bean, we need to recreate it on demand
try (final InitializationContext<D> context = createContext()) {
final D declaringInstance = disposerMethod.isStatic() ? null : getDeclaringInstance(context);
- injectionFactory.forDisposerMethod(disposerMethod, declaringInstance, disposerInjectionPoints, instance)
- .accept(context);
+ injector.dispose(declaringInstance, disposerMethod, disposerInjectionPoints, instance, context);
}
}
}
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultBeanManager.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultBeanManager.java
index b1a5334..d759f72 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultBeanManager.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultBeanManager.java
@@ -32,8 +32,8 @@ import org.apache.logging.log4j.plugins.spi.ValidationException;
import org.apache.logging.log4j.plugins.spi.bean.Bean;
import org.apache.logging.log4j.plugins.spi.bean.BeanManager;
import org.apache.logging.log4j.plugins.spi.bean.InitializationContext;
-import org.apache.logging.log4j.plugins.spi.bean.InjectionFactory;
import org.apache.logging.log4j.plugins.spi.bean.InjectionTargetFactory;
+import org.apache.logging.log4j.plugins.spi.bean.Injector;
import org.apache.logging.log4j.plugins.spi.bean.ProducerFactory;
import org.apache.logging.log4j.plugins.spi.bean.ScopeContext;
import org.apache.logging.log4j.plugins.spi.model.ElementManager;
@@ -71,7 +71,7 @@ import java.util.stream.Stream;
public class DefaultBeanManager implements BeanManager {
private final ElementManager elementManager;
- private final InjectionFactory injectionFactory = new DefaultInjectionFactory(this);
+ private final Injector injector = new DefaultInjector(this);
private final Collection<Bean<?>> enabledBeans = ConcurrentHashMap.newKeySet();
private final Map<Type, Collection<Bean<?>>> beansByType = new ConcurrentHashMap<>();
@@ -105,7 +105,7 @@ public class DefaultBeanManager implements BeanManager {
if (elementManager.isInjectable(metaClass)) {
final Variable<T> variable = elementManager.createVariable(metaClass);
final InjectionTargetFactory<T> factory =
- new DefaultInjectionTargetFactory<>(elementManager, injectionFactory, metaClass);
+ new DefaultInjectionTargetFactory<>(elementManager, injector, metaClass);
created = addBean(new InjectionTargetBean<>(variable, metaClass, factory));
} else {
created = null;
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultInjectionFactory.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultInjectionFactory.java
deleted file mode 100644
index 48fd80a..0000000
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultInjectionFactory.java
+++ /dev/null
@@ -1,92 +0,0 @@
-/*
- * 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.logging.log4j.plugins.defaults.bean;
-
-import org.apache.logging.log4j.plugins.api.Disposes;
-import org.apache.logging.log4j.plugins.spi.bean.BeanManager;
-import org.apache.logging.log4j.plugins.spi.bean.InjectionFactory;
-import org.apache.logging.log4j.plugins.spi.model.InjectionPoint;
-import org.apache.logging.log4j.plugins.spi.model.MetaConstructor;
-import org.apache.logging.log4j.plugins.spi.model.MetaField;
-import org.apache.logging.log4j.plugins.spi.model.MetaMethod;
-import org.apache.logging.log4j.plugins.spi.model.MetaParameter;
-import org.apache.logging.log4j.plugins.spi.bean.InitializationContext;
-
-import java.util.Collection;
-import java.util.List;
-import java.util.function.Consumer;
-import java.util.function.Function;
-
-public class DefaultInjectionFactory implements InjectionFactory {
-
- private final BeanManager beanManager;
-
- public DefaultInjectionFactory(final BeanManager beanManager) {
- this.beanManager = beanManager;
- }
-
- private Object[] createArguments(final List<MetaParameter<?>> parameters,
- final Collection<InjectionPoint<?>> injectionPoints,
- final InitializationContext<?> context, final Object producedInstance) {
- return parameters.stream().map(parameter ->
- parameter.isAnnotationPresent(Disposes.class) ? producedInstance : injectionPoints.stream()
- .filter(point -> parameter.equals(point.getElement()))
- .findAny()
- .flatMap(point -> beanManager.getInjectableValue(point, context))
- .orElseThrow(() -> new UnsupportedOperationException("TODO: primitives and defaults")))
- .toArray();
- }
-
- @Override
- public <T> Function<InitializationContext<T>, T> forConstructor(final MetaConstructor<T> constructor,
- final Collection<InjectionPoint<?>> injectionPoints) {
- return context -> constructor.construct(
- createArguments(constructor.getParameters(), injectionPoints, context, null));
- }
-
- @Override
- public <D, T> Function<InitializationContext<T>, T> forProducerMethod(final MetaMethod<D, T> producerMethod,
- final D declaringInstance,
- final Collection<InjectionPoint<?>> injectionPoints) {
- return context -> producerMethod.invoke(declaringInstance,
- createArguments(producerMethod.getParameters(), injectionPoints, context, null));
- }
-
- @Override
- public <T> Consumer<InitializationContext<T>> forDisposerMethod(final MetaMethod<T, ?> disposerMethod,
- final T declaringInstance,
- final Collection<InjectionPoint<?>> injectionPoints,
- final Object producedInstance) {
- return context -> disposerMethod.invoke(declaringInstance,
- createArguments(disposerMethod.getParameters(), injectionPoints, context, producedInstance));
- }
-
- @Override
- public <D, T> Consumer<InitializationContext<D>> forField(final MetaField<D, T> field, final D declaringInstance,
- final InjectionPoint<T> injectionPoint) {
- return context -> beanManager.getInjectableValue(injectionPoint, context)
- .ifPresent(value -> field.set(declaringInstance, value));
- }
-
- @Override
- public <D, T> Consumer<InitializationContext<D>> forMethod(final MetaMethod<D, T> method, final D declaringInstance,
- final Collection<InjectionPoint<?>> injectionPoints) {
- return context -> method.invoke(declaringInstance,
- createArguments(method.getParameters(), injectionPoints, context, null));
- }
-}
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultInjectionTarget.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultInjectionTarget.java
index 0b8e308..869fa00 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultInjectionTarget.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultInjectionTarget.java
@@ -20,8 +20,9 @@ package org.apache.logging.log4j.plugins.defaults.bean;
import org.apache.logging.log4j.plugins.api.Disposes;
import org.apache.logging.log4j.plugins.api.Inject;
import org.apache.logging.log4j.plugins.api.Produces;
-import org.apache.logging.log4j.plugins.spi.bean.InjectionFactory;
+import org.apache.logging.log4j.plugins.spi.bean.InitializationContext;
import org.apache.logging.log4j.plugins.spi.bean.InjectionTarget;
+import org.apache.logging.log4j.plugins.spi.bean.Injector;
import org.apache.logging.log4j.plugins.spi.model.ElementManager;
import org.apache.logging.log4j.plugins.spi.model.InjectionPoint;
import org.apache.logging.log4j.plugins.spi.model.MetaClass;
@@ -30,7 +31,6 @@ import org.apache.logging.log4j.plugins.spi.model.MetaElement;
import org.apache.logging.log4j.plugins.spi.model.MetaField;
import org.apache.logging.log4j.plugins.spi.model.MetaMember;
import org.apache.logging.log4j.plugins.spi.model.MetaMethod;
-import org.apache.logging.log4j.plugins.spi.bean.InitializationContext;
import org.apache.logging.log4j.plugins.util.TypeUtil;
import java.util.Collection;
@@ -42,17 +42,17 @@ import java.util.Set;
import java.util.stream.Collectors;
class DefaultInjectionTarget<T> implements InjectionTarget<T> {
- private final InjectionFactory injectionFactory;
+ private final Injector injector;
private final ElementManager elementManager;
private final Collection<InjectionPoint<?>> injectionPoints;
private final MetaConstructor<T> constructor;
private final List<MetaMethod<T, ?>> postConstructMethods;
private final List<MetaMethod<T, ?>> preDestroyMethods;
- DefaultInjectionTarget(final InjectionFactory injectionFactory, final ElementManager elementManager,
+ DefaultInjectionTarget(final Injector injector, final ElementManager elementManager,
final Collection<InjectionPoint<?>> injectionPoints, final MetaConstructor<T> constructor,
final List<MetaMethod<T, ?>> postConstructMethods, final List<MetaMethod<T, ?>> preDestroyMethods) {
- this.injectionFactory = injectionFactory;
+ this.injector = injector;
this.elementManager = elementManager;
this.injectionPoints = Objects.requireNonNull(injectionPoints);
this.constructor = Objects.requireNonNull(constructor);
@@ -65,7 +65,7 @@ class DefaultInjectionTarget<T> implements InjectionTarget<T> {
final Set<InjectionPoint<?>> constructorInjectionPoints = injectionPoints.stream()
.filter(point -> constructor.equals(point.getMember()))
.collect(Collectors.toSet());
- return injectionFactory.forConstructor(constructor, constructorInjectionPoints).apply(context);
+ return injector.construct(constructor, constructorInjectionPoints, context);
}
@Override
@@ -76,7 +76,7 @@ class DefaultInjectionTarget<T> implements InjectionTarget<T> {
final MetaClass<T> metaClass = elementManager.getMetaClass(clazz);
for (final MetaMethod<T, ?> method : metaClass.getMethods()) {
if (method.isAnnotationPresent(Inject.class) && method.getParameters().isEmpty()) {
- injectionFactory.forMethod(method, instance, Collections.emptySet()).accept(context);
+ injector.invoke(instance, method, Collections.emptySet(), context);
}
}
}
@@ -91,7 +91,7 @@ class DefaultInjectionTarget<T> implements InjectionTarget<T> {
final MetaElement<F> element = point.getElement();
if (element instanceof MetaField<?, ?> && ((MetaField<?, F>) element).getDeclaringClass().getJavaClass().isInstance(instance)) {
final MetaField<T, F> field = (MetaField<T, F>) element;
- injectionFactory.forField(field, instance, point).accept(context);
+ injector.set(instance, field, point, context);
}
}
@@ -107,7 +107,7 @@ class DefaultInjectionTarget<T> implements InjectionTarget<T> {
final Set<InjectionPoint<?>> methodInjectionPoints = injectionPoints.stream()
.filter(p -> method.equals(p.getMember()))
.collect(Collectors.toSet());
- injectionFactory.forMethod(method, instance, methodInjectionPoints).accept(context);
+ injector.invoke(instance, method, methodInjectionPoints, context);
injectedMethods.add(method);
}
}
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultInjectionTargetFactory.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultInjectionTargetFactory.java
index 029911e..d048a14 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultInjectionTargetFactory.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultInjectionTargetFactory.java
@@ -22,9 +22,9 @@ import org.apache.logging.log4j.plugins.api.PostConstruct;
import org.apache.logging.log4j.plugins.api.PreDestroy;
import org.apache.logging.log4j.plugins.spi.InjectionException;
import org.apache.logging.log4j.plugins.spi.bean.Bean;
-import org.apache.logging.log4j.plugins.spi.bean.InjectionFactory;
import org.apache.logging.log4j.plugins.spi.bean.InjectionTarget;
import org.apache.logging.log4j.plugins.spi.bean.InjectionTargetFactory;
+import org.apache.logging.log4j.plugins.spi.bean.Injector;
import org.apache.logging.log4j.plugins.spi.model.ElementManager;
import org.apache.logging.log4j.plugins.spi.model.InjectionPoint;
import org.apache.logging.log4j.plugins.spi.model.MetaClass;
@@ -40,13 +40,13 @@ import java.util.stream.Collectors;
class DefaultInjectionTargetFactory<T> implements InjectionTargetFactory<T> {
private final ElementManager elementManager;
- private final InjectionFactory injectionFactory;
+ private final Injector injector;
private final MetaClass<T> type;
- DefaultInjectionTargetFactory(final ElementManager elementManager, final InjectionFactory injectionFactory,
+ DefaultInjectionTargetFactory(final ElementManager elementManager, final Injector injector,
final MetaClass<T> type) {
this.elementManager = elementManager;
- this.injectionFactory = injectionFactory;
+ this.injector = injector;
this.type = type;
}
@@ -75,7 +75,7 @@ class DefaultInjectionTargetFactory<T> implements InjectionTargetFactory<T> {
final List<MetaMethod<T, ?>> preDestroyMethods = methods.stream()
.filter(method -> method.isAnnotationPresent(PreDestroy.class))
.collect(Collectors.toList());
- return new DefaultInjectionTarget<>(injectionFactory, elementManager, injectionPoints, constructor,
+ return new DefaultInjectionTarget<>(injector, elementManager, injectionPoints, constructor,
postConstructMethods, preDestroyMethods);
}
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultInjector.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultInjector.java
new file mode 100644
index 0000000..0c9a2e6
--- /dev/null
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultInjector.java
@@ -0,0 +1,82 @@
+/*
+ * 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.logging.log4j.plugins.defaults.bean;
+
+import org.apache.logging.log4j.plugins.api.Disposes;
+import org.apache.logging.log4j.plugins.spi.bean.BeanManager;
+import org.apache.logging.log4j.plugins.spi.bean.InitializationContext;
+import org.apache.logging.log4j.plugins.spi.bean.Injector;
+import org.apache.logging.log4j.plugins.spi.model.InjectionPoint;
+import org.apache.logging.log4j.plugins.spi.model.MetaConstructor;
+import org.apache.logging.log4j.plugins.spi.model.MetaField;
+import org.apache.logging.log4j.plugins.spi.model.MetaMethod;
+import org.apache.logging.log4j.plugins.spi.model.MetaParameter;
+
+import java.util.Collection;
+import java.util.List;
+
+public class DefaultInjector implements Injector {
+ private final BeanManager beanManager;
+
+ public DefaultInjector(final BeanManager beanManager) {
+ this.beanManager = beanManager;
+ }
+
+ private Object[] createArguments(final List<MetaParameter<?>> parameters,
+ final Collection<InjectionPoint<?>> injectionPoints,
+ final InitializationContext<?> context, final Object producedInstance) {
+ return parameters.stream().map(parameter ->
+ parameter.isAnnotationPresent(Disposes.class) ? producedInstance : injectionPoints.stream()
+ .filter(point -> parameter.equals(point.getElement()))
+ .findAny()
+ .flatMap(point -> beanManager.getInjectableValue(point, context))
+ .orElseThrow(() -> new UnsupportedOperationException("TODO: primitives and defaults")))
+ .toArray();
+ }
+
+ @Override
+ public <T> T construct(final MetaConstructor<T> constructor, final Collection<InjectionPoint<?>> points,
+ final InitializationContext<T> context) {
+ return constructor.construct(createArguments(constructor.getParameters(), points, context, null));
+ }
+
+ @Override
+ public <D, T> T produce(final D producerInstance, final MetaMethod<D, T> producerMethod,
+ final Collection<InjectionPoint<?>> points, final InitializationContext<T> context) {
+ return producerMethod.invoke(producerInstance, createArguments(producerMethod.getParameters(), points, context, null));
+ }
+
+ @Override
+ public <T> void dispose(final T disposerInstance, final MetaMethod<T, ?> disposerMethod,
+ final Collection<InjectionPoint<?>> points, final Object instance,
+ final InitializationContext<T> context) {
+ disposerMethod.invoke(disposerInstance, createArguments(disposerMethod.getParameters(), points, context, instance));
+ }
+
+ @Override
+ public <T> void invoke(final T instance, final MetaMethod<T, ?> method, final Collection<InjectionPoint<?>> points,
+ final InitializationContext<T> context) {
+ method.invoke(instance, createArguments(method.getParameters(), points, context, null));
+ }
+
+ @Override
+ public <D, T> void set(final D instance, final MetaField<D, T> field, final InjectionPoint<T> point,
+ final InitializationContext<D> context) {
+ beanManager.getInjectableValue(point, context).ifPresent(value -> field.set(instance, value));
+ }
+}
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/MethodProducer.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/MethodProducer.java
index 927ab5b..4261951 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/MethodProducer.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/MethodProducer.java
@@ -20,9 +20,9 @@ package org.apache.logging.log4j.plugins.defaults.bean;
import org.apache.logging.log4j.plugins.spi.InjectionException;
import org.apache.logging.log4j.plugins.spi.bean.Bean;
import org.apache.logging.log4j.plugins.spi.bean.BeanManager;
+import org.apache.logging.log4j.plugins.spi.bean.InitializationContext;
import org.apache.logging.log4j.plugins.spi.model.InjectionPoint;
import org.apache.logging.log4j.plugins.spi.model.MetaMethod;
-import org.apache.logging.log4j.plugins.spi.bean.InitializationContext;
import java.lang.reflect.Type;
import java.util.Collection;
@@ -52,8 +52,7 @@ class MethodProducer<D, T> extends AbstractProducer<D, T> {
public T produce(final InitializationContext<T> context) {
try (final InitializationContext<D> parentContext = createContext()) {
final D declaringInstance = producerMethod.isStatic() ? null : getDeclaringInstance(parentContext);
- return injectionFactory.forProducerMethod(producerMethod, declaringInstance, producerInjectionPoints)
- .apply(context);
+ return injector.produce(declaringInstance, producerMethod, producerInjectionPoints, context);
}
}
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/InjectionFactory.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/InjectionFactory.java
deleted file mode 100644
index b118d67..0000000
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/InjectionFactory.java
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * 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.logging.log4j.plugins.spi.bean;
-
-import org.apache.logging.log4j.plugins.spi.model.InjectionPoint;
-import org.apache.logging.log4j.plugins.spi.model.MetaConstructor;
-import org.apache.logging.log4j.plugins.spi.model.MetaField;
-import org.apache.logging.log4j.plugins.spi.model.MetaMethod;
-
-import java.util.Collection;
-import java.util.function.Consumer;
-import java.util.function.Function;
-
-public interface InjectionFactory {
- <T> Function<InitializationContext<T>, T> forConstructor(final MetaConstructor<T> constructor,
- final Collection<InjectionPoint<?>> injectionPoints);
-
- <D, T> Function<InitializationContext<T>, T> forProducerMethod(final MetaMethod<D, T> producerMethod,
- final D declaringInstance,
- final Collection<InjectionPoint<?>> injectionPoints);
-
- <T> Consumer<InitializationContext<T>> forDisposerMethod(final MetaMethod<T, ?> disposerMethod,
- final T declaringInstance,
- final Collection<InjectionPoint<?>> injectionPoints,
- final Object producedInstance);
-
- <D, T> Consumer<InitializationContext<D>> forField(final MetaField<D, T> field, final D declaringInstance,
- final InjectionPoint<T> injectionPoint);
-
- <D, T> Consumer<InitializationContext<D>> forMethod(final MetaMethod<D, T> method, final D declaringInstance,
- final Collection<InjectionPoint<?>> injectionPoints);
-}
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/Injector.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/Injector.java
new file mode 100644
index 0000000..0d86baf
--- /dev/null
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/Injector.java
@@ -0,0 +1,43 @@
+/*
+ * 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.logging.log4j.plugins.spi.bean;
+
+import org.apache.logging.log4j.plugins.spi.model.InjectionPoint;
+import org.apache.logging.log4j.plugins.spi.model.MetaConstructor;
+import org.apache.logging.log4j.plugins.spi.model.MetaField;
+import org.apache.logging.log4j.plugins.spi.model.MetaMethod;
+
+import java.util.Collection;
+
+public interface Injector {
+ <T> T construct(final MetaConstructor<T> constructor, final Collection<InjectionPoint<?>> points,
+ final InitializationContext<T> context);
+
+ <D, T> T produce(final D producerInstance, final MetaMethod<D, T> producerMethod,
+ final Collection<InjectionPoint<?>> points, final InitializationContext<T> context);
+
+ <T> void dispose(final T disposerInstance, final MetaMethod<T, ?> disposerMethod,
+ final Collection<InjectionPoint<?>> points, final Object instance,
+ final InitializationContext<T> context);
+
+ <T> void invoke(final T instance, final MetaMethod<T, ?> method, final Collection<InjectionPoint<?>> points,
+ final InitializationContext<T> context);
+
+ <D, T> void set(final D instance, final MetaField<D, T> field, final InjectionPoint<T> point,
+ final InitializationContext<D> context);
+}
diff --git a/log4j-plugins/src/test/java/org/apache/logging/log4j/plugins/test/BeanJUnit4Runner.java b/log4j-plugins/src/test/java/org/apache/logging/log4j/plugins/test/BeanJUnit4Runner.java
index c671ef1..31977d8 100644
--- a/log4j-plugins/src/test/java/org/apache/logging/log4j/plugins/test/BeanJUnit4Runner.java
+++ b/log4j-plugins/src/test/java/org/apache/logging/log4j/plugins/test/BeanJUnit4Runner.java
@@ -18,18 +18,18 @@
package org.apache.logging.log4j.plugins.test;
import org.apache.logging.log4j.plugins.defaults.bean.DefaultBeanManager;
-import org.apache.logging.log4j.plugins.defaults.bean.DefaultInjectionFactory;
+import org.apache.logging.log4j.plugins.defaults.bean.DefaultInjector;
import org.apache.logging.log4j.plugins.defaults.model.DefaultElementManager;
import org.apache.logging.log4j.plugins.spi.InjectionException;
import org.apache.logging.log4j.plugins.spi.UnsatisfiedBeanException;
import org.apache.logging.log4j.plugins.spi.bean.Bean;
import org.apache.logging.log4j.plugins.spi.bean.BeanManager;
-import org.apache.logging.log4j.plugins.spi.bean.InjectionFactory;
+import org.apache.logging.log4j.plugins.spi.bean.InitializationContext;
+import org.apache.logging.log4j.plugins.spi.bean.Injector;
import org.apache.logging.log4j.plugins.spi.model.ElementManager;
import org.apache.logging.log4j.plugins.spi.model.InjectionPoint;
import org.apache.logging.log4j.plugins.spi.model.MetaClass;
import org.apache.logging.log4j.plugins.spi.model.MetaMethod;
-import org.apache.logging.log4j.plugins.spi.bean.InitializationContext;
import org.apache.logging.log4j.plugins.util.TypeUtil;
import org.junit.Test;
import org.junit.runners.BlockJUnit4ClassRunner;
@@ -53,7 +53,7 @@ public class BeanJUnit4Runner extends BlockJUnit4ClassRunner {
private MetaClass<?> testMetaClass;
private BeanManager beanManager;
- private InjectionFactory injectionFactory;
+ private Injector injector;
private Bean<?> testClassBean;
public BeanJUnit4Runner(final Class<?> clazz) throws InitializationError {
@@ -89,7 +89,7 @@ public class BeanJUnit4Runner extends BlockJUnit4ClassRunner {
private <T> T createTestInstance() {
beanManager = new DefaultBeanManager(elementManager);
- injectionFactory = new DefaultInjectionFactory(beanManager);
+ injector = new DefaultInjector(beanManager);
final WithBeans testClassBeans = getTestClass().getAnnotation(WithBeans.class);
if (testClassBeans != null) {
beanManager.loadBeans(testClassBeans.value());
@@ -125,7 +125,7 @@ public class BeanJUnit4Runner extends BlockJUnit4ClassRunner {
final MetaMethod<T, Void> metaMethod = metaClass.getMetaMethod(method.getMethod());
final Collection<InjectionPoint<?>> points =
elementManager.createExecutableInjectionPoints(metaMethod, testClassBean);
- injectionFactory.forMethod(metaMethod, testInstance, points).accept(context);
+ injector.invoke(testInstance, metaMethod, points, context);
} finally {
beanManager.close();
beanManager = null;