/** * Get the underlying {@link Parameter}. * * @return the {@link Parameter} */ default Parameter getJavaParameter() { Member member = getDeclaringCallable().getJavaMember(); if (!(member instanceof Executable)) { throw new IllegalStateException("Parameter does not belong to an executable: " + member); } Executable executable = (Executable) member; return executable.getParameters()[getPosition()]; }
private boolean containAnnotatedParameters(final Collection<AnnotatedCallable> annotatedCallables, final Set<Class<? extends Annotation>> annotationSet) { for (final AnnotatedCallable c : annotatedCallables) { if (containAnnotation(c.getParameters(), annotationSet)) { return true; } } return false; }
@Override public Set<Annotation> getAnnotations() { Set<Annotation> annotations = new HashSet<Annotation>( wrappedCallable.getAnnotations() ); annotations.add( methodValidationAnnotation ); return annotations; }
private Timer findTimer(final Executable executable) { if (timers == null) { synchronized (this) { if (timers == null) { timers = new ConcurrentHashMap<>(); } } } Timer timer = timers.get(executable); if (timer == null) { final AnnotatedType<?> type = beanManager.createAnnotatedType(bean.getBeanClass()); final Timed timed = Stream.concat(type.getMethods().stream(), type.getConstructors().stream()) .filter(it -> it.getJavaMember().equals(executable)) .findFirst() .map(m -> m.getAnnotation(Timed.class)) .orElse(null); final String name = Names.findName( Modifier.isAbstract(executable.getDeclaringClass().getModifiers()) ? type.getJavaClass() : executable.getDeclaringClass(), executable, timed == null ? null : timed.name(), timed != null && timed.absolute(), ofNullable(type.getAnnotation(Timed.class)).map(Timed::name).orElse("")); timer = Timer.class.cast(registry.getMetrics().get(name)); if (timer == null) { throw new IllegalStateException("No timer with name [" + name + "] found in registry [" + registry + "]"); } timers.putIfAbsent(executable, timer); } return timer; } }
@Override public ObserverMethodConfigurator<T> read(AnnotatedMethod<?> method) { checkArgumentNotNull(method); Set<AnnotatedParameter<?>> eventParameters = method.getParameters().stream() .filter((p) -> p.isAnnotationPresent(Observes.class) || p.isAnnotationPresent(ObservesAsync.class)).collect(Collectors.toSet()); checkEventParams(eventParameters, method.getJavaMember()); AnnotatedParameter<?> eventParameter = eventParameters.iterator().next(); Observes observesAnnotation = eventParameter.getAnnotation(Observes.class); if (observesAnnotation != null) { reception(observesAnnotation.notifyObserver()); transactionPhase(observesAnnotation.during()); } else { reception(eventParameter.getAnnotation(ObservesAsync.class).notifyObserver()); } Priority priority = method.getAnnotation(Priority.class); if (priority != null) { priority(priority.value()); } beanClass(eventParameter.getDeclaringCallable().getDeclaringType().getJavaClass()); observedType(eventParameter.getBaseType()); qualifiers(Configurators.getQualifiers(eventParameter)); return this; }
@Override public ParameterInjectionPointAttributes<?, ?> createInjectionPoint(AnnotatedParameter<?> parameter) { AnnotatedTypeValidator.validateAnnotatedParameter(parameter); EnhancedAnnotatedParameter<?, ?> enhancedParameter = services.get(MemberTransformer.class).loadEnhancedParameter(parameter, getId()); return validateInjectionPoint(InferringParameterInjectionPointAttributes.of(enhancedParameter, null, parameter.getDeclaringCallable().getDeclaringType().getJavaClass(), this)); }
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)); } } } }
@SpecAssertions({ @SpecAssertion(section = PROCESS_BEAN, id = "eba"), @SpecAssertion(section = PROCESS_BEAN, id = "ebb"), @SpecAssertion(section = PROCESS_BEAN, id = "edd"), @SpecAssertion(section = PROCESS_BEAN, id = "efd"), @SpecAssertion(section = PROCESS_BEAN, id = "fd"), @SpecAssertion(section = PROCESS_BEAN, id = "n"), @SpecAssertion(section = BEAN_DISCOVERY_STEPS, id = "jb"), @SpecAssertion(section = BEAN_DISCOVERY_STEPS, id = "jd") }) @Test public void testProcessProducerFieldEvent() { assertTrue(ProcessBeanObserver.getChickenBean().getTypes().contains(Chicken.class)); assertEquals(ProcessBeanObserver.getChickenBean().getBeanClass(), ChickenHutch.class); assertEquals(ProcessBeanObserver.getChickenField().getBaseType(), Chicken.class); assertEquals(ProcessBeanObserver.getChickenField().getDeclaringType().getBaseType(), ChickenHutch.class); // There are bugs in the API that mean generic type parameter ordering is wrong for ProcessProducerField and // ProcessProducerMethod // https://issues.jboss.org/browse/CDITCK-168 // https://issues.jboss.org/browse/WELD-586 assertEquals(ProcessBeanObserver.getChickenHutchProcessBeanCount(), 2); assertTrue(ProcessBeanObserver.getChickedAnnotated() instanceof AnnotatedField<?>); assertEquals(ProcessBeanObserver.getChickenField().getJavaMember().getName(), "chicken"); assertEquals(ProcessBeanObserver.getChickenField().getJavaMember().getDeclaringClass(), ChickenHutch.class); AnnotatedParameter<Chicken> disposedParam = ProcessBeanObserver.getChickenParameter(); assertNotNull(disposedParam); assertTrue(disposedParam.isAnnotationPresent(Disposes.class)); assertEquals(disposedParam.getBaseType(), Chicken.class); assertEquals(disposedParam.getDeclaringCallable().getJavaMember().getName(), "disposeOfRocky"); assertEquals(disposedParam.getDeclaringCallable().getJavaMember().getDeclaringClass(), ChickenHutch.class); assertEquals(disposedParam.getDeclaringCallable().getDeclaringType().getJavaClass(), ChickenHutch.class); assertEquals(ProcessBeanObserver.getChickenActionSeq().getData(), Arrays.asList(ProcessBeanAttributes.class.getName(), ProcessProducerField.class.getName())); }
@Override protected Class<?> getOwningClass() { return declaringCallable.getDeclaringType().getJavaClass(); }
public static <X> String createCallableId(AnnotatedCallable<X> method) { StringBuilder builder = new StringBuilder(); builder.append(method.getJavaMember().getDeclaringClass().getName()); builder.append('.'); builder.append(method.getJavaMember().getName()); builder.append(createAnnotationCollectionId(method.getAnnotations())); builder.append(createParameterListId(method.getParameters())); return builder.toString(); }
/** * Generates a deterministic signature for an {@link AnnotatedCallable}. Two <code>AnnotatedCallable</code>s that * have the same annotations and underlying callable will generate the same signature. */ public static <X> String createCallableId(AnnotatedCallable<X> method) { StringBuilder builder = new StringBuilder(); builder.append(method.getJavaMember().getDeclaringClass().getName()); builder.append('.'); builder.append(method.getJavaMember().getName()); builder.append(createAnnotationCollectionId(method.getAnnotations())); builder.append(createParameterListId(method.getParameters())); return builder.toString(); }
private static <X> boolean hasMethodParameters(AnnotatedCallable<X> callable) { for (AnnotatedParameter<X> parameter : callable.getParameters()) { if (!parameter.getAnnotations().isEmpty()) { return true; } } return false; }
public static boolean compareAnnotatedCallable(AnnotatedCallable<?> m1, AnnotatedCallable<?> m2) { if (!m1.getJavaMember().equals(m2.getJavaMember())) { return false; } if (!compareAnnotated(m1, m2)) { return false; } return compareAnnotatedParameters(m1.getParameters(), m2.getParameters()); }
@SpecAssertions({ @SpecAssertion(section = "11.5.8", id = "eaa"), @SpecAssertion(section = "11.5.8", id = "edc"), @SpecAssertion(section = "11.5.8", id = "efc"), @SpecAssertion(section = "11.5.8", id = "fc"), @SpecAssertion(section = "11.5.8", id = "i"), @SpecAssertion(section = "11.5.8", id = "j"), @SpecAssertion(section = "12.3", id = "ha") }) @Test public void testProcessProducerMethodEvent() { assert ProcessBeanObserver.getCowProcessProducerMethod().getBean().getTypes().contains(Cow.class); assert ProcessBeanObserver.getCowProcessProducerMethod().getBean().getBeanClass().equals(Cowshed.class); assert ProcessBeanObserver.getCowProcessProducerMethod().getAnnotatedProducerMethod().getBaseType().equals(Cow.class); assert ProcessBeanObserver.getCowProcessProducerMethod().getAnnotatedProducerMethod().getDeclaringType().getBaseType().equals(Cowshed.class); // This is intentionally disabled, there are bugs in the API that mean generic type parameter ordering is wrong for ProcessProducerField and ProcessProducerMethod //assert ProcessBeanObserver.getCowShedProcessBeanCount() == 1; assert ProcessBeanObserver.getCowProcessProducerMethod().getAnnotated() instanceof AnnotatedMethod<?>; assert ProcessBeanObserver.getCowProcessProducerMethod().getAnnotatedProducerMethod().getJavaMember().getName().equals("getDaisy"); assert ProcessBeanObserver.getCowProcessProducerMethod().getAnnotatedProducerMethod().getJavaMember().getDeclaringClass().equals(Cowshed.class); assert ProcessBeanObserver.getCowProcessProducerMethod().getAnnotatedDisposedParameter().getDeclaringCallable().getJavaMember().getName().equals("disposeOfDaisy"); assert ProcessBeanObserver.getCowProcessProducerMethod().getAnnotatedDisposedParameter().getDeclaringCallable().getJavaMember().getDeclaringClass().equals(Cowshed.class); }
InjectionPointImpl(InjectManager manager, InjectionTargetBuilder<T> target, AnnotatedParameter<?> param) { this(manager, target.getBean(), param, param.getDeclaringCallable().getJavaMember(), param.getBaseType()); _target = target; }
@Override public Member getMember() { return getAnnotated().getJavaMember(); }
protected static BaseType createBaseType(AnnotatedCallable<?> callable, Type type, HashMap<String,BaseType> paramMap) { if (callable != null && callable.getDeclaringType() != null) { AnnotatedType<?> declAnnType = callable.getDeclaringType(); String callableName = callable.getJavaMember().getName(); return createBaseType(declAnnType, type, paramMap, callableName); } return createBaseType(type); }
@Override public <A extends Annotation> A getQualifier(Class<A> annotationType) { A qualifier = getAnnotated().getAnnotation(annotationType); if (getQualifiers().contains(qualifier)) { return qualifier; } else { return null; } }
private void calculateEjbMethodInterceptors(BusinessMethodInterceptorInfo methodInterceptorInfo, Set<Interceptor<?>> allUsedEjbInterceptors, List<Interceptor<?>> classLevelEjbInterceptors, AnnotatedCallable annotatedMethod, boolean failOnFinal) { boolean unproxyable = isUnproxyable(annotatedMethod, failOnFinal); List<Interceptor<?>> methodInterceptors = new ArrayList<>(); if (classLevelEjbInterceptors != null && classLevelEjbInterceptors.size() > 0 && !unproxyable) { // add the class level defined Interceptors first ExcludeClassInterceptors excludeClassInterceptors = annotatedMethod.getAnnotation(ExcludeClassInterceptors.class); if (excludeClassInterceptors == null) { // but only if there is no exclusion of all class-level interceptors methodInterceptors.addAll(classLevelEjbInterceptors); } } collectEjbInterceptors(methodInterceptors, annotatedMethod, unproxyable, Collections.<Type>singleton(annotatedMethod.getJavaMember().getDeclaringClass())); allUsedEjbInterceptors.addAll(methodInterceptors); if (methodInterceptors.size() > 0) { methodInterceptorInfo.setEjbInterceptors(methodInterceptors); } }
@Override public Method getJavaMember() { return (Method) getWrappedCallable().getJavaMember(); } }