Java Code Examples for javax.enterprise.inject.spi.ProcessProducer#getProducer()

/**
 * Scans for a configurer producer.
 *
 * @param processProducer process producer event.
 */
<T> void processConfigurerProducer(
        @Observes final ProcessProducer<T, Configurer> processProducer) {
    // TODO Handle multiple producer definitions.

    logger.debug("Producer for configurer found: {}.", processProducer.getProducer());

    this.configurerProducer = processProducer.getProducer();
}
 

<T> void processEventProcessingConfigurationProducer(
        @Observes final ProcessProducer<T, EventProcessingConfiguration> processProducer) {
    // TODO Handle multiple producer definitions.

    logger.debug("Producer for event processing configuration found: {}.",
            processProducer.getProducer());

    this.eventProcessingConfigurationProducer = processProducer.getProducer();
}
 

<T> void processEventHandlingConfigurationProducer(
        @Observes final ProcessProducer<T, EventHandlingConfiguration> processProducer) {
    // TODO Handle multiple producer definitions.

    logger.debug("Producer for event handling configuration found: {}.",
            processProducer.getProducer());

    this.eventHandlingConfigurationProducer = processProducer.getProducer();
}
 

<T> void processDeadlineManagerProducer(
        @Observes final ProcessProducer<T, DeadlineManager> processProducer) {
    // TODO Handle multiple producer definitions.

    logger.debug("Producer for deadline manager found: {}.", processProducer.getProducer());

    this.deadlineManagerProducer = processProducer.getProducer();
}
 

<T> void processQueryUpdateEmitterProducer(
        @Observes final ProcessProducer<T, QueryUpdateEmitter> processProducer) {
    // TODO Handle multiple producer definitions.

    logger.debug("Producer for query update emitter found: {}.", processProducer.getProducer());

    this.queryUpdateEmitterProducer = processProducer.getProducer();
}
 

<T> void processQueryGatewayProducer(
        @Observes final ProcessProducer<T, QueryGateway> processProducer) {
    // TODO Handle multiple producer definitions.

    logger.debug("Producer for query gateway found: {}.",
            processProducer.getProducer());

    this.queryGatewayProducer = processProducer.getProducer();
}
 

<T> void processQueryBusProducer(
        @Observes final ProcessProducer<T, QueryBus> processProducer) {
    // TODO Handle multiple producer definitions.

    logger.debug("Producer for query bus found: {}.",
            processProducer.getProducer());

    this.queryBusProducer = processProducer.getProducer();
}
 

<T> void processListenerInvocationErrorHandlerProducer(
        @Observes final ProcessProducer<T, ListenerInvocationErrorHandler> processProducer) {
    // TODO Handle multiple producer definitions.

    logger.debug("Producer for listener invocation error handler found: {}.",
            processProducer.getProducer());

    this.listenerInvocationErrorHandlerProducer = processProducer.getProducer();
}
 

<T> void processErrorHandlerProducer(
        @Observes final ProcessProducer<T, ErrorHandler> processProducer) {
    // TODO Handle multiple producer definitions.

    logger.debug("Producer for error handler found: {}.", processProducer.getProducer());

    this.errorHandlerProducer = processProducer.getProducer();
}
 

/**
 * Scans for a token store producer.
 *
 * @param processProducer process producer event.
 */
<T> void processTokenStoreProducer(
        @Observes final ProcessProducer<T, TokenStore> processProducer) {
    // TODO Handle multiple producer definitions.

    logger.debug("Producer for token store found: {}.", processProducer.getProducer());

    this.tokenStoreProducer = processProducer.getProducer();
}
 

/**
 * Scans for an entity manager provider producer.
 *
 * @param processProducer process producer event.
 */
<T> void processEntityManagerProviderProducer(
        @Observes final ProcessProducer<T, EntityManagerProvider> processProducer) {
    // TODO Investigate if there is a way to look up the entity manager
    // from the environment. There likely isn't.
    // TODO Handle multiple producer definitions.

    logger.debug("Producer for entity manager provider found: {}.",
            processProducer.getProducer());

    this.entityManagerProviderProducer = processProducer.getProducer();
}
 

/**
 * Scans for a command bus producer.
 *
 * @param processProducer process producer event.
 */
<T> void processCommandBusProducer(
        @Observes final ProcessProducer<T, CommandBus> processProducer) {
    // TODO Handle multiple producer definitions.

    logger.debug("Producer for command bus found: {}.",
            processProducer.getProducer());

    this.commandBusProducer = processProducer.getProducer();
}
 

