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/22 17:40:00 UTC
[logging-log4j2] branch mean-bean-machine updated (0fe2003 ->
9043b20)
This is an automated email from the ASF dual-hosted git repository.
mattsicker pushed a change to branch mean-bean-machine
in repository https://gitbox.apache.org/repos/asf/logging-log4j2.git.
from 0fe2003 Improve annotation meta-modeling
new b95c818 Remove unused type parameters
new 41b8043 Add variable withers
new b228c68 Removed unused methods
new aaccfb9 Use normalized internal state for qualifers
new a3d7805 Rename scope annotations to use Scoped suffix
new 9043b20 Add tests around deferred instantiation
The 6 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
.../api/{Dependent.java => DependentScoped.java} | 2 +-
.../apache/logging/log4j/plugins/api/Produces.java | 4 +-
.../api/{Singleton.java => SingletonScoped.java} | 2 +-
.../log4j/plugins/defaults/bean/AbstractBean.java | 23 +++--
.../plugins/defaults/bean/AbstractProducer.java | 4 +-
.../defaults/bean/AbstractProducerFactory.java | 11 ++-
.../plugins/defaults/bean/DefaultBeanManager.java | 109 +++++++++++----------
.../bean/DefaultInitializationContext.java | 2 +-
.../defaults/bean/DefaultInjectionTarget.java | 29 ++----
.../bean/DefaultInjectionTargetFactory.java | 2 +-
.../plugins/defaults/bean/DefaultInjector.java | 18 ++--
.../defaults/bean/DependentScopeContext.java | 4 +-
.../log4j/plugins/defaults/bean/FieldProducer.java | 6 +-
.../defaults/bean/FieldProducerFactory.java | 2 +-
.../plugins/defaults/bean/InjectionTargetBean.java | 4 +-
.../plugins/defaults/bean/MethodProducer.java | 8 +-
.../defaults/bean/MethodProducerFactory.java | 6 +-
.../log4j/plugins/defaults/bean/ProducerBean.java | 8 +-
.../log4j/plugins/defaults/bean/SystemBean.java | 21 ++--
.../defaults/model/AbstractMetaExecutable.java | 8 +-
.../plugins/defaults/model/AbstractMetaMember.java | 2 +-
.../defaults/model/DefaultElementManager.java | 28 +++---
.../defaults/model/DefaultInjectionPoint.java | 14 +--
.../model/DefaultMetaAnnotationElement.java | 6 --
.../defaults/model/DefaultMetaParameter.java | 10 +-
.../plugins/defaults/model/DefaultQualifiers.java | 39 +++++---
.../plugins/defaults/model/DefaultVariable.java | 18 ++--
.../plugins/spi/UnsatisfiedBeanException.java | 2 +-
.../logging/log4j/plugins/spi/bean/Bean.java | 2 +-
.../log4j/plugins/spi/bean/BeanManager.java | 2 +-
.../logging/log4j/plugins/spi/bean/Injector.java | 10 +-
.../logging/log4j/plugins/spi/bean/Producer.java | 2 +-
.../log4j/plugins/spi/bean/ProducerFactory.java | 2 +-
.../log4j/plugins/spi/model/ElementManager.java | 18 ++--
.../log4j/plugins/spi/model/InjectionPoint.java | 8 +-
.../plugins/spi/model/MetaAnnotationElement.java | 2 +-
.../logging/log4j/plugins/spi/model/MetaClass.java | 2 +-
.../log4j/plugins/spi/model/MetaConstructor.java | 2 +-
.../log4j/plugins/spi/model/MetaElement.java | 7 +-
.../log4j/plugins/spi/model/MetaExecutable.java | 4 +-
.../logging/log4j/plugins/spi/model/MetaField.java | 2 +-
.../log4j/plugins/spi/model/MetaMember.java | 2 +-
.../log4j/plugins/spi/model/MetaMethod.java | 2 +-
.../log4j/plugins/spi/model/MetaParameter.java | 2 +-
.../log4j/plugins/spi/model/Qualifiers.java | 17 +++-
.../logging/log4j/plugins/spi/model/Variable.java | 6 +-
.../defaults/bean/DefaultBeanManagerTest.java | 48 ++++++++-
.../log4j/plugins/test/BeanJUnit4Runner.java | 2 +-
48 files changed, 295 insertions(+), 239 deletions(-)
rename log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/{Dependent.java => DependentScoped.java} (97%)
rename log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/{Singleton.java => SingletonScoped.java} (96%)
[logging-log4j2] 02/06: Add variable withers
Posted by ma...@apache.org.
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 41b8043f16f09321b7c00325cc517710431f67f2
Author: Matt Sicker <bo...@gmail.com>
AuthorDate: Sat Mar 21 17:00:08 2020 -0500
Add variable withers
Signed-off-by: Matt Sicker <bo...@gmail.com>
---
.../log4j/plugins/defaults/bean/AbstractBean.java | 19 +++++-
.../plugins/defaults/bean/DefaultBeanManager.java | 69 +++++++++++-----------
.../log4j/plugins/defaults/bean/SystemBean.java | 19 +++++-
.../defaults/model/DefaultElementManager.java | 2 +-
.../plugins/defaults/model/DefaultVariable.java | 28 ++++++---
.../logging/log4j/plugins/spi/model/Variable.java | 6 ++
6 files changed, 95 insertions(+), 48 deletions(-)
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/AbstractBean.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/AbstractBean.java
index c9110bf..5987ff3 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/AbstractBean.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/AbstractBean.java
@@ -42,13 +42,23 @@ abstract class AbstractBean<T> implements Bean<T> {
}
@Override
+ public Collection<Type> getTypes() {
+ return variable.getTypes();
+ }
+
+ @Override
+ public Variable withTypes(final Collection<Type> types) {
+ return variable.withTypes(types);
+ }
+
+ @Override
public Qualifiers getQualifiers() {
return variable.getQualifiers();
}
@Override
- public Collection<Type> getTypes() {
- return variable.getTypes();
+ public Variable withQualifiers(final Qualifiers qualifiers) {
+ return variable.withQualifiers(qualifiers);
}
@Override
@@ -57,6 +67,11 @@ abstract class AbstractBean<T> implements Bean<T> {
}
@Override
+ public Variable withScopeType(final Class<? extends Annotation> scopeType) {
+ return variable.withScopeType(scopeType);
+ }
+
+ @Override
public boolean equals(final Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
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 592a279..5c98bf1 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
@@ -23,7 +23,6 @@ import org.apache.logging.log4j.plugins.api.Produces;
import org.apache.logging.log4j.plugins.api.Provider;
import org.apache.logging.log4j.plugins.api.Singleton;
import org.apache.logging.log4j.plugins.defaults.model.DefaultElementManager;
-import org.apache.logging.log4j.plugins.defaults.model.DefaultVariable;
import org.apache.logging.log4j.plugins.spi.AmbiguousBeanException;
import org.apache.logging.log4j.plugins.spi.DefinitionException;
import org.apache.logging.log4j.plugins.spi.InjectionException;
@@ -232,7 +231,7 @@ public class DefaultBeanManager implements BeanManager {
}
}
- private <T> void validateInjectionPoint(final InjectionPoint point) {
+ private void validateInjectionPoint(final InjectionPoint point) {
final MetaElement element = point.getElement();
if (element.isAnnotationPresent(Produces.class)) {
throw new DefinitionException("Cannot inject into a @Produces element: " + element);
@@ -257,7 +256,7 @@ public class DefaultBeanManager implements BeanManager {
validateBeanInjectionPoint(point, ((ProducerBean<?>) bean).getType());
}
}
- final Optional<Bean<T>> bean = getInjectionPointBean(point);
+ final Optional<Bean<?>> bean = getBeanForInjectionPoint(point);
if (!bean.isPresent() && !rawType.equals(Optional.class)) {
throw new UnsatisfiedBeanException(point);
}
@@ -282,54 +281,49 @@ public class DefaultBeanManager implements BeanManager {
}
}
- private <T> Optional<Bean<T>> getInjectionPointBean(final InjectionPoint point) {
+ private Optional<Bean<?>> getBeanForInjectionPoint(final InjectionPoint point) {
// TODO: this will need to allow for TypeConverter usage somehow
// first, look for an existing bean
final Type type = point.getType();
final Qualifiers qualifiers = point.getQualifiers();
- final Variable variable = elementManager.createVariable(point);
- final Optional<Bean<T>> existingBean = getExistingOrProvidedBean(type, qualifiers, () -> variable);
+ final Optional<Bean<?>> existingBean = getExistingOrProvidedBean(type, qualifiers,
+ () -> elementManager.createVariable(point));
if (existingBean.isPresent()) {
return existingBean;
}
if (type instanceof ParameterizedType) {
final Class<?> rawType = TypeUtil.getRawType(type);
- final Type actualType = ((ParameterizedType) type).getActualTypeArguments()[0];
- if (rawType.equals(Provider.class)) {
+ if (rawType == Provider.class) {
+ final Type actualType = ((ParameterizedType) type).getActualTypeArguments()[0];
// if a Provider<T> is requested, we can convert an existing Bean<T> into a Bean<Provider<T>>
- return this.<T>getBean(actualType, qualifiers)
- .map(bean -> new ProviderBean<>(variable, context -> getValue(bean, context)))
- .map(this::addBean)
- .map(TypeUtil::cast);
- } else if (rawType.equals(Optional.class)) {
- final Optional<Bean<T>> actualExistingBean = getExistingOrProvidedBean(actualType, qualifiers,
- // FIXME: remove need for DefaultVariable to be public
- () -> DefaultVariable.newVariable(
- TypeUtil.getTypeClosure(actualType), qualifiers, variable.getScopeType()));
- final Bean<Optional<T>> optionalBean = addBean(new OptionalBean<>(variable,
- context -> actualExistingBean.map(bean -> getValue(bean, context))));
- return Optional.of(TypeUtil.cast(optionalBean));
+ return getExistingBean(actualType, qualifiers)
+ .map(bean -> new ProviderBean<>(
+ elementManager.createVariable(point), context -> getValue(bean, context)))
+ .map(this::addBean);
+ } else if (rawType == Optional.class) {
+ final Type actualType = ((ParameterizedType) type).getActualTypeArguments()[0];
+ final Variable variable = elementManager.createVariable(point);
+ return Optional.of(createOptionalBean(actualType, qualifiers, variable));
}
}
return Optional.empty();
}
- private <T> Optional<Bean<T>> getExistingOrProvidedBean(final Type type, final Qualifiers qualifiers,
- final Supplier<Variable> variableSupplier) {
- final Optional<Bean<T>> existingBean = getBean(type, qualifiers);
+ private Optional<Bean<?>> getExistingOrProvidedBean(final Type type, final Qualifiers qualifiers,
+ final Supplier<Variable> variableSupplier) {
+ final Optional<Bean<?>> existingBean = getExistingBean(type, qualifiers);
if (existingBean.isPresent()) {
return existingBean;
}
- final Variable variable = variableSupplier.get();
final Type providerType = new ParameterizedTypeImpl(null, Provider.class, type);
- final Optional<Bean<Provider<T>>> providerBean = getBean(providerType, qualifiers);
- return providerBean.map(bean -> new ProvidedBean<>(variable, context -> getValue(bean, context).get()))
+ return getExistingBean(providerType, qualifiers)
+ .<Bean<Provider<?>>>map(TypeUtil::cast)
+ .map(bean -> new ProvidedBean<>(variableSupplier.get(), context -> getValue(bean, context).get()))
.map(this::addBean);
}
- // FIXME: this needs to consider scopes
- private <T> Optional<Bean<T>> getBean(final Type type, final Qualifiers qualifiers) {
- final Set<Bean<T>> beans = this.<T>streamBeansMatchingType(type)
+ private Optional<Bean<?>> getExistingBean(final Type type, final Qualifiers qualifiers) {
+ final Set<Bean<?>> beans = beansWithType(type)
.filter(bean -> qualifiers.equals(bean.getQualifiers()))
.collect(Collectors.toSet());
if (beans.size() > 1) {
@@ -338,19 +332,26 @@ public class DefaultBeanManager implements BeanManager {
return beans.isEmpty() ? Optional.empty() : Optional.of(beans.iterator().next());
}
- private <T> Stream<Bean<T>> streamBeansMatchingType(final Type requiredType) {
+ private Stream<Bean<?>> beansWithType(final Type requiredType) {
if (beansByType.containsKey(requiredType)) {
- return beansByType.get(requiredType).stream().map(TypeUtil::cast);
+ return beansByType.get(requiredType).stream();
}
if (requiredType instanceof ParameterizedType) {
return beansByType.getOrDefault(((ParameterizedType) requiredType).getRawType(), Collections.emptySet())
.stream()
- .filter(bean -> bean.hasMatchingType(requiredType))
- .map(TypeUtil::cast);
+ .filter(bean -> bean.hasMatchingType(requiredType));
}
return Stream.empty();
}
+ private Bean<?> createOptionalBean(final Type actualType, final Qualifiers qualifiers, final Variable variable) {
+ final Supplier<Variable> variableSupplier = () -> variable.withTypes(TypeUtil.getTypeClosure(actualType));
+ final Bean<?> optionalBean = new OptionalBean<>(variable, context ->
+ getExistingOrProvidedBean(actualType, qualifiers, variableSupplier)
+ .map(bean -> getValue(bean, context)));
+ return addBean(optionalBean);
+ }
+
@Override
public <T> InitializationContext<T> createInitializationContext(final Bean<T> bean) {
return new DefaultInitializationContext<>(bean);
@@ -374,7 +375,7 @@ public class DefaultBeanManager implements BeanManager {
@Override
public <T> Optional<T> getInjectableValue(final InjectionPoint point, final InitializationContext<?> parentContext) {
- final Optional<Bean<T>> optionalResolvedBean = getInjectionPointBean(point);
+ final Optional<Bean<T>> optionalResolvedBean = getBeanForInjectionPoint(point).map(TypeUtil::cast);
final Bean<T> resolvedBean = optionalResolvedBean.orElseThrow(() -> new UnsatisfiedBeanException(point));
final Optional<T> existingValue = point.getBean()
.filter(bean -> !bean.equals(resolvedBean))
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/SystemBean.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/SystemBean.java
index 97cfb94..ed7810e 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/SystemBean.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/SystemBean.java
@@ -37,13 +37,23 @@ abstract class SystemBean<T> implements Bean<T> {
}
@Override
+ public Collection<Type> getTypes() {
+ return variable.getTypes();
+ }
+
+ @Override
+ public Variable withTypes(final Collection<Type> types) {
+ return variable.withTypes(types);
+ }
+
+ @Override
public Qualifiers getQualifiers() {
return variable.getQualifiers();
}
@Override
- public Collection<Type> getTypes() {
- return variable.getTypes();
+ public Variable withQualifiers(final Qualifiers qualifiers) {
+ return variable.withQualifiers(qualifiers);
}
@Override
@@ -52,6 +62,11 @@ abstract class SystemBean<T> implements Bean<T> {
}
@Override
+ public Variable withScopeType(final Class<? extends Annotation> scopeType) {
+ return variable.withScopeType(scopeType);
+ }
+
+ @Override
public Collection<InjectionPoint> getInjectionPoints() {
return Collections.emptySet();
}
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultElementManager.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultElementManager.java
index b1a4066..b690d59 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultElementManager.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultElementManager.java
@@ -193,7 +193,7 @@ public class DefaultElementManager implements ElementManager {
private Variable createVariable(final MetaElement element, final Qualifiers qualifiers) {
final Collection<Type> types = element.getTypeClosure();
final Class<? extends Annotation> scopeType = getScopeType(element);
- return DefaultVariable.newVariable(types, qualifiers, scopeType);
+ return new DefaultVariable(types, qualifiers, scopeType);
}
@Override
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultVariable.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultVariable.java
index f06d8b4..cdf7928 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultVariable.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultVariable.java
@@ -23,21 +23,16 @@ import org.apache.logging.log4j.plugins.spi.model.Variable;
import java.lang.annotation.Annotation;
import java.lang.reflect.Type;
import java.util.Collection;
+import java.util.Collections;
import java.util.Objects;
public class DefaultVariable implements Variable {
-
- public static DefaultVariable newVariable(final Collection<Type> types, final Qualifiers qualifiers,
- final Class<? extends Annotation> scopeType) {
- return new DefaultVariable(types, qualifiers, scopeType);
- }
-
private final Collection<Type> types;
private final Qualifiers qualifiers;
private final Class<? extends Annotation> scopeType;
- private DefaultVariable(final Collection<Type> types, final Qualifiers qualifiers,
- final Class<? extends Annotation> scopeType) {
+ DefaultVariable(final Collection<Type> types, final Qualifiers qualifiers,
+ final Class<? extends Annotation> scopeType) {
this.types = Objects.requireNonNull(types);
this.qualifiers = Objects.requireNonNull(qualifiers);
this.scopeType = Objects.requireNonNull(scopeType);
@@ -45,7 +40,12 @@ public class DefaultVariable implements Variable {
@Override
public Collection<Type> getTypes() {
- return types;
+ return Collections.unmodifiableCollection(types);
+ }
+
+ @Override
+ public Variable withTypes(final Collection<Type> types) {
+ return new DefaultVariable(types, getQualifiers(), getScopeType());
}
@Override
@@ -54,11 +54,21 @@ public class DefaultVariable implements Variable {
}
@Override
+ public Variable withQualifiers(final Qualifiers qualifiers) {
+ return new DefaultVariable(getTypes(), qualifiers, getScopeType());
+ }
+
+ @Override
public Class<? extends Annotation> getScopeType() {
return scopeType;
}
@Override
+ public Variable withScopeType(final Class<? extends Annotation> scopeType) {
+ return new DefaultVariable(getTypes(), getQualifiers(), scopeType);
+ }
+
+ @Override
public boolean equals(final Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/Variable.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/Variable.java
index dc8eeb2..0d9c035 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/Variable.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/Variable.java
@@ -27,6 +27,8 @@ import java.util.Collection;
public interface Variable {
Collection<Type> getTypes();
+ Variable withTypes(final Collection<Type> types);
+
default boolean hasMatchingType(final Type requiredType) {
for (final Type type : getTypes()) {
if (TypeUtil.typesMatch(requiredType, type)) {
@@ -38,8 +40,12 @@ public interface Variable {
Qualifiers getQualifiers();
+ Variable withQualifiers(final Qualifiers qualifiers);
+
Class<? extends Annotation> getScopeType();
+ Variable withScopeType(final Class<? extends Annotation> scopeType);
+
default boolean isDependentScoped() {
return getScopeType() == Dependent.class;
}
[logging-log4j2] 03/06: Removed unused methods
Posted by ma...@apache.org.
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 b228c68f4a41e5a6ef2c6184d34b4b7a31139049
Author: Matt Sicker <bo...@gmail.com>
AuthorDate: Sun Mar 22 12:01:38 2020 -0500
Removed unused methods
Signed-off-by: Matt Sicker <bo...@gmail.com>
---
.../logging/log4j/plugins/defaults/bean/AbstractBean.java | 10 ----------
.../apache/logging/log4j/plugins/defaults/bean/SystemBean.java | 10 ----------
.../logging/log4j/plugins/defaults/model/DefaultVariable.java | 10 ----------
.../org/apache/logging/log4j/plugins/spi/model/Variable.java | 4 ----
4 files changed, 34 deletions(-)
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/AbstractBean.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/AbstractBean.java
index 5987ff3..1798af1 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/AbstractBean.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/AbstractBean.java
@@ -57,21 +57,11 @@ abstract class AbstractBean<T> implements Bean<T> {
}
@Override
- public Variable withQualifiers(final Qualifiers qualifiers) {
- return variable.withQualifiers(qualifiers);
- }
-
- @Override
public Class<? extends Annotation> getScopeType() {
return variable.getScopeType();
}
@Override
- public Variable withScopeType(final Class<? extends Annotation> scopeType) {
- return variable.withScopeType(scopeType);
- }
-
- @Override
public boolean equals(final Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/SystemBean.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/SystemBean.java
index ed7810e..00771f8 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/SystemBean.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/SystemBean.java
@@ -52,21 +52,11 @@ abstract class SystemBean<T> implements Bean<T> {
}
@Override
- public Variable withQualifiers(final Qualifiers qualifiers) {
- return variable.withQualifiers(qualifiers);
- }
-
- @Override
public Class<? extends Annotation> getScopeType() {
return variable.getScopeType();
}
@Override
- public Variable withScopeType(final Class<? extends Annotation> scopeType) {
- return variable.withScopeType(scopeType);
- }
-
- @Override
public Collection<InjectionPoint> getInjectionPoints() {
return Collections.emptySet();
}
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultVariable.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultVariable.java
index cdf7928..8fd2160 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultVariable.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultVariable.java
@@ -54,21 +54,11 @@ public class DefaultVariable implements Variable {
}
@Override
- public Variable withQualifiers(final Qualifiers qualifiers) {
- return new DefaultVariable(getTypes(), qualifiers, getScopeType());
- }
-
- @Override
public Class<? extends Annotation> getScopeType() {
return scopeType;
}
@Override
- public Variable withScopeType(final Class<? extends Annotation> scopeType) {
- return new DefaultVariable(getTypes(), getQualifiers(), scopeType);
- }
-
- @Override
public boolean equals(final Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/Variable.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/Variable.java
index 0d9c035..2396158 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/Variable.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/Variable.java
@@ -40,12 +40,8 @@ public interface Variable {
Qualifiers getQualifiers();
- Variable withQualifiers(final Qualifiers qualifiers);
-
Class<? extends Annotation> getScopeType();
- Variable withScopeType(final Class<? extends Annotation> scopeType);
-
default boolean isDependentScoped() {
return getScopeType() == Dependent.class;
}
[logging-log4j2] 06/06: Add tests around deferred instantiation
Posted by ma...@apache.org.
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 9043b20b7eaee343951aa537cf284e802b2827f8
Author: Matt Sicker <bo...@gmail.com>
AuthorDate: Sun Mar 22 12:39:41 2020 -0500
Add tests around deferred instantiation
This shows that injecting a Provider<T> can substitute for the 2.x plugin feature of deferChildren.
Signed-off-by: Matt Sicker <bo...@gmail.com>
---
.../defaults/bean/DefaultBeanManagerTest.java | 38 ++++++++++++++++++++++
1 file changed, 38 insertions(+)
diff --git a/log4j-plugins/src/test/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultBeanManagerTest.java b/log4j-plugins/src/test/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultBeanManagerTest.java
index e679643..78b42ce 100644
--- a/log4j-plugins/src/test/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultBeanManagerTest.java
+++ b/log4j-plugins/src/test/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultBeanManagerTest.java
@@ -230,6 +230,10 @@ public class DefaultBeanManagerTest {
public int nextId() {
return current.incrementAndGet();
}
+
+ public int getCurrent() {
+ return current.get();
+ }
}
public static class PostConstructInjection {
@@ -301,6 +305,40 @@ public class DefaultBeanManagerTest {
assertNotNull(fooBar);
}
+ @SingletonScoped
+ public static class DeferredSingleton {
+ private final int id;
+
+ @Inject
+ public DeferredSingleton(final int id) {
+ this.id = id;
+ }
+ }
+
+ public static class DeferredDependent {
+ private final int id;
+
+ @Inject
+ public DeferredDependent(final int id) {
+ this.id = id;
+ }
+ }
+
+ @WithBeans({IdGenerator.class, DeferredSingleton.class, DeferredDependent.class})
+ @Test
+ public void testDeferredProviderNotInvokedUntilInitiallyProvided(final IdGenerator generator,
+ final Provider<DeferredSingleton> singletonProvider,
+ final Provider<DeferredDependent> dependentProvider) {
+ assertEquals(0, generator.getCurrent());
+ assertEquals(1, singletonProvider.get().id);
+ assertEquals(1, singletonProvider.get().id);
+ assertEquals(2, dependentProvider.get().id);
+ assertEquals(1, singletonProvider.get().id);
+ assertEquals(3, dependentProvider.get().id);
+ assertEquals(1, singletonProvider.get().id);
+ assertEquals(4, dependentProvider.get().id);
+ }
+
// TODO: add tests for other supported injection scenarios
// TODO: add tests for hierarchical scopes
// TODO: add tests for @Named alias annotations like @PluginAttribute == @Named
[logging-log4j2] 05/06: Rename scope annotations to use Scoped
suffix
Posted by ma...@apache.org.
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 a3d78053a818a3b7b5efb92471fec2df47eac6ac
Author: Matt Sicker <bo...@gmail.com>
AuthorDate: Sun Mar 22 12:25:41 2020 -0500
Rename scope annotations to use Scoped suffix
This will make them more consistent as additional scopes are added such as @ConfigurationScoped, @RequestScoped, etc.
Signed-off-by: Matt Sicker <bo...@gmail.com>
---
.../log4j/plugins/api/{Dependent.java => DependentScoped.java} | 2 +-
.../java/org/apache/logging/log4j/plugins/api/Produces.java | 4 +++-
.../log4j/plugins/api/{Singleton.java => SingletonScoped.java} | 2 +-
.../log4j/plugins/defaults/bean/DefaultBeanManager.java | 10 +++++-----
.../log4j/plugins/defaults/bean/DependentScopeContext.java | 4 ++--
.../log4j/plugins/defaults/model/DefaultElementManager.java | 4 ++--
.../org/apache/logging/log4j/plugins/spi/model/Variable.java | 4 ++--
.../log4j/plugins/defaults/bean/DefaultBeanManagerTest.java | 10 +++++-----
8 files changed, 21 insertions(+), 19 deletions(-)
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/Dependent.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/DependentScoped.java
similarity index 97%
rename from log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/Dependent.java
rename to log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/DependentScoped.java
index 57f2a58..da8e77e 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/Dependent.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/DependentScoped.java
@@ -34,5 +34,5 @@ import java.lang.annotation.RetentionPolicy;
@Documented
@Inherited
@ScopeType
-public @interface Dependent {
+public @interface DependentScoped {
}
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/Produces.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/Produces.java
index 213ba26..5c46c56 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/Produces.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/Produces.java
@@ -23,7 +23,9 @@ import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
-@Target({ElementType.METHOD, ElementType.FIELD, ElementType.TYPE_USE})
+// https://docs.jboss.org/cdi/api/2.0/javax/enterprise/inject/Produces.html
+// https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/context/annotation/Bean.html
+@Target({ElementType.METHOD, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Produces {
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/Singleton.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/SingletonScoped.java
similarity index 96%
rename from log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/Singleton.java
rename to log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/SingletonScoped.java
index 6daa25d..750bc69 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/Singleton.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/SingletonScoped.java
@@ -27,5 +27,5 @@ import java.lang.annotation.RetentionPolicy;
@Documented
@Inherited
@ScopeType
-public @interface Singleton {
+public @interface SingletonScoped {
}
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 5c98bf1..46afdbf 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
@@ -17,11 +17,11 @@
package org.apache.logging.log4j.plugins.defaults.bean;
-import org.apache.logging.log4j.plugins.api.Dependent;
+import org.apache.logging.log4j.plugins.api.DependentScoped;
import org.apache.logging.log4j.plugins.api.Disposes;
import org.apache.logging.log4j.plugins.api.Produces;
import org.apache.logging.log4j.plugins.api.Provider;
-import org.apache.logging.log4j.plugins.api.Singleton;
+import org.apache.logging.log4j.plugins.api.SingletonScoped;
import org.apache.logging.log4j.plugins.defaults.model.DefaultElementManager;
import org.apache.logging.log4j.plugins.spi.AmbiguousBeanException;
import org.apache.logging.log4j.plugins.spi.DefinitionException;
@@ -86,8 +86,8 @@ public class DefaultBeanManager implements BeanManager {
public DefaultBeanManager(final ElementManager elementManager) {
this.elementManager = elementManager;
// TODO: need a better way to register scope contexts
- scopes.put(Dependent.class, new DependentScopeContext());
- scopes.put(Singleton.class, new DefaultScopeContext(Singleton.class));
+ scopes.put(DependentScoped.class, new DependentScopeContext());
+ scopes.put(SingletonScoped.class, new DefaultScopeContext(SingletonScoped.class));
}
@Override
@@ -245,7 +245,7 @@ public class DefaultBeanManager implements BeanManager {
final Bean<?> bean = point.getBean()
.orElseThrow(() -> new DefinitionException("Cannot inject " + point + " into a non-bean"));
if (!bean.isDependentScoped()) {
- throw new DefinitionException("Injection points can only be @Dependent scoped; got: " + point);
+ throw new DefinitionException("Injection points can only be @DependentScoped scoped; got: " + point);
}
}
if (rawType.equals(Bean.class)) {
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DependentScopeContext.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DependentScopeContext.java
index b8c8208..09b4a7a 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DependentScopeContext.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DependentScopeContext.java
@@ -17,7 +17,7 @@
package org.apache.logging.log4j.plugins.defaults.bean;
-import org.apache.logging.log4j.plugins.api.Dependent;
+import org.apache.logging.log4j.plugins.api.DependentScoped;
import org.apache.logging.log4j.plugins.spi.bean.Bean;
import org.apache.logging.log4j.plugins.spi.bean.InitializationContext;
import org.apache.logging.log4j.plugins.spi.bean.ScopeContext;
@@ -28,7 +28,7 @@ import java.util.Optional;
class DependentScopeContext implements ScopeContext {
@Override
public Class<? extends Annotation> getScopeType() {
- return Dependent.class;
+ return DependentScoped.class;
}
@Override
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultElementManager.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultElementManager.java
index b690d59..9fed171 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultElementManager.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultElementManager.java
@@ -19,7 +19,7 @@ package org.apache.logging.log4j.plugins.defaults.model;
import org.apache.logging.log4j.plugins.api.AnnotationAlias;
import org.apache.logging.log4j.plugins.api.Default;
-import org.apache.logging.log4j.plugins.api.Dependent;
+import org.apache.logging.log4j.plugins.api.DependentScoped;
import org.apache.logging.log4j.plugins.api.Ignore;
import org.apache.logging.log4j.plugins.api.Named;
import org.apache.logging.log4j.plugins.api.QualifierType;
@@ -138,7 +138,7 @@ public class DefaultElementManager implements ElementManager {
private Class<? extends Annotation> getScopeType(final MetaElement element) {
final Collection<Class<? extends Annotation>> scopeTypes = filterScopeTypes(element.getAnnotations());
- return scopeTypes.isEmpty() ? Dependent.class : scopeTypes.iterator().next();
+ return scopeTypes.isEmpty() ? DependentScoped.class : scopeTypes.iterator().next();
}
private Collection<Class<? extends Annotation>> filterScopeTypes(final Collection<MetaAnnotation> annotations) {
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/Variable.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/Variable.java
index 2396158..31b379a 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/Variable.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/Variable.java
@@ -17,7 +17,7 @@
package org.apache.logging.log4j.plugins.spi.model;
-import org.apache.logging.log4j.plugins.api.Dependent;
+import org.apache.logging.log4j.plugins.api.DependentScoped;
import org.apache.logging.log4j.plugins.util.TypeUtil;
import java.lang.annotation.Annotation;
@@ -43,6 +43,6 @@ public interface Variable {
Class<? extends Annotation> getScopeType();
default boolean isDependentScoped() {
- return getScopeType() == Dependent.class;
+ return getScopeType() == DependentScoped.class;
}
}
diff --git a/log4j-plugins/src/test/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultBeanManagerTest.java b/log4j-plugins/src/test/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultBeanManagerTest.java
index 9b35cba..e679643 100644
--- a/log4j-plugins/src/test/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultBeanManagerTest.java
+++ b/log4j-plugins/src/test/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultBeanManagerTest.java
@@ -24,7 +24,7 @@ import org.apache.logging.log4j.plugins.api.PostConstruct;
import org.apache.logging.log4j.plugins.api.Produces;
import org.apache.logging.log4j.plugins.api.Provider;
import org.apache.logging.log4j.plugins.api.QualifierType;
-import org.apache.logging.log4j.plugins.api.Singleton;
+import org.apache.logging.log4j.plugins.api.SingletonScoped;
import org.apache.logging.log4j.plugins.test.BeanJUnit4Runner;
import org.apache.logging.log4j.plugins.test.WithBeans;
import org.junit.Test;
@@ -46,11 +46,11 @@ public class DefaultBeanManagerTest {
}
@Produces
- @Singleton
+ @SingletonScoped
public String globalString = "global string value";
@Produces
- @Singleton
+ @SingletonScoped
@Run
public String testString() {
return "test string value";
@@ -130,7 +130,7 @@ public class DefaultBeanManagerTest {
assertNotSame(first, second);
}
- @Singleton
+ @SingletonScoped
public static class SingletonInjection {
}
@@ -222,7 +222,7 @@ public class DefaultBeanManagerTest {
assertTrue(instance.isPresent());
}
- @Singleton
+ @SingletonScoped
public static class IdGenerator {
private final AtomicInteger current = new AtomicInteger();
[logging-log4j2] 04/06: Use normalized internal state for qualifers
Posted by ma...@apache.org.
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 aaccfb9fd387458b105282eed093c293fd548e0b
Author: Matt Sicker <bo...@gmail.com>
AuthorDate: Sun Mar 22 12:02:08 2020 -0500
Use normalized internal state for qualifers
This will allow for a different implementation in the annotation processor if necessary.
Signed-off-by: Matt Sicker <bo...@gmail.com>
---
.../plugins/defaults/model/DefaultQualifiers.java | 39 +++++++++++++---------
.../log4j/plugins/spi/model/Qualifiers.java | 17 +++++++---
2 files changed, 37 insertions(+), 19 deletions(-)
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultQualifiers.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultQualifiers.java
index 2a6eed2..9104b6b 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultQualifiers.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultQualifiers.java
@@ -20,39 +20,48 @@ package org.apache.logging.log4j.plugins.defaults.model;
import org.apache.logging.log4j.plugins.api.Default;
import org.apache.logging.log4j.plugins.spi.model.MetaAnnotation;
import org.apache.logging.log4j.plugins.spi.model.MetaAnnotationElement;
+import org.apache.logging.log4j.plugins.spi.model.MetaElement;
import org.apache.logging.log4j.plugins.spi.model.Qualifiers;
import org.apache.logging.log4j.util.StringBuilders;
-import java.util.Collection;
-import java.util.Objects;
+import java.lang.annotation.Annotation;
+import java.util.Map;
import java.util.Set;
+import java.util.stream.Collectors;
/**
* Represents a normalized set of {@linkplain org.apache.logging.log4j.plugins.api.QualifierType qualifier annotations}.
*/
class DefaultQualifiers implements Qualifiers {
- private final Set<MetaAnnotation> qualifiers;
+ private final Map<Class<? extends Annotation>, Map<String, Object>> qualifiers;
DefaultQualifiers(final Set<MetaAnnotation> qualifiers) {
- this.qualifiers = qualifiers;
+ this.qualifiers = qualifiers.stream()
+ .collect(Collectors.toMap(MetaAnnotation::getAnnotationType,
+ ann -> ann.getAnnotationElements().stream()
+ .collect(Collectors.toMap(MetaElement::getName, MetaAnnotationElement::getValue))));
}
@Override
public boolean hasDefaultQualifier() {
- return qualifiers.stream().anyMatch(q -> q.getAnnotationType() == Default.class);
+ return qualifiers.containsKey(Default.class);
+ }
+
+ @Override
+ public Set<Map.Entry<Class<? extends Annotation>, Map<String, Object>>> getQualifierEntries() {
+ return qualifiers.entrySet();
}
@Override
public boolean equals(final Object o) {
- if (this == o) return true;
- if (o == null || getClass() != o.getClass()) return false;
- final DefaultQualifiers that = (DefaultQualifiers) o;
- return qualifiers.equals(that.qualifiers);
+ // these should intentionally be substitutable by never using the subclass types directly
+ // i.e., we'd like to allow equality with annotation-processor-generated qualifiers later
+ return this == o || o instanceof Qualifiers && this.equalTo((Qualifiers) o);
}
@Override
public int hashCode() {
- return Objects.hash(qualifiers);
+ return hash();
}
@Override
@@ -61,13 +70,13 @@ class DefaultQualifiers implements Qualifiers {
return "[]";
}
StringBuilder sb = new StringBuilder().append('[');
- for (final MetaAnnotation qualifier : qualifiers) {
- sb.append('@').append(qualifier.getAnnotationType().getSimpleName());
- final Collection<MetaAnnotationElement<?>> elements = qualifier.getAnnotationElements();
+ for (final Map.Entry<Class<? extends Annotation>, Map<String, Object>> qualifier : qualifiers.entrySet()) {
+ sb.append('@').append(qualifier.getKey().getSimpleName());
+ final Map<String, Object> elements = qualifier.getValue();
if (!elements.isEmpty()) {
sb.append('(');
- for (final MetaAnnotationElement<?> element : elements) {
- StringBuilders.appendKeyDqValue(sb, element.getName(), element.getValue()).append(", ");
+ for (final Map.Entry<String, Object> element : elements.entrySet()) {
+ StringBuilders.appendKeyDqValue(sb, element.getKey(), element.getValue()).append(", ");
}
sb.delete(sb.length() - 2, sb.length()).append(')');
}
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/Qualifiers.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/Qualifiers.java
index 762f349..648d460 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/Qualifiers.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/Qualifiers.java
@@ -17,12 +17,21 @@
package org.apache.logging.log4j.plugins.spi.model;
+import java.lang.annotation.Annotation;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+
public interface Qualifiers {
boolean hasDefaultQualifier();
- @Override
- boolean equals(Object o);
+ Set<Map.Entry<Class<? extends Annotation>, Map<String, Object>>> getQualifierEntries();
+
+ default boolean equalTo(final Qualifiers other) {
+ return Objects.equals(getQualifierEntries(), other.getQualifierEntries());
+ }
- @Override
- int hashCode();
+ default int hash() {
+ return Objects.hashCode(getQualifierEntries());
+ }
}
[logging-log4j2] 01/06: Remove unused type parameters
Posted by ma...@apache.org.
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 b95c818cfb6baea30a8b49d16ccbd08a02402271
Author: Matt Sicker <bo...@gmail.com>
AuthorDate: Sat Mar 21 12:40:49 2020 -0500
Remove unused type parameters
These type parameters are occasionally used by their concrete implementations,
but this can be a hidden detail.
Signed-off-by: Matt Sicker <bo...@gmail.com>
---
.../log4j/plugins/defaults/bean/AbstractBean.java | 10 +++---
.../plugins/defaults/bean/AbstractProducer.java | 4 +--
.../defaults/bean/AbstractProducerFactory.java | 11 ++++---
.../plugins/defaults/bean/DefaultBeanManager.java | 36 +++++++++++-----------
.../bean/DefaultInitializationContext.java | 2 +-
.../defaults/bean/DefaultInjectionTarget.java | 29 ++++++-----------
.../bean/DefaultInjectionTargetFactory.java | 2 +-
.../plugins/defaults/bean/DefaultInjector.java | 18 ++++++-----
.../log4j/plugins/defaults/bean/FieldProducer.java | 6 ++--
.../defaults/bean/FieldProducerFactory.java | 2 +-
.../plugins/defaults/bean/InjectionTargetBean.java | 4 +--
.../plugins/defaults/bean/MethodProducer.java | 8 ++---
.../defaults/bean/MethodProducerFactory.java | 6 ++--
.../log4j/plugins/defaults/bean/ProducerBean.java | 8 ++---
.../log4j/plugins/defaults/bean/SystemBean.java | 8 ++---
.../defaults/model/AbstractMetaExecutable.java | 8 ++---
.../plugins/defaults/model/AbstractMetaMember.java | 2 +-
.../defaults/model/DefaultElementManager.java | 22 ++++++-------
.../defaults/model/DefaultInjectionPoint.java | 14 ++++-----
.../model/DefaultMetaAnnotationElement.java | 6 ----
.../defaults/model/DefaultMetaParameter.java | 10 +++---
.../plugins/spi/UnsatisfiedBeanException.java | 2 +-
.../logging/log4j/plugins/spi/bean/Bean.java | 2 +-
.../log4j/plugins/spi/bean/BeanManager.java | 2 +-
.../logging/log4j/plugins/spi/bean/Injector.java | 10 +++---
.../logging/log4j/plugins/spi/bean/Producer.java | 2 +-
.../log4j/plugins/spi/bean/ProducerFactory.java | 2 +-
.../log4j/plugins/spi/model/ElementManager.java | 18 +++++------
.../log4j/plugins/spi/model/InjectionPoint.java | 8 ++---
.../plugins/spi/model/MetaAnnotationElement.java | 2 +-
.../logging/log4j/plugins/spi/model/MetaClass.java | 2 +-
.../log4j/plugins/spi/model/MetaConstructor.java | 2 +-
.../log4j/plugins/spi/model/MetaElement.java | 7 +++--
.../log4j/plugins/spi/model/MetaExecutable.java | 4 +--
.../logging/log4j/plugins/spi/model/MetaField.java | 2 +-
.../log4j/plugins/spi/model/MetaMember.java | 2 +-
.../log4j/plugins/spi/model/MetaMethod.java | 2 +-
.../log4j/plugins/spi/model/MetaParameter.java | 2 +-
.../log4j/plugins/test/BeanJUnit4Runner.java | 2 +-
39 files changed, 137 insertions(+), 152 deletions(-)
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/AbstractBean.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/AbstractBean.java
index 947d722..c9110bf 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/AbstractBean.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/AbstractBean.java
@@ -27,17 +27,17 @@ import java.lang.reflect.Type;
import java.util.Collection;
import java.util.Objects;
-abstract class AbstractBean<D, T> implements Bean<T> {
+abstract class AbstractBean<T> implements Bean<T> {
private final Variable variable;
- private final MetaClass<D> declaringClass;
+ private final MetaClass<?> declaringClass;
- AbstractBean(final Variable variable, final MetaClass<D> declaringClass) {
+ AbstractBean(final Variable variable, final MetaClass<?> declaringClass) {
this.variable = Objects.requireNonNull(variable);
this.declaringClass = declaringClass;
}
@Override
- public MetaClass<D> getDeclaringClass() {
+ public MetaClass<?> getDeclaringClass() {
return declaringClass;
}
@@ -60,7 +60,7 @@ abstract class AbstractBean<D, T> implements Bean<T> {
public boolean equals(final Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
- final AbstractBean<?, ?> that = (AbstractBean<?, ?>) o;
+ final AbstractBean<?> that = (AbstractBean<?>) o;
return variable.equals(that.variable) &&
Objects.equals(declaringClass, that.declaringClass);
}
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 5781a2b..df73dc6 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
@@ -33,11 +33,11 @@ abstract class AbstractProducer<P, T> implements Producer<T> {
private final BeanManager beanManager;
private final Bean<P> producerBean;
private final MetaMethod<P, ?> disposerMethod;
- private final Collection<InjectionPoint<?>> disposerInjectionPoints;
+ private final Collection<InjectionPoint> disposerInjectionPoints;
final Injector injector;
AbstractProducer(final BeanManager beanManager, final Bean<P> producerBean, final MetaMethod<P, ?> disposerMethod,
- final Collection<InjectionPoint<?>> disposerInjectionPoints) {
+ final Collection<InjectionPoint> disposerInjectionPoints) {
this.beanManager = beanManager;
this.producerBean = producerBean;
this.disposerMethod = disposerMethod;
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/AbstractProducerFactory.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/AbstractProducerFactory.java
index a73840f..2ded1aa 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/AbstractProducerFactory.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/AbstractProducerFactory.java
@@ -26,14 +26,15 @@ import org.apache.logging.log4j.plugins.spi.model.MetaMethod;
import java.util.Collection;
import java.util.Objects;
-abstract class AbstractProducerFactory<D> implements ProducerFactory<D> {
+abstract class AbstractProducerFactory<D> implements ProducerFactory {
final Bean<D> declaringBean;
- final MetaMember<D, ?> producerMember;
+ final MetaMember<D> producerMember;
final MetaMethod<D, ?> disposerMethod;
- final Collection<InjectionPoint<?>> disposerInjectionPoints;
+ final Collection<InjectionPoint> disposerInjectionPoints;
- AbstractProducerFactory(final Bean<D> declaringBean, final MetaMember<D, ?> producerMember,
- final MetaMethod<D, ?> disposerMethod, final Collection<InjectionPoint<?>> disposerInjectionPoints) {
+ AbstractProducerFactory(final Bean<D> declaringBean, final MetaMember<D> producerMember,
+ final MetaMethod<D, ?> disposerMethod,
+ final Collection<InjectionPoint> disposerInjectionPoints) {
this.declaringBean = declaringBean;
this.producerMember = Objects.requireNonNull(producerMember);
this.disposerMethod = disposerMethod;
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 eb369be..592a279 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
@@ -154,7 +154,7 @@ public class DefaultBeanManager implements BeanManager {
private <T> void loadDisposerMethods(final MetaClass<T> metaClass, final Bean<T> bean) {
for (final MetaMethod<T, ?> method : metaClass.getMethods()) {
- for (final MetaParameter<?> parameter : method.getParameters()) {
+ for (final MetaParameter parameter : method.getParameters()) {
if (parameter.isAnnotationPresent(Disposes.class)) {
disposesMethods.add(new DisposesMethod<>(
parameter.getType(), elementManager.getQualifiers(parameter), bean, method));
@@ -178,24 +178,24 @@ public class DefaultBeanManager implements BeanManager {
return beans;
}
- private <P, T> Bean<T> loadProducerBean(final MetaMember<P, T> member, final Bean<P> producingBean) {
+ private <P> Bean<?> loadProducerBean(final MetaMember<P> member, final Bean<P> producingBean) {
final Variable variable = elementManager.createVariable(member);
final MetaClass<P> declaringType = member.getDeclaringClass();
- final ProducerFactory<P> factory = getProducerFactory(member, producingBean);
+ final ProducerFactory factory = getProducerFactory(member, producingBean);
return addBean(new ProducerBean<>(variable, declaringType, factory));
}
- private <P> ProducerFactory<P> getProducerFactory(final MetaMember<P, ?> member, final Bean<P> producingBean) {
+ private <P> ProducerFactory getProducerFactory(final MetaMember<P> member, final Bean<P> producingBean) {
final Variable variable = elementManager.createVariable(member);
final MetaMethod<P, ?> disposerMethod = resolveDisposerMethod(variable, producingBean);
- final Collection<InjectionPoint<?>> disposerIPs = disposerMethod == null ? Collections.emptySet() :
+ final Collection<InjectionPoint> disposerIPs = disposerMethod == null ? Collections.emptySet() :
elementManager.createExecutableInjectionPoints(disposerMethod, producingBean);
if (member instanceof MetaField<?, ?>) {
- final MetaField<P, ?> field = TypeUtil.cast(member);
+ final MetaField<P, ?> field = (MetaField<P, ?>) member;
return new FieldProducerFactory<>(this, producingBean, field, disposerMethod, disposerIPs);
} else {
- final MetaMethod<P, ?> method = TypeUtil.cast(member);
- final Collection<InjectionPoint<?>> producerIPs =
+ final MetaMethod<P, ?> method = (MetaMethod<P, ?>) member;
+ final Collection<InjectionPoint> producerIPs =
elementManager.createExecutableInjectionPoints(method, producingBean);
return new MethodProducerFactory<>(this, producingBean, method, producerIPs, disposerMethod, disposerIPs);
}
@@ -219,7 +219,7 @@ public class DefaultBeanManager implements BeanManager {
public void validateBeans(final Iterable<Bean<?>> beans) {
final List<Throwable> errors = new ArrayList<>();
for (final Bean<?> bean : beans) {
- for (final InjectionPoint<?> point : bean.getInjectionPoints()) {
+ for (final InjectionPoint point : bean.getInjectionPoints()) {
try {
validateInjectionPoint(point);
} catch (final InjectionException e) {
@@ -232,8 +232,8 @@ public class DefaultBeanManager implements BeanManager {
}
}
- private <T> void validateInjectionPoint(final InjectionPoint<T> point) {
- final MetaElement<T> element = point.getElement();
+ private <T> void validateInjectionPoint(final InjectionPoint point) {
+ final MetaElement element = point.getElement();
if (element.isAnnotationPresent(Produces.class)) {
throw new DefinitionException("Cannot inject into a @Produces element: " + element);
}
@@ -253,8 +253,8 @@ public class DefaultBeanManager implements BeanManager {
final Bean<?> bean = point.getBean().orElseThrow(() -> new UnsatisfiedBeanException(point));
if (bean instanceof InjectionTargetBean<?>) {
validateBeanInjectionPoint(point, bean.getDeclaringClass().getType());
- } else if (bean instanceof ProducerBean<?, ?>) {
- validateBeanInjectionPoint(point, ((ProducerBean<?, ?>) bean).getType());
+ } else if (bean instanceof ProducerBean<?>) {
+ validateBeanInjectionPoint(point, ((ProducerBean<?>) bean).getType());
}
}
final Optional<Bean<T>> bean = getInjectionPointBean(point);
@@ -263,7 +263,7 @@ public class DefaultBeanManager implements BeanManager {
}
}
- private void validateBeanInjectionPoint(final InjectionPoint<?> point, final Type expectedType) {
+ private void validateBeanInjectionPoint(final InjectionPoint point, final Type expectedType) {
final Type type = point.getType();
if (!(type instanceof ParameterizedType)) {
throw new DefinitionException("Expected parameterized type for " + point + " but got " + expectedType);
@@ -282,7 +282,7 @@ public class DefaultBeanManager implements BeanManager {
}
}
- private <T> Optional<Bean<T>> getInjectionPointBean(final InjectionPoint<T> point) {
+ private <T> Optional<Bean<T>> getInjectionPointBean(final InjectionPoint point) {
// TODO: this will need to allow for TypeConverter usage somehow
// first, look for an existing bean
final Type type = point.getType();
@@ -373,9 +373,9 @@ public class DefaultBeanManager implements BeanManager {
}
@Override
- public <T> Optional<T> getInjectableValue(final InjectionPoint<T> point, final InitializationContext<?> parentContext) {
- final Bean<T> resolvedBean = getInjectionPointBean(point)
- .orElseThrow(() -> new UnsatisfiedBeanException(point));
+ public <T> Optional<T> getInjectableValue(final InjectionPoint point, final InitializationContext<?> parentContext) {
+ final Optional<Bean<T>> optionalResolvedBean = getInjectionPointBean(point);
+ final Bean<T> resolvedBean = optionalResolvedBean.orElseThrow(() -> new UnsatisfiedBeanException(point));
final Optional<T> existingValue = point.getBean()
.filter(bean -> !bean.equals(resolvedBean))
.flatMap(bean -> getExistingValue(resolvedBean, bean, parentContext));
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultInitializationContext.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultInitializationContext.java
index 3ed8893..7e54175 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultInitializationContext.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultInitializationContext.java
@@ -67,7 +67,7 @@ public class DefaultInitializationContext<T> implements InitializationContext<T>
@Override
public boolean isTrackingDependencies(final Bean<T> bean) {
return !dependentInstances.isEmpty() ||
- (bean instanceof AbstractBean<?, ?> && ((AbstractBean<?, ?>) bean).isTrackingDependencies());
+ (bean instanceof AbstractBean<?> && ((AbstractBean<?>) bean).isTrackingDependencies());
}
@Override
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 869fa00..069ead6 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
@@ -27,7 +27,6 @@ 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.MetaConstructor;
-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;
@@ -44,13 +43,13 @@ import java.util.stream.Collectors;
class DefaultInjectionTarget<T> implements InjectionTarget<T> {
private final Injector injector;
private final ElementManager elementManager;
- private final Collection<InjectionPoint<?>> injectionPoints;
+ private final Collection<InjectionPoint> injectionPoints;
private final MetaConstructor<T> constructor;
private final List<MetaMethod<T, ?>> postConstructMethods;
private final List<MetaMethod<T, ?>> preDestroyMethods;
DefaultInjectionTarget(final Injector injector, final ElementManager elementManager,
- final Collection<InjectionPoint<?>> injectionPoints, final MetaConstructor<T> constructor,
+ final Collection<InjectionPoint> injectionPoints, final MetaConstructor<T> constructor,
final List<MetaMethod<T, ?>> postConstructMethods, final List<MetaMethod<T, ?>> preDestroyMethods) {
this.injector = injector;
this.elementManager = elementManager;
@@ -62,7 +61,7 @@ class DefaultInjectionTarget<T> implements InjectionTarget<T> {
@Override
public T produce(final InitializationContext<T> context) {
- final Set<InjectionPoint<?>> constructorInjectionPoints = injectionPoints.stream()
+ final Set<InjectionPoint> constructorInjectionPoints = injectionPoints.stream()
.filter(point -> constructor.equals(point.getMember()))
.collect(Collectors.toSet());
return injector.construct(constructor, constructorInjectionPoints, context);
@@ -82,29 +81,21 @@ class DefaultInjectionTarget<T> implements InjectionTarget<T> {
}
private void injectFields(final T instance, final InitializationContext<T> context) {
- for (final InjectionPoint<?> point : injectionPoints) {
- injectField(instance, context, point);
- }
- }
-
- private <F> void injectField(final T instance, final InitializationContext<T> context, final InjectionPoint<F> point) {
- 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;
- injector.set(instance, field, point, context);
- }
+ injectionPoints.stream()
+ .filter(point -> point.getElement() instanceof MetaField<?, ?>)
+ .forEachOrdered(point -> injector.set(instance, TypeUtil.cast(point.getElement()), point, context));
}
private void injectMethods(final T instance, final InitializationContext<T> context) {
- final Set<MetaMember<?, ?>> injectedMethods = new HashSet<>();
- for (final InjectionPoint<?> point : injectionPoints) {
+ final Set<MetaMember<?>> injectedMethods = new HashSet<>();
+ for (final InjectionPoint point : injectionPoints) {
if (point.getMember() instanceof MetaMethod<?, ?> &&
point.getMember().getDeclaringClass().getJavaClass().isInstance(instance) &&
!injectedMethods.contains(point.getMember()) &&
!point.getElement().isAnnotationPresent(Produces.class) &&
!point.getElement().isAnnotationPresent(Disposes.class)) {
final MetaMethod<T, ?> method = TypeUtil.cast(point.getMember());
- final Set<InjectionPoint<?>> methodInjectionPoints = injectionPoints.stream()
+ final Set<InjectionPoint> methodInjectionPoints = injectionPoints.stream()
.filter(p -> method.equals(p.getMember()))
.collect(Collectors.toSet());
injector.invoke(instance, method, methodInjectionPoints, context);
@@ -128,7 +119,7 @@ class DefaultInjectionTarget<T> implements InjectionTarget<T> {
}
@Override
- public Collection<InjectionPoint<?>> getInjectionPoints() {
+ public Collection<InjectionPoint> getInjectionPoints() {
return injectionPoints;
}
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 30c30ec..78ab70d 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
@@ -53,7 +53,7 @@ class DefaultInjectionTargetFactory<T> implements InjectionTargetFactory<T> {
@Override
public InjectionTarget<T> createInjectionTarget(final Bean<T> bean) {
final MetaConstructor<T> constructor = getInjectableConstructor();
- final Collection<InjectionPoint<?>> injectionPoints =
+ final Collection<InjectionPoint> injectionPoints =
new HashSet<>(elementManager.createExecutableInjectionPoints(constructor, bean));
for (final MetaField<T, ?> field : type.getFields()) {
if (elementManager.isInjectable(field)) {
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
index 0d12b6f..6e228a8 100644
--- 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
@@ -29,6 +29,7 @@ import org.apache.logging.log4j.plugins.spi.model.MetaParameter;
import java.util.Collection;
import java.util.List;
+import java.util.Optional;
public class DefaultInjector implements Injector {
private final BeanManager beanManager;
@@ -37,8 +38,8 @@ public class DefaultInjector implements Injector {
this.beanManager = beanManager;
}
- private Object[] createArguments(final List<MetaParameter<?>> parameters,
- final Collection<InjectionPoint<?>> injectionPoints,
+ 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()
@@ -50,33 +51,34 @@ public class DefaultInjector implements Injector {
}
@Override
- public <T> T construct(final MetaConstructor<T> constructor, final Collection<InjectionPoint<?>> points,
+ 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<D> context) {
+ final Collection<InjectionPoint> points, final InitializationContext<D> 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 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,
+ 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,
+ public <D, T> void set(final D instance, final MetaField<D, T> field, final InjectionPoint point,
final InitializationContext<D> context) {
- beanManager.getInjectableValue(point, context).ifPresent(value -> field.set(instance, value));
+ final Optional<T> optionalValue = beanManager.getInjectableValue(point, context);
+ optionalValue.ifPresent(value -> field.set(instance, value));
}
}
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/FieldProducer.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/FieldProducer.java
index 8c21750..7529ee1 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/FieldProducer.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/FieldProducer.java
@@ -19,10 +19,10 @@ 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.InitializationContext;
import org.apache.logging.log4j.plugins.spi.model.InjectionPoint;
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.bean.InitializationContext;
import java.lang.reflect.Type;
import java.util.Collection;
@@ -32,7 +32,7 @@ class FieldProducer<P, T> extends AbstractProducer<P, T> {
private final MetaField<P, T> field;
FieldProducer(final BeanManager beanManager, final Bean<P> producerBean, final MetaField<P, T> field,
- final MetaMethod<P, ?> disposerMethod, final Collection<InjectionPoint<?>> disposerInjectionPoints) {
+ final MetaMethod<P, ?> disposerMethod, final Collection<InjectionPoint> disposerInjectionPoints) {
super(beanManager, producerBean, disposerMethod, disposerInjectionPoints);
this.field = field;
}
@@ -53,7 +53,7 @@ class FieldProducer<P, T> extends AbstractProducer<P, T> {
}
@Override
- public Collection<InjectionPoint<?>> getInjectionPoints() {
+ public Collection<InjectionPoint> getInjectionPoints() {
return Collections.emptySet();
}
}
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/FieldProducerFactory.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/FieldProducerFactory.java
index 8ac3097..f629a45 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/FieldProducerFactory.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/FieldProducerFactory.java
@@ -32,7 +32,7 @@ class FieldProducerFactory<D> extends AbstractProducerFactory<D> {
FieldProducerFactory(final BeanManager beanManager, final Bean<D> declaringBean,
final MetaField<D, ?> producerField, final MetaMethod<D, ?> disposerMethod,
- final Collection<InjectionPoint<?>> disposerInjectionPoints) {
+ final Collection<InjectionPoint> disposerInjectionPoints) {
super(declaringBean, producerField, disposerMethod, disposerInjectionPoints);
this.beanManager = beanManager;
}
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/InjectionTargetBean.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/InjectionTargetBean.java
index d71839a..663ecd4 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/InjectionTargetBean.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/InjectionTargetBean.java
@@ -28,7 +28,7 @@ import org.apache.logging.log4j.plugins.spi.model.Variable;
import java.util.Collection;
import java.util.Objects;
-class InjectionTargetBean<T> extends AbstractBean<T, T> {
+class InjectionTargetBean<T> extends AbstractBean<T> {
private final InjectionTarget<T> injectionTarget;
InjectionTargetBean(final Variable variable, final MetaClass<T> declaringClass,
@@ -39,7 +39,7 @@ class InjectionTargetBean<T> extends AbstractBean<T, T> {
}
@Override
- public Collection<InjectionPoint<?>> getInjectionPoints() {
+ public Collection<InjectionPoint> getInjectionPoints() {
return injectionTarget.getInjectionPoints();
}
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 8b80a4a..8baf1c2 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
@@ -29,11 +29,11 @@ import java.util.Collection;
class MethodProducer<P, T> extends AbstractProducer<P, T> {
private final MetaMethod<P, T> producerMethod;
- private final Collection<InjectionPoint<?>> producerInjectionPoints;
+ private final Collection<InjectionPoint> producerInjectionPoints;
MethodProducer(final BeanManager beanManager, final Bean<P> producerBean,
- final MetaMethod<P, T> producerMethod, final Collection<InjectionPoint<?>> producerInjectionPoints,
- final MetaMethod<P, ?> disposerMethod, final Collection<InjectionPoint<?>> disposerInjectionPoints) {
+ final MetaMethod<P, T> producerMethod, final Collection<InjectionPoint> producerInjectionPoints,
+ final MetaMethod<P, ?> disposerMethod, final Collection<InjectionPoint> disposerInjectionPoints) {
super(beanManager, producerBean, disposerMethod, disposerInjectionPoints);
if (!producerMethod.isStatic() && producerBean == null) {
throw new DefinitionException("Producer instance method must be in a bean");
@@ -56,7 +56,7 @@ class MethodProducer<P, T> extends AbstractProducer<P, T> {
}
@Override
- public Collection<InjectionPoint<?>> getInjectionPoints() {
+ public Collection<InjectionPoint> getInjectionPoints() {
return producerInjectionPoints;
}
}
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/MethodProducerFactory.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/MethodProducerFactory.java
index 73e4b35..d503cea 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/MethodProducerFactory.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/MethodProducerFactory.java
@@ -28,11 +28,11 @@ import java.util.Collection;
class MethodProducerFactory<D> extends AbstractProducerFactory<D> {
private final BeanManager beanManager;
- private final Collection<InjectionPoint<?>> producerInjectionPoints;
+ private final Collection<InjectionPoint> producerInjectionPoints;
MethodProducerFactory(final BeanManager beanManager, final Bean<D> declaringBean,
- final MetaMethod<D, ?> producerMethod, final Collection<InjectionPoint<?>> producerInjectionPoints,
- final MetaMethod<D, ?> disposerMethod, final Collection<InjectionPoint<?>> disposerInjectionPoints) {
+ final MetaMethod<D, ?> producerMethod, final Collection<InjectionPoint> producerInjectionPoints,
+ final MetaMethod<D, ?> disposerMethod, final Collection<InjectionPoint> disposerInjectionPoints) {
super(declaringBean, producerMethod, disposerMethod, disposerInjectionPoints);
this.producerInjectionPoints = producerInjectionPoints;
this.beanManager = beanManager;
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/ProducerBean.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/ProducerBean.java
index 5eea07b..a70f1fd 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/ProducerBean.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/ProducerBean.java
@@ -18,22 +18,22 @@
package org.apache.logging.log4j.plugins.defaults.bean;
import org.apache.logging.log4j.plugins.spi.IllegalProductException;
+import org.apache.logging.log4j.plugins.spi.bean.InitializationContext;
import org.apache.logging.log4j.plugins.spi.bean.Producer;
import org.apache.logging.log4j.plugins.spi.bean.ProducerFactory;
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.Variable;
-import org.apache.logging.log4j.plugins.spi.bean.InitializationContext;
import java.lang.reflect.Type;
import java.util.Collection;
import java.util.Objects;
-class ProducerBean<D, T> extends AbstractBean<D, T> {
+class ProducerBean<T> extends AbstractBean<T> {
private final Producer<T> producer;
private final Type type;
- ProducerBean(final Variable variable, final MetaClass<D> declaringClass, final ProducerFactory<D> factory) {
+ ProducerBean(final Variable variable, final MetaClass<?> declaringClass, final ProducerFactory factory) {
super(variable, declaringClass);
Objects.requireNonNull(factory);
producer = factory.createProducer(this);
@@ -49,7 +49,7 @@ class ProducerBean<D, T> extends AbstractBean<D, T> {
}
@Override
- public Collection<InjectionPoint<?>> getInjectionPoints() {
+ public Collection<InjectionPoint> getInjectionPoints() {
return producer.getInjectionPoints();
}
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/SystemBean.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/SystemBean.java
index 8b55f3d..97cfb94 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/SystemBean.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/SystemBean.java
@@ -17,12 +17,12 @@
package org.apache.logging.log4j.plugins.defaults.bean;
-import org.apache.logging.log4j.plugins.spi.model.MetaClass;
import org.apache.logging.log4j.plugins.spi.bean.Bean;
+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.MetaClass;
import org.apache.logging.log4j.plugins.spi.model.Qualifiers;
import org.apache.logging.log4j.plugins.spi.model.Variable;
-import org.apache.logging.log4j.plugins.spi.model.InjectionPoint;
-import org.apache.logging.log4j.plugins.spi.bean.InitializationContext;
import java.lang.annotation.Annotation;
import java.lang.reflect.Type;
@@ -52,7 +52,7 @@ abstract class SystemBean<T> implements Bean<T> {
}
@Override
- public Collection<InjectionPoint<?>> getInjectionPoints() {
+ public Collection<InjectionPoint> getInjectionPoints() {
return Collections.emptySet();
}
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/AbstractMetaExecutable.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/AbstractMetaExecutable.java
index 60a6fb7..e34a5cc 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/AbstractMetaExecutable.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/AbstractMetaExecutable.java
@@ -26,19 +26,19 @@ import java.lang.reflect.Parameter;
import java.util.ArrayList;
import java.util.List;
-abstract class AbstractMetaExecutable<D, T> extends AbstractMetaMember<D, T> implements MetaExecutable<D, T> {
- private final List<MetaParameter<?>> parameters;
+abstract class AbstractMetaExecutable<D, T> extends AbstractMetaMember<D, T> implements MetaExecutable<D> {
+ private final List<MetaParameter> parameters;
AbstractMetaExecutable(final MetaClass<D> declaringClass, final Executable executable, final MetaClass<T> type) {
super(declaringClass, executable, type);
parameters = new ArrayList<>(executable.getParameterCount());
for (final Parameter parameter : executable.getParameters()) {
- parameters.add(new DefaultMetaParameter<>(parameter));
+ parameters.add(new DefaultMetaParameter(parameter));
}
}
@Override
- public List<MetaParameter<?>> getParameters() {
+ public List<MetaParameter> getParameters() {
return parameters;
}
}
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/AbstractMetaMember.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/AbstractMetaMember.java
index 52dbad2..a7cecdc 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/AbstractMetaMember.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/AbstractMetaMember.java
@@ -27,7 +27,7 @@ import java.lang.reflect.Modifier;
import java.lang.reflect.Type;
import java.util.Collection;
-abstract class AbstractMetaMember<D, T> implements MetaMember<D, T> {
+abstract class AbstractMetaMember<D, T> implements MetaMember<D> {
private final String name;
private final Collection<MetaAnnotation> annotations;
private final MetaClass<D> declaringClass;
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultElementManager.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultElementManager.java
index 8193144..b1a4066 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultElementManager.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultElementManager.java
@@ -90,7 +90,7 @@ public class DefaultElementManager implements ElementManager {
}
@Override
- public Qualifiers getQualifiers(final MetaElement<?> element) {
+ public Qualifiers getQualifiers(final MetaElement element) {
final String elementName = element.getName();
final String defaultNamedValue;
if (element instanceof MetaMethod<?, ?>) {
@@ -136,7 +136,7 @@ public class DefaultElementManager implements ElementManager {
return new DefaultMetaAnnotation(annotationType, elements);
}
- private Class<? extends Annotation> getScopeType(final MetaElement<?> element) {
+ private Class<? extends Annotation> getScopeType(final MetaElement element) {
final Collection<Class<? extends Annotation>> scopeTypes = filterScopeTypes(element.getAnnotations());
return scopeTypes.isEmpty() ? Dependent.class : scopeTypes.iterator().next();
}
@@ -162,35 +162,35 @@ public class DefaultElementManager implements ElementManager {
}
@Override
- public <D, T> InjectionPoint<T> createFieldInjectionPoint(final MetaField<D, T> field, final Bean<D> owner) {
+ public <D> InjectionPoint createFieldInjectionPoint(final MetaField<D, ?> field, final Bean<D> owner) {
Objects.requireNonNull(field);
final Qualifiers qualifiers = getQualifiers(field);
- return new DefaultInjectionPoint<>(field.getType(), qualifiers, owner, field, field);
+ return new DefaultInjectionPoint(field.getType(), qualifiers, owner, field, field);
}
@Override
- public <D, P> InjectionPoint<P> createParameterInjectionPoint(final MetaExecutable<D, ?> executable,
- final MetaParameter<P> parameter,
- final Bean<D> owner) {
+ public <D> InjectionPoint createParameterInjectionPoint(final MetaExecutable<D> executable,
+ final MetaParameter parameter,
+ final Bean<D> owner) {
Objects.requireNonNull(executable);
Objects.requireNonNull(parameter);
final Qualifiers qualifiers = getQualifiers(parameter);
- return new DefaultInjectionPoint<>(parameter.getType(), qualifiers, owner, executable, parameter);
+ return new DefaultInjectionPoint(parameter.getType(), qualifiers, owner, executable, parameter);
}
@Override
- public Variable createVariable(final MetaElement<?> element) {
+ public Variable createVariable(final MetaElement element) {
Objects.requireNonNull(element);
return createVariable(element, getQualifiers(element));
}
@Override
- public Variable createVariable(final InjectionPoint<?> point) {
+ public Variable createVariable(final InjectionPoint point) {
Objects.requireNonNull(point);
return createVariable(point.getElement(), point.getQualifiers());
}
- private Variable createVariable(final MetaElement<?> element, final Qualifiers qualifiers) {
+ private Variable createVariable(final MetaElement element, final Qualifiers qualifiers) {
final Collection<Type> types = element.getTypeClosure();
final Class<? extends Annotation> scopeType = getScopeType(element);
return DefaultVariable.newVariable(types, qualifiers, scopeType);
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultInjectionPoint.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultInjectionPoint.java
index c79405c..eba0996 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultInjectionPoint.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultInjectionPoint.java
@@ -27,15 +27,15 @@ import java.lang.reflect.Type;
import java.util.Objects;
import java.util.Optional;
-class DefaultInjectionPoint<T> implements InjectionPoint<T> {
+class DefaultInjectionPoint implements InjectionPoint {
private final Type type;
private final Qualifiers qualifiers;
private final Bean<?> bean;
- private final MetaMember<?, ?> member;
- private final MetaElement<T> element;
+ private final MetaMember<?> member;
+ private final MetaElement element;
DefaultInjectionPoint(final Type type, final Qualifiers qualifiers, final Bean<?> bean,
- final MetaMember<?, ?> member, final MetaElement<T> element) {
+ final MetaMember<?> member, final MetaElement element) {
this.type = type;
this.qualifiers = qualifiers;
this.bean = bean;
@@ -59,12 +59,12 @@ class DefaultInjectionPoint<T> implements InjectionPoint<T> {
}
@Override
- public MetaMember<?, ?> getMember() {
+ public MetaMember<?> getMember() {
return member;
}
@Override
- public MetaElement<T> getElement() {
+ public MetaElement getElement() {
return element;
}
@@ -72,7 +72,7 @@ class DefaultInjectionPoint<T> implements InjectionPoint<T> {
public boolean equals(final Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
- final DefaultInjectionPoint<?> that = (DefaultInjectionPoint<?>) o;
+ final DefaultInjectionPoint that = (DefaultInjectionPoint) o;
return qualifiers.equals(that.qualifiers) &&
Objects.equals(bean, that.bean) &&
member.equals(that.member) &&
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultMetaAnnotationElement.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultMetaAnnotationElement.java
index acd3e48..ce436c0 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultMetaAnnotationElement.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultMetaAnnotationElement.java
@@ -19,7 +19,6 @@ package org.apache.logging.log4j.plugins.defaults.model;
import org.apache.logging.log4j.plugins.spi.model.MetaAnnotation;
import org.apache.logging.log4j.plugins.spi.model.MetaAnnotationElement;
-import org.apache.logging.log4j.plugins.util.TypeUtil;
import java.lang.reflect.Type;
import java.util.Collection;
@@ -48,11 +47,6 @@ class DefaultMetaAnnotationElement<T> implements MetaAnnotationElement<T> {
}
@Override
- public Collection<Type> getTypeClosure() {
- return TypeUtil.getTypeClosure(getType());
- }
-
- @Override
public Collection<MetaAnnotation> getAnnotations() {
return annotations;
}
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultMetaParameter.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultMetaParameter.java
index 2b7af20..e581fa4 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultMetaParameter.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultMetaParameter.java
@@ -20,22 +20,20 @@ package org.apache.logging.log4j.plugins.defaults.model;
import org.apache.logging.log4j.plugins.spi.model.MetaAnnotation;
import org.apache.logging.log4j.plugins.spi.model.MetaClass;
import org.apache.logging.log4j.plugins.spi.model.MetaParameter;
-import org.apache.logging.log4j.plugins.util.TypeUtil;
import java.lang.reflect.Parameter;
import java.lang.reflect.Type;
import java.util.Collection;
-class DefaultMetaParameter<T> implements MetaParameter<T> {
+class DefaultMetaParameter implements MetaParameter {
private final String name;
- private final MetaClass<T> parameterClass;
+ private final MetaClass<?> parameterClass;
private final String toString;
DefaultMetaParameter(final Parameter parameter) {
name = parameter.getName();
- final Type type = parameter.getParameterizedType();
- final Class<T> javaClass = TypeUtil.cast(parameter.getType());
- parameterClass = DefaultMetaClass.newMetaClass(type, javaClass, parameter.getAnnotations());
+ parameterClass = DefaultMetaClass.newMetaClass(
+ parameter.getParameterizedType(), parameter.getType(), parameter.getAnnotations());
toString = parameter.toString();
}
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/UnsatisfiedBeanException.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/UnsatisfiedBeanException.java
index 3b17bf6..2fc2dff 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/UnsatisfiedBeanException.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/UnsatisfiedBeanException.java
@@ -22,7 +22,7 @@ import org.apache.logging.log4j.plugins.spi.model.InjectionPoint;
import java.lang.reflect.Type;
public class UnsatisfiedBeanException extends ResolutionException {
- public UnsatisfiedBeanException(final InjectionPoint<?> point) {
+ public UnsatisfiedBeanException(final InjectionPoint point) {
super("No beans found for " + point);
}
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/Bean.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/Bean.java
index 482aeec..4950ac8 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/Bean.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/Bean.java
@@ -42,7 +42,7 @@ public interface Bean<T> extends Variable {
*/
void destroy(final T instance, final InitializationContext<T> context);
- Collection<InjectionPoint<?>> getInjectionPoints();
+ Collection<InjectionPoint> getInjectionPoints();
// for a managed bean: that class
// for a producer field or producer method: the declaring class
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/BeanManager.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/BeanManager.java
index a66d1b1..acd772e 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/BeanManager.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/BeanManager.java
@@ -86,7 +86,7 @@ public interface BeanManager extends AutoCloseable {
* @param <T> type of injectable value
* @return value to inject if defined or empty otherwise
*/
- <T> Optional<T> getInjectableValue(final InjectionPoint<T> point, final InitializationContext<?> parentContext);
+ <T> Optional<T> getInjectableValue(final InjectionPoint point, final InitializationContext<?> parentContext);
@Override
void close();
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
index a2c0c4f..e803790 100644
--- 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
@@ -25,19 +25,19 @@ 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,
+ <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<D> context);
+ final Collection<InjectionPoint> points, final InitializationContext<D> context);
<T> void dispose(final T disposerInstance, final MetaMethod<T, ?> disposerMethod,
- final Collection<InjectionPoint<?>> points, final Object instance,
+ 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,
+ <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,
+ <D, T> void set(final D instance, final MetaField<D, T> field, final InjectionPoint point,
final InitializationContext<D> context);
}
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/Producer.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/Producer.java
index 4a8f27a..b598f46 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/Producer.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/Producer.java
@@ -33,5 +33,5 @@ public interface Producer<T> {
// for a class: injected fields, @Inject constructor parameters, and initializer method params
// for a producer method: method params
- Collection<InjectionPoint<?>> getInjectionPoints();
+ Collection<InjectionPoint> getInjectionPoints();
}
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/ProducerFactory.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/ProducerFactory.java
index c266224..29e0684 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/ProducerFactory.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/ProducerFactory.java
@@ -17,7 +17,7 @@
package org.apache.logging.log4j.plugins.spi.bean;
-public interface ProducerFactory<D> {
+public interface ProducerFactory {
// only time bean is null is static @Produces potentially?
<T> Producer<T> createProducer(final Bean<T> bean);
}
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/ElementManager.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/ElementManager.java
index ee213c3..32d94e2 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/ElementManager.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/ElementManager.java
@@ -53,7 +53,7 @@ public interface ElementManager extends AutoCloseable {
* @param element program element to extract qualifiers from
* @return qualifiers present on the element
*/
- Qualifiers getQualifiers(MetaElement<?> element);
+ Qualifiers getQualifiers(MetaElement element);
/**
* Checks if a class has exactly one injectable constructor. A constructor is <i>injectable</i> if:
@@ -98,7 +98,7 @@ public interface ElementManager extends AutoCloseable {
* @param element field, method, or parameter to check
* @return true if the element is injectable or false otherwise
*/
- default boolean isInjectable(final MetaElement<?> element) {
+ default boolean isInjectable(final MetaElement element) {
return element.isAnnotationPresent(Inject.class) ||
(element.getAnnotations().stream().map(MetaAnnotation::getAnnotationType).anyMatch(this::isQualifierType) &&
!element.isAnnotationPresent(Produces.class));
@@ -110,10 +110,9 @@ public interface ElementManager extends AutoCloseable {
* @param field field where injection will take place
* @param owner bean where field is located or null for static fields
* @param <D> bean type
- * @param <T> field type
* @return an injection point describing the field
*/
- <D, T> InjectionPoint<T> createFieldInjectionPoint(final MetaField<D, T> field, final Bean<D> owner);
+ <D> InjectionPoint createFieldInjectionPoint(final MetaField<D, ?> field, final Bean<D> owner);
/**
* Creates an injection point for a method or constructor parameter with an optional owning bean.
@@ -122,11 +121,10 @@ public interface ElementManager extends AutoCloseable {
* @param parameter which parameter of that executable to create a point at
* @param owner bean where executable is located or null for static methods
* @param <D> bean type
- * @param <P> parameter type
* @return an injection point describing the parameter
*/
- <D, P> InjectionPoint<P> createParameterInjectionPoint(final MetaExecutable<D, ?> executable,
- final MetaParameter<P> parameter, final Bean<D> owner);
+ <D> InjectionPoint createParameterInjectionPoint(final MetaExecutable<D> executable,
+ final MetaParameter parameter, final Bean<D> owner);
/**
* Creates a collection of injection points for all the parameters of a method or constructor with an optional
@@ -137,7 +135,7 @@ public interface ElementManager extends AutoCloseable {
* @param <D> bean type
* @return collection of injection points describing the executable parameters
*/
- default <D> Collection<InjectionPoint<?>> createExecutableInjectionPoints(final MetaExecutable<D, ?> executable, final Bean<D> owner) {
+ default <D> Collection<InjectionPoint> createExecutableInjectionPoints(final MetaExecutable<D> executable, final Bean<D> owner) {
Objects.requireNonNull(executable);
return executable.getParameters().stream()
.map(parameter -> createParameterInjectionPoint(executable, parameter, owner))
@@ -147,12 +145,12 @@ public interface ElementManager extends AutoCloseable {
/**
* Creates a variable for an element.
*/
- Variable createVariable(final MetaElement<?> element);
+ Variable createVariable(final MetaElement element);
/**
* Creates a variable for an injection point.
*/
- Variable createVariable(final InjectionPoint<?> point);
+ Variable createVariable(final InjectionPoint point);
@Override
void close();
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/InjectionPoint.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/InjectionPoint.java
index 6e47521..05e09db 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/InjectionPoint.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/InjectionPoint.java
@@ -24,10 +24,8 @@ import java.util.Optional;
/**
* Represents metadata about an element in a program where a value should be injected.
- *
- * @param <T> type of element
*/
-public interface InjectionPoint<T> {
+public interface InjectionPoint {
/**
* Gets the generic type information of this point.
@@ -48,11 +46,11 @@ public interface InjectionPoint<T> {
/**
* Gets the field, method, or constructor where injection takes place.
*/
- MetaMember<?, ?> getMember();
+ MetaMember<?> getMember();
/**
* Gets the program element corresponding to this injection point.
*/
- MetaElement<T> getElement();
+ MetaElement getElement();
}
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/MetaAnnotationElement.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/MetaAnnotationElement.java
index 28506fe..460d6b8 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/MetaAnnotationElement.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/MetaAnnotationElement.java
@@ -17,7 +17,7 @@
package org.apache.logging.log4j.plugins.spi.model;
-public interface MetaAnnotationElement<T> extends MetaElement<T> {
+public interface MetaAnnotationElement<T> extends MetaElement {
T getValue();
MetaAnnotationElement<T> withNewValue(final T value);
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/MetaClass.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/MetaClass.java
index 48159bf..7d3b4d9 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/MetaClass.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/MetaClass.java
@@ -23,7 +23,7 @@ import java.lang.reflect.Method;
import java.util.Collection;
import java.util.Optional;
-public interface MetaClass<T> extends MetaElement<T> {
+public interface MetaClass<T> extends MetaElement {
Class<T> getJavaClass();
Collection<MetaConstructor<T>> getConstructors();
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/MetaConstructor.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/MetaConstructor.java
index 766d353..4402259 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/MetaConstructor.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/MetaConstructor.java
@@ -17,6 +17,6 @@
package org.apache.logging.log4j.plugins.spi.model;
-public interface MetaConstructor<T> extends MetaExecutable<T, T> {
+public interface MetaConstructor<T> extends MetaExecutable<T> {
T construct(final Object... args);
}
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/MetaElement.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/MetaElement.java
index dec4495..4ebe48c 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/MetaElement.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/MetaElement.java
@@ -18,12 +18,13 @@
package org.apache.logging.log4j.plugins.spi.model;
import org.apache.logging.log4j.plugins.api.AnnotationAlias;
+import org.apache.logging.log4j.plugins.util.TypeUtil;
import java.lang.annotation.Annotation;
import java.lang.reflect.Type;
import java.util.Collection;
-public interface MetaElement<T> {
+public interface MetaElement {
/**
* Returns the source code name of this element.
@@ -32,7 +33,9 @@ public interface MetaElement<T> {
Type getType();
- Collection<Type> getTypeClosure();
+ default Collection<Type> getTypeClosure() {
+ return TypeUtil.getTypeClosure(getType());
+ }
/**
* Returns all the annotations present on this element.
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/MetaExecutable.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/MetaExecutable.java
index b2ae5e1..049cf21 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/MetaExecutable.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/MetaExecutable.java
@@ -19,6 +19,6 @@ package org.apache.logging.log4j.plugins.spi.model;
import java.util.List;
-public interface MetaExecutable<D, T> extends MetaMember<D, T> {
- List<MetaParameter<?>> getParameters();
+public interface MetaExecutable<T> extends MetaMember<T> {
+ List<MetaParameter> getParameters();
}
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/MetaField.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/MetaField.java
index 9767eba..a406a96 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/MetaField.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/MetaField.java
@@ -17,7 +17,7 @@
package org.apache.logging.log4j.plugins.spi.model;
-public interface MetaField<D, T> extends MetaMember<D, T> {
+public interface MetaField<D, T> extends MetaMember<D> {
T get(final D target);
void set(final D target, final T value);
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/MetaMember.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/MetaMember.java
index b718867..4fc34a4 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/MetaMember.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/MetaMember.java
@@ -17,7 +17,7 @@
package org.apache.logging.log4j.plugins.spi.model;
-public interface MetaMember<D, T> extends MetaElement<T> {
+public interface MetaMember<D> extends MetaElement {
MetaClass<D> getDeclaringClass();
boolean isStatic();
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/MetaMethod.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/MetaMethod.java
index 80989b8..7e79f89 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/MetaMethod.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/MetaMethod.java
@@ -17,6 +17,6 @@
package org.apache.logging.log4j.plugins.spi.model;
-public interface MetaMethod<D, T> extends MetaExecutable<D, T> {
+public interface MetaMethod<D, T> extends MetaExecutable<D> {
T invoke(final D target, final Object... args);
}
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/MetaParameter.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/MetaParameter.java
index cac9b58..9ceaef0 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/MetaParameter.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/MetaParameter.java
@@ -17,5 +17,5 @@
package org.apache.logging.log4j.plugins.spi.model;
-public interface MetaParameter<T> extends MetaElement<T> {
+public interface MetaParameter extends MetaElement {
}
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 06a07bf..7376ab7 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
@@ -123,7 +123,7 @@ public class BeanJUnit4Runner extends BlockJUnit4ClassRunner {
final Class<T> testClass = TypeUtil.cast(getTestClass().getJavaClass());
final MetaClass<T> metaClass = elementManager.getMetaClass(testClass);
final MetaMethod<T, Void> metaMethod = metaClass.getMetaMethod(method.getMethod());
- final Collection<InjectionPoint<?>> points =
+ final Collection<InjectionPoint> points =
elementManager.createExecutableInjectionPoints(metaMethod, testClassBean);
injector.invoke(testInstance, metaMethod, points, context);
} finally {