Examples with ProcessAnnotatedType javax.enterprise.inject.spi.ProcessAnnotatedType used on opensource projects

Example 1 with ProcessAnnotatedType

use of javax.enterprise.inject.spi.ProcessAnnotatedType in project jersey by jersey.

the class CdiComponentProvider method processAnnotatedType.

@SuppressWarnings("unused")
private void processAnnotatedType(@Observes final //                                              PathParam.class})
ProcessAnnotatedType processAnnotatedType) {
    final AnnotatedType<?> annotatedType = processAnnotatedType.getAnnotatedType();
    // if one of the JAX-RS annotations is present in the currently seen class, add it to the "whitelist"
    if (containsJaxRsConstructorInjection(annotatedType) || containsJaxRsFieldInjection(annotatedType) || containsJaxRsMethodInjection(annotatedType)) {
        jaxrsInjectableTypes.add(annotatedType.getBaseType());
    }
    if (customHk2TypesProvider != null) {
        final Type baseType = annotatedType.getBaseType();
        if (customHk2TypesProvider.getHk2Types().contains(baseType)) {
            processAnnotatedType.veto();
            jerseyVetoedTypes.add(baseType);
        }
    }
    if (containsJaxRsParameterizedCtor(annotatedType)) {
        processAnnotatedType.setAnnotatedType(new AnnotatedType() {

            @Override
            public Class getJavaClass() {
                return annotatedType.getJavaClass();
            }

            @Override
            public Set<AnnotatedConstructor> getConstructors() {
                final Set<AnnotatedConstructor> result = new HashSet<>();
                for (final AnnotatedConstructor c : annotatedType.getConstructors()) {
                    result.add(enrichedConstructor(c));
                }
                return result;
            }

            @Override
            public Set getMethods() {
                return annotatedType.getMethods();
            }

            @Override
            public Set getFields() {
                return annotatedType.getFields();
            }

            @Override
            public Type getBaseType() {
                return annotatedType.getBaseType();
            }

            @Override
            public Set<Type> getTypeClosure() {
                return annotatedType.getTypeClosure();
            }

            @Override
            public <T extends Annotation> T getAnnotation(final Class<T> annotationType) {
                return annotatedType.getAnnotation(annotationType);
            }

            @Override
            public Set<Annotation> getAnnotations() {
                return annotatedType.getAnnotations();
            }

            @Override
            public boolean isAnnotationPresent(final Class<? extends Annotation> annotationType) {
                return annotatedType.isAnnotationPresent(annotationType);
            }
        });
    }
}

Example 2 with ProcessAnnotatedType

use of javax.enterprise.inject.spi.ProcessAnnotatedType in project core by weld.

the class ContainerLifecyleObserverTest method testExtensionBuilder.

