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/15 17:26:34 UTC

[logging-log4j2] branch mean-bean-machine updated (915a659 -> 0fe2003)

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 915a659  Use decapitalized simple class name for default @Named value
     new 3a6fee3  Use better exception type
     new f089940  Remove unused type parameter in Variable
     new a11f179  Use better exceptions
     new e9c1233  Decrease visibility
     new 41f31dd  Improve toString
     new 37aacb1  Remove unused import
     new 0fe2003  Improve annotation meta-modeling

The 7 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/{AliasFor.java => AnnotationAlias.java}    |  11 +-
 .../log4j/plugins/defaults/bean/AbstractBean.java  |   4 +-
 .../plugins/defaults/bean/DefaultBeanManager.java  |  79 ++++++------
 .../bean/DefaultInjectionTargetFactory.java        |   8 +-
 .../defaults/bean/DependentScopeContext.java       |   2 +-
 .../plugins/defaults/bean/InjectionTargetBean.java |   8 +-
 .../log4j/plugins/defaults/bean/OptionalBean.java  |   2 +-
 .../log4j/plugins/defaults/bean/ProducerBean.java  |   2 +-
 .../log4j/plugins/defaults/bean/ProvidedBean.java  |   2 +-
 .../log4j/plugins/defaults/bean/ProviderBean.java  |   2 +-
 .../log4j/plugins/defaults/bean/SystemBean.java    |   4 +-
 .../plugins/defaults/model/AbstractMetaMember.java |   9 +-
 .../defaults/model/DefaultElementManager.java      |  73 +++++++----
 .../defaults/model/DefaultInjectionPoint.java      |   6 +-
 .../defaults/model/DefaultMetaAnnotation.java      | 112 +++++++++++++++++
 .../model/DefaultMetaAnnotationElement.java        |  82 +++++++++++++
 .../plugins/defaults/model/DefaultMetaClass.java   |   9 +-
 .../defaults/model/DefaultMetaParameter.java       |   4 +-
 .../plugins/defaults/model/DefaultQualifiers.java  |  78 ++++++++++++
 .../plugins/defaults/model/DefaultVariable.java    |  10 +-
 .../log4j/plugins/spi/InjectionException.java      |   7 +-
 .../logging/log4j/plugins/spi/bean/Bean.java       |   2 +-
 .../log4j/plugins/spi/model/ElementManager.java    |   6 +-
 .../{MetaExecutable.java => MetaAnnotation.java}   |   9 +-
 ...Constructor.java => MetaAnnotationElement.java} |   6 +-
 .../log4j/plugins/spi/model/MetaElement.java       |  24 ++--
 .../log4j/plugins/spi/model/Qualifiers.java        | 133 +--------------------
 .../logging/log4j/plugins/spi/model/Variable.java  |   7 +-
 .../log4j/plugins/spi/model/QualifiersTest.java    |  79 ------------
 .../log4j/plugins/test/BeanJUnit4Runner.java       |   4 +-
 30 files changed, 435 insertions(+), 349 deletions(-)
 rename log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/{AliasFor.java => AnnotationAlias.java} (65%)
 create mode 100644 log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultMetaAnnotation.java
 create mode 100644 log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultMetaAnnotationElement.java
 create mode 100644 log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultQualifiers.java
 copy log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/{MetaExecutable.java => MetaAnnotation.java} (79%)
 copy log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/{MetaConstructor.java => MetaAnnotationElement.java} (85%)
 delete mode 100644 log4j-plugins/src/test/java/org/apache/logging/log4j/plugins/spi/model/QualifiersTest.java


[logging-log4j2] 04/07: Decrease visibility

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 e9c1233dd5550db9aa64852c49515ce43ae03e7a
Author: Matt Sicker <bo...@gmail.com>
AuthorDate: Sat Mar 14 14:08:35 2020 -0500

    Decrease visibility
    
    This class is not used elsewhere and only has the single use case.
    
    Signed-off-by: Matt Sicker <bo...@gmail.com>
---
 .../logging/log4j/plugins/defaults/bean/DependentScopeContext.java      | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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 2a7a4be..b8c8208 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
@@ -25,7 +25,7 @@ import org.apache.logging.log4j.plugins.spi.bean.ScopeContext;
 import java.lang.annotation.Annotation;
 import java.util.Optional;
 
