本文整理了Java中javax.enterprise.inject.spi.AnnotatedMethod类的一些代码示例，展示了AnnotatedMethod类的具体用法。这些代码示例主要来源于Github/Stackoverflow/Maven等平台，是从一些精选项目中提取出来的代码，具有较强的参考意义，能在一定程度帮忙到你。AnnotatedMethod类的具体详情如下：
包路径：javax.enterprise.inject.spi.AnnotatedMethod
类名称：AnnotatedMethod

AnnotatedMethod介绍

[英]Define method member contract.
[中]定义方法成员契约。

代码示例

代码示例来源：origin: oracle/helidon

/**
 * Collects all FT methods in a set for later processing.
 *
 * @param event Event information.
 */
void registerFaultToleranceMethods(@Observes ProcessManagedBean<?> event) {
  AnnotatedType<?> type = event.getAnnotatedBeanClass();
  for (AnnotatedMethod<?> method : type.getMethods()) {
    if (isFaultToleranceMethod(type.getJavaClass(), method.getJavaMember())) {
      getRegisteredMethods().add(new BeanMethod(type.getJavaClass(), method.getJavaMember()));
    }
  }
}

代码示例来源：origin: oracle/helidon

private void recordAnnotatedGaugeSite(@Observes @WithAnnotations(Gauge.class) ProcessAnnotatedType<?> pat) {
  LOGGER.log(Level.FINE, () -> "### recordAnnoatedGaugeSite for class " + pat.getAnnotatedType().getJavaClass());
  AnnotatedType<?> type = pat.getAnnotatedType();
  LOGGER.log(Level.FINE, () -> "### Processing annotations for " + type.getJavaClass().getName());
  // Register metrics based on annotations
  AnnotatedTypeConfigurator<?> configurator = pat.configureAnnotatedType();
  Class<?> clazz = configurator.getAnnotated().getJavaClass();
  // If abstract class, then handled by concrete subclasses
  if (Modifier.isAbstract(clazz.getModifiers())) {
    return;
  }
  // Process @Gauge methods keeping non-private declared on this class
  configurator.filterMethods(method -> method.getJavaMember().getDeclaringClass().equals(clazz)
      && !Modifier.isPrivate(method.getJavaMember().getModifiers())
      && method.isAnnotationPresent(Gauge.class))
      .forEach(method -> {
        Method javaMethod = method.getAnnotated().getJavaMember();
        String explicitGaugeName = method.getAnnotated().getAnnotation(Gauge.class).name();
        String gaugeName = String.format("%s.%s", clazz.getName(),
                         explicitGaugeName != null && explicitGaugeName.length() > 0
                             ? explicitGaugeName : javaMethod.getName());
        annotatedGaugeSites.put(gaugeName, method);
        LOGGER.log(Level.FINE, () -> String.format("### Recorded annotated gauge with name %s", gaugeName));
      });
}

代码示例来源：origin: oracle/helidon

/**
 * Records metric producer methods defined by the application. Ignores producers
 * with non-default qualifiers and library producers.
 *
 * @param ppm Producer method.
 */
private void recordProducerMethods(@Observes
                      ProcessProducerMethod<? extends org.eclipse.microprofile.metrics.Metric, ?> ppm) {
  LOGGER.log(Level.FINE, () -> "### recordProducerMethods " + ppm.getBean().getBeanClass());
  if (!MetricProducer.class.equals(ppm.getBean().getBeanClass())) {
    Metric metric = ppm.getAnnotatedProducerMethod().getAnnotation(Metric.class);
    if (metric != null) {
      Optional<? extends Annotation> hasQualifier
          = ppm.getAnnotatedProducerMethod()
          .getAnnotations()
          .stream()
          .filter(annotation -> annotation.annotationType().isAnnotationPresent(Qualifier.class))
          .findFirst();
      // Ignore producers with non-default qualifiers
      if (!hasQualifier.isPresent() || hasQualifier.get() instanceof Default) {
        producers.put(ppm.getBean(), ppm.getAnnotatedProducerMethod());
      }
    }
  }
}