@SuppressWarnings({ "serial" })
@Test
public void testExtensionBuilder() {
    ActionSequence.reset();
    Extension myExtension = ContainerLifecycleObserver.extensionBuilder().add(beforeBeanDiscovery((e) -> addAction(BeforeBeanDiscovery.class.getSimpleName()))).add(afterTypeDiscovery().notify((e, b) -> {
        addAction(AfterTypeDiscovery.class.getSimpleName());
        e.addAnnotatedType(b.createAnnotatedType(Charlie.class), Charlie.class.getName());
    })).add(afterBeanDiscovery((e) -> {
        addAction(AfterBeanDiscovery.class.getSimpleName());
        e.addObserverMethod().beanClass(Foo.class).observedType(Foo.class).notifyWith((ctx) -> {
        });
        e.addBean().beanClass(Integer.class).addType(Integer.class).addQualifier(Juicy.Literal.INSTANCE).createWith((ctx) -> Integer.valueOf(10));
    })).add(afterDeploymentValidation((e) -> addAction(AfterDeploymentValidation.class.getSimpleName()))).add(beforeShutdown((e) -> addAction(BeforeShutdown.class.getSimpleName()))).build();
    Extension myExtension2 = ContainerLifecycleObserver.extensionBuilder().add(processAnnotatedType().withAnnotations(RequestScoped.class).notify((e) -> e.veto())).add(processBeanAttributes().notify((e) -> addAction(ProcessBeanAttributes.class.getSimpleName()))).add(processSyntheticAnnotatedType(new TypeLiteral<ProcessSyntheticAnnotatedType<?>>() {
    }.getType()).notify((e) -> addAction(ProcessSyntheticAnnotatedType.class.getSimpleName()))).add(processInjectionPoint().notify((e) -> addAction(ProcessInjectionPoint.class.getSimpleName()))).add(processProducer().notify((e) -> addAction(ProcessProducer.class.getSimpleName()))).add(processBean().notify((e) -> addAction(ProcessBean.class.getSimpleName()))).add(processManagedBean().notify((e) -> addAction(ProcessManagedBean.class.getSimpleName()))).add(processProducerField().notify((e) -> addAction(ProcessProducerField.class.getSimpleName()))).add(processProducerMethod().notify((e) -> {
        // Weld SE defines some producer methods, e.g. ParametersFactory
        addAction(ProcessProducerMethod.class.getSimpleName());
    })).add(processBeanAttributes().notify((e) -> addAction(ProcessBeanAttributes.class.getSimpleName()))).add(processObserverMethod().notify((e) -> addAction(ProcessObserverMethod.class.getSimpleName()))).add(processObserverMethod(new TypeLiteral<ProcessObserverMethod<String, ?>>() {
    }.getType()).notify((e) -> addAction(ProcessObserverMethod.class.getSimpleName() + String.class.getSimpleName()))).add(processSyntheticObserverMethod(new TypeLiteral<ProcessSyntheticObserverMethod<Foo, ?>>() {
    }.getType()).notify((e) -> addAction(ProcessSyntheticObserverMethod.class.getSimpleName() + Foo.class.getSimpleName()))).add(processSyntheticBean(new TypeLiteral<ProcessSyntheticBean<Integer>>() {
    }.getType()).notify((e) -> addAction(ProcessSyntheticBean.class.getSimpleName() + Integer.class.getSimpleName()))).build();
    try (WeldContainer container = new Weld().disableDiscovery().beanClasses(Foo.class, Bravo.class).addExtension(myExtension).addExtension(myExtension2).initialize()) {
        assertTrue(container.select(Foo.class).isUnsatisfied());
        assertFalse(container.select(Bravo.class).isUnsatisfied());
        Assert.assertEquals(Integer.valueOf(10), container.select(Integer.class, Juicy.Literal.INSTANCE).get());
    }
    ActionSequence.assertSequenceDataContainsAll(BeforeBeanDiscovery.class, AfterTypeDiscovery.class, AfterBeanDiscovery.class, AfterDeploymentValidation.class, BeforeShutdown.class);
    ActionSequence.assertSequenceDataContainsAll(ProcessBeanAttributes.class, ProcessSyntheticAnnotatedType.class, ProcessInjectionPoint.class, ProcessObserverMethod.class, ProcessBeanAttributes.class, ProcessProducer.class);
    ActionSequence.assertSequenceDataContainsAll(ProcessObserverMethod.class.getSimpleName() + String.class.getSimpleName(), ProcessSyntheticObserverMethod.class.getSimpleName() + Foo.class.getSimpleName(), ProcessSyntheticBean.class.getSimpleName() + Integer.class.getSimpleName());
    ActionSequence.assertSequenceDataContainsAll(ProcessBean.class, ProcessManagedBean.class, ProcessProducerMethod.class, ProcessProducerField.class);
}

Example 3 with ProcessAnnotatedType

use of javax.enterprise.inject.spi.ProcessAnnotatedType in project core by weld.

the class ProbeExtensionsTest method testExtensionVisibleInProbe.

