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/08 22:57:17 UTC
[logging-log4j2] branch mean-bean-machine updated (bb256a7 ->
3aeec75)
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 bb256a7 Extract internal code into SPI interface
new 7906e63 Combine scoped and bean packages and other docs
new b4d7cfc Merge Scoped into Bean
new 5e17845 Clean up initialization context usage in bean runner
new 3aeec75 Remove BeanInstance class
The 4 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/{PrototypeScoped.java => Dependent.java} | 11 +-
.../api/{SingletonScoped.java => Singleton.java} | 3 +-
.../api/{Provider.java => package-info.java} | 11 +-
.../log4j/plugins/defaults/bean/AbstractBean.java | 2 +
.../plugins/defaults/bean/AbstractProducer.java | 8 +-
.../ScopedInstance.java => bean/BeanInstance.java} | 8 +-
.../plugins/defaults/bean/DefaultBeanManager.java | 46 +++----
.../bean/DefaultInitializationContext.java | 134 +++++++++++++++++++++
.../defaults/bean/DefaultInjectionFactory.java | 2 +-
.../defaults/bean/DefaultInjectionTarget.java | 6 +-
.../{scope => bean}/DefaultScopeContext.java | 40 +++---
.../DependentScopeContext.java} | 29 +++--
.../log4j/plugins/defaults/bean/FieldProducer.java | 2 +-
.../plugins/defaults/bean/InjectionTargetBean.java | 14 ++-
.../plugins/defaults/bean/MethodProducer.java | 2 +-
.../log4j/plugins/defaults/bean/OptionalBean.java | 2 +-
.../log4j/plugins/defaults/bean/ProducerBean.java | 14 ++-
.../log4j/plugins/defaults/bean/ProvidedBean.java | 2 +-
.../log4j/plugins/defaults/bean/ProviderBean.java | 2 +-
.../log4j/plugins/defaults/bean/SystemBean.java | 2 +-
.../defaults/model/DefaultElementManager.java | 4 +-
.../scope/DefaultInitializationContext.java | 106 ----------------
.../defaults/scope/DefaultScopedInstance.java | 50 --------
.../plugins/defaults/scope/LazyScopedInstance.java | 57 ---------
.../logging/log4j/plugins/spi/bean/Bean.java | 21 +++-
.../log4j/plugins/spi/bean/BeanManager.java | 12 +-
.../spi/{scope => bean}/InitializationContext.java | 25 ++--
.../log4j/plugins/spi/bean/InjectionFactory.java | 1 -
.../log4j/plugins/spi/bean/InjectionTarget.java | 2 -
.../logging/log4j/plugins/spi/bean/Producer.java | 1 -
.../plugins/spi/{scope => bean}/ScopeContext.java | 24 ++--
.../logging/log4j/plugins/spi/model/Variable.java | 5 +
.../logging/log4j/plugins/spi/scope/Scoped.java | 58 ---------
.../logging/log4j/plugins/util/LazyValue.java | 28 ++++-
.../apache/logging/log4j/plugins/util/Value.java | 5 +-
.../logging/log4j/plugins/util/WeakLazyValue.java | 8 ++
.../defaults/bean/DefaultBeanManagerTest.java | 12 +-
.../log4j/plugins/test/BeanJUnit4Runner.java | 17 ++-
38 files changed, 354 insertions(+), 422 deletions(-)
rename log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/{PrototypeScoped.java => Dependent.java} (61%)
rename log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/{SingletonScoped.java => Singleton.java} (93%)
copy log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/{Provider.java => package-info.java} (73%)
rename log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/{scope/ScopedInstance.java => bean/BeanInstance.java} (81%)
create mode 100644 log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultInitializationContext.java
rename log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/{scope => bean}/DefaultScopeContext.java (55%)
rename log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/{scope/PrototypeScopeContext.java => bean/DependentScopeContext.java} (57%)
delete mode 100644 log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/scope/DefaultInitializationContext.java
delete mode 100644 log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/scope/DefaultScopedInstance.java
delete mode 100644 log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/scope/LazyScopedInstance.java
rename log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/{scope => bean}/InitializationContext.java (58%)
rename log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/{scope => bean}/ScopeContext.java (64%)
delete mode 100644 log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/scope/Scoped.java
[logging-log4j2] 03/04: Clean up initialization context usage in
bean runner
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 5e17845a4af9f39b240ea4dbd6e5193bcf508b9d
Author: Matt Sicker <bo...@gmail.com>
AuthorDate: Sun Mar 8 16:57:40 2020 -0500
Clean up initialization context usage in bean runner
Signed-off-by: Matt Sicker <bo...@gmail.com>
---
.../logging/log4j/plugins/test/BeanJUnit4Runner.java | 15 ++++++---------
1 file changed, 6 insertions(+), 9 deletions(-)
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 28c8c32..c671ef1 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
@@ -55,7 +55,6 @@ public class BeanJUnit4Runner extends BlockJUnit4ClassRunner {
private BeanManager beanManager;
private InjectionFactory injectionFactory;
private Bean<?> testClassBean;
- private InitializationContext<?> initializationContext;
public BeanJUnit4Runner(final Class<?> clazz) throws InitializationError {
super(clazz);
@@ -103,9 +102,7 @@ public class BeanJUnit4Runner extends BlockJUnit4ClassRunner {
final Bean<T> testClassBean = testBean
.orElseThrow(() -> new UnsatisfiedBeanException(testClass));
this.testClassBean = testClassBean;
- // FIXME: should we use a null bean or not? I'm still confused by the init context thing
- initializationContext = beanManager.createInitializationContext(testClassBean);
- return beanManager.getValue(testClassBean, initializationContext);
+ return beanManager.getValue(testClassBean, beanManager.createInitializationContext(null));
}
@Override
@@ -118,13 +115,10 @@ public class BeanJUnit4Runner extends BlockJUnit4ClassRunner {
return new Statement() {
@Override
public void evaluate() throws Throwable {
- try (final BeanManager manager = beanManager;
- final InitializationContext<T> context = TypeUtil.cast(initializationContext)) {
- beanManager = null;
- initializationContext = null;
+ try (final InitializationContext<T> context = beanManager.createInitializationContext(testClassBean)) {
final WithBeans methodBeans = method.getAnnotation(WithBeans.class);
if (methodBeans != null) {
- manager.loadBeans(methodBeans.value());
+ beanManager.loadBeans(methodBeans.value());
}
final Class<T> testClass = TypeUtil.cast(getTestClass().getJavaClass());
final MetaClass<T> metaClass = elementManager.getMetaClass(testClass);
@@ -132,6 +126,9 @@ public class BeanJUnit4Runner extends BlockJUnit4ClassRunner {
final Collection<InjectionPoint<?>> points =
elementManager.createExecutableInjectionPoints(metaMethod, testClassBean);
injectionFactory.forMethod(metaMethod, testInstance, points).accept(context);
+ } finally {
+ beanManager.close();
+ beanManager = null;
}
}
};
[logging-log4j2] 02/04: Merge Scoped into Bean
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 b4d7cfc1a51fd8bfccb54445b62880e72c839c9b
Author: Matt Sicker <bo...@gmail.com>
AuthorDate: Sun Mar 8 15:19:36 2020 -0500
Merge Scoped into Bean
As the interfaces were initially separated in CDI due to their support for interceptors and decorators, that distinction is not necessary here.
Signed-off-by: Matt Sicker <bo...@gmail.com>
---
.../{ScopedInstance.java => BeanInstance.java} | 6 +--
...copedInstance.java => DefaultBeanInstance.java} | 16 +++---
.../plugins/defaults/bean/DefaultBeanManager.java | 13 +++--
.../bean/DefaultInitializationContext.java | 56 ++++++++++-----------
.../plugins/defaults/bean/DefaultScopeContext.java | 28 +++++------
.../defaults/bean/DependentScopeContext.java | 12 ++---
...zyScopedInstance.java => LazyBeanInstance.java} | 18 +++----
.../logging/log4j/plugins/spi/bean/Bean.java | 20 +++++++-
.../log4j/plugins/spi/bean/BeanManager.java | 10 ++--
.../plugins/spi/bean/InitializationContext.java | 17 +++----
.../log4j/plugins/spi/bean/ScopeContext.java | 22 ++++-----
.../logging/log4j/plugins/spi/bean/Scoped.java | 57 ----------------------
.../logging/log4j/plugins/spi/model/Variable.java | 5 ++
13 files changed, 122 insertions(+), 158 deletions(-)
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/ScopedInstance.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/BeanInstance.java
similarity index 87%
rename from log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/ScopedInstance.java
rename to log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/BeanInstance.java
index 196d303..f47e889 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/ScopedInstance.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/BeanInstance.java
@@ -17,10 +17,10 @@
package org.apache.logging.log4j.plugins.defaults.bean;
-import org.apache.logging.log4j.plugins.spi.bean.Scoped;
+import org.apache.logging.log4j.plugins.spi.bean.Bean;
-interface ScopedInstance<T> extends AutoCloseable {
- Scoped<T> getScoped();
+interface BeanInstance<T> extends AutoCloseable {
+ Bean<T> getBean();
T getInstance();
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultScopedInstance.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultBeanInstance.java
similarity index 75%
rename from log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultScopedInstance.java
rename to log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultBeanInstance.java
index 4548d08..2f5a5d3 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultScopedInstance.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultBeanInstance.java
@@ -17,25 +17,25 @@
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.InitializationContext;
-import org.apache.logging.log4j.plugins.spi.bean.Scoped;
import java.util.Objects;
-class DefaultScopedInstance<T> implements ScopedInstance<T> {
- private final Scoped<T> scoped;
+class DefaultBeanInstance<T> implements BeanInstance<T> {
+ private final Bean<T> bean;
private final T instance;
private final InitializationContext<T> context;
- DefaultScopedInstance(final Scoped<T> scoped, final T instance, final InitializationContext<T> context) {
- this.scoped = Objects.requireNonNull(scoped);
+ DefaultBeanInstance(final Bean<T> bean, final T instance, final InitializationContext<T> context) {
+ this.bean = Objects.requireNonNull(bean);
this.instance = Objects.requireNonNull(instance);
this.context = Objects.requireNonNull(context);
}
@Override
- public Scoped<T> getScoped() {
- return scoped;
+ public Bean<T> getBean() {
+ return bean;
}
@Override
@@ -45,6 +45,6 @@ class DefaultScopedInstance<T> implements ScopedInstance<T> {
@Override
public void close() {
- scoped.destroy(instance, context);
+ bean.destroy(instance, context);
}
}
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultBeanManager.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultBeanManager.java
index 87bffc2..b1a5334 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,9 +17,9 @@
package org.apache.logging.log4j.plugins.defaults.bean;
+import org.apache.logging.log4j.plugins.api.Dependent;
import org.apache.logging.log4j.plugins.api.Disposes;
import org.apache.logging.log4j.plugins.api.Produces;
-import org.apache.logging.log4j.plugins.api.Dependent;
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;
@@ -31,9 +31,11 @@ import org.apache.logging.log4j.plugins.spi.UnsatisfiedBeanException;
import org.apache.logging.log4j.plugins.spi.ValidationException;
import org.apache.logging.log4j.plugins.spi.bean.Bean;
import org.apache.logging.log4j.plugins.spi.bean.BeanManager;
+import org.apache.logging.log4j.plugins.spi.bean.InitializationContext;
import org.apache.logging.log4j.plugins.spi.bean.InjectionFactory;
import org.apache.logging.log4j.plugins.spi.bean.InjectionTargetFactory;
import org.apache.logging.log4j.plugins.spi.bean.ProducerFactory;
+import org.apache.logging.log4j.plugins.spi.bean.ScopeContext;
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;
@@ -44,9 +46,6 @@ import org.apache.logging.log4j.plugins.spi.model.MetaMethod;
import org.apache.logging.log4j.plugins.spi.model.MetaParameter;
import org.apache.logging.log4j.plugins.spi.model.Qualifiers;
import org.apache.logging.log4j.plugins.spi.model.Variable;
-import org.apache.logging.log4j.plugins.spi.bean.InitializationContext;
-import org.apache.logging.log4j.plugins.spi.bean.ScopeContext;
-import org.apache.logging.log4j.plugins.spi.bean.Scoped;
import org.apache.logging.log4j.plugins.util.ParameterizedTypeImpl;
import org.apache.logging.log4j.plugins.util.TypeUtil;
@@ -356,8 +355,8 @@ public class DefaultBeanManager implements BeanManager {
}
@Override
- public <T> InitializationContext<T> createInitializationContext(final Scoped<T> scoped) {
- return new DefaultInitializationContext<>(scoped);
+ public <T> InitializationContext<T> createInitializationContext(final Bean<T> bean) {
+ return new DefaultInitializationContext<>(bean);
}
@Override
@@ -398,7 +397,7 @@ public class DefaultBeanManager implements BeanManager {
}
final Optional<Bean<?>> bean;
if (pointBean.isDependentScoped() && !resolvedBean.isDependentScoped()) {
- bean = parentContext.getNonDependentScopedDependent().filter(Bean.class::isInstance).map(TypeUtil::cast);
+ bean = parentContext.getNonDependentScopedDependent();
} else {
bean = Optional.of(pointBean);
}
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 d3c6350..9e00a66 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
@@ -17,8 +17,8 @@
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.InitializationContext;
-import org.apache.logging.log4j.plugins.spi.bean.Scoped;
import org.apache.logging.log4j.plugins.util.TypeUtil;
import java.util.List;
@@ -29,25 +29,25 @@ import java.util.concurrent.CopyOnWriteArrayList;
public class DefaultInitializationContext<T> implements InitializationContext<T> {
- private final Scoped<T> scoped;
- private Map<Scoped<?>, Object> incompleteInstances;
- private final List<ScopedInstance<?>> dependentInstances = new CopyOnWriteArrayList<>();
- private final List<ScopedInstance<?>> parentDependentInstances;
+ private final Bean<T> bean;
+ private Map<Bean<?>, Object> incompleteInstances;
+ private final List<BeanInstance<?>> dependentInstances = new CopyOnWriteArrayList<>();
+ private final List<BeanInstance<?>> parentDependentInstances;
private final InitializationContext<?> parentContext;
- public DefaultInitializationContext(final Scoped<T> scoped) {
- this(scoped, null, new CopyOnWriteArrayList<>(), null);
+ public DefaultInitializationContext(final Bean<T> bean) {
+ this(bean, null, new CopyOnWriteArrayList<>(), null);
}
- private DefaultInitializationContext(final Scoped<T> scoped, final Map<Scoped<?>, Object> incompleteInstances) {
- this(scoped, incompleteInstances, new CopyOnWriteArrayList<>(), null);
+ private DefaultInitializationContext(final Bean<T> bean, final Map<Bean<?>, Object> incompleteInstances) {
+ this(bean, incompleteInstances, new CopyOnWriteArrayList<>(), null);
}
- private DefaultInitializationContext(final Scoped<T> scoped, final Map<Scoped<?>, Object> incompleteInstances,
- final List<ScopedInstance<?>> parentDependentInstances,
+ private DefaultInitializationContext(final Bean<T> bean, final Map<Bean<?>, Object> incompleteInstances,
+ final List<BeanInstance<?>> parentDependentInstances,
final InitializationContext<?> parentContext) {
- this.scoped = scoped;
+ this.bean = bean;
this.incompleteInstances = incompleteInstances;
this.parentDependentInstances = parentDependentInstances;
this.parentContext = parentContext;
@@ -58,51 +58,51 @@ public class DefaultInitializationContext<T> implements InitializationContext<T>
if (incompleteInstances == null) {
incompleteInstances = new ConcurrentHashMap<>();
}
- if (scoped != null) {
- incompleteInstances.put(scoped, incompleteInstance);
+ if (bean != null) {
+ incompleteInstances.put(bean, incompleteInstance);
}
}
@Override
- public boolean isTrackingDependencies(final Scoped<T> scoped) {
+ public boolean isTrackingDependencies(final Bean<T> bean) {
return !dependentInstances.isEmpty() ||
- (scoped instanceof AbstractBean<?, ?> && ((AbstractBean<?, ?>) scoped).isTrackingDependencies());
+ (bean instanceof AbstractBean<?, ?> && ((AbstractBean<?, ?>) bean).isTrackingDependencies());
}
@Override
public void addDependentInstance(final T dependentInstance) {
- parentDependentInstances.add(new DefaultScopedInstance<>(scoped, dependentInstance, this));
+ parentDependentInstances.add(new DefaultBeanInstance<>(bean, dependentInstance, this));
}
@Override
- public Optional<Scoped<?>> getNonDependentScopedDependent() {
- if (parentContext == null || scoped == null) {
+ public Optional<Bean<?>> getNonDependentScopedDependent() {
+ if (parentContext == null || bean == null) {
return Optional.empty();
}
- return scoped.isDependentScoped() ? parentContext.getNonDependentScopedDependent() : Optional.of(scoped);
+ return bean.isDependentScoped() ? parentContext.getNonDependentScopedDependent() : Optional.of(bean);
}
@Override
- public <S> InitializationContext<S> createDependentContext(final Scoped<S> scoped) {
- return new DefaultInitializationContext<>(scoped, incompleteInstances, dependentInstances, this);
+ public <S> InitializationContext<S> createDependentContext(final Bean<S> bean) {
+ return new DefaultInitializationContext<>(bean, incompleteInstances, dependentInstances, this);
}
@Override
- public <S> InitializationContext<S> createIndependentContext(final Scoped<S> scoped) {
- return new DefaultInitializationContext<>(scoped, incompleteInstances == null ? null : new ConcurrentHashMap<>(incompleteInstances));
+ public <S> InitializationContext<S> createIndependentContext(final Bean<S> bean) {
+ return new DefaultInitializationContext<>(bean, incompleteInstances == null ? null : new ConcurrentHashMap<>(incompleteInstances));
}
@Override
- public <S> Optional<S> getIncompleteInstance(final Scoped<S> scoped) {
+ public <S> Optional<S> getIncompleteInstance(final Bean<S> bean) {
return Optional.ofNullable(incompleteInstances)
- .map(map -> map.get(scoped))
+ .map(map -> map.get(bean))
.map(TypeUtil::cast);
}
@Override
public void close() {
- for (final ScopedInstance<?> dependentInstance : dependentInstances) {
- if (!(scoped != null && scoped.equals(dependentInstance.getScoped()))) {
+ for (final BeanInstance<?> dependentInstance : dependentInstances) {
+ if (dependentInstance.getBean().equals(bean)) {
dependentInstance.close();
}
}
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultScopeContext.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultScopeContext.java
index 0fc5f6d..e0a5965 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultScopeContext.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultScopeContext.java
@@ -17,9 +17,9 @@
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.InitializationContext;
import org.apache.logging.log4j.plugins.spi.bean.ScopeContext;
-import org.apache.logging.log4j.plugins.spi.bean.Scoped;
import org.apache.logging.log4j.plugins.util.TypeUtil;
import java.lang.annotation.Annotation;
@@ -29,7 +29,7 @@ import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
public class DefaultScopeContext implements ScopeContext {
- private final Map<Scoped<?>, ScopedInstance<?>> cache = new ConcurrentHashMap<>();
+ private final Map<Bean<?>, BeanInstance<?>> cache = new ConcurrentHashMap<>();
private final Class<? extends Annotation> scopeType;
public DefaultScopeContext(final Class<? extends Annotation> scopeType) {
@@ -42,24 +42,24 @@ public class DefaultScopeContext implements ScopeContext {
}
@Override
- public <T> T getOrCreate(final Scoped<T> scoped, final InitializationContext<T> context) {
- final ScopedInstance<T> scopedInstance =
- TypeUtil.cast(cache.computeIfAbsent(scoped, ignored -> new LazyScopedInstance<>(scoped, context)));
- return scopedInstance.getInstance();
+ public <T> T getOrCreate(final Bean<T> bean, final InitializationContext<T> context) {
+ final BeanInstance<T> beanInstance =
+ TypeUtil.cast(cache.computeIfAbsent(bean, ignored -> new LazyBeanInstance<>(bean, context)));
+ return beanInstance.getInstance();
}
@Override
- public <T> Optional<T> getIfExists(final Scoped<T> scoped) {
- final ScopedInstance<T> scopedInstance = TypeUtil.cast(cache.get(scoped));
- return scopedInstance == null ? Optional.empty() : Optional.of(scopedInstance.getInstance());
+ public <T> Optional<T> getIfExists(final Bean<T> bean) {
+ final BeanInstance<T> beanInstance = TypeUtil.cast(cache.get(bean));
+ return beanInstance == null ? Optional.empty() : Optional.of(beanInstance.getInstance());
}
@Override
- public void destroy(final Scoped<?> scoped) {
- final ScopedInstance<?> scopedInstance = cache.get(scoped);
- if (scopedInstance != null) {
- scopedInstance.close();
- cache.remove(scoped, scopedInstance);
+ public void destroy(final Bean<?> bean) {
+ final BeanInstance<?> beanInstance = cache.get(bean);
+ if (beanInstance != null) {
+ beanInstance.close();
+ cache.remove(bean, beanInstance);
}
}
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 57554eb..2a7a4be 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
@@ -18,9 +18,9 @@
package org.apache.logging.log4j.plugins.defaults.bean;
import org.apache.logging.log4j.plugins.api.Dependent;
+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;
-import org.apache.logging.log4j.plugins.spi.bean.Scoped;
import java.lang.annotation.Annotation;
import java.util.Optional;
@@ -32,24 +32,24 @@ public class DependentScopeContext implements ScopeContext {
}
@Override
- public <T> T getOrCreate(final Scoped<T> scoped, final InitializationContext<T> context) {
+ public <T> T getOrCreate(final Bean<T> bean, final InitializationContext<T> context) {
if (context == null) {
return null;
}
- final T instance = scoped.create(context);
- if (context.isTrackingDependencies(scoped)) {
+ final T instance = bean.create(context);
+ if (context.isTrackingDependencies(bean)) {
context.addDependentInstance(instance);
}
return instance;
}
@Override
- public <T> Optional<T> getIfExists(final Scoped<T> scoped) {
+ public <T> Optional<T> getIfExists(final Bean<T> bean) {
return Optional.empty();
}
@Override
- public void destroy(final Scoped<?> scoped) {
+ public void destroy(final Bean<?> bean) {
}
@Override
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/LazyScopedInstance.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/LazyBeanInstance.java
similarity index 75%
rename from log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/LazyScopedInstance.java
rename to log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/LazyBeanInstance.java
index 64c1cb8..970fef9 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/LazyScopedInstance.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/LazyBeanInstance.java
@@ -17,24 +17,24 @@
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.InitializationContext;
-import org.apache.logging.log4j.plugins.spi.bean.Scoped;
import java.util.Objects;
-class LazyScopedInstance<T> implements ScopedInstance<T> {
- private final Scoped<T> scoped;
+class LazyBeanInstance<T> implements BeanInstance<T> {
+ private final Bean<T> bean;
private final InitializationContext<T> context;
private volatile T instance;
- LazyScopedInstance(final Scoped<T> scoped, final InitializationContext<T> context) {
- this.scoped = Objects.requireNonNull(scoped);
+ LazyBeanInstance(final Bean<T> bean, final InitializationContext<T> context) {
+ this.bean = Objects.requireNonNull(bean);
this.context = Objects.requireNonNull(context);
}
@Override
- public Scoped<T> getScoped() {
- return scoped;
+ public Bean<T> getBean() {
+ return bean;
}
@Override
@@ -42,7 +42,7 @@ class LazyScopedInstance<T> implements ScopedInstance<T> {
if (instance == null) {
synchronized (this) {
if (instance == null) {
- instance = scoped.create(context);
+ instance = bean.create(context);
}
}
}
@@ -51,7 +51,7 @@ class LazyScopedInstance<T> implements ScopedInstance<T> {
@Override
public void close() {
- scoped.destroy(instance, context);
+ bean.destroy(instance, context);
instance = null;
}
}
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 2fecd0c..3e93e2f 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
@@ -23,7 +23,25 @@ import org.apache.logging.log4j.plugins.spi.model.Variable;
import java.util.Collection;
-public interface Bean<T> extends Scoped<T>, Variable<T> {
+public interface Bean<T> extends Variable<T> {
+ /**
+ * Creates a new instance of this bean. The given {@link InitializationContext} should be used by implementations
+ * to track dependent objects.
+ *
+ * @param context the context in which the instance is being managed
+ * @return a managed, initialized instance
+ */
+ T create(final InitializationContext<T> context);
+
+ /**
+ * Destroys a managed instance in the given context. Implementations should call {@link InitializationContext#close()} to
+ * allow dependent objects to be destroyed.
+ *
+ * @param instance the managed instance to destroy
+ * @param context the context in which the instance is being managed
+ */
+ void destroy(final T instance, final InitializationContext<T> context);
+
Collection<InjectionPoint<?>> getInjectionPoints();
// for a managed bean: that 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 e8cd275..a66d1b1 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
@@ -60,13 +60,13 @@ public interface BeanManager extends AutoCloseable {
// Collection<Bean<?>> getBeans();
/**
- * Creates an InitializationContext for a given Scoped instance for use in dependency injection SPIs.
+ * Creates an InitializationContext for a given Bean instance for use in dependency injection SPIs.
*
- * @param scoped scoped object to create an initialization context for
- * @param <T> type of object created by scope
- * @return new InitializationContext for the given Scoped
+ * @param bean bean to create an initialization context for
+ * @param <T> type of object created by bean
+ * @return new InitializationContext for the given Bean
*/
- <T> InitializationContext<T> createInitializationContext(final Scoped<T> scoped);
+ <T> InitializationContext<T> createInitializationContext(final Bean<T> bean);
/**
* Gets or creates the value for a given bean inside a given InitializationContext.
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/InitializationContext.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/InitializationContext.java
index 117342e..b13b849 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/InitializationContext.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/InitializationContext.java
@@ -20,35 +20,34 @@ package org.apache.logging.log4j.plugins.spi.bean;
import java.util.Optional;
/**
- * Provides operations used by {@link Scoped} implementations for tracking lifecycle state.
+ * Provides operations used by {@link Bean} implementations for tracking lifecycle state.
*/
public interface InitializationContext<T> extends AutoCloseable {
/**
* Pushes an incomplete instance state. An instance is not completely initialized until it is returned from
- * {@link Scoped#create(InitializationContext)}.
+ * {@link Bean#create(InitializationContext)}.
*
* @param incompleteInstance incompletely initialized instance
*/
void addIncompleteInstance(final T incompleteInstance);
// TODO: this API is needlessly complicated currently
- boolean isTrackingDependencies(final Scoped<T> scoped);
+ boolean isTrackingDependencies(final Bean<T> bean);
void addDependentInstance(T dependentInstance);
- // TODO: consider returning Optional<Bean<?>> or flattening Scoped into Bean
- Optional<Scoped<?>> getNonDependentScopedDependent();
+ Optional<Bean<?>> getNonDependentScopedDependent();
- <S> Optional<S> getIncompleteInstance(Scoped<S> scoped);
+ <S> Optional<S> getIncompleteInstance(Bean<S> bean);
// dependent contexts share the same incomplete instances
- <S> InitializationContext<S> createDependentContext(Scoped<S> scoped);
+ <S> InitializationContext<S> createDependentContext(Bean<S> bean);
// independent contexts are used by producers to get their declaring bean separately
- <S> InitializationContext<S> createIndependentContext(Scoped<S> scoped);
+ <S> InitializationContext<S> createIndependentContext(Bean<S> bean);
/**
- * Destroys all dependent objects by propagating them to {@link Scoped#destroy(Object, InitializationContext)}.
+ * Destroys all dependent objects by propagating them to {@link Bean#destroy(Object, InitializationContext)}.
*/
@Override
void close();
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/ScopeContext.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/ScopeContext.java
index ced2798..ac154ae 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/ScopeContext.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/ScopeContext.java
@@ -23,7 +23,7 @@ import java.lang.annotation.Annotation;
import java.util.Optional;
/**
- * Manages {@link Scoped} instances within a particular {@linkplain ScopeType scope}.
+ * Manages {@link Bean} instances within a particular {@linkplain ScopeType scope}.
*/
public interface ScopeContext extends AutoCloseable {
@@ -33,30 +33,30 @@ public interface ScopeContext extends AutoCloseable {
Class<? extends Annotation> getScopeType();
/**
- * Gets or {@linkplain Scoped#create(InitializationContext) creates} a scoped instance of a specific type.
+ * Gets or {@linkplain Bean#create(InitializationContext) creates} a bean instance of a specific type.
*
- * @param scoped the managed type
+ * @param bean the bean to get or create an instance of
* @param context the context to create a new instance in
* @param <T> the instance type being managed
* @return the new or existing instance
*/
- <T> T getOrCreate(final Scoped<T> scoped, final InitializationContext<T> context);
+ <T> T getOrCreate(final Bean<T> bean, final InitializationContext<T> context);
/**
- * Returns an existing scoped instance if it exists.
+ * Returns an existing bean instance if it exists.
*
- * @param scoped the managed type
- * @param <T> the instance type being managed
+ * @param bean the bean to look up an existing instance of
+ * @param <T> the instance type being managed
* @return the existing instance or empty
*/
- <T> Optional<T> getIfExists(final Scoped<T> scoped);
+ <T> Optional<T> getIfExists(final Bean<T> bean);
/**
- * Destroys the existing scoped instance of a specified type if it exists or otherwise does nothing.
+ * Destroys the existing bean instance of a specified type if it exists or otherwise does nothing.
*
- * @param scoped the managed type
+ * @param bean the managed type
*/
- void destroy(final Scoped<?> scoped);
+ void destroy(final Bean<?> bean);
@Override
void close();
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/Scoped.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/Scoped.java
deleted file mode 100644
index 7953435..0000000
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/Scoped.java
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache license, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the license for the specific language governing permissions and
- * limitations under the license.
- */
-
-package org.apache.logging.log4j.plugins.spi.bean;
-
-import org.apache.logging.log4j.plugins.api.Dependent;
-import org.apache.logging.log4j.plugins.api.Singleton;
-
-import java.lang.annotation.Annotation;
-
-/**
- * Manages the creation and destruction of instances of a specific type within a particular scope context. Scopes
- * provide managed life-cycles for objects such as {@linkplain Singleton singleton} and {@linkplain Dependent dependent}.
- *
- * @param <T> type of managed instance
- * @see org.apache.logging.log4j.plugins.api.ScopeType
- */
-public interface Scoped<T> {
-
- /**
- * Creates a new instance of this managed type. The given {@link InitializationContext} should be used by implementations
- * to track dependent objects.
- *
- * @param context the context in which the instance is being managed
- * @return a managed, initialized instance
- */
- T create(final InitializationContext<T> context);
-
- /**
- * Destroys a managed instance in the given context. Implementations should call {@link InitializationContext#close()} to
- * allow dependent objects to be destroyed.
- *
- * @param instance the managed instance to destroy
- * @param context the context in which the instance is being managed
- */
- void destroy(final T instance, final InitializationContext<T> context);
-
- Class<? extends Annotation> getScopeType();
-
- default boolean isDependentScoped() {
- return getScopeType() == Dependent.class;
- }
-}
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 bb8db73..c11748d 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,6 +17,7 @@
package org.apache.logging.log4j.plugins.spi.model;
+import org.apache.logging.log4j.plugins.api.Dependent;
import org.apache.logging.log4j.plugins.util.TypeUtil;
import java.lang.annotation.Annotation;
@@ -38,4 +39,8 @@ public interface Variable<T> {
Qualifiers getQualifiers();
Class<? extends Annotation> getScopeType();
+
+ default boolean isDependentScoped() {
+ return getScopeType() == Dependent.class;
+ }
}
[logging-log4j2] 04/04: Remove BeanInstance class
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 3aeec758eada8d6471bb1d48d72f56da2c9c3c02
Author: Matt Sicker <bo...@gmail.com>
AuthorDate: Sun Mar 8 17:56:12 2020 -0500
Remove BeanInstance class
Signed-off-by: Matt Sicker <bo...@gmail.com>
---
.../plugins/defaults/bean/DefaultBeanInstance.java | 50 -------------------
.../bean/DefaultInitializationContext.java | 35 ++++++++++---
.../plugins/defaults/bean/DefaultScopeContext.java | 26 +++++-----
.../plugins/defaults/bean/LazyBeanInstance.java | 57 ----------------------
.../logging/log4j/plugins/util/LazyValue.java | 28 ++++++++---
.../apache/logging/log4j/plugins/util/Value.java | 5 +-
.../logging/log4j/plugins/util/WeakLazyValue.java | 8 +++
7 files changed, 77 insertions(+), 132 deletions(-)
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultBeanInstance.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultBeanInstance.java
deleted file mode 100644
index 2f5a5d3..0000000
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultBeanInstance.java
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache license, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the license for the specific language governing permissions and
- * limitations under the license.
- */
-
-package org.apache.logging.log4j.plugins.defaults.bean;
-
-import org.apache.logging.log4j.plugins.spi.bean.Bean;
-import org.apache.logging.log4j.plugins.spi.bean.InitializationContext;
-
-import java.util.Objects;
-
-class DefaultBeanInstance<T> implements BeanInstance<T> {
- private final Bean<T> bean;
- private final T instance;
- private final InitializationContext<T> context;
-
- DefaultBeanInstance(final Bean<T> bean, final T instance, final InitializationContext<T> context) {
- this.bean = Objects.requireNonNull(bean);
- this.instance = Objects.requireNonNull(instance);
- this.context = Objects.requireNonNull(context);
- }
-
- @Override
- public Bean<T> getBean() {
- return bean;
- }
-
- @Override
- public T getInstance() {
- return instance;
- }
-
- @Override
- public void close() {
- bean.destroy(instance, context);
- }
-}
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 9e00a66..962c61c 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
@@ -20,6 +20,7 @@ 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.InitializationContext;
import org.apache.logging.log4j.plugins.util.TypeUtil;
+import org.apache.logging.log4j.plugins.util.Value;
import java.util.List;
import java.util.Map;
@@ -31,8 +32,8 @@ public class DefaultInitializationContext<T> implements InitializationContext<T>
private final Bean<T> bean;
private Map<Bean<?>, Object> incompleteInstances;
- private final List<BeanInstance<?>> dependentInstances = new CopyOnWriteArrayList<>();
- private final List<BeanInstance<?>> parentDependentInstances;
+ private final List<DependentInstance<?>> dependentInstances = new CopyOnWriteArrayList<>();
+ private final List<DependentInstance<?>> parentDependentInstances;
private final InitializationContext<?> parentContext;
public DefaultInitializationContext(final Bean<T> bean) {
@@ -44,7 +45,7 @@ public class DefaultInitializationContext<T> implements InitializationContext<T>
}
private DefaultInitializationContext(final Bean<T> bean, final Map<Bean<?>, Object> incompleteInstances,
- final List<BeanInstance<?>> parentDependentInstances,
+ final List<DependentInstance<?>> parentDependentInstances,
final InitializationContext<?> parentContext) {
this.bean = bean;
@@ -71,7 +72,7 @@ public class DefaultInitializationContext<T> implements InitializationContext<T>
@Override
public void addDependentInstance(final T dependentInstance) {
- parentDependentInstances.add(new DefaultBeanInstance<>(bean, dependentInstance, this));
+ parentDependentInstances.add(new DependentInstance<>(bean, this, dependentInstance));
}
@Override
@@ -101,11 +102,33 @@ public class DefaultInitializationContext<T> implements InitializationContext<T>
@Override
public void close() {
- for (final BeanInstance<?> dependentInstance : dependentInstances) {
- if (dependentInstance.getBean().equals(bean)) {
+ for (final DependentInstance<?> dependentInstance : dependentInstances) {
+ if (dependentInstance.bean.equals(bean)) {
dependentInstance.close();
}
}
}
+ private static class DependentInstance<T> implements Value<T> {
+ private final Bean<T> bean;
+ private final InitializationContext<T> context;
+ private final T instance;
+
+ private DependentInstance(final Bean<T> bean, final InitializationContext<T> context, final T instance) {
+ this.bean = bean;
+ this.context = context;
+ this.instance = instance;
+ }
+
+ @Override
+ public T get() {
+ return instance;
+ }
+
+ @Override
+ public void close() {
+ bean.destroy(instance, context);
+ }
+ }
+
}
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultScopeContext.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultScopeContext.java
index e0a5965..42e46b0 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultScopeContext.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultScopeContext.java
@@ -20,7 +20,9 @@ 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.InitializationContext;
import org.apache.logging.log4j.plugins.spi.bean.ScopeContext;
+import org.apache.logging.log4j.plugins.util.LazyValue;
import org.apache.logging.log4j.plugins.util.TypeUtil;
+import org.apache.logging.log4j.plugins.util.Value;
import java.lang.annotation.Annotation;
import java.util.Map;
@@ -29,7 +31,7 @@ import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
public class DefaultScopeContext implements ScopeContext {
- private final Map<Bean<?>, BeanInstance<?>> cache = new ConcurrentHashMap<>();
+ private final Map<Bean<?>, Value<?>> beanValues = new ConcurrentHashMap<>();
private final Class<? extends Annotation> scopeType;
public DefaultScopeContext(final Class<? extends Annotation> scopeType) {
@@ -43,28 +45,28 @@ public class DefaultScopeContext implements ScopeContext {
@Override
public <T> T getOrCreate(final Bean<T> bean, final InitializationContext<T> context) {
- final BeanInstance<T> beanInstance =
- TypeUtil.cast(cache.computeIfAbsent(bean, ignored -> new LazyBeanInstance<>(bean, context)));
- return beanInstance.getInstance();
+ final Value<T> value = TypeUtil.cast(beanValues.computeIfAbsent(bean,
+ ignored -> LazyValue.forScope(() -> bean.create(context), instance -> bean.destroy(instance, context))));
+ return value.get();
}
@Override
public <T> Optional<T> getIfExists(final Bean<T> bean) {
- final BeanInstance<T> beanInstance = TypeUtil.cast(cache.get(bean));
- return beanInstance == null ? Optional.empty() : Optional.of(beanInstance.getInstance());
+ return Optional.ofNullable(beanValues.get(bean))
+ .map(Value::get)
+ .map(TypeUtil::cast);
}
@Override
public void destroy(final Bean<?> bean) {
- final BeanInstance<?> beanInstance = cache.get(bean);
- if (beanInstance != null) {
- beanInstance.close();
- cache.remove(bean, beanInstance);
- }
+ beanValues.computeIfPresent(bean, (ignored, value) -> {
+ value.close();
+ return null;
+ });
}
@Override
public void close() {
- cache.keySet().forEach(this::destroy);
+ beanValues.keySet().forEach(this::destroy);
}
}
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/LazyBeanInstance.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/LazyBeanInstance.java
deleted file mode 100644
index 970fef9..0000000
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/LazyBeanInstance.java
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache license, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the license for the specific language governing permissions and
- * limitations under the license.
- */
-
-package org.apache.logging.log4j.plugins.defaults.bean;
-
-import org.apache.logging.log4j.plugins.spi.bean.Bean;
-import org.apache.logging.log4j.plugins.spi.bean.InitializationContext;
-
-import java.util.Objects;
-
-class LazyBeanInstance<T> implements BeanInstance<T> {
- private final Bean<T> bean;
- private final InitializationContext<T> context;
- private volatile T instance;
-
- LazyBeanInstance(final Bean<T> bean, final InitializationContext<T> context) {
- this.bean = Objects.requireNonNull(bean);
- this.context = Objects.requireNonNull(context);
- }
-
- @Override
- public Bean<T> getBean() {
- return bean;
- }
-
- @Override
- public T getInstance() {
- if (instance == null) {
- synchronized (this) {
- if (instance == null) {
- instance = bean.create(context);
- }
- }
- }
- return instance;
- }
-
- @Override
- public void close() {
- bean.destroy(instance, context);
- instance = null;
- }
-}
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/util/LazyValue.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/util/LazyValue.java
index 385997f..abaa550 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/util/LazyValue.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/util/LazyValue.java
@@ -17,19 +17,27 @@
package org.apache.logging.log4j.plugins.util;
+import java.util.function.Consumer;
import java.util.function.Supplier;
public class LazyValue<T> implements Value<T> {
- public static <T> LazyValue<T> forSupplier(final Supplier<T> valueSupplier) {
- return new LazyValue<>(valueSupplier);
+ public static <T> LazyValue<T> forSupplier(final Supplier<T> constructor) {
+ return new LazyValue<>(constructor, value -> {
+ });
}
- private final Supplier<T> valueSupplier;
+ public static <T> LazyValue<T> forScope(final Supplier<T> constructor, final Consumer<T> destructor) {
+ return new LazyValue<>(constructor, destructor);
+ }
+
+ private final Supplier<T> constructor;
+ private final Consumer<T> destructor;
private volatile T value;
- private LazyValue(final Supplier<T> valueSupplier) {
- this.valueSupplier = valueSupplier;
+ private LazyValue(final Supplier<T> constructor, final Consumer<T> destructor) {
+ this.constructor = constructor;
+ this.destructor = destructor;
}
@Override
@@ -39,10 +47,18 @@ public class LazyValue<T> implements Value<T> {
synchronized (this) {
value = this.value;
if (value == null) {
- this.value = value = valueSupplier.get();
+ this.value = value = constructor.get();
}
}
}
return value;
}
+
+ @Override
+ public void close() {
+ if (value != null) {
+ destructor.accept(value);
+ value = null;
+ }
+ }
}
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/util/Value.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/util/Value.java
index b59b66d..5b01df6 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/util/Value.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/util/Value.java
@@ -17,6 +17,9 @@
package org.apache.logging.log4j.plugins.util;
-public interface Value<T> {
+public interface Value<T> extends AutoCloseable {
T get();
+
+ @Override
+ void close();
}
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/util/WeakLazyValue.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/util/WeakLazyValue.java
index b90a3a7..8886ba1 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/util/WeakLazyValue.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/util/WeakLazyValue.java
@@ -47,4 +47,12 @@ public class WeakLazyValue<T> implements Value<T> {
}
return value;
}
+
+ @Override
+ public void close() {
+ if (reference != null) {
+ reference.clear();
+ reference = null;
+ }
+ }
}
[logging-log4j2] 01/04: Combine scoped and bean packages and other
docs
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 7906e63e90487e36436c29a44ddab647beba00eb
Author: Matt Sicker <bo...@gmail.com>
AuthorDate: Sun Mar 8 14:47:40 2020 -0500
Combine scoped and bean packages and other docs
This also renames prototype scope to dependent scope upon further reading of the CDI spec to help clarify its purpose compared to any other scope.
Signed-off-by: Matt Sicker <bo...@gmail.com>
---
.../api/{PrototypeScoped.java => Dependent.java} | 11 +++-
.../api/{SingletonScoped.java => Singleton.java} | 3 +-
.../{PrototypeScoped.java => package-info.java} | 20 +++-----
.../log4j/plugins/defaults/bean/AbstractBean.java | 2 +
.../plugins/defaults/bean/AbstractProducer.java | 8 ++-
.../plugins/defaults/bean/DefaultBeanManager.java | 43 ++++++----------
.../DefaultInitializationContext.java | 59 ++++++++++++----------
.../defaults/bean/DefaultInjectionFactory.java | 2 +-
.../defaults/bean/DefaultInjectionTarget.java | 6 ++-
.../{scope => bean}/DefaultScopeContext.java | 8 +--
.../{scope => bean}/DefaultScopedInstance.java | 6 +--
.../DependentScopeContext.java} | 21 ++++----
.../log4j/plugins/defaults/bean/FieldProducer.java | 2 +-
.../plugins/defaults/bean/InjectionTargetBean.java | 14 +++--
.../{scope => bean}/LazyScopedInstance.java | 6 +--
.../plugins/defaults/bean/MethodProducer.java | 2 +-
.../log4j/plugins/defaults/bean/OptionalBean.java | 2 +-
.../log4j/plugins/defaults/bean/ProducerBean.java | 14 +++--
.../log4j/plugins/defaults/bean/ProvidedBean.java | 2 +-
.../log4j/plugins/defaults/bean/ProviderBean.java | 2 +-
.../defaults/{scope => bean}/ScopedInstance.java | 4 +-
.../log4j/plugins/defaults/bean/SystemBean.java | 2 +-
.../defaults/model/DefaultElementManager.java | 4 +-
.../logging/log4j/plugins/spi/bean/Bean.java | 1 -
.../log4j/plugins/spi/bean/BeanManager.java | 2 -
.../spi/{scope => bean}/InitializationContext.java | 16 ++++--
.../log4j/plugins/spi/bean/InjectionFactory.java | 1 -
.../log4j/plugins/spi/bean/InjectionTarget.java | 2 -
.../logging/log4j/plugins/spi/bean/Producer.java | 1 -
.../plugins/spi/{scope => bean}/ScopeContext.java | 2 +-
.../log4j/plugins/spi/{scope => bean}/Scoped.java | 13 +++--
.../defaults/bean/DefaultBeanManagerTest.java | 12 ++---
.../log4j/plugins/test/BeanJUnit4Runner.java | 2 +-
33 files changed, 156 insertions(+), 139 deletions(-)
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/PrototypeScoped.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/Dependent.java
similarity index 61%
copy from log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/PrototypeScoped.java
copy to log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/Dependent.java
index 43a2934..57f2a58 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/PrototypeScoped.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/Dependent.java
@@ -22,10 +22,17 @@ import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
+/**
+ * Dependent scoped beans are beans that belong to another bean. Beans with this scope are created and destroyed in
+ * participation of the lifecycle of the owning bean. That is, when a bean is destroyed, any of its dependent objects
+ * are destroyed; dependent beans injected into a {@linkplain Disposes disposer method} are destroyed after the method
+ * is finished executing; dependent beans created to {@linkplain Produces produce} or {@linkplain Disposes dispose}
+ * a bean are destroyed after the producer or disposer is finished executing; and any other dependent beans no longer
+ * directly referenced by the application may be destroyed.
+ */
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@ScopeType
-// TODO: consider renaming to DefaultScoped or DependentScoped
-public @interface PrototypeScoped {
+public @interface Dependent {
}
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/SingletonScoped.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/Singleton.java
similarity index 93%
rename from log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/SingletonScoped.java
rename to log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/Singleton.java
index 434c03b..6daa25d 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/SingletonScoped.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/Singleton.java
@@ -22,9 +22,10 @@ import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
+// TODO: consider making this the default scope?
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@ScopeType
-public @interface SingletonScoped {
+public @interface Singleton {
}
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/PrototypeScoped.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/package-info.java
similarity index 71%
rename from log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/PrototypeScoped.java
rename to log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/package-info.java
index 43a2934..cbddbbf 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/PrototypeScoped.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/package-info.java
@@ -15,17 +15,11 @@
* limitations under the license.
*/
+/**
+ * Plugin scopes and dependency injection APIs. These annotations and interfaces form the public API used by plugins
+ * to declare necessary dependencies of a class along with any produced objects and other lifecycle callbacks to
+ * participate in the Log4j plugin system.
+ *
+ * @since 3.0
+ */
package org.apache.logging.log4j.plugins.api;
-
-import java.lang.annotation.Documented;
-import java.lang.annotation.Inherited;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-
-@Retention(RetentionPolicy.RUNTIME)
-@Documented
-@Inherited
-@ScopeType
-// TODO: consider renaming to DefaultScoped or DependentScoped
-public @interface PrototypeScoped {
-}
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 524e849..e46f7d2 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
@@ -69,4 +69,6 @@ abstract class AbstractBean<D, T> implements Bean<T> {
public int hashCode() {
return Objects.hash(variable, declaringClass);
}
+
+ abstract boolean isTrackingDependencies();
}
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 e16d6fb..b7069fb 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
@@ -23,7 +23,7 @@ import org.apache.logging.log4j.plugins.spi.bean.InjectionFactory;
import org.apache.logging.log4j.plugins.spi.bean.Producer;
import org.apache.logging.log4j.plugins.spi.model.InjectionPoint;
import org.apache.logging.log4j.plugins.spi.model.MetaMethod;
-import org.apache.logging.log4j.plugins.spi.scope.InitializationContext;
+import org.apache.logging.log4j.plugins.spi.bean.InitializationContext;
import java.lang.reflect.Type;
import java.util.Collection;
@@ -58,9 +58,13 @@ abstract class AbstractProducer<D, T> implements Producer<T> {
abstract Type getType();
+ boolean hasDisposerMethod() {
+ return disposerMethod != null;
+ }
+
@Override
public void dispose(final T instance) {
- if (disposerMethod != null) {
+ if (hasDisposerMethod()) {
// as producer and disposer bean is unrelated to this bean, we need to recreate it on demand
try (final InitializationContext<D> context = createContext()) {
final D declaringInstance = disposerMethod.isStatic() ? null : getDeclaringInstance(context);
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 bb88b4d..87bffc2 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
@@ -19,14 +19,11 @@ package org.apache.logging.log4j.plugins.defaults.bean;
import org.apache.logging.log4j.plugins.api.Disposes;
import org.apache.logging.log4j.plugins.api.Produces;
-import org.apache.logging.log4j.plugins.api.PrototypeScoped;
+import org.apache.logging.log4j.plugins.api.Dependent;
import org.apache.logging.log4j.plugins.api.Provider;
-import org.apache.logging.log4j.plugins.api.SingletonScoped;
+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.defaults.scope.DefaultInitializationContext;
-import org.apache.logging.log4j.plugins.defaults.scope.DefaultScopeContext;
-import org.apache.logging.log4j.plugins.defaults.scope.PrototypeScopeContext;
import org.apache.logging.log4j.plugins.spi.AmbiguousBeanException;
import org.apache.logging.log4j.plugins.spi.InjectionException;
import org.apache.logging.log4j.plugins.spi.ResolutionException;
@@ -47,9 +44,9 @@ import org.apache.logging.log4j.plugins.spi.model.MetaMethod;
import org.apache.logging.log4j.plugins.spi.model.MetaParameter;
import org.apache.logging.log4j.plugins.spi.model.Qualifiers;
import org.apache.logging.log4j.plugins.spi.model.Variable;
-import org.apache.logging.log4j.plugins.spi.scope.InitializationContext;
-import org.apache.logging.log4j.plugins.spi.scope.ScopeContext;
-import org.apache.logging.log4j.plugins.spi.scope.Scoped;
+import org.apache.logging.log4j.plugins.spi.bean.InitializationContext;
+import org.apache.logging.log4j.plugins.spi.bean.ScopeContext;
+import org.apache.logging.log4j.plugins.spi.bean.Scoped;
import org.apache.logging.log4j.plugins.util.ParameterizedTypeImpl;
import org.apache.logging.log4j.plugins.util.TypeUtil;
@@ -90,8 +87,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(PrototypeScoped.class, new PrototypeScopeContext());
- scopes.put(SingletonScoped.class, new DefaultScopeContext(SingletonScoped.class));
+ scopes.put(Dependent.class, new DependentScopeContext());
+ scopes.put(Singleton.class, new DefaultScopeContext(Singleton.class));
}
@Override
@@ -125,7 +122,7 @@ public class DefaultBeanManager implements BeanManager {
private <T> Bean<T> addBean(final Bean<T> bean) {
if (enabledBeans.add(bean)) {
addBeanTypes(bean);
- if (!bean.isPrototypeScoped() && !isSystemBean(bean)) {
+ if (!bean.isDependentScoped() && !isSystemBean(bean)) {
sharedBeans.add(bean);
}
}
@@ -248,9 +245,8 @@ public class DefaultBeanManager implements BeanManager {
if (rawType.equals(InjectionPoint.class)) {
final Bean<?> bean = point.getBean()
.orElseThrow(() -> new InjectionException("Cannot inject " + point + " into a non-bean"));
- if (!bean.isPrototypeScoped()) {
- // TODO: more useful error message
- throw new InjectionException("Injection of " + point + " requires use of prototype scope");
+ if (!bean.isDependentScoped()) {
+ throw new InjectionException("Injection points can only be @Dependent scoped; got: " + point);
}
}
if (rawType.equals(Bean.class)) {
@@ -391,22 +387,22 @@ public class DefaultBeanManager implements BeanManager {
return existingValue;
}
final InitializationContext<?> context =
- resolvedBean.isPrototypeScoped() ? parentContext : createInitializationContext(resolvedBean);
+ resolvedBean.isDependentScoped() ? parentContext : createInitializationContext(resolvedBean);
return Optional.of(getValue(resolvedBean, context));
}
private <T> Optional<T> getExistingInjectableValue(final Bean<T> resolvedBean, final Bean<?> pointBean,
final InitializationContext<?> parentContext) {
- if (resolvedBean.getScopeType() != SingletonScoped.class) {
+ if (resolvedBean.getScopeType() != Singleton.class) {
return Optional.empty();
}
final Optional<Bean<?>> bean;
- if (pointBean.isPrototypeScoped() && !resolvedBean.isPrototypeScoped()) {
- bean = findNonPrototypeScopedDependent(parentContext);
+ if (pointBean.isDependentScoped() && !resolvedBean.isDependentScoped()) {
+ bean = parentContext.getNonDependentScopedDependent().filter(Bean.class::isInstance).map(TypeUtil::cast);
} else {
bean = Optional.of(pointBean);
}
- return bean.filter(b -> SingletonScoped.class == b.getScopeType())
+ return bean.filter(b -> Singleton.class == b.getScopeType())
.flatMap(b -> {
final Optional<T> incompleteInstance = parentContext.getIncompleteInstance(resolvedBean);
if (incompleteInstance.isPresent()) {
@@ -426,15 +422,6 @@ public class DefaultBeanManager implements BeanManager {
scopes.clear();
}
- private static Optional<Bean<?>> findNonPrototypeScopedDependent(final InitializationContext<?> context) {
- return context.getParentContext().flatMap(parentContext ->
- parentContext.getScoped()
- .filter(Bean.class::isInstance)
- .map(scoped -> (Bean<?>) scoped)
- .flatMap(bean -> bean.isPrototypeScoped() ?
- findNonPrototypeScopedDependent(parentContext) : Optional.of(bean)));
- }
-
private static class DisposesMethod<D> {
private final Type type;
private final Qualifiers qualifiers;
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/scope/DefaultInitializationContext.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultInitializationContext.java
similarity index 63%
rename from log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/scope/DefaultInitializationContext.java
rename to log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultInitializationContext.java
index dc255ed..d3c6350 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/scope/DefaultInitializationContext.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultInitializationContext.java
@@ -15,60 +15,71 @@
* limitations under the license.
*/
-package org.apache.logging.log4j.plugins.defaults.scope;
+package org.apache.logging.log4j.plugins.defaults.bean;
-import org.apache.logging.log4j.plugins.spi.scope.InitializationContext;
-import org.apache.logging.log4j.plugins.spi.scope.Scoped;
+import org.apache.logging.log4j.plugins.spi.bean.InitializationContext;
+import org.apache.logging.log4j.plugins.spi.bean.Scoped;
import org.apache.logging.log4j.plugins.util.TypeUtil;
-import java.util.ArrayList;
-import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CopyOnWriteArrayList;
public class DefaultInitializationContext<T> implements InitializationContext<T> {
private final Scoped<T> scoped;
- private final Map<Scoped<?>, Object> incompleteInstances;
- private final List<ScopedInstance<?>> dependentInstances;
+ private Map<Scoped<?>, Object> incompleteInstances;
+ private final List<ScopedInstance<?>> dependentInstances = new CopyOnWriteArrayList<>();
private final List<ScopedInstance<?>> parentDependentInstances;
private final InitializationContext<?> parentContext;
public DefaultInitializationContext(final Scoped<T> scoped) {
- this(scoped, null);
+ this(scoped, null, new CopyOnWriteArrayList<>(), null);
}
private DefaultInitializationContext(final Scoped<T> scoped, final Map<Scoped<?>, Object> incompleteInstances) {
- this(scoped, incompleteInstances, null, null);
+ this(scoped, incompleteInstances, new CopyOnWriteArrayList<>(), null);
}
private DefaultInitializationContext(final Scoped<T> scoped, final Map<Scoped<?>, Object> incompleteInstances,
final List<ScopedInstance<?>> parentDependentInstances,
final InitializationContext<?> parentContext) {
+
this.scoped = scoped;
- this.incompleteInstances = incompleteInstances != null ? incompleteInstances : new ConcurrentHashMap<>();
- this.dependentInstances = newSynchronizedList();
- this.parentDependentInstances = parentDependentInstances != null ? parentDependentInstances : newSynchronizedList();
+ this.incompleteInstances = incompleteInstances;
+ this.parentDependentInstances = parentDependentInstances;
this.parentContext = parentContext;
}
@Override
- public void push(final T incompleteInstance) {
+ public void addIncompleteInstance(final T incompleteInstance) {
+ if (incompleteInstances == null) {
+ incompleteInstances = new ConcurrentHashMap<>();
+ }
if (scoped != null) {
incompleteInstances.put(scoped, incompleteInstance);
}
}
@Override
- public Optional<Scoped<T>> getScoped() {
- return Optional.ofNullable(scoped);
+ public boolean isTrackingDependencies(final Scoped<T> scoped) {
+ return !dependentInstances.isEmpty() ||
+ (scoped instanceof AbstractBean<?, ?> && ((AbstractBean<?, ?>) scoped).isTrackingDependencies());
}
@Override
- public Optional<InitializationContext<?>> getParentContext() {
- return Optional.ofNullable(parentContext);
+ public void addDependentInstance(final T dependentInstance) {
+ parentDependentInstances.add(new DefaultScopedInstance<>(scoped, dependentInstance, this));
+ }
+
+ @Override
+ public Optional<Scoped<?>> getNonDependentScopedDependent() {
+ if (parentContext == null || scoped == null) {
+ return Optional.empty();
+ }
+ return scoped.isDependentScoped() ? parentContext.getNonDependentScopedDependent() : Optional.of(scoped);
}
@Override
@@ -78,17 +89,14 @@ public class DefaultInitializationContext<T> implements InitializationContext<T>
@Override
public <S> InitializationContext<S> createIndependentContext(final Scoped<S> scoped) {
- return new DefaultInitializationContext<>(scoped, new ConcurrentHashMap<>(incompleteInstances));
+ return new DefaultInitializationContext<>(scoped, incompleteInstances == null ? null : new ConcurrentHashMap<>(incompleteInstances));
}
@Override
public <S> Optional<S> getIncompleteInstance(final Scoped<S> scoped) {
- return Optional.ofNullable(TypeUtil.cast(incompleteInstances.get(scoped)));
- }
-
- void addDependentInstance(final T dependentInstance) {
- // TODO: why does this use the parent dependent when remove uses these dependent?
- parentDependentInstances.add(new DefaultScopedInstance<>(scoped, dependentInstance, this));
+ return Optional.ofNullable(incompleteInstances)
+ .map(map -> map.get(scoped))
+ .map(TypeUtil::cast);
}
@Override
@@ -100,7 +108,4 @@ public class DefaultInitializationContext<T> implements InitializationContext<T>
}
}
- private static <T> List<T> newSynchronizedList() {
- return Collections.synchronizedList(new ArrayList<>());
- }
}
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultInjectionFactory.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultInjectionFactory.java
index a5311ad..48fd80a 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultInjectionFactory.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultInjectionFactory.java
@@ -25,7 +25,7 @@ import org.apache.logging.log4j.plugins.spi.model.MetaConstructor;
import org.apache.logging.log4j.plugins.spi.model.MetaField;
import org.apache.logging.log4j.plugins.spi.model.MetaMethod;
import org.apache.logging.log4j.plugins.spi.model.MetaParameter;
-import org.apache.logging.log4j.plugins.spi.scope.InitializationContext;
+import org.apache.logging.log4j.plugins.spi.bean.InitializationContext;
import java.util.Collection;
import java.util.List;
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 42ecce3..0b8e308 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
@@ -30,7 +30,7 @@ import org.apache.logging.log4j.plugins.spi.model.MetaElement;
import org.apache.logging.log4j.plugins.spi.model.MetaField;
import org.apache.logging.log4j.plugins.spi.model.MetaMember;
import org.apache.logging.log4j.plugins.spi.model.MetaMethod;
-import org.apache.logging.log4j.plugins.spi.scope.InitializationContext;
+import org.apache.logging.log4j.plugins.spi.bean.InitializationContext;
import org.apache.logging.log4j.plugins.util.TypeUtil;
import java.util.Collection;
@@ -131,4 +131,8 @@ class DefaultInjectionTarget<T> implements InjectionTarget<T> {
public Collection<InjectionPoint<?>> getInjectionPoints() {
return injectionPoints;
}
+
+ boolean hasPreDestroyMethods() {
+ return !preDestroyMethods.isEmpty();
+ }
}
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/scope/DefaultScopeContext.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultScopeContext.java
similarity index 90%
rename from log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/scope/DefaultScopeContext.java
rename to log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultScopeContext.java
index c8faa1c..0fc5f6d 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/scope/DefaultScopeContext.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultScopeContext.java
@@ -15,11 +15,11 @@
* limitations under the license.
*/
-package org.apache.logging.log4j.plugins.defaults.scope;
+package org.apache.logging.log4j.plugins.defaults.bean;
-import org.apache.logging.log4j.plugins.spi.scope.InitializationContext;
-import org.apache.logging.log4j.plugins.spi.scope.ScopeContext;
-import org.apache.logging.log4j.plugins.spi.scope.Scoped;
+import org.apache.logging.log4j.plugins.spi.bean.InitializationContext;
+import org.apache.logging.log4j.plugins.spi.bean.ScopeContext;
+import org.apache.logging.log4j.plugins.spi.bean.Scoped;
import org.apache.logging.log4j.plugins.util.TypeUtil;
import java.lang.annotation.Annotation;
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/scope/DefaultScopedInstance.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultScopedInstance.java
similarity index 89%
rename from log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/scope/DefaultScopedInstance.java
rename to log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultScopedInstance.java
index 01594a6..4548d08 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/scope/DefaultScopedInstance.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultScopedInstance.java
@@ -15,10 +15,10 @@
* limitations under the license.
*/
-package org.apache.logging.log4j.plugins.defaults.scope;
+package org.apache.logging.log4j.plugins.defaults.bean;
-import org.apache.logging.log4j.plugins.spi.scope.InitializationContext;
-import org.apache.logging.log4j.plugins.spi.scope.Scoped;
+import org.apache.logging.log4j.plugins.spi.bean.InitializationContext;
+import org.apache.logging.log4j.plugins.spi.bean.Scoped;
import java.util.Objects;
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/scope/PrototypeScopeContext.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DependentScopeContext.java
similarity index 70%
rename from log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/scope/PrototypeScopeContext.java
rename to log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DependentScopeContext.java
index 51f8ced..57554eb 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/scope/PrototypeScopeContext.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DependentScopeContext.java
@@ -15,27 +15,30 @@
* limitations under the license.
*/
-package org.apache.logging.log4j.plugins.defaults.scope;
+package org.apache.logging.log4j.plugins.defaults.bean;
-import org.apache.logging.log4j.plugins.api.PrototypeScoped;
-import org.apache.logging.log4j.plugins.spi.scope.InitializationContext;
-import org.apache.logging.log4j.plugins.spi.scope.ScopeContext;
-import org.apache.logging.log4j.plugins.spi.scope.Scoped;
+import org.apache.logging.log4j.plugins.api.Dependent;
+import org.apache.logging.log4j.plugins.spi.bean.InitializationContext;
+import org.apache.logging.log4j.plugins.spi.bean.ScopeContext;
+import org.apache.logging.log4j.plugins.spi.bean.Scoped;
import java.lang.annotation.Annotation;
import java.util.Optional;
-public class PrototypeScopeContext implements ScopeContext {
+public class DependentScopeContext implements ScopeContext {
@Override
public Class<? extends Annotation> getScopeType() {
- return PrototypeScoped.class;
+ return Dependent.class;
}
@Override
public <T> T getOrCreate(final Scoped<T> scoped, final InitializationContext<T> context) {
+ if (context == null) {
+ return null;
+ }
final T instance = scoped.create(context);
- if (context instanceof DefaultInitializationContext<?>) {
- ((DefaultInitializationContext<T>) context).addDependentInstance(instance);
+ if (context.isTrackingDependencies(scoped)) {
+ context.addDependentInstance(instance);
}
return instance;
}
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 e862adf..2555e50 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
@@ -22,7 +22,7 @@ import org.apache.logging.log4j.plugins.spi.bean.BeanManager;
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.scope.InitializationContext;
+import org.apache.logging.log4j.plugins.spi.bean.InitializationContext;
import java.lang.reflect.Type;
import java.util.Collection;
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 0022e00..a5f071d 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
@@ -23,7 +23,7 @@ import org.apache.logging.log4j.plugins.spi.bean.InjectionTargetFactory;
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.scope.InitializationContext;
+import org.apache.logging.log4j.plugins.spi.bean.InitializationContext;
import java.util.Collection;
import java.util.Objects;
@@ -51,8 +51,8 @@ class InjectionTargetBean<T> extends AbstractBean<T, T> {
}
injectionTarget.inject(instance, context);
injectionTarget.postConstruct(instance);
- if (isPrototypeScoped()) {
- context.push(instance);
+ if (isDependentScoped()) {
+ context.addIncompleteInstance(instance);
}
return instance;
}
@@ -60,7 +60,7 @@ class InjectionTargetBean<T> extends AbstractBean<T, T> {
@Override
public void destroy(final T instance, final InitializationContext<T> context) {
try {
- if (isPrototypeScoped()) {
+ if (isDependentScoped()) {
injectionTarget.preDestroy(instance);
}
} finally {
@@ -77,4 +77,10 @@ class InjectionTargetBean<T> extends AbstractBean<T, T> {
", declaringClass=" + getDeclaringClass() +
'}';
}
+
+ @Override
+ boolean isTrackingDependencies() {
+ return injectionTarget instanceof DefaultInjectionTarget<?> &&
+ ((DefaultInjectionTarget<?>) injectionTarget).hasPreDestroyMethods();
+ }
}
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/scope/LazyScopedInstance.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/LazyScopedInstance.java
similarity index 89%
rename from log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/scope/LazyScopedInstance.java
rename to log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/LazyScopedInstance.java
index aa09204..64c1cb8 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/scope/LazyScopedInstance.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/LazyScopedInstance.java
@@ -15,10 +15,10 @@
* limitations under the license.
*/
-package org.apache.logging.log4j.plugins.defaults.scope;
+package org.apache.logging.log4j.plugins.defaults.bean;
-import org.apache.logging.log4j.plugins.spi.scope.InitializationContext;
-import org.apache.logging.log4j.plugins.spi.scope.Scoped;
+import org.apache.logging.log4j.plugins.spi.bean.InitializationContext;
+import org.apache.logging.log4j.plugins.spi.bean.Scoped;
import java.util.Objects;
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 d372197..927ab5b 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
@@ -22,7 +22,7 @@ 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.model.InjectionPoint;
import org.apache.logging.log4j.plugins.spi.model.MetaMethod;
-import org.apache.logging.log4j.plugins.spi.scope.InitializationContext;
+import org.apache.logging.log4j.plugins.spi.bean.InitializationContext;
import java.lang.reflect.Type;
import java.util.Collection;
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/OptionalBean.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/OptionalBean.java
index 4acd865..0d753c8 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/OptionalBean.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/OptionalBean.java
@@ -18,7 +18,7 @@
package org.apache.logging.log4j.plugins.defaults.bean;
import org.apache.logging.log4j.plugins.spi.model.Variable;
-import org.apache.logging.log4j.plugins.spi.scope.InitializationContext;
+import org.apache.logging.log4j.plugins.spi.bean.InitializationContext;
import java.util.Optional;
import java.util.function.Function;
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 83c9a16..6a382fe 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
@@ -23,7 +23,7 @@ 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.scope.InitializationContext;
+import org.apache.logging.log4j.plugins.spi.bean.InitializationContext;
import java.lang.reflect.Type;
import java.util.Collection;
@@ -59,8 +59,9 @@ class ProducerBean<D, T> extends AbstractBean<D, T> {
if (instance == null) {
throw new IllegalProductException("Producer created null instance: " + producer);
}
- if (isPrototypeScoped()) {
- context.push(instance);
+ // FIXME: this logic doesn't seem to be in Weld? only seems to be required in InjectionTargetBean
+ if (isDependentScoped()) {
+ context.addIncompleteInstance(instance);
}
return instance;
}
@@ -68,7 +69,7 @@ class ProducerBean<D, T> extends AbstractBean<D, T> {
@Override
public void destroy(final T instance, final InitializationContext<T> context) {
try {
- if (isPrototypeScoped()) {
+ if (isDependentScoped()) {
producer.dispose(instance);
}
} finally {
@@ -85,4 +86,9 @@ class ProducerBean<D, T> extends AbstractBean<D, T> {
", declaringClass=" + getDeclaringClass() +
'}';
}
+
+ @Override
+ boolean isTrackingDependencies() {
+ return producer instanceof AbstractProducer<?, ?> && ((AbstractProducer<?, ?>) producer).hasDisposerMethod();
+ }
}
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/ProvidedBean.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/ProvidedBean.java
index cef3a9f..632218d 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/ProvidedBean.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/ProvidedBean.java
@@ -18,7 +18,7 @@
package org.apache.logging.log4j.plugins.defaults.bean;
import org.apache.logging.log4j.plugins.spi.model.Variable;
-import org.apache.logging.log4j.plugins.spi.scope.InitializationContext;
+import org.apache.logging.log4j.plugins.spi.bean.InitializationContext;
import java.util.function.Function;
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/ProviderBean.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/ProviderBean.java
index b815a64..bbd8522 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/ProviderBean.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/ProviderBean.java
@@ -19,7 +19,7 @@ package org.apache.logging.log4j.plugins.defaults.bean;
import org.apache.logging.log4j.plugins.api.Provider;
import org.apache.logging.log4j.plugins.spi.model.Variable;
-import org.apache.logging.log4j.plugins.spi.scope.InitializationContext;
+import org.apache.logging.log4j.plugins.spi.bean.InitializationContext;
import java.util.function.Function;
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/scope/ScopedInstance.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/ScopedInstance.java
similarity index 89%
rename from log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/scope/ScopedInstance.java
rename to log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/ScopedInstance.java
index c03eeed..196d303 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/scope/ScopedInstance.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/ScopedInstance.java
@@ -15,9 +15,9 @@
* limitations under the license.
*/
-package org.apache.logging.log4j.plugins.defaults.scope;
+package org.apache.logging.log4j.plugins.defaults.bean;
-import org.apache.logging.log4j.plugins.spi.scope.Scoped;
+import org.apache.logging.log4j.plugins.spi.bean.Scoped;
interface ScopedInstance<T> extends AutoCloseable {
Scoped<T> getScoped();
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 66d8230..b5c9519 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
@@ -22,7 +22,7 @@ import org.apache.logging.log4j.plugins.spi.bean.Bean;
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.scope.InitializationContext;
+import org.apache.logging.log4j.plugins.spi.bean.InitializationContext;
import java.lang.annotation.Annotation;
import java.lang.reflect.Type;
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 882c124..e60fa31 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
@@ -18,7 +18,7 @@
package org.apache.logging.log4j.plugins.defaults.model;
import org.apache.logging.log4j.plugins.api.AliasFor;
-import org.apache.logging.log4j.plugins.api.PrototypeScoped;
+import org.apache.logging.log4j.plugins.api.Dependent;
import org.apache.logging.log4j.plugins.api.QualifierType;
import org.apache.logging.log4j.plugins.api.ScopeType;
import org.apache.logging.log4j.plugins.api.Stereotype;
@@ -120,7 +120,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() ? PrototypeScoped.class : scopeTypes.iterator().next();
+ return scopeTypes.isEmpty() ? Dependent.class : scopeTypes.iterator().next();
}
private Collection<Class<? extends Annotation>> filterScopeTypes(final Collection<Annotation> annotations) {
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 831a4a8..2fecd0c 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
@@ -20,7 +20,6 @@ package org.apache.logging.log4j.plugins.spi.bean;
import org.apache.logging.log4j.plugins.spi.model.InjectionPoint;
import org.apache.logging.log4j.plugins.spi.model.MetaClass;
import org.apache.logging.log4j.plugins.spi.model.Variable;
-import org.apache.logging.log4j.plugins.spi.scope.Scoped;
import java.util.Collection;
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 d767d50..e8cd275 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
@@ -19,8 +19,6 @@ package org.apache.logging.log4j.plugins.spi.bean;
import org.apache.logging.log4j.plugins.spi.ValidationException;
import org.apache.logging.log4j.plugins.spi.model.InjectionPoint;
-import org.apache.logging.log4j.plugins.spi.scope.InitializationContext;
-import org.apache.logging.log4j.plugins.spi.scope.Scoped;
import java.util.Arrays;
import java.util.Collection;
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/scope/InitializationContext.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/InitializationContext.java
similarity index 74%
rename from log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/scope/InitializationContext.java
rename to log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/InitializationContext.java
index 5bf2f4a..117342e 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/scope/InitializationContext.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/InitializationContext.java
@@ -15,7 +15,7 @@
* limitations under the license.
*/
-package org.apache.logging.log4j.plugins.spi.scope;
+package org.apache.logging.log4j.plugins.spi.bean;
import java.util.Optional;
@@ -29,16 +29,22 @@ public interface InitializationContext<T> extends AutoCloseable {
*
* @param incompleteInstance incompletely initialized instance
*/
- void push(final T incompleteInstance);
+ void addIncompleteInstance(final T incompleteInstance);
- <S> Optional<S> getIncompleteInstance(Scoped<S> scoped);
+ // TODO: this API is needlessly complicated currently
+ boolean isTrackingDependencies(final Scoped<T> scoped);
+
+ void addDependentInstance(T dependentInstance);
- Optional<Scoped<T>> getScoped();
+ // TODO: consider returning Optional<Bean<?>> or flattening Scoped into Bean
+ Optional<Scoped<?>> getNonDependentScopedDependent();
- Optional<InitializationContext<?>> getParentContext();
+ <S> Optional<S> getIncompleteInstance(Scoped<S> scoped);
+ // dependent contexts share the same incomplete instances
<S> InitializationContext<S> createDependentContext(Scoped<S> scoped);
+ // independent contexts are used by producers to get their declaring bean separately
<S> InitializationContext<S> createIndependentContext(Scoped<S> scoped);
/**
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/InjectionFactory.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/InjectionFactory.java
index 50aed45..b118d67 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/InjectionFactory.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/InjectionFactory.java
@@ -21,7 +21,6 @@ import org.apache.logging.log4j.plugins.spi.model.InjectionPoint;
import org.apache.logging.log4j.plugins.spi.model.MetaConstructor;
import org.apache.logging.log4j.plugins.spi.model.MetaField;
import org.apache.logging.log4j.plugins.spi.model.MetaMethod;
-import org.apache.logging.log4j.plugins.spi.scope.InitializationContext;
import java.util.Collection;
import java.util.function.Consumer;
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/InjectionTarget.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/InjectionTarget.java
index df5c616..409d1d3 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/InjectionTarget.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/InjectionTarget.java
@@ -17,8 +17,6 @@
package org.apache.logging.log4j.plugins.spi.bean;
-import org.apache.logging.log4j.plugins.spi.scope.InitializationContext;
-
public interface InjectionTarget<T> extends Producer<T> {
// sets values of injected fields and calls initializer methods
void inject(final T instance, final InitializationContext<T> 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 6a6d4a0..4a8f27a 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
@@ -18,7 +18,6 @@
package org.apache.logging.log4j.plugins.spi.bean;
import org.apache.logging.log4j.plugins.spi.model.InjectionPoint;
-import org.apache.logging.log4j.plugins.spi.scope.InitializationContext;
import java.util.Collection;
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/scope/ScopeContext.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/ScopeContext.java
similarity index 97%
rename from log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/scope/ScopeContext.java
rename to log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/ScopeContext.java
index 9617a7d..ced2798 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/scope/ScopeContext.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/ScopeContext.java
@@ -15,7 +15,7 @@
* limitations under the license.
*/
-package org.apache.logging.log4j.plugins.spi.scope;
+package org.apache.logging.log4j.plugins.spi.bean;
import org.apache.logging.log4j.plugins.api.ScopeType;
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/scope/Scoped.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/Scoped.java
similarity index 85%
rename from log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/scope/Scoped.java
rename to log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/Scoped.java
index d214662..7953435 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/scope/Scoped.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/bean/Scoped.java
@@ -15,17 +15,16 @@
* limitations under the license.
*/
-package org.apache.logging.log4j.plugins.spi.scope;
+package org.apache.logging.log4j.plugins.spi.bean;
-import org.apache.logging.log4j.plugins.api.PrototypeScoped;
-import org.apache.logging.log4j.plugins.api.SingletonScoped;
+import org.apache.logging.log4j.plugins.api.Dependent;
+import org.apache.logging.log4j.plugins.api.Singleton;
import java.lang.annotation.Annotation;
/**
* Manages the creation and destruction of instances of a specific type within a particular scope context. Scopes
- * provide managed life-cycles for objects such as {@linkplain SingletonScoped singleton}
- * and {@linkplain PrototypeScoped prototype}.
+ * provide managed life-cycles for objects such as {@linkplain Singleton singleton} and {@linkplain Dependent dependent}.
*
* @param <T> type of managed instance
* @see org.apache.logging.log4j.plugins.api.ScopeType
@@ -52,7 +51,7 @@ public interface Scoped<T> {
Class<? extends Annotation> getScopeType();
- default boolean isPrototypeScoped() {
- return getScopeType() == PrototypeScoped.class;
+ default boolean isDependentScoped() {
+ return getScopeType() == Dependent.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 315b5d8..07fd6f6 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
@@ -23,7 +23,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.SingletonScoped;
+import org.apache.logging.log4j.plugins.api.Singleton;
import org.apache.logging.log4j.plugins.test.BeanJUnit4Runner;
import org.apache.logging.log4j.plugins.test.WithBeans;
import org.junit.Test;
@@ -45,11 +45,11 @@ public class DefaultBeanManagerTest {
}
@Produces
- @SingletonScoped
+ @Singleton
public String globalString = "global string value";
@Produces
- @SingletonScoped
+ @Singleton
@Run
public String testString() {
return "test string value";
@@ -124,12 +124,12 @@ public class DefaultBeanManagerTest {
@WithBeans(DefaultConstructorInjection.class)
@Test
- public void testPrototypeScopeDifferentInstances(final DefaultConstructorInjection first,
+ public void testDependentScopeDifferentInstances(final DefaultConstructorInjection first,
final DefaultConstructorInjection second) {
assertNotSame(first, second);
}
- @SingletonScoped
+ @Singleton
public static class SingletonInjection {
}
@@ -221,7 +221,7 @@ public class DefaultBeanManagerTest {
assertTrue(instance.isPresent());
}
- @SingletonScoped
+ @Singleton
public static class IdGenerator {
private final AtomicInteger current = new AtomicInteger();
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 92a8ffd..28c8c32 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
@@ -29,7 +29,7 @@ import org.apache.logging.log4j.plugins.spi.model.ElementManager;
import org.apache.logging.log4j.plugins.spi.model.InjectionPoint;
import org.apache.logging.log4j.plugins.spi.model.MetaClass;
import org.apache.logging.log4j.plugins.spi.model.MetaMethod;
-import org.apache.logging.log4j.plugins.spi.scope.InitializationContext;
+import org.apache.logging.log4j.plugins.spi.bean.InitializationContext;
import org.apache.logging.log4j.plugins.util.TypeUtil;
import org.junit.Test;
import org.junit.runners.BlockJUnit4ClassRunner;