Going further with CDI 1.2

@Qualifier
@Retention(RUNTIME)
@Target({TYPE, METHOD, FIELD, PARAMETER})
public @interface HttpParam {
  @Nonbinding public String value()
}
...
@Produces @HttpParam("")
String getParamValue(InjectionPoint ip,HttpServletRequest req) {
  return req.getParameter(ip.getAnnotated().getAnnotation(HttpParam.class).value())
}
...
@HttpParam("productId") @Inject String productId

public class MyMapProducer() {
  @Produces
  public <K, V> Map<K, V> produceMap(InjectionPoint ip) {
       if (valueIsNumber(((ParameterizedType)ip.getType())))
           return new TreeMap<K, V>()
       return new HashMap<K, V>()
  }

  private boolean valueIsNumber(ParameterizedType t) {
        Class<?> valueClass = (Class<?>) t.getActualTypeArguments()[1]
        return Number.class.isAssignableFrom(valueClass)
  }
}

public abstract class AbstractService {
  //resolver with same qualifiers than the current bean
  private Resolver resolver;

  @Inject //@Inject can be used on an initializer method
  void initResolver(Bean<AbstractService> meta, @Any Instance<Resolver> resolvers)
 {
    Annotation[] beanQualifiers = (Annotation[]) meta.getQualifiers().toArray()
    resolver = resolvers.select(beanQualifiers).get()
  }

public Resolver getResolver() {
    return resolver
  }
}

@ApplicationScoped
public class MyService {

  private void strictListen(@Observes @Qualified Payload evt, EventMetadata meta) {
    if(meta.getQualifiers().contains(new QualifiedLiteral())
       && meta.getType().equals(Payload.class))
         System.out.println("Do something")
       else
         System.out.println("ignore")
  }
}

public class VetoEntity implements Extension {

    void vetoEntity(@Observes @WithAnnotations(Entity.class)
                    ProcessAnnotatedType<?> pat) {
        pat.veto();
    }
}

@Inject
@Formula(name = "Fpml2mxmlTransformation", path = "fpml2mxml.jar")
Transformer<FpML, MxML> fpmlToMxmlTransformer;

...

@Inject
@Formula(name = "Fixml2mxmlTransformation", path = "fixml2mxml.jar")
Transformer<FixML, MxML> fixmlToMxmlTransformer;

...

public interface ProcessInjectionPoint<T, X> {
    public InjectionPoint getInjectionPoint();
    public void setInjectionPoint(InjectionPoint injectionPoint);
    public void addDefinitionError(Throwable t);
}

class LegacyComponentExtension implements Extension {

  final List<String> pathes = new ArrayList<>();

  void collectPathes(@Observes ProcessInjectionPoint<?, Transformer> pit) { (1)
    Annotated annotated = pit.getInjectionPoint().getAnnotated();
    if (annotated.isAnnotationPresent(Formula.class))
        pathes.add(annotated.getAnnotation(Formula.class).path()); (2)
  }
}

public interface Bean<T> extends Contextual<T>, BeanAttributes<T> {
    public Class<?> getBeanClass();
    public Set<InjectionPoint> getInjectionPoints();
    public T create(CreationalContext<T> creationalContext); // Contextual<T>
    public void destroy(T instance, CreationalContext<T> creationalContext);
    public Set<Type> getTypes(); // BeanAttributes<T>
    public Set<Annotation> getQualifiers();
    public Class<? extends Annotation> getScope();
    public String getName();
    public Set<Class<? extends Annotation>> getStereotypes();
    public boolean isAlternative();
}

public interface AfterBeanDiscovery {
    public void addDefinitionError(Throwable t);
    public void addBean(Bean<?> bean);
    public void addObserverMethod(ObserverMethod<?> observerMethod);
    public void addContext(Context context);
    public <T> AnnotatedType<T> getAnnotatedType(Class<T> type, String id);
    public <T> Iterable<AnnotatedType<T>> getAnnotatedTypes(Class<T> type);
}