代码示例来源：origin: org.jboss.weld.se/weld-se

public void processBeans(@Observes ProcessBean<?> event, BeanManager beanManager) {
  probe.getBootstrapStats().increment(EventType.PB);
  if (eventMonitorContainerLifecycleEvents) {
    Object info;
    if (event instanceof ProcessProducerMethod) {
      info = formatMember(((ProcessProducerMethod<?, ?>) event).getAnnotatedProducerMethod().getJavaMember());
    } else if (event instanceof ProcessProducerField) {
      info = formatMember(((ProcessProducerField<?, ?>) event).getAnnotatedProducerField().getJavaMember());
    } else {
      info = Formats.formatType(event.getBean().getBeanClass(), false);
    }
    addContainerLifecycleEvent(event, info, beanManager);
  }
}

代码示例来源：origin: org.demoiselle.jee/demoiselle-core

protected void startup(@Observes ProcessAnnotatedType<?> event) {
  final AnnotatedType<?> annotatedType = event.getAnnotatedType();
  for (AnnotatedMethod<?> am : annotatedType.getMethods()) {
    if (am.isAnnotationPresent(Startup.class)) {
      methodsWithStartup.add(new AnnotatedMethodProcessor(am));
    }
    if (am.isAnnotationPresent(Shutdown.class)) {
      methodsWithShutdown.add(new AnnotatedMethodProcessor(am));
    }
  }
}

代码示例来源：origin: oracle/helidon