-public class DependentScopeContext implements ScopeContext {
+class DependentScopeContext implements ScopeContext {
     @Override
     public Class<? extends Annotation> getScopeType() {
         return Dependent.class;


[logging-log4j2] 01/07: Use better exception type

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 3a6fee33f05eca2af2cecea27a16579c31a914d7
Author: Matt Sicker <bo...@gmail.com>
AuthorDate: Sat Mar 14 13:32:15 2020 -0500

    Use better exception type
    
    Signed-off-by: Matt Sicker <bo...@gmail.com>
---
 .../plugins/defaults/bean/DefaultInjectionTargetFactory.java      | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultInjectionTargetFactory.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultInjectionTargetFactory.java
index d048a14..30c30ec 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultInjectionTargetFactory.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/DefaultInjectionTargetFactory.java
@@ -20,7 +20,7 @@ package org.apache.logging.log4j.plugins.defaults.bean;
 import org.apache.logging.log4j.plugins.api.Inject;
 import org.apache.logging.log4j.plugins.api.PostConstruct;
 import org.apache.logging.log4j.plugins.api.PreDestroy;
-import org.apache.logging.log4j.plugins.spi.InjectionException;
+import org.apache.logging.log4j.plugins.spi.DefinitionException;
 import org.apache.logging.log4j.plugins.spi.bean.Bean;
 import org.apache.logging.log4j.plugins.spi.bean.InjectionTarget;
 import org.apache.logging.log4j.plugins.spi.bean.InjectionTargetFactory;
@@ -85,7 +85,7 @@ class DefaultInjectionTargetFactory<T> implements InjectionTargetFactory<T> {
                 .filter(constructor -> constructor.isAnnotationPresent(Inject.class))
                 .collect(Collectors.toList());
         if (injectConstructors.size() > 1) {
-            throw new InjectionException("Found more than one constructor with @Inject for " + type);
+            throw new DefinitionException("Found more than one constructor with @Inject for " + type);
         }
         if (injectConstructors.size() == 1) {
             return injectConstructors.get(0);
@@ -94,7 +94,7 @@ class DefaultInjectionTargetFactory<T> implements InjectionTargetFactory<T> {
                 .filter(constructor -> constructor.getParameters().stream().anyMatch(elementManager::isInjectable))
                 .collect(Collectors.toList());
         if (injectParameterConstructors.size() > 1) {
-            throw new InjectionException("No @Inject constructors found and remaining constructors ambiguous for " + type);
+            throw new DefinitionException("No @Inject constructors found and remaining constructors ambiguous for " + type);
         }
         if (injectParameterConstructors.size() == 1) {
             return injectParameterConstructors.get(0);
@@ -106,6 +106,6 @@ class DefaultInjectionTargetFactory<T> implements InjectionTargetFactory<T> {
             }
         }
         return type.getDefaultConstructor()
-                .orElseThrow(() -> new InjectionException("No candidate constructors found for " + type));
+                .orElseThrow(() -> new DefinitionException("No candidate constructors found for " + type));
     }
 }


[logging-log4j2] 06/07: Remove unused import

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 37aacb133cbdf17c4a5d04c1ddc22eeba0131f2c
Author: Matt Sicker <bo...@gmail.com>
AuthorDate: Sun Mar 15 12:19:35 2020 -0500

    Remove unused import
    
    Signed-off-by: Matt Sicker <bo...@gmail.com>
---
 .../main/java/org/apache/logging/log4j/plugins/spi/model/Variable.java   | 1 -
 1 file changed, 1 deletion(-)

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 af703ac..dc8eeb2 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
@@ -18,7 +18,6 @@
 package org.apache.logging.log4j.plugins.spi.model;
 
 import org.apache.logging.log4j.plugins.api.Dependent;
-import org.apache.logging.log4j.plugins.api.Singleton;
 import org.apache.logging.log4j.plugins.util.TypeUtil;
 
 import java.lang.annotation.Annotation;


[logging-log4j2] 03/07: Use better exceptions

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 a11f1792465f7cbc33b0dec656a76062f27ceae4
Author: Matt Sicker <bo...@gmail.com>
AuthorDate: Sat Mar 14 14:01:24 2020 -0500

    Use better exceptions
    
    This also makes InjectionException have protected constructors to prevent code from throwing the generic parent type.
    
    Signed-off-by: Matt Sicker <bo...@gmail.com>
---
 .../log4j/plugins/defaults/bean/DefaultBeanManager.java | 17 +++++++++--------
 .../plugins/defaults/bean/InjectionTargetBean.java      |  6 +++---
 .../logging/log4j/plugins/spi/InjectionException.java   |  7 ++-----
 .../logging/log4j/plugins/spi/model/Qualifiers.java     |  6 +++---
 .../logging/log4j/plugins/test/BeanJUnit4Runner.java    |  4 ++--
 5 files changed, 19 insertions(+), 21 deletions(-)

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 6028c43..eb369be 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
@@ -25,6 +25,7 @@ import org.apache.logging.log4j.plugins.api.Singleton;
 import org.apache.logging.log4j.plugins.defaults.model.DefaultElementManager;
 import org.apache.logging.log4j.plugins.defaults.model.DefaultVariable;
 import org.apache.logging.log4j.plugins.spi.AmbiguousBeanException;
+import org.apache.logging.log4j.plugins.spi.DefinitionException;
 import org.apache.logging.log4j.plugins.spi.InjectionException;
 import org.apache.logging.log4j.plugins.spi.ResolutionException;
 import org.apache.logging.log4j.plugins.spi.UnsatisfiedBeanException;
@@ -234,18 +235,18 @@ public class DefaultBeanManager implements BeanManager {
     private <T> void validateInjectionPoint(final InjectionPoint<T> point) {
         final MetaElement<T> element = point.getElement();
         if (element.isAnnotationPresent(Produces.class)) {
-            throw new InjectionException("Cannot inject into a @Produces element: " + element);
+            throw new DefinitionException("Cannot inject into a @Produces element: " + element);
         }
         final Type type = point.getType();
         if (type instanceof TypeVariable<?>) {
-            throw new InjectionException("Cannot inject into a TypeVariable: " + point);
+            throw new DefinitionException("Cannot inject into a TypeVariable: " + point);
         }
         final Class<?> rawType = TypeUtil.getRawType(type);
         if (rawType.equals(InjectionPoint.class)) {
             final Bean<?> bean = point.getBean()
-                    .orElseThrow(() -> new InjectionException("Cannot inject " + point + " into a non-bean"));
+                    .orElseThrow(() -> new DefinitionException("Cannot inject " + point + " into a non-bean"));
             if (!bean.isDependentScoped()) {
-                throw new InjectionException("Injection points can only be @Dependent scoped; got: " + point);
+                throw new DefinitionException("Injection points can only be @Dependent scoped; got: " + point);
             }
         }
         if (rawType.equals(Bean.class)) {
@@ -265,18 +266,18 @@ public class DefaultBeanManager implements BeanManager {
     private void validateBeanInjectionPoint(final InjectionPoint<?> point, final Type expectedType) {
         final Type type = point.getType();
         if (!(type instanceof ParameterizedType)) {
-            throw new InjectionException("Expected parameterized type for " + point + " but got " + expectedType);
+            throw new DefinitionException("Expected parameterized type for " + point + " but got " + expectedType);
         }
         final ParameterizedType parameterizedType = (ParameterizedType) type;
         final Type[] typeArguments = parameterizedType.getActualTypeArguments();
         if (typeArguments.length != 1) {
-            throw new InjectionException("Expected one type parameter argument for " + point + " but got " +
+            throw new DefinitionException("Expected one type parameter argument for " + point + " but got " +
                     Arrays.toString(typeArguments));
         }
         if (point.getQualifiers().hasDefaultQualifier()) {
             final Type typeArgument = typeArguments[0];
             if (!typeArgument.equals(expectedType)) {
-                throw new InjectionException("Expected type " + expectedType + " but got " + typeArgument + " in " + point);
+                throw new DefinitionException("Expected type " + expectedType + " but got " + typeArgument + " in " + point);
             }
         }
     }
@@ -366,7 +367,7 @@ public class DefaultBeanManager implements BeanManager {
     private ScopeContext getScopeContext(final Class<? extends Annotation> scopeType) {
         final ScopeContext scopeContext = scopes.get(scopeType);
         if (scopeContext == null) {
-            throw new InjectionException("No active scope context found for scope @" + scopeType.getName());
+            throw new ResolutionException("No active scope context found for scope @" + scopeType.getName());
         }
         return scopeContext;
     }
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 9535f02..d71839a 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
@@ -17,13 +17,13 @@
 
 package org.apache.logging.log4j.plugins.defaults.bean;
 
-import org.apache.logging.log4j.plugins.spi.InjectionException;
+import org.apache.logging.log4j.plugins.spi.IllegalProductException;
+import org.apache.logging.log4j.plugins.spi.bean.InitializationContext;
 import org.apache.logging.log4j.plugins.spi.bean.InjectionTarget;
 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.bean.InitializationContext;
 
 import java.util.Collection;
 import java.util.Objects;
@@ -47,7 +47,7 @@ class InjectionTargetBean<T> extends AbstractBean<T, T> {
     public T create(final InitializationContext<T> context) {
         final T instance = injectionTarget.produce(context);
         if (instance == null) {
-            throw new InjectionException("Injection target created null instance: " + injectionTarget);
+            throw new IllegalProductException("Injection target created null instance: " + injectionTarget);
         }
         injectionTarget.inject(instance, context);
         injectionTarget.postConstruct(instance);
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/InjectionException.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/InjectionException.java
index 853afa9..1b7475f 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/InjectionException.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/InjectionException.java
@@ -17,15 +17,12 @@
 
 package org.apache.logging.log4j.plugins.spi;
 
-// TODO: create more exception types such as:
-//       invalid use of annotations
-//       constraint validation errors
 public class InjectionException extends RuntimeException {
-    public InjectionException(final String message) {
+    protected InjectionException(final String message) {
         super(message);
     }
 
-    public InjectionException(final String message, final Throwable cause) {
+    protected InjectionException(final String message, final Throwable cause) {
         super(message, cause);
     }
 }
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/Qualifiers.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/Qualifiers.java
index 19c500b..a3293c0 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/Qualifiers.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/Qualifiers.java
@@ -21,7 +21,7 @@ import org.apache.logging.log4j.plugins.api.AliasFor;
 import org.apache.logging.log4j.plugins.api.Default;
 import org.apache.logging.log4j.plugins.api.Ignore;
 import org.apache.logging.log4j.plugins.api.Named;
-import org.apache.logging.log4j.plugins.spi.InjectionException;
+import org.apache.logging.log4j.plugins.spi.InitializationException;
 import org.apache.logging.log4j.util.StringBuilders;
 import org.apache.logging.log4j.util.Strings;
 
@@ -132,9 +132,9 @@ public final class Qualifiers {
         try {
             return element.invoke(annotation);
         } catch (final IllegalAccessException e) {
-            throw new InjectionException("Cannot access element " + element.getName() + " of annotation " + annotation, e);
+            throw new InitializationException("Cannot access element " + element.getName() + " of annotation " + annotation, e);
         } catch (final InvocationTargetException e) {
-            throw new InjectionException("Cannot access element " + element.getName() + " of annotation " + annotation,
+            throw new InitializationException("Cannot access element " + element.getName() + " of annotation " + annotation,
                     e.getCause());
         }
     }
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 31977d8..06a07bf 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
@@ -20,7 +20,7 @@ package org.apache.logging.log4j.plugins.test;
 import org.apache.logging.log4j.plugins.defaults.bean.DefaultBeanManager;
 import org.apache.logging.log4j.plugins.defaults.bean.DefaultInjector;
 import org.apache.logging.log4j.plugins.defaults.model.DefaultElementManager;
-import org.apache.logging.log4j.plugins.spi.InjectionException;
+import org.apache.logging.log4j.plugins.spi.DefinitionException;
 import org.apache.logging.log4j.plugins.spi.UnsatisfiedBeanException;
 import org.apache.logging.log4j.plugins.spi.bean.Bean;
 import org.apache.logging.log4j.plugins.spi.bean.BeanManager;
@@ -71,7 +71,7 @@ public class BeanJUnit4Runner extends BlockJUnit4ClassRunner {
     @Override
     protected void validateConstructor(final List<Throwable> errors) {
         if (!elementManager.isInjectable(testMetaClass)) {
-            errors.add(new InjectionException(testMetaClass + " does not have any injectable constructors"));
+            errors.add(new DefinitionException(testMetaClass + " does not have any injectable constructors"));
         }
     }
 


[logging-log4j2] 02/07: Remove unused type parameter in Variable

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 f089940964de2ff32555d7e83cb7f5fd9865b702
Author: Matt Sicker <bo...@gmail.com>
AuthorDate: Sat Mar 14 13:54:07 2020 -0500

    Remove unused type parameter in Variable
    
    Signed-off-by: Matt Sicker <bo...@gmail.com>
---
 .../log4j/plugins/defaults/bean/AbstractBean.java  |  4 +-
 .../plugins/defaults/bean/DefaultBeanManager.java  | 62 ++++++++++------------
 .../plugins/defaults/bean/InjectionTargetBean.java |  2 +-
 .../log4j/plugins/defaults/bean/OptionalBean.java  |  2 +-
 .../log4j/plugins/defaults/bean/ProducerBean.java  |  2 +-
 .../log4j/plugins/defaults/bean/ProvidedBean.java  |  2 +-
 .../log4j/plugins/defaults/bean/ProviderBean.java  |  2 +-
 .../log4j/plugins/defaults/bean/SystemBean.java    |  4 +-
 .../defaults/model/DefaultElementManager.java      |  6 +--
 .../plugins/defaults/model/DefaultVariable.java    | 10 ++--
 .../logging/log4j/plugins/spi/bean/Bean.java       |  2 +-
 .../log4j/plugins/spi/model/ElementManager.java    |  4 +-
 .../logging/log4j/plugins/spi/model/Variable.java  |  6 +--
 13 files changed, 50 insertions(+), 58 deletions(-)

diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/AbstractBean.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/bean/AbstractBean.java
index e46f7d2..947d722 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
@@ -28,10 +28,10 @@ import java.util.Collection;
 import java.util.Objects;
 
 abstract class AbstractBean<D, T> implements Bean<T> {
-    private final Variable<T> variable;
+    private final Variable variable;
     private final MetaClass<D> declaringClass;
 
-    AbstractBean(final Variable<T> variable, final MetaClass<D> declaringClass) {
+    AbstractBean(final Variable variable, final MetaClass<D> declaringClass) {
         this.variable = Objects.requireNonNull(variable);
         this.declaringClass = declaringClass;
     }
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 8163bbf..6028c43 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
@@ -103,7 +103,7 @@ public class DefaultBeanManager implements BeanManager {
     private <T> Collection<Bean<?>> loadBeans(final MetaClass<T> metaClass) {
         final Bean<T> created;
         if (elementManager.isInjectable(metaClass)) {
-            final Variable<T> variable = elementManager.createVariable(metaClass);
+            final Variable variable = elementManager.createVariable(metaClass);
             final InjectionTargetFactory<T> factory =
                     new DefaultInjectionTargetFactory<>(elementManager, injector, metaClass);
             created = addBean(new InjectionTargetBean<>(variable, metaClass, factory));
@@ -162,47 +162,47 @@ public class DefaultBeanManager implements BeanManager {
         }
     }
 
-    private <T> Collection<Bean<?>> loadProducerBeans(final MetaClass<T> metaClass, final Bean<T> bean) {
+    private <P> Collection<Bean<?>> loadProducerBeans(final MetaClass<P> producingClass, final Bean<P> producingBean) {
         final Collection<Bean<?>> beans = new HashSet<>();
-        for (final MetaMethod<T, ?> method : metaClass.getMethods()) {
+        for (final MetaMethod<P, ?> method : producingClass.getMethods()) {
             if (method.isAnnotationPresent(Produces.class)) {
-                beans.add(loadProducerBean(method, bean));
+                beans.add(loadProducerBean(method, producingBean));
             }
         }
-        for (final MetaField<T, ?> field : metaClass.getFields()) {
+        for (final MetaField<P, ?> field : producingClass.getFields()) {
             if (field.isAnnotationPresent(Produces.class)) {
-                beans.add(loadProducerBean(field, bean));
+                beans.add(loadProducerBean(field, producingBean));
             }
         }
         return beans;
     }
 
-    private <D, T> Bean<T> loadProducerBean(final MetaMember<D, T> member, final Bean<D> bean) {
-        final Variable<T> variable = elementManager.createVariable(member);
-        final MetaClass<D> declaringType = member.getDeclaringClass();
-        final ProducerFactory<D> factory = getProducerFactory(member, bean);
+    private <P, T> Bean<T> loadProducerBean(final MetaMember<P, T> member, final Bean<P> producingBean) {
+        final Variable variable = elementManager.createVariable(member);
+        final MetaClass<P> declaringType = member.getDeclaringClass();
+        final ProducerFactory<P> factory = getProducerFactory(member, producingBean);
         return addBean(new ProducerBean<>(variable, declaringType, factory));
     }
 
-    private <D> ProducerFactory<D> getProducerFactory(final MetaMember<D, ?> member, final Bean<D> declaringBean) {
-        final Variable<?> variable = elementManager.createVariable(member);
-        final MetaMethod<D, ?> disposerMethod = resolveDisposerMethod(variable, declaringBean);
+    private <P> ProducerFactory<P> getProducerFactory(final MetaMember<P, ?> member, final Bean<P> producingBean) {
+        final Variable variable = elementManager.createVariable(member);
+        final MetaMethod<P, ?> disposerMethod = resolveDisposerMethod(variable, producingBean);
         final Collection<InjectionPoint<?>> disposerIPs = disposerMethod == null ? Collections.emptySet() :
-                elementManager.createExecutableInjectionPoints(disposerMethod, declaringBean);
+                elementManager.createExecutableInjectionPoints(disposerMethod, producingBean);
         if (member instanceof MetaField<?, ?>) {
-            final MetaField<D, ?> field = TypeUtil.cast(member);
-            return new FieldProducerFactory<>(this, declaringBean, field, disposerMethod, disposerIPs);
+            final MetaField<P, ?> field = TypeUtil.cast(member);
+            return new FieldProducerFactory<>(this, producingBean, field, disposerMethod, disposerIPs);
         } else {
-            final MetaMethod<D, ?> method = TypeUtil.cast(member);
+            final MetaMethod<P, ?> method = TypeUtil.cast(member);
             final Collection<InjectionPoint<?>> producerIPs =
-                    elementManager.createExecutableInjectionPoints(method, declaringBean);
-            return new MethodProducerFactory<>(this, declaringBean, method, producerIPs, disposerMethod, disposerIPs);
+                    elementManager.createExecutableInjectionPoints(method, producingBean);
+            return new MethodProducerFactory<>(this, producingBean, method, producerIPs, disposerMethod, disposerIPs);
         }
     }
 
-    private <D, T> MetaMethod<D, ?> resolveDisposerMethod(final Variable<T> variable, final Bean<D> bean) {
+    private <D> MetaMethod<D, ?> resolveDisposerMethod(final Variable variable, final Bean<D> disposingBean) {
         final List<MetaMethod<?, ?>> methods = disposesMethods.stream()
-                .filter(method -> method.matches(variable, bean))
+                .filter(method -> method.matches(variable, disposingBean))
                 .map(method -> method.disposesMethod)
                 .collect(Collectors.toList());
         if (methods.isEmpty()) {
@@ -286,8 +286,8 @@ public class DefaultBeanManager implements BeanManager {
         // first, look for an existing bean
         final Type type = point.getType();
         final Qualifiers qualifiers = point.getQualifiers();
-        final Optional<Bean<T>> existingBean = getExistingOrProvidedBean(type, qualifiers,
-                () -> elementManager.createVariable(point));
+        final Variable variable = elementManager.createVariable(point);
+        final Optional<Bean<T>> existingBean = getExistingOrProvidedBean(type, qualifiers, () -> variable);
         if (existingBean.isPresent()) {
             return existingBean;
         }
@@ -295,22 +295,17 @@ public class DefaultBeanManager implements BeanManager {
             final Class<?> rawType = TypeUtil.getRawType(type);
             final Type actualType = ((ParameterizedType) type).getActualTypeArguments()[0];
             if (rawType.equals(Provider.class)) {
-                // generics abuse ahoy
-                final InjectionPoint<Provider<T>> ip = TypeUtil.cast(point);
-                final Variable<Provider<T>> variable = elementManager.createVariable(ip);
                 // if a Provider<T> is requested, we can convert an existing Bean<T> into a Bean<Provider<T>>
                 return this.<T>getBean(actualType, qualifiers)
                         .map(bean -> new ProviderBean<>(variable, context -> getValue(bean, context)))
                         .map(this::addBean)
                         .map(TypeUtil::cast);
             } else if (rawType.equals(Optional.class)) {
-                final InjectionPoint<Optional<T>> ip = TypeUtil.cast(point);
-                final Variable<Optional<T>> optionalVariable = elementManager.createVariable(ip);
                 final Optional<Bean<T>> actualExistingBean = getExistingOrProvidedBean(actualType, qualifiers,
                         // FIXME: remove need for DefaultVariable to be public
                         () -> DefaultVariable.newVariable(
-                                TypeUtil.getTypeClosure(actualType), qualifiers, optionalVariable.getScopeType()));
-                final Bean<Optional<T>> optionalBean = addBean(new OptionalBean<>(optionalVariable,
+                                TypeUtil.getTypeClosure(actualType), qualifiers, variable.getScopeType()));
+                final Bean<Optional<T>> optionalBean = addBean(new OptionalBean<>(variable,
                         context -> actualExistingBean.map(bean -> getValue(bean, context))));
                 return Optional.of(TypeUtil.cast(optionalBean));
             }
@@ -319,18 +314,19 @@ public class DefaultBeanManager implements BeanManager {
     }
 
     private <T> Optional<Bean<T>> getExistingOrProvidedBean(final Type type, final Qualifiers qualifiers,
-                                                            final Supplier<Variable<T>> variableSupplier) {
+                                                            final Supplier<Variable> variableSupplier) {
         final Optional<Bean<T>> existingBean = getBean(type, qualifiers);
         if (existingBean.isPresent()) {
             return existingBean;
         }
-        final Variable<T> variable = variableSupplier.get();
+        final Variable variable = variableSupplier.get();
         final Type providerType = new ParameterizedTypeImpl(null, Provider.class, type);
         final Optional<Bean<Provider<T>>> providerBean = getBean(providerType, qualifiers);
         return providerBean.map(bean -> new ProvidedBean<>(variable, context -> getValue(bean, context).get()))
                 .map(this::addBean);
     }
 
+    // FIXME: this needs to consider scopes
     private <T> Optional<Bean<T>> getBean(final Type type, final Qualifiers qualifiers) {
         final Set<Bean<T>> beans = this.<T>streamBeansMatchingType(type)
                 .filter(bean -> qualifiers.equals(bean.getQualifiers()))
@@ -427,7 +423,7 @@ public class DefaultBeanManager implements BeanManager {
             this.disposesMethod = disposesMethod;
         }
 
-        boolean matches(final Variable<?> variable, final Bean<?> declaringBean) {
+        boolean matches(final Variable variable, final Bean<?> declaringBean) {
             return Objects.equals(declaringBean, this.declaringBean) &&
                     variable.hasMatchingType(type) &&
                     qualifiers.equals(variable.getQualifiers());
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 a5f071d..9535f02 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
@@ -31,7 +31,7 @@ import java.util.Objects;
 class InjectionTargetBean<T> extends AbstractBean<T, T> {
     private final InjectionTarget<T> injectionTarget;
 
-    InjectionTargetBean(final Variable<T> variable, final MetaClass<T> declaringClass,
+    InjectionTargetBean(final Variable variable, final MetaClass<T> declaringClass,
                         final InjectionTargetFactory<T> factory) {
         super(variable, declaringClass);
         Objects.requireNonNull(factory);
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 0d753c8..d98ce88 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
@@ -26,7 +26,7 @@ import java.util.function.Function;
 class OptionalBean<T> extends SystemBean<Optional<T>> {
     private final Function<InitializationContext<?>, Optional<T>> optionalValueFactory;
 
-    OptionalBean(final Variable<Optional<T>> variable, final Function<InitializationContext<?>, Optional<T>> optionalValueFactory) {
+    OptionalBean(final Variable variable, final Function<InitializationContext<?>, Optional<T>> optionalValueFactory) {
         super(variable);
         this.optionalValueFactory = optionalValueFactory;
     }
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 6a382fe..5eea07b 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
@@ -33,7 +33,7 @@ class ProducerBean<D, T> extends AbstractBean<D, T> {
     private final Producer<T> producer;
     private final Type type;
 
-    ProducerBean(final Variable<T> variable, final MetaClass<D> declaringClass, final ProducerFactory<D> factory) {
+    ProducerBean(final Variable variable, final MetaClass<D> declaringClass, final ProducerFactory<D> factory) {
         super(variable, declaringClass);
         Objects.requireNonNull(factory);
         producer = factory.createProducer(this);
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 632218d..80a6c26 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
@@ -25,7 +25,7 @@ import java.util.function.Function;
 class ProvidedBean<T> extends SystemBean<T> {
     private final Function<InitializationContext<?>, T> providedValueFactory;
 
-    ProvidedBean(final Variable<T> variable, final Function<InitializationContext<?>, T> providedValueFactory) {
+    ProvidedBean(final Variable variable, final Function<InitializationContext<?>, T> providedValueFactory) {
         super(variable);
         this.providedValueFactory = providedValueFactory;
     }
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 bbd8522..d3ae88f 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
@@ -26,7 +26,7 @@ import java.util.function.Function;
 class ProviderBean<T> extends SystemBean<Provider<T>> {
     private final Function<InitializationContext<?>, T> providedValueFactory;
 
-    ProviderBean(final Variable<Provider<T>> variable, final Function<InitializationContext<?>, T> providedValueFactory) {
+    ProviderBean(final Variable variable, final Function<InitializationContext<?>, T> providedValueFactory) {
         super(variable);
         this.providedValueFactory = providedValueFactory;
     }
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 b5c9519..8b55f3d 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
@@ -30,9 +30,9 @@ import java.util.Collection;
 import java.util.Collections;
 
 abstract class SystemBean<T> implements Bean<T> {
-    private final Variable<T> variable;
+    private final Variable variable;
 
-    SystemBean(final Variable<T> variable) {
+    SystemBean(final Variable variable) {
         this.variable = variable;
     }
 
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 9daaf65..6144a14 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
@@ -154,18 +154,18 @@ public class DefaultElementManager implements ElementManager {
     }
 
     @Override
-    public <T> Variable<T> createVariable(final MetaElement<T> element) {
+    public Variable createVariable(final MetaElement<?> element) {
         Objects.requireNonNull(element);
         return createVariable(element, getQualifiers(element));
     }
 
     @Override
-    public <T> Variable<T> createVariable(final InjectionPoint<T> point) {
+    public Variable createVariable(final InjectionPoint<?> point) {
         Objects.requireNonNull(point);
         return createVariable(point.getElement(), point.getQualifiers());
     }
 
-    private <T> Variable<T> createVariable(final MetaElement<T> element, final Qualifiers qualifiers) {
+    private Variable createVariable(final MetaElement<?> element, final Qualifiers qualifiers) {
         final Collection<Type> types = element.getTypeClosure();
         final Class<? extends Annotation> scopeType = getScopeType(element);
         return DefaultVariable.newVariable(types, qualifiers, scopeType);
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultVariable.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultVariable.java
index f756908..f06d8b4 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultVariable.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultVariable.java
@@ -25,11 +25,11 @@ import java.lang.reflect.Type;
 import java.util.Collection;
 import java.util.Objects;
 
-public class DefaultVariable<T> implements Variable<T> {
+public class DefaultVariable implements Variable {
 
-    public static <T> DefaultVariable<T> newVariable(final Collection<Type> types, final Qualifiers qualifiers,
-                                                     final Class<? extends Annotation> scopeType) {
-        return new DefaultVariable<>(types, qualifiers, scopeType);
+    public static DefaultVariable newVariable(final Collection<Type> types, final Qualifiers qualifiers,
+                                              final Class<? extends Annotation> scopeType) {
+        return new DefaultVariable(types, qualifiers, scopeType);
     }
 
     private final Collection<Type> types;
@@ -62,7 +62,7 @@ public class DefaultVariable<T> implements Variable<T> {
     public boolean equals(final Object o) {
         if (this == o) return true;
         if (o == null || getClass() != o.getClass()) return false;
-        final DefaultVariable<?> that = (DefaultVariable<?>) o;
+        final DefaultVariable that = (DefaultVariable) o;
         return types.equals(that.types) &&
                 qualifiers.equals(that.qualifiers) &&
                 scopeType.equals(that.scopeType);
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 3e93e2f..482aeec 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,7 @@ import org.apache.logging.log4j.plugins.spi.model.Variable;
 
 import java.util.Collection;
 
-public interface Bean<T> extends Variable<T> {
+public interface Bean<T> extends Variable {
     /**
      * Creates a new instance of this bean. The given {@link InitializationContext} should be used by implementations
      * to track dependent objects.
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/ElementManager.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/ElementManager.java
index 00aa67d..c979eee 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/ElementManager.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/ElementManager.java
@@ -147,12 +147,12 @@ public interface ElementManager extends AutoCloseable {
     /**
      * Creates a variable for an element.
      */
-    <T> Variable<T> createVariable(final MetaElement<T> element);
+    Variable createVariable(final MetaElement<?> element);
 
     /**
      * Creates a variable for an injection point.
      */
-    <T> Variable<T> createVariable(final InjectionPoint<T> point);
+    Variable createVariable(final InjectionPoint<?> point);
 
     @Override
     void close();
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 1cc9186..af703ac 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
@@ -25,7 +25,7 @@ import java.lang.annotation.Annotation;
 import java.lang.reflect.Type;
 import java.util.Collection;
 
-public interface Variable<T> {
+public interface Variable {
     Collection<Type> getTypes();
 
     default boolean hasMatchingType(final Type requiredType) {
@@ -44,8 +44,4 @@ public interface Variable<T> {
     default boolean isDependentScoped() {
         return getScopeType() == Dependent.class;
     }
-
-    default boolean isSingletonScoped() {
-        return getScopeType() == Singleton.class;
-    }
 }


[logging-log4j2] 07/07: Improve annotation meta-modeling

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 0fe200301a248599fb515fcd62ee559a8c3698a4
Author: Matt Sicker <bo...@gmail.com>
AuthorDate: Sun Mar 15 12:26:14 2020 -0500

    Improve annotation meta-modeling
    
    This allows for more complex annotation backward compatibility mappings.
    
    Signed-off-by: Matt Sicker <bo...@gmail.com>
---
 .../api/{AliasFor.java => AnnotationAlias.java}    |  11 +-
 .../plugins/defaults/model/AbstractMetaMember.java |   9 +-
 .../defaults/model/DefaultElementManager.java      |  67 +++++++----
 .../defaults/model/DefaultMetaAnnotation.java      | 112 +++++++++++++++++
 .../model/DefaultMetaAnnotationElement.java        |  82 +++++++++++++
 .../plugins/defaults/model/DefaultMetaClass.java   |   9 +-
 .../defaults/model/DefaultMetaParameter.java       |   4 +-
 .../plugins/defaults/model/DefaultQualifiers.java  |  78 ++++++++++++
 .../log4j/plugins/spi/model/ElementManager.java    |   2 +-
 .../model/MetaAnnotation.java}                     |  18 +--
 .../model/MetaAnnotationElement.java}              |  17 +--
 .../log4j/plugins/spi/model/MetaElement.java       |  24 ++--
 .../log4j/plugins/spi/model/Qualifiers.java        | 133 +--------------------
 .../log4j/plugins/spi/model/QualifiersTest.java    |  79 ------------
 14 files changed, 361 insertions(+), 284 deletions(-)

diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/AliasFor.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/AnnotationAlias.java
similarity index 65%
copy from log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/AliasFor.java
copy to log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/AnnotationAlias.java
index b7541d8..d97830d 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/AliasFor.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/AnnotationAlias.java
@@ -24,10 +24,17 @@ import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
-// TODO: documentation around where this can be applied
+/**
+ * Meta annotation for making an annotation an alias for another annotation. Annotations with this annotation will be
+ * interpreted as if they were implemented by the given annotation type instead. This applies to
+ * {@linkplain QualifierType qualifiers}, {@linkplain ScopeType scopes}, {@link Inject}, {@link Produces},
+ * {@link Disposes}, {@link PostConstruct}, and {@link PreDestroy}. Individual annotation elements are aliased to the
+ * same element names from the aliased annotation unless otherwise annotated with {@link Named} which should specify
+ * the aliased annotation element name.
+ */
 @Retention(RetentionPolicy.RUNTIME)
 @Target(ElementType.ANNOTATION_TYPE)
 @Documented
-public @interface AliasFor {
+public @interface AnnotationAlias {
     Class<? extends Annotation> value();
 }
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/AbstractMetaMember.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/AbstractMetaMember.java
index a6d976a..52dbad2 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/AbstractMetaMember.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/AbstractMetaMember.java
@@ -17,27 +17,26 @@
 
 package org.apache.logging.log4j.plugins.defaults.model;
 
+import org.apache.logging.log4j.plugins.spi.model.MetaAnnotation;
 import org.apache.logging.log4j.plugins.spi.model.MetaClass;
 import org.apache.logging.log4j.plugins.spi.model.MetaMember;
 
-import java.lang.annotation.Annotation;
 import java.lang.reflect.AnnotatedElement;
 import java.lang.reflect.Member;
 import java.lang.reflect.Modifier;
 import java.lang.reflect.Type;
-import java.util.Arrays;
 import java.util.Collection;
 
 abstract class AbstractMetaMember<D, T> implements MetaMember<D, T> {
     private final String name;
-    private final Collection<Annotation> annotations;
+    private final Collection<MetaAnnotation> annotations;
     private final MetaClass<D> declaringClass;
     private final MetaClass<T> type;
     private final boolean isStatic;
 
     AbstractMetaMember(final MetaClass<D> declaringClass, final Member member, final MetaClass<T> type) {
         this.name = member.getName();
-        this.annotations = Arrays.asList(((AnnotatedElement) member).getAnnotations());
+        this.annotations = DefaultMetaAnnotation.fromAnnotations(((AnnotatedElement) member).getAnnotations());
         this.declaringClass = declaringClass;
         this.type = type;
         this.isStatic = Modifier.isStatic(member.getModifiers());
@@ -49,7 +48,7 @@ abstract class AbstractMetaMember<D, T> implements MetaMember<D, T> {
     }
 
     @Override
-    public Collection<Annotation> getAnnotations() {
+    public Collection<MetaAnnotation> getAnnotations() {
         return annotations;
     }
 
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 6144a14..8193144 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
@@ -17,13 +17,18 @@
 
 package org.apache.logging.log4j.plugins.defaults.model;
 
-import org.apache.logging.log4j.plugins.api.AliasFor;
+import org.apache.logging.log4j.plugins.api.AnnotationAlias;
+import org.apache.logging.log4j.plugins.api.Default;
 import org.apache.logging.log4j.plugins.api.Dependent;
+import org.apache.logging.log4j.plugins.api.Ignore;
+import org.apache.logging.log4j.plugins.api.Named;
 import org.apache.logging.log4j.plugins.api.QualifierType;
 import org.apache.logging.log4j.plugins.api.ScopeType;
 import org.apache.logging.log4j.plugins.spi.bean.Bean;
 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.MetaAnnotation;
+import org.apache.logging.log4j.plugins.spi.model.MetaAnnotationElement;
 import org.apache.logging.log4j.plugins.spi.model.MetaClass;
 import org.apache.logging.log4j.plugins.spi.model.MetaElement;
 import org.apache.logging.log4j.plugins.spi.model.MetaExecutable;
@@ -33,6 +38,7 @@ 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.util.Cache;
+import org.apache.logging.log4j.plugins.util.TypeUtil;
 import org.apache.logging.log4j.plugins.util.WeakCache;
 
 import java.beans.Introspector;
@@ -42,8 +48,10 @@ import java.util.Collection;
 import java.util.Collections;
 import java.util.LinkedHashSet;
 import java.util.Objects;
+import java.util.Set;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
+import java.util.stream.Collectors;
 
 public class DefaultElementManager implements ElementManager {
 
@@ -58,8 +66,8 @@ public class DefaultElementManager implements ElementManager {
     private final Cache<Class<? extends Annotation>, AnnotationType> annotationTypeCache = WeakCache.newCache(clazz -> {
         for (final Annotation annotation : clazz.getAnnotations()) {
             Class<? extends Annotation> type = annotation.annotationType();
-            if (type == AliasFor.class) {
-                type = ((AliasFor) annotation).value();
+            if (type == AnnotationAlias.class) {
+                type = ((AnnotationAlias) annotation).value();
             }
             if (type == QualifierType.class) {
                 return AnnotationType.QUALIFIER;
@@ -84,31 +92,48 @@ public class DefaultElementManager implements ElementManager {
     @Override
     public Qualifiers getQualifiers(final MetaElement<?> element) {
         final String elementName = element.getName();
-        final String defaultName;
+        final String defaultNamedValue;
         if (element instanceof MetaMethod<?, ?>) {
             final Matcher matcher = BEAN_METHOD.matcher(elementName);
             if (matcher.matches()) {
-                defaultName = Introspector.decapitalize(matcher.group(2));
+                defaultNamedValue = Introspector.decapitalize(matcher.group(2));
             } else {
-                defaultName = elementName;
+                defaultNamedValue = elementName;
             }
         } else if (element instanceof MetaClass<?>) {
-            defaultName = Introspector.decapitalize(((MetaClass<?>) element).getJavaClass().getSimpleName());
+            defaultNamedValue = Introspector.decapitalize(((MetaClass<?>) element).getJavaClass().getSimpleName());
         } else {
-            defaultName = elementName;
+            defaultNamedValue = elementName;
         }
-        return Qualifiers.fromQualifierAnnotations(filterQualifiers(element.getAnnotations()), defaultName);
+        final Set<MetaAnnotation> qualifiers = element.getAnnotations().stream()
+                .filter(annotation -> isQualifierType(annotation.getAnnotationType()))
+                .map(annotation -> transformQualifier(annotation, defaultNamedValue))
+                .collect(Collectors.toCollection(LinkedHashSet::new));
+        if (qualifiers.stream().map(MetaAnnotation::getAnnotationType).noneMatch(type -> type != Named.class)) {
+            qualifiers.add(new DefaultMetaAnnotation(Default.class, Collections.emptySet()));
+        }
+        return new DefaultQualifiers(qualifiers);
     }
 
-    private Collection<Annotation> filterQualifiers(final Collection<Annotation> annotations) {
-        final Collection<Annotation> qualifiers = new LinkedHashSet<>(annotations.size());
-        for (final Annotation annotation : annotations) {
-            final Class<? extends Annotation> annotationType = annotation.annotationType();
-            if (isQualifierType(annotationType)) {
-                qualifiers.add(annotation);
-            }
-        }
-        return qualifiers;
+    private static MetaAnnotation transformQualifier(final MetaAnnotation annotation, final String defaultNamedValue) {
+        final Class<? extends Annotation> annotationType = annotation.getAnnotationType();
+        final Set<MetaAnnotationElement<?>> elements = annotation.getAnnotationElements().stream()
+                .filter(element -> !element.isAnnotationPresent(Ignore.class))
+                .map(element -> {
+                    if (annotationType == Named.class && element.getName().equals("value")) {
+                        final MetaAnnotationElement<String> namedValue = TypeUtil.cast(element);
+                        final String value = namedValue.getValue();
+                        if (value.isEmpty()) {
+                            return namedValue.withNewValue(defaultNamedValue);
+                        } else {
+                            return namedValue;
+                        }
+                    } else {
+                        return element;
+                    }
+                })
+                .collect(Collectors.toCollection(LinkedHashSet::new));
+        return new DefaultMetaAnnotation(annotationType, elements);
     }
 
     private Class<? extends Annotation> getScopeType(final MetaElement<?> element) {
@@ -116,11 +141,11 @@ public class DefaultElementManager implements ElementManager {
         return scopeTypes.isEmpty() ? Dependent.class : scopeTypes.iterator().next();
     }
 
-    private Collection<Class<? extends Annotation>> filterScopeTypes(final Collection<Annotation> annotations) {
+    private Collection<Class<? extends Annotation>> filterScopeTypes(final Collection<MetaAnnotation> annotations) {
         // only expect at most one scope
         final Collection<Class<? extends Annotation>> scopeTypes = new LinkedHashSet<>(1);
-        for (final Annotation annotation : annotations) {
-            final Class<? extends Annotation> annotationType = annotation.annotationType();
+        for (final MetaAnnotation annotation : annotations) {
+            final Class<? extends Annotation> annotationType = annotation.getAnnotationType();
             if (isScopeType(annotationType)) {
                 scopeTypes.add(annotationType);
             }
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultMetaAnnotation.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultMetaAnnotation.java
new file mode 100644
index 0000000..0751817
--- /dev/null
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultMetaAnnotation.java
@@ -0,0 +1,112 @@
+/*
+ * 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.model;
+
+import org.apache.logging.log4j.plugins.api.AnnotationAlias;
+import org.apache.logging.log4j.plugins.api.Named;
+import org.apache.logging.log4j.plugins.spi.InitializationException;
+import org.apache.logging.log4j.plugins.spi.model.MetaAnnotation;
+import org.apache.logging.log4j.plugins.spi.model.MetaAnnotationElement;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+
+class DefaultMetaAnnotation implements MetaAnnotation {
+
+    static List<MetaAnnotation> fromAnnotations(final Annotation... annotations) {
+        if (annotations.length == 0) {
+            return Collections.emptyList();
+        }
+        final List<MetaAnnotation> metaAnnotations = new ArrayList<>(annotations.length);
+        for (final Annotation annotation : annotations) {
+            metaAnnotations.add(fromAnnotation(annotation));
+        }
+        return Collections.unmodifiableList(metaAnnotations);
+    }
+
+    private static DefaultMetaAnnotation fromAnnotation(final Annotation annotation) {
+        final Class<? extends Annotation> originalType = annotation.annotationType();
+        final Method[] annotationElements = originalType.getDeclaredMethods();
+        final Set<MetaAnnotationElement<?>> elements = new LinkedHashSet<>(annotationElements.length);
+        for (final Method element : annotationElements) {
+            final String name;
+            final Named named = element.getAnnotation(Named.class);
+            if (named != null && !named.value().isEmpty()) {
+                name = named.value();
+            } else {
+                name = element.getName();
+            }
+            final Object value = getAnnotationElementValue(annotation, element);
+            elements.add(new DefaultMetaAnnotationElement<>(name, value, fromAnnotations(element.getAnnotations())));
+        }
+        final AnnotationAlias alias = originalType.getAnnotation(AnnotationAlias.class);
+        final Class<? extends Annotation> annotationType = alias != null ? alias.value() : originalType;
+        return new DefaultMetaAnnotation(annotationType, elements);
+    }
+
+    private static Object getAnnotationElementValue(final Annotation annotation, final Method element) {
+        try {
+            return element.invoke(annotation);
+        } catch (final IllegalAccessException e) {
+            throw new InitializationException("Cannot access element " + element.getName() + " of annotation " + annotation, e);
+        } catch (final InvocationTargetException e) {
+            throw new InitializationException("Cannot access element " + element.getName() + " of annotation " + annotation,
+                    e.getCause());
+        }
+    }
+
+    private final Class<? extends Annotation> annotationType;
+    private final Set<MetaAnnotationElement<?>> elements;
+
+    DefaultMetaAnnotation(final Class<? extends Annotation> annotationType, final Set<MetaAnnotationElement<?>> elements) {
+        this.annotationType = annotationType;
+        this.elements = Collections.unmodifiableSet(elements);
+    }
+
+    @Override
+    public Class<? extends Annotation> getAnnotationType() {
+        return annotationType;
+    }
+
+    @Override
+    public Collection<MetaAnnotationElement<?>> getAnnotationElements() {
+        return elements;
+    }
+
+    @Override
+    public boolean equals(final Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        final DefaultMetaAnnotation that = (DefaultMetaAnnotation) o;
+        return annotationType.equals(that.annotationType) &&
+                elements.equals(that.elements);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(annotationType, elements);
+    }
+}
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultMetaAnnotationElement.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultMetaAnnotationElement.java
new file mode 100644
index 0000000..acd3e48
--- /dev/null
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultMetaAnnotationElement.java
@@ -0,0 +1,82 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache license, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the license for the specific language governing permissions and
+ * limitations under the license.
+ */
+
+package org.apache.logging.log4j.plugins.defaults.model;
+
+import org.apache.logging.log4j.plugins.spi.model.MetaAnnotation;
+import org.apache.logging.log4j.plugins.spi.model.MetaAnnotationElement;
+import org.apache.logging.log4j.plugins.util.TypeUtil;
+
+import java.lang.reflect.Type;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Objects;
+
+class DefaultMetaAnnotationElement<T> implements MetaAnnotationElement<T> {
+    private final String name;
+    private final T value;
+    private final Collection<MetaAnnotation> annotations;
+
+    DefaultMetaAnnotationElement(final String name, final T value, final Collection<MetaAnnotation> annotations) {
+        this.name = name;
+        this.value = value;
+        this.annotations = Collections.unmodifiableCollection(annotations);
+    }
+
+    @Override
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public Type getType() {
+        return value.getClass();
+    }
+
+    @Override
+    public Collection<Type> getTypeClosure() {
+        return TypeUtil.getTypeClosure(getType());
+    }
+
+    @Override
+    public Collection<MetaAnnotation> getAnnotations() {
+        return annotations;
+    }
+
+    @Override
+    public T getValue() {
+        return value;
+    }
+
+    @Override
+    public MetaAnnotationElement<T> withNewValue(final T value) {
+        return new DefaultMetaAnnotationElement<>(name, value, annotations);
+    }
+
+    @Override
+    public boolean equals(final Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        final DefaultMetaAnnotationElement<?> that = (DefaultMetaAnnotationElement<?>) o;
+        return name.equals(that.name) && value.equals(that.value);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(name, value);
+    }
+}
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultMetaClass.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultMetaClass.java
index 80afe92..219ff77 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultMetaClass.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultMetaClass.java
@@ -17,6 +17,7 @@
 
 package org.apache.logging.log4j.plugins.defaults.model;
 
+import org.apache.logging.log4j.plugins.spi.model.MetaAnnotation;
 import org.apache.logging.log4j.plugins.spi.model.MetaClass;
 import org.apache.logging.log4j.plugins.spi.model.MetaConstructor;
 import org.apache.logging.log4j.plugins.spi.model.MetaField;
@@ -42,19 +43,19 @@ class DefaultMetaClass<T> implements MetaClass<T> {
     }
 
     static <T> MetaClass<T> newMetaClass(final Type baseType, final Class<T> javaClass, final Annotation... annotations) {
-        return new DefaultMetaClass<>(baseType, javaClass, TypeUtil.getTypeClosure(baseType), Arrays.asList(annotations));
+        return new DefaultMetaClass<>(baseType, javaClass, TypeUtil.getTypeClosure(baseType), DefaultMetaAnnotation.fromAnnotations(annotations));
     }
 
     private final Type baseType;
     private final Class<T> javaClass;
     private final Collection<Type> typeClosure;
-    private final Collection<Annotation> annotations;
+    private final Collection<MetaAnnotation> annotations;
     private final Value<Collection<MetaConstructor<T>>> constructors;
     private final Value<Collection<MetaMethod<T, ?>>> methods;
     private final Value<Collection<MetaField<T, ?>>> fields;
 
     private DefaultMetaClass(final Type baseType, final Class<T> javaClass, final Collection<Type> typeClosure,
-                             final Collection<Annotation> annotations) {
+                             final Collection<MetaAnnotation> annotations) {
         this.baseType = baseType;
         this.javaClass = javaClass;
         this.typeClosure = typeClosure;
@@ -77,7 +78,7 @@ class DefaultMetaClass<T> implements MetaClass<T> {
     }
 
     @Override
-    public Collection<Annotation> getAnnotations() {
+    public Collection<MetaAnnotation> getAnnotations() {
         return annotations;
     }
 
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultMetaParameter.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultMetaParameter.java
index 960e81f..2b7af20 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultMetaParameter.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultMetaParameter.java
@@ -17,11 +17,11 @@
 
 package org.apache.logging.log4j.plugins.defaults.model;
 
+import org.apache.logging.log4j.plugins.spi.model.MetaAnnotation;
 import org.apache.logging.log4j.plugins.spi.model.MetaClass;
 import org.apache.logging.log4j.plugins.spi.model.MetaParameter;
 import org.apache.logging.log4j.plugins.util.TypeUtil;
 
-import java.lang.annotation.Annotation;
 import java.lang.reflect.Parameter;
 import java.lang.reflect.Type;
 import java.util.Collection;
@@ -45,7 +45,7 @@ class DefaultMetaParameter<T> implements MetaParameter<T> {
     }
 
     @Override
-    public Collection<Annotation> getAnnotations() {
+    public Collection<MetaAnnotation> getAnnotations() {
         return parameterClass.getAnnotations();
     }
 
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultQualifiers.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultQualifiers.java
new file mode 100644
index 0000000..2a6eed2
--- /dev/null
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultQualifiers.java
@@ -0,0 +1,78 @@
+/*
+ * 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.model;
+
+import org.apache.logging.log4j.plugins.api.Default;
+import org.apache.logging.log4j.plugins.spi.model.MetaAnnotation;
+import org.apache.logging.log4j.plugins.spi.model.MetaAnnotationElement;
+import org.apache.logging.log4j.plugins.spi.model.Qualifiers;
+import org.apache.logging.log4j.util.StringBuilders;
+
+import java.util.Collection;
+import java.util.Objects;
+import java.util.Set;
+
+/**
+ * Represents a normalized set of {@linkplain org.apache.logging.log4j.plugins.api.QualifierType qualifier annotations}.
+ */
+class DefaultQualifiers implements Qualifiers {
+    private final Set<MetaAnnotation> qualifiers;
+
+    DefaultQualifiers(final Set<MetaAnnotation> qualifiers) {
+        this.qualifiers = qualifiers;
+    }
+
+    @Override
+    public boolean hasDefaultQualifier() {
+        return qualifiers.stream().anyMatch(q -> q.getAnnotationType() == Default.class);
+    }
+
+    @Override
+    public boolean equals(final Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        final DefaultQualifiers that = (DefaultQualifiers) o;
+        return qualifiers.equals(that.qualifiers);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(qualifiers);
+    }
+
+    @Override
+    public String toString() {
+        if (qualifiers.isEmpty()) {
+            return "[]";
+        }
+        StringBuilder sb = new StringBuilder().append('[');
+        for (final MetaAnnotation qualifier : qualifiers) {
+            sb.append('@').append(qualifier.getAnnotationType().getSimpleName());
+            final Collection<MetaAnnotationElement<?>> elements = qualifier.getAnnotationElements();
+            if (!elements.isEmpty()) {
+                sb.append('(');
+                for (final MetaAnnotationElement<?> element : elements) {
+                    StringBuilders.appendKeyDqValue(sb, element.getName(), element.getValue()).append(", ");
+                }
+                sb.delete(sb.length() - 2, sb.length()).append(')');
+            }
+            sb.append(", ");
+        }
+        return sb.delete(sb.length() - 2, sb.length()).append(']').toString();
+    }
+}
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/ElementManager.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/ElementManager.java
index c979eee..ee213c3 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/ElementManager.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/ElementManager.java
@@ -100,7 +100,7 @@ public interface ElementManager extends AutoCloseable {
      */
     default boolean isInjectable(final MetaElement<?> element) {
         return element.isAnnotationPresent(Inject.class) ||
-                (element.getAnnotations().stream().map(Annotation::annotationType).anyMatch(this::isQualifierType) &&
+                (element.getAnnotations().stream().map(MetaAnnotation::getAnnotationType).anyMatch(this::isQualifierType) &&
                         !element.isAnnotationPresent(Produces.class));
     }
 
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/AliasFor.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/MetaAnnotation.java
similarity index 64%
copy from log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/AliasFor.java
copy to log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/MetaAnnotation.java
index b7541d8..0038f7d 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/AliasFor.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/MetaAnnotation.java
@@ -15,19 +15,13 @@
  * limitations under the license.
  */
 
-package org.apache.logging.log4j.plugins.api;
+package org.apache.logging.log4j.plugins.spi.model;
 
 import java.lang.annotation.Annotation;
-import java.lang.annotation.Documented;
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
+import java.util.Collection;
 
-// TODO: documentation around where this can be applied
-@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.ANNOTATION_TYPE)
-@Documented
-public @interface AliasFor {
-    Class<? extends Annotation> value();
+public interface MetaAnnotation {
+    Class<? extends Annotation> getAnnotationType();
+
+    Collection<MetaAnnotationElement<?>> getAnnotationElements();
 }
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/AliasFor.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/MetaAnnotationElement.java
similarity index 61%
rename from log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/AliasFor.java
rename to log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/MetaAnnotationElement.java
index b7541d8..28506fe 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/api/AliasFor.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/MetaAnnotationElement.java
@@ -15,19 +15,10 @@
  * limitations under the license.
  */
 
-package org.apache.logging.log4j.plugins.api;
+package org.apache.logging.log4j.plugins.spi.model;
 
-import java.lang.annotation.Annotation;
-import java.lang.annotation.Documented;
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
+public interface MetaAnnotationElement<T> extends MetaElement<T> {
+    T getValue();
 
-// TODO: documentation around where this can be applied
-@Retention(RetentionPolicy.RUNTIME)
-@Target(ElementType.ANNOTATION_TYPE)
-@Documented
-public @interface AliasFor {
-    Class<? extends Annotation> value();
+    MetaAnnotationElement<T> withNewValue(final T value);
 }
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/MetaElement.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/MetaElement.java
index 3de8421..dec4495 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/MetaElement.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/MetaElement.java
@@ -17,7 +17,7 @@
 
 package org.apache.logging.log4j.plugins.spi.model;
 
-import org.apache.logging.log4j.plugins.api.AliasFor;
+import org.apache.logging.log4j.plugins.api.AnnotationAlias;
 
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Type;
@@ -30,32 +30,24 @@ public interface MetaElement<T> {
      */
     String getName();
 
+    Type getType();
+
+    Collection<Type> getTypeClosure();
+
     /**
      * Returns all the annotations present on this element.
      */
-    Collection<Annotation> getAnnotations();
+    Collection<MetaAnnotation> getAnnotations();
 
     /**
      * Indicates whether or not an annotation is present on this element taking into account
-     * {@linkplain AliasFor annotation aliasing}.
+     * {@linkplain AnnotationAlias annotation aliasing}.
      *
      * @param annotationType type of annotation to look for
      * @return whether or not the annotation is directly or indirectly present on this element
      */
     default boolean isAnnotationPresent(final Class<? extends Annotation> annotationType) {
-        for (final Annotation annotation : getAnnotations()) {
-            if (annotationType.equals(annotation.annotationType())) {
-                return true;
-            }
-            if (annotation instanceof AliasFor) {
-                return annotationType.equals(((AliasFor) annotation).value());
-            }
-        }
-        return false;
+        return getAnnotations().stream().anyMatch(annotation -> annotationType == annotation.getAnnotationType());
     }
 
-    Type getType();
-
-    Collection<Type> getTypeClosure();
-
 }
diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/Qualifiers.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/Qualifiers.java
index a3293c0..762f349 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/Qualifiers.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/spi/model/Qualifiers.java
@@ -17,137 +17,12 @@
 
 package org.apache.logging.log4j.plugins.spi.model;
 
-import org.apache.logging.log4j.plugins.api.AliasFor;
-import org.apache.logging.log4j.plugins.api.Default;
-import org.apache.logging.log4j.plugins.api.Ignore;
-import org.apache.logging.log4j.plugins.api.Named;
-import org.apache.logging.log4j.plugins.spi.InitializationException;
-import org.apache.logging.log4j.util.StringBuilders;
-import org.apache.logging.log4j.util.Strings;
-
-import java.lang.annotation.Annotation;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Set;
-
-/**
- * Represents a normalized set of {@linkplain org.apache.logging.log4j.plugins.api.QualifierType qualifier annotations}.
- */
-public final class Qualifiers {
-    private final Map<Class<? extends Annotation>, Map<String, Object>> qualifiers;
-
-    private Qualifiers(final Map<Class<? extends Annotation>, Map<String, Object>> qualifiers) {
-        this.qualifiers = qualifiers;
-    }
-
-    public boolean hasDefaultQualifier() {
-        return qualifiers.containsKey(Default.class);
-    }
-
-    @Override
-    public boolean equals(final Object o) {
-        if (this == o) return true;
-        if (o == null || getClass() != o.getClass()) return false;
-        final Qualifiers that = (Qualifiers) o;
-        return qualifiers.equals(that.qualifiers);
-    }
+public interface Qualifiers {
+    boolean hasDefaultQualifier();
 
     @Override
-    public int hashCode() {
-        return Objects.hash(qualifiers);
-    }
+    boolean equals(Object o);
 
     @Override
-    public String toString() {
-        final Set<Map.Entry<Class<? extends Annotation>, Map<String, Object>>> entries = qualifiers.entrySet();
-        if (entries.isEmpty()) {
-            return "[]";
-        }
-        StringBuilder sb = new StringBuilder().append('[');
-        for (final Map.Entry<Class<? extends Annotation>, Map<String, Object>> entry : entries) {
-            sb.append('@').append(entry.getKey().getSimpleName());
-            final Map<String, Object> attributes = entry.getValue();
-            if (!attributes.isEmpty()) {
-                sb.append('(');
-                for (final Map.Entry<String, Object> attribute : attributes.entrySet()) {
-                    StringBuilders.appendKeyDqValue(sb, attribute.getKey(), attribute.getValue());
-                    sb.append(", ");
-                }
-                sb.delete(sb.length() - 2, sb.length()).append(')');
-            }
-            sb.append(", ");
-        }
-        return sb.delete(sb.length() - 2, sb.length()).append(']').toString();
-    }
-
-    /**
-     * Creates a normalized Qualifiers instance from a collection of qualifier annotation instances.
-     */
-    public static Qualifiers fromQualifierAnnotations(final Collection<Annotation> annotations) {
-        return fromQualifierAnnotations(annotations, Strings.EMPTY);
-    }
-
-    /**
-     * Creates a normalized Qualifiers instance from a collection of qualifier annotation instances and a default name
-     * to use when {@linkplain Named named qualifiers} do not specify a value.
-     */
-    public static Qualifiers fromQualifierAnnotations(final Collection<Annotation> annotations, final String defaultName) {
-        final Map<Class<? extends Annotation>, Map<String, Object>> qualifiers = new HashMap<>(annotations.size());
-        for (final Annotation annotation : annotations) {
-            final Class<? extends Annotation> annotationType = annotation.annotationType();
-            final AliasFor alias = annotationType.getAnnotation(AliasFor.class);
-            final Class<? extends Annotation> qualifierType = alias != null ? alias.value() : annotationType;
-            qualifiers.put(qualifierType, getQualifierAttributes(annotation, defaultName));
-        }
-        if (needsDefaultQualifier(qualifiers.keySet())) {
-            qualifiers.put(Default.class, Collections.emptyMap());
-        }
-        return new Qualifiers(Collections.unmodifiableMap(qualifiers));
-    }
-
-    private static Map<String, Object> getQualifierAttributes(final Annotation annotation, final String defaultName) {
-        final Class<? extends Annotation> annotationType = annotation.annotationType();
-        final Method[] elements = annotationType.getDeclaredMethods();
-        final Map<String, Object> attributes = new HashMap<>(elements.length);
-        for (final Method element : elements) {
-            if (!element.isAnnotationPresent(Ignore.class)) {
-                final String name = element.getName();
-                final Object value = getAnnotationElementValue(annotation, element);
-                if (annotationType == Named.class && name.equals("value") && value.toString().isEmpty()) {
-                    attributes.put("value", defaultName);
-                } else {
-                    attributes.put(name, value);
-                }
-            }
-        }
-        return Collections.unmodifiableMap(attributes);
-    }
-
-    private static Object getAnnotationElementValue(final Annotation annotation, final Method element) {
-        try {
-            return element.invoke(annotation);
-        } catch (final IllegalAccessException e) {
-            throw new InitializationException("Cannot access element " + element.getName() + " of annotation " + annotation, e);
-        } catch (final InvocationTargetException e) {
-            throw new InitializationException("Cannot access element " + element.getName() + " of annotation " + annotation,
-                    e.getCause());
-        }
-    }
-
-    private static boolean needsDefaultQualifier(final Collection<Class<? extends Annotation>> qualifierTypes) {
-        if (qualifierTypes.contains(Default.class)) {
-            return false;
-        }
-        for (final Class<? extends Annotation> qualifierType : qualifierTypes) {
-            if (qualifierType != Named.class) {
-                return false;
-            }
-        }
-        return true;
-    }
+    int hashCode();
 }
diff --git a/log4j-plugins/src/test/java/org/apache/logging/log4j/plugins/spi/model/QualifiersTest.java b/log4j-plugins/src/test/java/org/apache/logging/log4j/plugins/spi/model/QualifiersTest.java
deleted file mode 100644
index 739ec6b..0000000
--- a/log4j-plugins/src/test/java/org/apache/logging/log4j/plugins/spi/model/QualifiersTest.java
+++ /dev/null
@@ -1,79 +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.model;
-
-import org.apache.logging.log4j.plugins.api.AliasFor;
-import org.apache.logging.log4j.plugins.api.Named;
-import org.apache.logging.log4j.plugins.api.QualifierType;
-import org.junit.Test;
-
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.util.Arrays;
-import java.util.Collections;
-
-import static org.junit.Assert.*;
-
-public class QualifiersTest {
-    @Test
-    public void emptyQualifiersShouldContainDefaultQualifier() {
-        final Qualifiers qualifiers = Qualifiers.fromQualifierAnnotations(Collections.emptyList());
-        assertTrue(qualifiers.hasDefaultQualifier());
-    }
-
-    @Test
-    public void qualifiersWithNamedOnlyShouldContainDefaultQualifier() {
-        @Named
-        class Foo {
-        }
-        final Qualifiers qualifiers = Qualifiers.fromQualifierAnnotations(Arrays.asList(Foo.class.getAnnotations()));
-        assertTrue(qualifiers.hasDefaultQualifier());
-    }
-
-    @Retention(RetentionPolicy.RUNTIME)
-    @QualifierType
-    public @interface Bar {
-    }
-
-    @Test
-    public void qualifiersWithNonDefaultQualifiersShouldNotContainDefaultQualifier() {
-        @Bar
-        class Foo {
-        }
-        final Qualifiers qualifiers = Qualifiers.fromQualifierAnnotations(Arrays.asList(Foo.class.getAnnotations()));
-        assertFalse(qualifiers.hasDefaultQualifier());
-    }
-
-    @Retention(RetentionPolicy.RUNTIME)
-    @AliasFor(Bar.class)
-    public @interface BarAlias {
-    }
-
-    @Test
-    public void qualifiersShouldAccountForAliases() {
-        @Bar
-        class Foo {
-        }
-        @BarAlias
-        class FooAlias {
-        }
-        final Qualifiers foo = Qualifiers.fromQualifierAnnotations(Arrays.asList(Foo.class.getAnnotations()));
-        final Qualifiers fooAlias = Qualifiers.fromQualifierAnnotations(Arrays.asList(FooAlias.class.getAnnotations()));
-        assertEquals(foo, fooAlias);
-    }
-}
\ No newline at end of file


[logging-log4j2] 05/07: Improve toString

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 41f31ddb3cbaa7318eff135d96ff1fb593883400
Author: Matt Sicker <bo...@gmail.com>
AuthorDate: Sat Mar 14 14:08:45 2020 -0500

    Improve toString
    
    Signed-off-by: Matt Sicker <bo...@gmail.com>
---
 .../logging/log4j/plugins/defaults/model/DefaultInjectionPoint.java | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultInjectionPoint.java b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultInjectionPoint.java
index 80bc723..c79405c 100644
--- a/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultInjectionPoint.java
+++ b/log4j-plugins/src/main/java/org/apache/logging/log4j/plugins/defaults/model/DefaultInjectionPoint.java
@@ -88,11 +88,11 @@ class DefaultInjectionPoint<T> implements InjectionPoint<T> {
     @Override
     public String toString() {
         return "DefaultInjectionPoint{" +
-                "type=" + type +
+                "type=" + type.getTypeName() +
                 ", qualifiers=" + qualifiers +
                 ", bean=" + bean +
-                ", member=" + member.getName() +
-                ", element=" + element.getName() +
+                ", member=" + member +
+                ", element=" + element +
                 '}';
     }
 }