class LegacyComponentExtension implements Extension {

    final List<String> pathes = new ArrayList<>();

    void collectPathes(@Observes ProcessInjectionPoint<?, Transformer> pit) {
        Annotated annotated = pit.getInjectionPoint().getAnnotated();
        if (annotated.isAnnotationPresent(Formula.class))
            pathes.add(annotated.getAnnotation(Formula.class).path());
    }

    void addLegacyComponentBean(@Observes AfterBeanDiscovery abd) {
        abd.addBean(new LegacyExecutorBean(pathes));
    }
}

class MetricsHelper {
    public static MetricRegistry registry = new MetricRegistry();
}

class TimedMethodClass {
    void timedMethod() {
        Timer timer = MetricsHelper.registry.timer("timer"); (1)
        Timer.Context time = timer.time();
        try { ... }
        finally { time.stop();}
    }
}

class MetricRegistryBean {
    @Produces @ApplicationScoped
    MetricRegistry registry = new MetricRegistry();
}
...
class TimedMethodBean {
    @Inject MetricRegistry registry;
    void timedMethod() {
        Timer timer = registry.timer("timer");
        Timer.Context time = timer.time();
        try { ... } finally { time.stop();}
    }
}

class TimedMethodBean {
    @Inject MetricRegistry registry;
    void timedMethod() {
        Timer timer = registry.timer("timer");
        Timer.Context time = timer.time();
        try { //business code }
        finally { time.stop(); }
    }
}

@Interceptor
@Priority(Interceptor.Priority.LIBRARY_BEFORE)  (1)
class TimedInterceptor {
    @Inject MetricRegistry registry;
    @AroundInvoke
    Object timeMethod(InvocationContext context) throws Exception {
        String name = context.getMethod().getAnnotation(Timed.class).name();
        Timer timer = registry.timer(name);
        Timer.Context time = timer.time();
        try { return context.proceed(); }
        finally { time.stop(); }
    }
}

@Interceptor
@Timed  (1)
@Priority(Interceptor.Priority.LIBRARY_BEFORE)
class TimedInterceptor {
    @Inject MetricRegistry registry;
    @AroundInvoke
    Object timeMethod(InvocationContext context) throws Exception {
        String name = context.getMethod().getAnnotation(Timed.class).name();
        Timer timer = registry.timer(name);
        Timer.Context time = timer.time();
        try { return context.proceed(); }
        finally { time.stop(); }
    }
}

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.TYPE, ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.ANNOTATION_TYPE })
(1)
public @interface Timed {
    String name() default ""; (2)
    boolean absolute() default false; (2)
}

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.TYPE, ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.ANNOTATION_TYPE })
@InterceptorBinding
public @interface Timed {
    @NonBinding String name() default "";
    @NonBinding boolean absolute() default false;
}

AnnotatedType createTimedAnnotatedType() throws Exception {
    Annotation nonBinding = new AnnotationLiteral<Nonbinding>() {}; (1)
    return new AnnotatedTypeBuilder().readFromType(Timed.class) (2)
        .addToMethod(Timed.class.getMethod("name"), nonBinding) (3)
        .addToMethod(Timed.class.getMethod("absolute"), nonBinding) (3)
        .create();
}

public interface BeforeBeanDiscovery {
  addQualifier(Class<? extends Annotation> qual);
  addQualifier(AnnotatedType<? extends Annotation> qual);
  addScope(Class<? extends Annotation> scp, boolean nm, boolean psv);
  addStereotype(Class<? extends Annotation> strt, Annotation... sd);
  addInterceptorBinding(AnnotatedType<? extends Annotation> type);  (1)
  addInterceptorBinding(Class<? extends Annotation> type, Annotation... btd);
  addAnnotatedType(AnnotatedType<?> type);
  addAnnotatedType(AnnotatedType<?> type, String id);
}

class MetricsExtension implements Extension {

