skeleton code for @Attribute injection.

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

@@ -25,6 +25,7 @@
 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;
 
@@ -46,6 +47,16 @@ static String findName(Param param, Object nameRetrievalTarget) {
         return getName(nameRetrievalTarget);
     }
 
+    static String findName(Attribute attribute, Object nameRetrievalTarget) {
+        requireNonNull(nameRetrievalTarget, "nameRetrievalTarget");
+
+        final String value = attribute.value();
+        if (DefaultValues.isSpecified(value)) {
+            checkArgument(!value.isEmpty(), "value is empty.");
+            return value;
+        }
+        return getName(nameRetrievalTarget);
+    }
     /**
      * 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

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

@@ -55,6 +55,7 @@
 import java.util.function.BiFunction;
 import java.util.function.Function;
 import java.util.function.Supplier;
+import java.util.stream.Collectors;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -84,6 +85,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 +101,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,6 +447,13 @@ 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(attr, typeElement);
+            return ofAttribute(name, annotatedElement, typeElement, type, description);
+        }
+
         final Param param = annotatedElement.getAnnotation(Param.class);
         if (param != null) {
             final String name = findName(param, typeElement);
@@ -520,6 +530,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 +632,25 @@ private static AnnotatedValueResolver ofRequestObject(String name, AnnotatedElem
                 .build();
     }
 
+    private static AnnotatedValueResolver ofAttribute(String name,
+                                                      AnnotatedElement annotatedElement,
+                                                      AnnotatedElement typeElement, Class<?> type,
+                                                      DescriptionInfo description) {
+        return new Builder(annotatedElement, type, name)
+                .annotationType(Attribute.class)
+                .typeElement(typeElement)
+                .supportDefault(true)
+                .supportContainer(true)
+                .description(description)
+                .resolver(resolverAttribute((ctx, clazz) -> {
+                                                return ctx.context.attr(AttributeKey.valueOf(clazz, name)) != null ?
+                                                       ctx.context.attr(AttributeKey.valueOf(clazz, name)) :
+                                                       ctx.context.attr(AttributeKey.valueOf(name));
+                                            }
+                ))
+                .build();
+    }
+
     @Nullable
     private static AnnotatedValueResolver ofInjectableTypes(String name, AnnotatedElement annotatedElement,
                                                             Class<?> type, boolean useBlockingExecutor) {
@@ -775,6 +805,61 @@ private static AnnotatedValueResolver ofInjectableTypes0(String name, AnnotatedE
         };
     }
 
+    private static BiFunction<AnnotatedValueResolver, ResolverContext, Object>
+    resolverAttribute(BiFunction<ResolverContext, Class<?>, Object> getter) {
+        return (resolver, ctx) -> {
+            final Class<?> type = resolver.elementType().isPrimitive() ?
+                                  PrimitiveToReference.primitiveToReference(resolver.elementType.getName()) :
+                                  resolver.elementType();
+            // Primitive to Reference.
+            Object value = getter.apply(ctx, type);
+            if (value != null) {
+                return value;
+            }
+            return resolver.defaultOrException();
+        };
+    }
+
+    enum PrimitiveToReference {
+        BOOLEAN("boolean", Boolean.class),
+        BYTE("byte", Byte.class),
+        CHAR("char", Character.class),
+        SHORT("short", Short.class),
+        INTEGER("int", Integer.class),
+        LONG("long", Long.class),
+        FLOAT("float", Float.class),
+        DOUBLE("double", Double.class);
+
+        PrimitiveToReference(String name, Class<?> clazz) {
+            this.name = name;
+            this.clazz = clazz;
+        }
+
+        public String getName() {
+            return this.name;
+        }
+
+        public Class<?> getClazz() {
+            return this.clazz;
+        }
+
+        static Class<?> primitiveToReference(String name) {
+            final Class<?> clazz = PrimitiveToReference.map.get(name);
+            if (clazz != null) {
+                return clazz;
+            }
+            throw new IllegalStateException("There is no Reference type corresponding to " + name);
+        }
+
+        private final String name;
+        private final Class<?> clazz;
+        private static final Map<String, Class<?>> map = Arrays.stream(values())
+                                                               .collect(Collectors.toMap(
+                                                                       e -> e.getName(),
+                                                                       e -> e.getClazz()));
+    }
+
+
     /**
      * 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

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

@@ -0,0 +1,15 @@
+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() default DefaultValues.UNSPECIFIED;
+}