/**
 * Scans for an event bus producer.
 *
 * @param processProducer process producer event.
 */
<T> void processEventBusProducer(
        @Observes final ProcessProducer<T, EventBus> processProducer) {
    // TODO Handle multiple producer definitions.

    logger.debug("Producer for event bus found: {}.", processProducer.getProducer());

    this.eventBusProducer = processProducer.getProducer();
}
 

/**
 * Scans for a serializer producer.
 *
 * @param processProducer process producer event.
 */
<T> void processSerializerProducer(
        @Observes final ProcessProducer<T, Serializer> processProducer) {
    // TODO Handle multiple serializer definitions of the same type.

    AnnotatedMember<T> annotatedMember = processProducer.getAnnotatedMember();
    Named named = annotatedMember.getAnnotation(Named.class);

    if (named != null) {
        String namedValue = named.value();
        String serializerName = "".equals(namedValue)
                ? annotatedMember.getJavaMember().getName()
                : namedValue;
        switch (serializerName) {
            case "eventSerializer":
                logger.debug("Producer for event serializer found: {}.",
                        processProducer.getProducer());
                eventSerializerProducer = processProducer.getProducer();
                break;
            case "messageSerializer":
                logger.debug("Producer for message serializer found: {}.",
                        processProducer.getProducer());
                messageSerializerProducer = processProducer.getProducer();
                break;
            case "serializer":
                logger.debug("Producer for serializer found: {}.",
                        processProducer.getProducer());
                this.serializerProducer = processProducer.getProducer();
                break;
            default:
                logger.warn("Unknown named serializer configured: " + serializerName);
        }
    } else {
        logger.debug("Producer for serializer found: {}.", processProducer.getProducer());
        this.serializerProducer = processProducer.getProducer();
    }
}
 

/**
 * Scans for a transaction manager producer.
 *
 * @param processProducer process producer event.
 */
<T> void processTransactionManagerProducer(
        @Observes final ProcessProducer<T, TransactionManager> processProducer) {
    // TODO Handle multiple producer definitions.

    logger.debug("Producer for transaction manager found: {}.",
            processProducer.getProducer());

    this.transactionManagerProducer = processProducer.getProducer();
}
 

/**
 * Scans for an event storage engine producer.
 *
 * @param processProducer process producer event.
 */
// Mark: I know these seem especially frivolous and looks like they may be
// replaced with post deployment look-ups or injection of some kind.
// Unfortunately I don't think it is that straightforwards for reasons 
// explained a bit later. That said, I do want to discuss these with you.
<T> void processEventStorageEngineProducer(
        @Observes final ProcessProducer<T, EventStorageEngine> processProducer) {
    // TODO Handle multiple producer definitions.

    logger.debug("Producer for event storage engine found: {}.",
            processProducer.getProducer());

    this.eventStorageEngineProducer = processProducer.getProducer();
}
 

public <X, T> void onProcessProducer(@Observes ProcessProducer<X, T> processProducer, BeanManager beanManager)
{
    if (!isActivated)
    {
        return;
    }

    for (MockFilter mockFilter : mockFilters)
    {
        if (!mockFilter.isMockedImplementationSupported(beanManager, processProducer.getAnnotatedMember()))
        {
            return;
        }
    }

    final Producer<T> originalProducer = processProducer.getProducer();
    AnnotatedMember<X> annotatedMember = processProducer.getAnnotatedMember();
    List<Annotation> qualifiers = new ArrayList<Annotation>();
    for (Annotation annotation : annotatedMember.getAnnotations())
    {
        if (beanManager.isQualifier(annotation.annotationType()))
        {
            qualifiers.add(annotation);
        }
    }

    Typed typed = annotatedMember.getAnnotation(Typed.class);

    List<Type> foundTypes = new ArrayList<Type>();
    if (typed != null)
    {
        Collections.addAll(foundTypes, typed.value());
    }
    else if (annotatedMember.getBaseType() instanceof Class)
    {
        foundTypes.addAll(extractTypes((Class)annotatedMember.getBaseType()));
    }

    if (foundTypes.isEmpty())
    {
        return;
    }

    processProducer.setProducer(new MockAwareProducerWrapper<T>(
        beanManager, originalProducer, foundTypes, qualifiers));
}