Implement @Attribute Injection.

core/src/main/java/com/linecorp/armeria/internal/server/annotation/AnnotatedElementNameUtil.java

@@ -20,51 +20,34 @@
 
 import java.lang.reflect.Field;
 import java.lang.reflect.Parameter;
+import java.util.function.Function;
 
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Ascii;
 import com.google.common.base.CaseFormat;
 
+import com.linecorp.armeria.server.annotation.Attribute;
 import com.linecorp.armeria.server.annotation.Header;
 import com.linecorp.armeria.server.annotation.Param;
 
 final class AnnotatedElementNameUtil {
 
-    /**
-     * Returns the value of the {@link Param} annotation which is specified on the {@code element} if
-     * the value is not blank. If the value is blank, it returns the name of the specified
-     * {@code nameRetrievalTarget} object which is an instance of {@link Parameter} or {@link Field}.
-     */
-    static String findName(Param param, Object nameRetrievalTarget) {
-        requireNonNull(nameRetrievalTarget, "nameRetrievalTarget");
-
-        final String value = param.value();
-        if (DefaultValues.isSpecified(value)) {
-            checkArgument(!value.isEmpty(), "value is empty.");
-            return value;
-        }
-        return getName(nameRetrievalTarget);
+    static String findName(Object nameRetrievalTarget, String value) {
+        return findName(nameRetrievalTarget, value, Function.identity());
     }
 
     /**
-     * Returns the value of the {@link Header} annotation which is specified on the {@code element} if
-     * the value is not blank. If the value is blank, it returns the name of the specified
-     * {@code nameRetrievalTarget} object which is an instance of {@link Parameter} or {@link Field}.
-     *
-     * <p>Note that the name of the specified {@code nameRetrievalTarget} will be converted as
-     * {@link CaseFormat#LOWER_HYPHEN} that the string elements are separated with one hyphen({@code -})
-     * character. The value of the {@link Header} annotation will not be converted because it is clearly
-     * specified by a user.
+     * Returns the value of {@link Header}, {@link Param}, {@link Attribute} if the value is not blank.
+     * If the value is blank, it returns the name of the specified {@code nameRetrievalTarget} object
+     * which is an instance of {@link Header}, {@link Param}, {@link Attribute} or {@link Field}.
      */
-    static String findName(Header header, Object nameRetrievalTarget) {
+    static String findName(Object nameRetrievalTarget, String value, Function<String, String> delegate) {
         requireNonNull(nameRetrievalTarget, "nameRetrievalTarget");
-
-        final String value = header.value();
         if (DefaultValues.isSpecified(value)) {
             checkArgument(!value.isEmpty(), "value is empty.");
             return value;
         }
-        return toHeaderName(getName(nameRetrievalTarget));
+        return delegate.apply(getName(nameRetrievalTarget));
     }
 
     /**
@@ -89,8 +72,7 @@ static String getName(Object element) {
                 throw new IllegalArgumentException(
                         "cannot obtain the name of the parameter or field automatically. " +
                         "Please make sure you compiled your code with '-parameters' option. " +
-                        "If not, you need to specify parameter and header names with @" +
-                        Param.class.getSimpleName() + " and @" + Header.class.getSimpleName() + '.');
+                        "Alternatively, you could specify the name explicitly in the annotation.");
             }
             return parameter.getName();
         }

core/src/main/java/com/linecorp/armeria/internal/server/annotation/AnnotatedValueResolver.java

@@ -22,6 +22,7 @@
 import static com.linecorp.armeria.internal.server.annotation.AnnotatedElementNameUtil.findName;
 import static com.linecorp.armeria.internal.server.annotation.AnnotatedElementNameUtil.getName;
 import static com.linecorp.armeria.internal.server.annotation.AnnotatedElementNameUtil.getNameOrDefault;
+import static com.linecorp.armeria.internal.server.annotation.AnnotatedElementNameUtil.toHeaderName;
 import static com.linecorp.armeria.internal.server.annotation.AnnotatedServiceFactory.findDescription;
 import static com.linecorp.armeria.internal.server.annotation.AnnotatedServiceTypeUtil.stringToType;
 import static com.linecorp.armeria.internal.server.annotation.DefaultValues.getSpecifiedValue;
@@ -64,6 +65,7 @@
 import com.google.common.base.Splitter;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Iterables;
+import com.google.common.primitives.Primitives;
 
 import com.linecorp.armeria.common.AggregatedHttpRequest;
 import com.linecorp.armeria.common.Cookie;
@@ -84,6 +86,7 @@
 import com.linecorp.armeria.internal.server.FileAggregatedMultipart;
 import com.linecorp.armeria.internal.server.annotation.AnnotatedBeanFactoryRegistry.BeanFactoryId;
 import com.linecorp.armeria.server.ServiceRequestContext;
+import com.linecorp.armeria.server.annotation.Attribute;
 import com.linecorp.armeria.server.annotation.ByteArrayRequestConverterFunction;
 import com.linecorp.armeria.server.annotation.Default;
 import com.linecorp.armeria.server.annotation.Delimiter;
@@ -99,6 +102,7 @@
 import com.linecorp.armeria.server.docs.DescriptionInfo;
 
 import io.netty.handler.codec.http.HttpConstants;
+import io.netty.util.AttributeKey;
 import scala.concurrent.ExecutionContext;
 
 final class AnnotatedValueResolver {
@@ -444,9 +448,16 @@ private static AnnotatedValueResolver of(AnnotatedElement annotatedElement,
         requireNonNull(dependencyInjector, "dependencyInjector");
 
         final DescriptionInfo description = findDescription(annotatedElement);
+
+        final Attribute attr = annotatedElement.getAnnotation(Attribute.class);
+        if (attr != null) {
+            final String name = findName(typeElement, attr.value());
+            return ofAttribute(name, attr, annotatedElement, typeElement, type, description);
+        }
+
         final Param param = annotatedElement.getAnnotation(Param.class);
         if (param != null) {
-            final String name = findName(param, typeElement);
+            final String name = findName(typeElement, param.value());
             if (type == File.class || type == Path.class || type == MultipartFile.class) {
                 return ofFileParam(name, annotatedElement, typeElement, type, description);
             }
@@ -459,7 +470,7 @@ private static AnnotatedValueResolver of(AnnotatedElement annotatedElement,
 
         final Header header = annotatedElement.getAnnotation(Header.class);
         if (header != null) {
-            final String name = findName(header, typeElement);
+            final String name = findName(typeElement, header.value(), v -> toHeaderName(v));
             return ofHeader(name, annotatedElement, typeElement, type, description);
         }
 
@@ -520,6 +531,7 @@ static List<RequestObjectResolver> addToFirstIfExists(List<RequestObjectResolver
 
     private static boolean isAnnotationPresent(AnnotatedElement element) {
         return element.isAnnotationPresent(Param.class) ||
+               element.isAnnotationPresent(Attribute.class) ||
                element.isAnnotationPresent(Header.class) ||
                element.isAnnotationPresent(RequestObject.class);
     }
@@ -621,6 +633,35 @@ private static AnnotatedValueResolver ofRequestObject(String name, AnnotatedElem
                 .build();
     }
 
+    private static AnnotatedValueResolver ofAttribute(String name,
+                                                      Attribute attr,
+                                                      AnnotatedElement annotatedElement,
+                                                      AnnotatedElement typeElement, Class<?> type,
+                                                      DescriptionInfo description) {
+
+        final ImmutableList.Builder<AttributeKey<?>> builder = ImmutableList.builder();
+
+        if (attr.prefix() != DefaultValues.class) {
+            builder.add(AttributeKey.valueOf(attr.prefix(), name));
+        }
+        else {
+            final Class<?> serviceClass = ((Parameter) annotatedElement).getDeclaringExecutable()
+                                                                        .getDeclaringClass();
+            builder.add(AttributeKey.valueOf(serviceClass, name));
+            builder.add(AttributeKey.valueOf(name));
+        }
+
+        final ImmutableList<AttributeKey<?>> attrKeys = builder.build();
+        return new Builder(annotatedElement, type, name)
+                .annotationType(Attribute.class)
+                .typeElement(typeElement)
+                .supportDefault(true)
+                .supportContainer(true)
+                .description(description)
+                .resolver(attributeResolver(attrKeys))
+                .build();
+    }
+
     @Nullable
     private static AnnotatedValueResolver ofInjectableTypes(String name, AnnotatedElement annotatedElement,
                                                             Class<?> type, boolean useBlockingExecutor) {
@@ -775,6 +816,23 @@ private static AnnotatedValueResolver ofInjectableTypes0(String name, AnnotatedE
         };
     }
 
+    /**
+     * Returns a collection value resolver which retrieves a list of string from the specified {@code getter}
+     * AttributeKeys {@code ofAttribute} and adds them to the specified collection data type.
+     */
+    private static BiFunction<AnnotatedValueResolver, ResolverContext, Object>
+    attributeResolver(Iterable<AttributeKey<?>> attrKeys) {
+        return (resolver, ctx) -> {
+            for (AttributeKey<?> attrKey : attrKeys) {
+                final Object value = ctx.context.attr(attrKey);
+                if (value != null) {
+                    return value;
+                }
+            }
+            return resolver.defaultOrException();
+        };
+    }
+
     /**
      * Returns a bean resolver which retrieves a value using request converters. If the target element
      * is an annotated bean, a bean factory of the specified {@link BeanFactoryId} will be used for creating an
@@ -1089,6 +1147,7 @@ private Builder(AnnotatedElement annotatedElement, Type type, String name) {
          */
         private Builder annotationType(Class<? extends Annotation> annotationType) {
             assert annotationType == Param.class ||
+                   annotationType == Attribute.class ||
                    annotationType == Header.class ||
                    annotationType == RequestObject.class : annotationType.getSimpleName();
             this.annotationType = annotationType;

core/src/main/java/com/linecorp/armeria/server/annotation/Attribute.java

@@ -0,0 +1,16 @@
+package com.linecorp.armeria.server.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import com.linecorp.armeria.internal.server.annotation.DefaultValues;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.PARAMETER)
+public @interface Attribute {
+
+    String value();
+    Class<?> prefix() default DefaultValues.class;
+}