private void registerMetrics(@Observes @WithAnnotations({Counted.class, Metered.class, Timed.class})
                   ProcessAnnotatedType<?> pat) {
  Interceptor annot = type.getAnnotation(Interceptor.class);
  if (annot != null) {
    return;
  LOGGER.log(Level.FINE, () -> "### Processing annotations for " + pat.getAnnotatedType().getJavaClass().getName());
  Class<?> clazz = configurator.getAnnotated().getJavaClass();
  configurator.filterMethods(method -> !Modifier.isPrivate(method.getJavaMember().getModifiers()))
      .forEach(method -> {
        METRIC_ANNOTATIONS.forEach(annotation -> {
          LookupResult<? extends Annotation> lookupResult
              = lookupAnnotation(method.getAnnotated().getJavaMember(), annotation, clazz);
          if (lookupResult != null) {
            registerMetric(method.getAnnotated().getJavaMember(), clazz, lookupResult);
  configurator.filterConstructors(constructor -> !Modifier.isPrivate(constructor.getJavaMember().getModifiers()))
      .forEach(constructor -> {
        METRIC_ANNOTATIONS.forEach(annotation -> {
          LookupResult<? extends Annotation> lookupResult
              = lookupAnnotation(constructor.getAnnotated().getJavaMember(), annotation, clazz);
          if (lookupResult != null) {
            registerMetric(constructor.getAnnotated().getJavaMember(), clazz, lookupResult);

代码示例来源：origin: org.jboss.seam.solder/seam-solder

<T, X> void registerGenericBeanObserverMethod(@Observes ProcessObserverMethod<T, X> event)
{
 AnnotatedType<X> declaringType = event.getAnnotatedMethod().getDeclaringType();
 if (declaringType.isAnnotationPresent(GenericConfiguration.class))
 {
   AnnotatedMethod<X> method = event.getAnnotatedMethod();
   Class<? extends Annotation> genericConfigurationType = declaringType.getAnnotation(GenericConfiguration.class).value();
   genericBeanObserverMethods.put(genericConfigurationType, new ObserverMethodHolder<X, T>(method, event.getObserverMethod()));
 }
}

代码示例来源：origin: org.jboss.cdi.tck/cdi-tck-impl

void observesAnimalShelterPAT(@Observes ProcessAnnotatedType<AnimalShelter> event) {
  AnnotatedTypeConfigurator<AnimalShelter> annotatedTypeConfigurator = event.configureAnnotatedType();
  AnnotatedMethod<? super AnimalShelter> annotatedMethod = methodConfigurator.getAnnotated();
  annotatedMethodEqual.set(AnnotatedTypes.compareAnnotatedCallable(
      event.getAnnotatedType().getMethods().stream().filter(m -> m.getJavaMember().getName().equals("observesRoomInShelter")).findAny().get(),
      annotatedMethod));
      .filterConstructors(ac -> ac.isAnnotationPresent(Inject.class))
      .findFirst().get();
  AnnotatedConstructor<AnimalShelter> originalAnnotatedConstructor = event.getAnnotatedType().getConstructors().stream()
      .filter(m -> m.isAnnotationPresent(Inject.class)).findAny().get();
      .set(AnnotatedTypes.compareAnnotatedParameters(originalAnnotatedConstructor.getParameters(), configuratorAnnotatedConstructor.getParameters()));
    return annotatedField.getJavaMember().getName().equals("cat");
  }).findFirst().get();
      .compareAnnotatedField(event.getAnnotatedType().getFields().stream().filter(af -> af.getJavaMember().getName().equals("cat")).findAny().get(),
          annotatedField));

代码示例来源：origin: org.jboss.weld.se/weld-se

public static String formatAnnotatedMethod(AnnotatedMethod<?> method) {
  return Formats.formatSimpleClassName(method) + " " + Formats.addSpaceIfNeeded(Formats.formatAnnotations(method.getAnnotations()))
      + Formats.addSpaceIfNeeded(Formats.formatModifiers(method.getJavaMember().getModifiers())) + method.getDeclaringType().getJavaClass().getName() + "."
      + method.getJavaMember().getName() + Formats.formatAsFormalParameterList(method.getParameters());
}

代码示例来源：origin: org.agorava/solder-generics-impl

<X> void registerGenericBean(@Observes ProcessManagedBean<X> event) {
  AnnotatedType<X> type = event.getAnnotatedBeanClass();
  if (type.isAnnotationPresent(GenericConfiguration.class)) {
    Class<? extends Annotation> genericType = type.getAnnotation(GenericConfiguration.class).value();
    genericBeans.put(genericType, new BeanHolder<X>(event.getAnnotatedBeanClass(), event.getBean()));
    for (AnnotatedMethod<? super X> m : event.getAnnotatedBeanClass().getMethods()) {
      if (m.isAnnotationPresent(Unwraps.class)) {
        unwrapsMethods.put(genericType, m);
      }
    }
  }
}

代码示例来源：origin: oracle/helidon

private void registerAnnotatedGauges(@Observes AfterDeploymentValidation adv, BeanManager bm) {
  LOGGER.log(Level.FINE, () -> "### registerGauges");
  MetricRegistry registry = getMetricRegistry();
  annotatedGaugeSites.entrySet().forEach(gaugeSite -> {
    LOGGER.log(Level.FINE, () -> "### gaugeSite " + gaugeSite.toString());
    String gaugeName = gaugeSite.getKey();
    AnnotatedMethodConfigurator<?> site = gaugeSite.getValue();
    DelegatingGauge<?> dg = buildDelegatingGauge(gaugeName, site, bm);
    Gauge gaugeAnnotation = site.getAnnotated().getAnnotation(Gauge.class);
    Metadata md = new Metadata(gaugeName,
        gaugeAnnotation.displayName(),
        gaugeAnnotation.description(),
        MetricType.GAUGE,
        gaugeAnnotation.unit(),
        toTags(gaugeAnnotation.tags()));
    LOGGER.log(Level.FINE, () -> String.format("### Registering gauge with metadata %s", md.toString()));
    registry.register(md, dg);
  });
  annotatedGaugeSites.clear();
}

代码示例来源：origin: org.graniteds/granite-server-cdi

public <X> void processBean(@Observes ProcessBean<X> event) {
  if (event.getAnnotated().isAnnotationPresent(TideComponent.class) || event.getAnnotated().isAnnotationPresent(TideBean.class)) {
    instrumentedBeans.put(event.getAnnotated().getBaseType(), event.getBean());
    log.info("Instrumented Tide component %s", event.getBean().toString());
  }
  
  Bean<?> bean = event.getBean();
  if (event instanceof ProcessProducerMethod<?, ?>) {
    Type type = ((ProcessProducerMethod<?, ?>)event).getAnnotatedProducerMethod().getDeclaringType().getBaseType();			
    producedBeans.put(((ProcessProducerMethod<?, ?>)event).getAnnotatedProducerMethod().getBaseType(), type);
    if (bean.getName() != null)
      producedBeans.put(bean.getName(), type);
  }
  else if (event instanceof ProcessProducerField<?, ?>) {
    Type type = ((ProcessProducerField<?, ?>)event).getAnnotatedProducerField().getDeclaringType().getBaseType();
    producedBeans.put(((ProcessProducerField<?, ?>)event).getAnnotatedProducerField().getBaseType(), type);
    if (bean.getName() != null)
      producedBeans.put(bean.getName(), type);
  }
  
  if (event.getBean().getBeanClass().equals(TideInstrumentedBeans.class))
    tideInstrumentedBeans = event.getBean();
}

代码示例来源：origin: com.kumuluz.ee.metrics/kumuluzee-metrics-core

private void metricProducerMethod(@Observes ProcessProducerMethod<? extends Metric, ?> ppm) {
  if (ppm.getAnnotatedProducerMethod().getAnnotation(org.eclipse.microprofile.metrics.annotation.Metric.class)
      != null) {
    Method member = ppm.getAnnotatedProducerMethod().getJavaMember();
    Class<?> bean = member.getDeclaringClass();
    Metadata metadata = AnnotationMetadata.buildMetadata(bean, member,
        org.eclipse.microprofile.metrics.annotation.Metric.class);
    producerMembers.add(new ProducerMemberRegistration(ppm.getBean(), ppm.getAnnotatedProducerMethod(),
        metadata));
  }
}

代码示例来源：origin: org.infinispan/infinispan-cdi

this.javaClass = type.getJavaClass();
for (AnnotatedField<? super X> field : type.getFields()) {
  if (fields.get(field.getJavaMember()) == null) {
   fields.put(field.getJavaMember(), new AnnotationBuilder());
  mergeAnnotationsOnElement(field, overwrite, fields.get(field.getJavaMember()));
for (AnnotatedMethod<? super X> method : type.getMethods()) {
  if (methods.get(method.getJavaMember()) == null) {
   methods.put(method.getJavaMember(), new AnnotationBuilder());
  mergeAnnotationsOnElement(method, overwrite, methods.get(method.getJavaMember()));
  for (AnnotatedParameter<? super X> p : method.getParameters()) {
   if (methodParameters.get(method.getJavaMember()) == null) {
     methodParameters.put(method.getJavaMember(), new HashMap<Integer, AnnotationBuilder>());
   if (methodParameters.get(method.getJavaMember()).get(p.getPosition()) == null) {
     methodParameters.get(method.getJavaMember()).put(p.getPosition(), new AnnotationBuilder());
   mergeAnnotationsOnElement(p, overwrite, methodParameters.get(method.getJavaMember()).get(p.getPosition()));
for (AnnotatedConstructor<? super X> constructor : type.getConstructors()) {
  if (constructors.get(constructor.getJavaMember()) == null) {
   constructors.put(constructor.getJavaMember(), new AnnotationBuilder());

代码示例来源：origin: org.jboss.cdi.tck/cdi-tck-impl

void processObserverMethod(@Observes ProcessObserverMethod<?, ?> event) {
  ObserverMethod<?> observer = event.getObserverMethod();
  AnnotatedMethod<?> method = event.getAnnotatedMethod();
  int order = 0; // the default order is 0
  if (method.isAnnotationPresent(Ordered.class)) {
    Ordered ordered = method.getAnnotation(Ordered.class);
    order = ordered.value();
  }
  observerMethodOrder.put(observer, order);
}

代码示例来源：origin: weld/core

static String annotatedMethodToString(AnnotatedMethod<?> method, Class<?> beanClass) {
  StringBuilder builder = new StringBuilder();
  builder.append(Formats.addSpaceIfNeeded(Formats.formatAnnotations(method.getAnnotations())));
  builder.append(Formats.formatModifiers(method.getJavaMember().getModifiers()));
  TypeVariable<Method>[] typeParams = method.getJavaMember().getTypeParameters();
  builder.append(' ');
  if (typeParams.length > 0) {
    builder.append(Formats.formatTypeParameters(typeParams));
    builder.append(' ');
  }
  builder.append(Formats.formatType(method.getJavaMember().getGenericReturnType()));
  builder.append(' ');
  if (!beanClass.getName().equals(method.getDeclaringType().getJavaClass().getName())) {
    builder.append(Formats.formatType(method.getDeclaringType().getJavaClass()));
    builder.append('.');
  }
  builder.append(method.getJavaMember().getName());
  builder.append(Formats.formatAsFormalParameterList(method.getParameters()));
  return builder.toString();
}

代码示例来源：origin: org.jboss.weld.se/weld-se

protected static void validateParameterCount(AnnotatedCallable<?> callable) {
    if (callable instanceof BackedAnnotatedMember) {
      return; // do not validate backed implementation
    }
    Class<?>[] parameterTypes = null;
    if (callable instanceof AnnotatedConstructor<?>) {
      parameterTypes = AnnotatedConstructor.class.cast(callable).getJavaMember().getParameterTypes();
    } else {
      parameterTypes = AnnotatedMethod.class.cast(callable).getJavaMember().getParameterTypes();
    }
    if (callable.getParameters().size() != parameterTypes.length) {
      // For enums, BackedAnnotatedConstructor sets parameters to an empty list, so we shouldn't throw the DefinitionException
      Class<?> declaringClass = callable.getDeclaringType().getJavaClass();
      if (!declaringClass.isEnum() && !declaringClass.isMemberClass()) {
        throw ReflectionLogger.LOG.incorrectNumberOfAnnotatedParametersMethod(callable.getParameters().size(), callable, callable.getParameters(), Arrays.asList(parameterTypes));
      }
    }
  }
}

代码示例来源：origin: org.jboss.weld.se/weld-se

public boolean isEqual(Annotation instance, Annotation other, boolean includeNonBindingTypes) {
    if (instance.annotationType().equals(getRawType()) && other.annotationType().equals(getRawType())) {
      for (AnnotatedMethod<?> annotatedMethod : getAnnotatedAnnotation().getMethods()) {
        if (includeNonBindingTypes || !getNonBindingMembers().contains(annotatedMethod)) {
          try {
            AccessController.doPrivileged(SetAccessibleAction.of(annotatedMethod.getJavaMember()));
            Object thisValue = annotatedMethod.getJavaMember().invoke(instance);
            Object thatValue = annotatedMethod.getJavaMember().invoke(other);
            if (!thisValue.equals(thatValue)) {
              return false;
            }
          } catch (IllegalArgumentException e) {
            throw new WeldException(e);
          } catch (IllegalAccessException e) {
            throw new WeldException(e);
          } catch (InvocationTargetException e) {
            throw new WeldException(e);
          }

        }
      }
      return true;
    }
    return false;
  }
}

代码示例来源：origin: org.jboss.cdi.tck/cdi-tck-impl

private void validateManagedBean(AnnotatedType<Farm> type) {
  assert type.getBaseType().equals(Farm.class);
  assert typeSetMatches(type.getTypeClosure(), Farm.class, Object.class);
  assert type.getFields().size() == 1;
  assert type.getFields().iterator().next().isAnnotationPresent(Produces.class);
  assert type.getMethods().size() == 1;
  assert type.getMethods().iterator().next().isAnnotationPresent(Produces.class);
}

代码示例来源：origin: weld/core

public static <X, Y extends X> AnnotatedMethod<X> of(AnnotatedMethod<X> originalMethod, UnbackedAnnotatedType<Y> declaringType, SharedObjectCache cache) {
  UnbackedAnnotatedType<X> downcastDeclaringType = cast(declaringType);
  return new UnbackedAnnotatedMethod<X>(originalMethod.getBaseType(), originalMethod.getTypeClosure(), originalMethod.getAnnotations(), downcastDeclaringType,
      originalMethod.getParameters(), originalMethod.getJavaMember(), cache);
}