    void addTimedBinding(@Observes BeforeBeanDiscovery bbd) throws Exception {
        bbd.addInterceptorBinding(createTimedAnnotatedType());
    }

    private AnnotatedType createTimedAnnotatedType() throws Exception {
        Annotation nonBinding = new AnnotationLiteral<Nonbinding>() {};
        return new AnnotatedTypeBuilder().readFromType(Timed.class)
            .addToMethod(Timed.class.getMethod("name"), nonBinding)
            .addToMethod(Timed.class.getMethod("absolute"), nonBinding)
            .create();
    }
}

@AroundInvoke
Object timedMethod(InvocationContext context) throws Exception {
    String name = context.getMethod().getAnnotation(Timed.class).name();
    Timer timer = registry.timer(name); (1)
    Timer.Context time = timer.time();
    try {
        return context.proceed();
    } finally { time.stop();}
}

@Produces @Metric(name="myTimer")
Timer timer = new Timer(new SlidingTimeWindowReservoir(1L, TimeUnit.MINUTES));

public class MetricExtension implements Extension {

    void addMetricQualifier(@Observes BeforeBeanDiscovery bbd) {
        bbd.addQualifier(Metric.class);
    }
    ...
}

public interface ProcessProducer<T, X> {
    public AnnotatedMember<T> getAnnotatedMember(); (1)

    public Producer<X> getProducer(); (2)

    public void setProducer(Producer<X> producer); (3)

    public void addDefinitionError(Throwable t);
}

public class MetricExtension implements Extension {
...
    void reproduceMetric(@Observes ProcessProducer<?, com.codahale.metrics.Metric> pp,
                         BeanManager bm) {

        String name = pp.getAnnotatedMember().getAnnotation(Metric.class).name();
        pp.setProducer(new MetricProducer(pp.getProducer(),name,bm));
    }
...
}

class FileToJmsRouteBean extends RouteBuilder {
    @Override
    public void configure() {
        from("file:inputDir?delay=1000")
          .convertBodyTo(String.class)
          .to("sjms:queue:outputDest");
    }
}

class JmsComponentFactoryBean {
    @Produces
    @ApplicationScoped
    SjmsComponent sjmsComponent() {
        SjmsComponent component = new SjmsComponent();
        component.setConnectionFactory(/*...*/);
        return component;
    }
}

public interface Bean<T> extends Contextual<T>, BeanAttributes<T> {
    public Class<?> getBeanClass();
    public Set<InjectionPoint> getInjectionPoints();
    public T create(CreationalContext<T> creationalContext); // Contextual<T>
    public void destroy(T instance, CreationalContext<T> creationalContext);
    public Set<Type> getTypes(); // BeanAttributes<T>
    public Set<Annotation> getQualifiers();
    public Class<? extends Annotation> getScope();
    public String getName();
    public Set<Class<? extends Annotation>> getStereotypes();
    public boolean isAlternative();
}

public class CamelExtension implements Extension {

    void addCamelContextBean(@Observes AfterBeanDiscovery abd, BeanManager bm) {
        Set<Bean<?>> beans = bm.getBeans(CamelContext.class);
        if (beans.isEmpty())
            abd.addBean(new CamelContextBean(bm));
    }
}

public class CamelExtension implements Extension {
    ...
    void configureContext(@Observes AfterDeploymentValidation adv, BeanManager bm) {
        CamelContext context = getReference(bm, CamelContext.class);
        for (Bean<?> bean : bm.getBeans(RoutesBuilder.class))
            context.addRoutes(getReference(bm, RouteBuilder.class, bean));
    }
    <T> T getReference(BeanManager bm, Class<T> type) {
        return getReference(bm, type, bm.resolve(bm.getBeans(type)));
    }
    <T> T getReference(BeanManager bm, Class<T> type, Bean<?> bean) {
        return (T) bm.getReference(bean, type, bm.createCreationalContext(bean));
    }
}

public class CamelExtension implements Extension {

    private CamelContext context;