@Test
public void testExtensionVisibleInProbe() throws IOException {
    JsonObject beansInTestArchive = getPageAsJSONObject(BEANS_PATH_ALL, url);
    assertNotNull(beansInTestArchive);
    JsonArray beansArray = beansInTestArchive.getJsonArray(DATA);
    ReadContext ctx = JsonPath.parse(beansInTestArchive.toString());
    List<String> beanClasses = ctx.read("$." + DATA + "[*]." + BEAN_CLASS, List.class);
    assertBeanClassVisibleInProbe(TestExtension.class, beanClasses);
    // test extension attributes
    JsonObject extensionBeanDetail = getBeanDetail(BEANS_PATH_ALL, TestExtension.class, url);
    assertEquals(BeanType.EXTENSION.name(), extensionBeanDetail.getString(KIND));
    ctx = JsonPath.parse(extensionBeanDetail.toString());
    List<String> observedTypes = ctx.read("$." + DECLARED_OBSERVERS + "[*]." + OBSERVED_TYPE, List.class);
    assertTrue("Cannot find ProcessAnnotatedType observer method!", observedTypes.contains(ProcessAnnotatedType.class.getName() + "<DummyBean>"));
    // test bean altered by extension
    JsonObject dummyBeanDetail = getBeanDetail(BEANS_PATH_ALL, DummyBean.class, url);
    ctx = JsonPath.parse(dummyBeanDetail.toString());
    List<String> qualifiers = ctx.read("$." + QUALIFIERS + "[*]", List.class);
    assertTrue("Cannot find " + Collector.class + " qualifier on " + DummyBean.class, qualifiers.contains("@" + Collector.class.getName().concat("(value=\"\")")));
}

Example 4 with ProcessAnnotatedType

use of javax.enterprise.inject.spi.ProcessAnnotatedType in project core by weld.

the class FastProcessAnnotatedTypeResolver method process.

private void process(ContainerLifecycleEventObserverMethod<?> observer, Type observedType) throws UnsupportedObserverMethodException {
    if (Object.class.equals(observedType)) {
        // void observe(Object event)
        catchAllObservers.add(observer);
    } else if (ProcessAnnotatedType.class.equals(observedType)) {
        // void observe(ProcessAnnotatedType event)
        catchAllObservers.add(observer);
    } else if (observedType instanceof ParameterizedType) {
        ParameterizedType type = (ParameterizedType) observedType;
        if (ProcessAnnotatedType.class.equals(type.getRawType())) {
            Type typeParameter = type.getActualTypeArguments()[0];
            if (typeParameter instanceof Class<?>) {
                this.observers.put(observer, new ExactTypePredicate(Reflections.getRawType(typeParameter)));
            } else if (typeParameter instanceof ParameterizedType) {
                /*
                     * The event type always has the form of ProcessAnnotatedType<X> where X is a raw type.
                     * Therefore, no event will ever match an observer with type ProcessAnnotatedType<Foo<Y>> no matter
                     * what Y is. This would be because primarily because parameterized are invariant. Event for an exact match
                     * of the raw type, Foo raw event type is not assignable to Foo<?> parameterized type according to CDI assignability rules.
                     */
                return;
            } else if (typeParameter instanceof WildcardType) {
                // void observe(ProcessAnnotatedType<?> event)
                WildcardType wildCard = (WildcardType) typeParameter;
                checkBounds(observer, wildCard.getUpperBounds());
                this.observers.put(observer, CompositePredicate.assignable(Types.getRawTypes(wildCard.getUpperBounds())));
            } else if (typeParameter instanceof TypeVariable<?>) {
                // <T> void observe(ProcessAnnotatedType<T> event)
                TypeVariable<?> variable = (TypeVariable<?>) typeParameter;
                checkBounds(observer, variable.getBounds());
                this.observers.put(observer, CompositePredicate.assignable(Types.getRawTypes(variable.getBounds())));
            }
        }
    } else if (observedType instanceof TypeVariable<?>) {
        defaultRules(observer, observedType);
    }
}

Example 5 with ProcessAnnotatedType

use of javax.enterprise.inject.spi.ProcessAnnotatedType in project kie-wb-common by kiegroup.

the class ControllerExtensionTest method createAnnotatedType.

protected ProcessAnnotatedType createAnnotatedType(final Class aClass) {
    final ProcessAnnotatedType processAnnotatedType = mock(ProcessAnnotatedType.class);
    final AnnotatedType annotatedType = mock(AnnotatedType.class);
    when(processAnnotatedType.getAnnotatedType()).thenReturn(annotatedType);
    when(annotatedType.getJavaClass()).thenReturn(aClass);
    return processAnnotatedType;
}