Refine search
/** * Wraps all JAR-RS components by Jersey-specific injection target. * * @param pit process injection target. * @param <T> type of the processed injection target. */ public <T> void observeInjectionTarget(@Observes ProcessInjectionTarget<T> pit) { BasicInjectionTarget<T> it = (BasicInjectionTarget<T>) pit.getInjectionTarget(); JerseyInjectionTarget<T> jerseyInjectionTarget = new JerseyInjectionTarget<>(it, pit.getAnnotatedType().getJavaClass()); jerseyInjectionTargets.add(jerseyInjectionTarget); pit.setInjectionTarget(jerseyInjectionTarget); }
protected <T> InjectionTarget<T> wrapInjectionTarget(ProcessInjectionTarget<T> event) { return new JaxrsInjectionTarget<T>(event.getInjectionTarget(), event.getAnnotatedType().getJavaClass()); }
public <T> void process(@Observes ProcessInjectionTarget<T> event) { final InjectionTarget<T> injectionTarget = event.getInjectionTarget(); event.setInjectionTarget(new InjectionTarget<T>() {
public void processInjectionTargets(@Observes ProcessInjectionTarget<?> event, BeanManager beanManager) { probe.getBootstrapStats().increment(EventType.PIT); if (eventMonitorContainerLifecycleEvents) { addContainerLifecycleEvent(event, Formats.formatType(event.getAnnotatedType().getBaseType(), false), beanManager); } }
public void processCatProducer(@Observes ProcessInjectionTarget<Cat> event) { catInjectionTarget = event.getInjectionTarget(); }
public void observeSessionBeanInterceptor(@Observes ProcessInjectionTarget<SheepInterceptor> event) { sessionBeanInterceptorType = event.getAnnotatedType(); }
<T> void processInjectionTarget(@Observes ProcessInjectionTarget<T> event) { LOGGER.fine("Handling ProcessInjectionTarget event for " + event.getAnnotatedType().getJavaClass().getName()); }
/** * Gather Application or resource classes to start. * * @param pit injection target * @param <T> any type */ @SuppressWarnings("unchecked") public <T> void gatherApplications(@Observes ProcessInjectionTarget<T> pit) { AnnotatedType<T> at = pit.getAnnotatedType(); if (!at.isAnnotationPresent(ApplicationScoped.class)) { return; } // class is annotated, let's make sure it is an application Class<?> theClass = at.getJavaClass(); if (Application.class.isAssignableFrom(theClass)) { this.applications.add((Class<? extends Application>) theClass); } else { // still may be a jax-rs resource (with no application attached) if (at.isAnnotationPresent(Path.class)) { this.resourceClasses.add(theClass); } } }
<X> void registerGenericBeanInjectionTarget(@Observes ProcessInjectionTarget<X> event) { AnnotatedType<X> type = event.getAnnotatedType(); if (type.isAnnotationPresent(GenericConfiguration.class)) { genericInjectionTargets.put(type, event.getInjectionTarget()); } }
public void processDogInjectionTarget(@Observes ProcessInjectionTarget<Dog> injectionTargetEvent) { // There a couple, but it does not matter which one is used for the tests dogInjectionTarget = injectionTargetEvent.getInjectionTarget(); dogAnnotatedType = injectionTargetEvent.getAnnotatedType(); }
@LazyExtension @SuppressWarnings({ "unchecked" }) public void processTarget(@Observes ProcessInjectionTarget<?> event) { AnnotatedType<?> type = event.getAnnotatedType(); XmlCookie cookie = type.getAnnotation(XmlCookie.class); if (cookie != null) { InjectionTarget target = _cdiManager .getXmlInjectionTarget(cookie.value()); event.setInjectionTarget(target); } }
public void processDogInjectionTarget(@Observes ProcessInjectionTarget<Dog> injectionTargetEvent) { // Add an exception as a definition error injectionTargetEvent.addDefinitionError(new RuntimeException("Should abort processing after bean discovery")); }
public void processInjectionTarget(@Observes ProcessInjectionTarget<?> pit, BeanManager beanManager) { Set<InjectionPoint> ips = pit.getInjectionTarget().getInjectionPoints(); for(InjectionPoint ip : ips) { Set<Type> beanTypes = annotatedType.getTypeClosure();
<X> void detectInjections(@Observes ProcessInjectionTarget<X> event) { for (InjectionPoint ip : event.getInjectionTarget().getInjectionPoints()) { Annotated annotated = ip.getAnnotated(); for (Class<? extends Annotation> paramAnnotationType : producerBlueprints.keySet()) { for (Annotation q : ip.getQualifiers()) { if (!allowed.contains(q)) { event.addDefinitionError(new IllegalArgumentException(messages.additionalQualifiersNotPermitted( paramAnnotationType.getSimpleName(), ip))); error = true; event.addDefinitionError(new IllegalArgumentException(messages.rawTypeRequired( paramAnnotationType.getSimpleName(), ip))); break; event.addDefinitionError(new IllegalArgumentException(messages.noConverterForType( paramAnnotationType.getSimpleName(), ip)));
void execute() { event.getAnnotatedType(); } }.run();
void execute() { event.getInjectionTarget(); } }.run();
void execute() { event.setInjectionTarget(target); } }.run();
void execute() { event.addDefinitionError(new NullPointerException()); } }.run();
public <T> void process(@Observes ProcessInjectionTarget<T> event) { final InjectionTarget<T> injectionTarget = event.getInjectionTarget(); event.setInjectionTarget(new InjectionTarget<T>() { public T produce(CreationalContext<T> ctx) { T o = injectionTarget.produce(ctx); MockitoAnnotations.initMocks(o); return o; } public void dispose(T instance) { injectionTarget.dispose(instance); } public Set<InjectionPoint> getInjectionPoints() { return injectionTarget.getInjectionPoints(); } public void inject(T instance, CreationalContext<T> ctx) { injectionTarget.inject(instance, ctx); } public void postConstruct(T instance) { injectionTarget.postConstruct(instance); } public void preDestroy(T instance) { injectionTarget.preDestroy(instance); } }); }
public void processInjectionTargets(@Observes ProcessInjectionTarget<?> event, BeanManager beanManager) { probe.getBootstrapStats().increment(EventType.PIT); if (eventMonitorContainerLifecycleEvents) { addContainerLifecycleEvent(event, Formats.formatType(event.getAnnotatedType().getBaseType(), false), beanManager); } }