    void configureContext(@Observes AfterDeploymentValidation adv, BeanManager bm) {
        context = getReference(bm, CamelContext.class);
        for (Bean<?> bean : bm.getBeans(RoutesBuilder.class)
            context.addRoutes(getReference(bm, RouteBuilder.class, bean);
        context.start();
    }
    void stopCamelContext(@Observes BeforeShutdown bs, BeanManager bm) {
        context.stop();
    }
    ...
}

.to("sjms:queue:outputDest"); // Lookup by name (sjms) and type (Component)

// And also...
.bean(MyBean.class); // Lookup by type and Default qualifier
.beanRef("beanName"); // Lookup by name

class CdiRegistry implements Registry {
    private final BeanManager bm;
    public CdiRegistry(BeanManager bm) {
        this.bm = bm;
    }
    public <T> T lookupByNameAndType(String name, Class<T> type) {
        return getReference(bm, type, bm.resolve(bm.getBeans(name)));
    }
    public <T> Set<T> findByType(Class<T> type) {
        return getReference(bm, type, bm.resolve(bm.getBeans(type)));
    }
    public Object lookupByName(String name) {
        return lookupByNameAndType(name, Object.class);
    }
    <T> T getReference(BeanManager bm, Type type, Bean<?> bean) {
        return (T) bm.getReference(bean, type, bm.createCreationalContext(bean));
    }
}

public class CamelExtension implements Extension {
    ...
    void configureContext(@Observes AfterDeploymentValidation adv, BeanManager bm) {
        context = getReference(bm, DefaultCamelContext.class);
        for (Bean<?> bean : bm.getBeans(RoutesBuilder.class)
            context.addRoutes(getReference(bm, RouteBuilder.class, bean);

        context.setRegistry(new CdiRegistry(bm));
        context.start();
    }
    ...
}

@PropertyInject(value = "jms.queue.maxConnections", defaultValue = "10")
Integer maxConnections;

// But also...
@EndpointInject(uri="jms:queue:foo")
Endpoint endpoint;

@BeanInject("foo")
FooBean foo;

public interface InjectionTarget<T> extends Producer<T> {
    public void inject(T instance, CreationalContext<T> ctx);
    public void postConstruct(T instance);
    public void preDestroy(T instance);
}

class CamelInjectionTarget<T> implements InjectionTarget<T> {

  final DefaultCamelBeanPostProcessor processor = new DefaultCamelBeanPostProcessor();

  final InjectionTarget<T> delegate;

  CamelInjectionTarget(InjectionTarget<T> target) {
      delegate = target;
  }

  public void inject(T instance, CreationalContext<T> ctx) {
      processor.postProcessBeforeInitialization(instance); (1)
      delegate.inject(instance, ctx);
  }
  ...
}

public interface ProcessInjectionTarget<X> {
    public AnnotatedType<X> getAnnotatedType();
    public InjectionTarget<X> getInjectionTarget();
    public void setInjectionTarget(InjectionTarget<X> injectionTarget);
    public void addDefinitionError(Throwable t);
}

class CamelExtension implements Extension {

  <T> void camelBeansPostProcessor(@Observes ProcessInjectionTarget<T> pit) {
      pit.setInjectionTarget(new CamelInjectionTarget<T>(pit.getInjectionTarget()));
  }
}

class CamelExtension implements Extension {
  final Set<AnnotatedType<?>> camelBeans = new HashSet<>();

  void camelAnnotations(@Observes @WithAnnotations({BeanInject.class, (1)
      Consume.class, EndpointInject.class, Produce.class, PropertyInject.class})
      ProcessAnnotatedType<?> pat) {
        camelBeans.add(pat.getAnnotatedType());
  }

  <T> void camelBeansPostProcessor(@Observes ProcessInjectionTarget<T> pit) {
      if (camelBeans.contains(pit.getAnnotatedType())) (2)
        pit.setInjectionTarget(new CamelInjectionTarget<>(pit.getInjectionTarget()));
  }
}