Java 类javax.ejb.MessageDriven 实例源码

private static <T> JMSContextMock messageDrivenBean(T bean, Class<? extends T> beanType) {
    if (MessageListener.class.isAssignableFrom(beanType)) {
        MessageDriven md = beanType.getAnnotation(MessageDriven.class);
        Collection<ActivationConfigProperty> properties = asList(md.activationConfig());
        ActiveMQDestination destination = lookupDestination(properties);
        CTX.startBrokerIfAbsent();
        try {
            JMSContextMock ctx = new JMSContextMock(CTX.getConnectionFactory(),
                    lookupClientId(properties, destination.getPhysicalName()),
                    false,
                    lookupAcknowledgeMode(properties));
            createConsumer(properties, ctx.getSession(), destination)
                    .setMessageListener(new JMS20MessageListenerDecorator<>((MessageListener) bean));
            return ctx;
        } catch (JMSException e) {
            throw new EJBException(e.getLocalizedMessage(), e);
        }
    } else {
        throw new EJBException("The message driven bean \""
                + beanType.getName()
                + "\" must implement the appropriate message listener interface \""
                + MessageDriven.class.getName()
                + "\".");
    }
}

public <X> void beans(
        final @Observes ProcessAnnotatedType<X> processBean
) {
    final MessageDriven annotation = processBean.getAnnotatedType().getAnnotation(MessageDriven.class);
    if (annotation != null) {
        final Class<X> javaClass = processBean.getAnnotatedType().getJavaClass();
        if (!MessageListener.class.isAssignableFrom(javaClass)) {
            throw new TestEEfiException("The @MessageDriven bean " + javaClass.getName()
                    + " does not implement MessageListener"
            );
        }
        registry.register(annotation, (Class<? extends MessageListener>) javaClass);
    }
}

@Override
public <T> T bindContext(T bean, Class<?> beanType) {
    if (beanType.isAnnotationPresent(MessageDriven.class)) {
        MDCTX.get().computeIfAbsent(bean, b -> messageDrivenBean(bean, beanType));
    }
    return bean;
}

@Override
public <T> Optional<Object> lookupOf(Class<?> declaredInjectionType, Resource injectionAnnotation, T bean, Class<? extends T> beanType) {
    String mapping = injectionAnnotation.mappedName();
    if (mapping == null) mapping = injectionAnnotation.lookup();
    switch (mapping) {
        case "jms/ConnectionFactory": // Java EE spec
        case "java:/ConnectionFactory": // Java EE spec
        case "/ConnectionFactory": // JBoss
        case "java:comp/DefaultJMSConnectionFactory": // JBoss
        case "java:jboss/DefaultJMSConnectionFactory": // JBoss
        case "java:/JmsXA":
            return of(connectionFactory);

        case "java:jms/queue/test": // Java EE spec
        case "jms/queue/test": // Java EE spec
        case "queue/test": // JBoss
        case "/jms/queue/test": // JBoss
        case "/queue/test": // JBoss
            sanityCheckQueue(injectionAnnotation.type(), mapping, beanType);
            if (beanType.isAnnotationPresent(MessageDriven.class)) {
                if (MessageListener.class.isAssignableFrom(beanType)) {
                    try {
                        consumer.getMessageConsumer().setMessageListener((MessageListener) bean);
                    } catch (JMSException e) {
                        throw new IllegalStateException(e.getLocalizedMessage(), e);
                    }
                } else {
                    throw new EJBException("The message driven bean \""
                            + beanType.getName()
                            + "\" must implement the appropriate message listener interface \""
                            + MessageDriven.class.getName()
                            + "\".");
                }
            }
            return of(producer.getDestination());

        default:
            return empty();
    }
}

public <X extends  MessageListener> void register(final MessageDriven annotation, final Class<X> javaClass) {
    LOG.info("{} -> {}", annotation.mappedName(), javaClass.getName());
    messageDrivenBeans.put(annotation.mappedName(), javaClass);
}

private String getEjbName(final MessageDriven mdb, final Class<?> beanClass) {
    return mdb.name().isEmpty() ? beanClass.getSimpleName() : mdb.name();
}

private boolean isValidEjbAnnotationUsage(final Class annotationClass, final Annotated<Class<?>> beanClass, final String ejbName, final EjbModule ejbModule) {
    final List<Class<? extends Annotation>> annotations = new ArrayList(Arrays.asList(Singleton.class, Stateless.class, Stateful.class, MessageDriven.class));
    annotations.remove(annotationClass);

    final boolean b = true;
    for (final Class<? extends Annotation> secondAnnotation : annotations) {
        final Annotation annotation = beanClass.getAnnotation(secondAnnotation);

        if (annotation == null) {
            continue;
        }

        String secondEjbName = null;
        if (annotation instanceof Stateful) {
            secondEjbName = getEjbName((Stateful) annotation, beanClass.get());
        } else if (annotation instanceof Stateless) {
            secondEjbName = getEjbName((Stateless) annotation, beanClass.get());
        } else if (annotation instanceof Singleton) {
            secondEjbName = getEjbName((Singleton) annotation, beanClass.get());
        } else if (annotation instanceof MessageDriven) {
            secondEjbName = getEjbName((MessageDriven) annotation, beanClass.get());
        }

        if (ejbName.equals(secondEjbName)) {
            ejbModule.getValidation().fail(ejbName, "multiplyAnnotatedAsBean", annotationClass.getSimpleName(), secondAnnotation.getSimpleName(), ejbName, beanClass.get().getName());
        }
    }

    if (beanClass.get().isInterface()) {
        if (!CheckClasses.isAbstractAllowed(beanClass.get())) {
            ejbModule.getValidation().fail(ejbName, "interfaceAnnotatedAsBean", annotationClass.getSimpleName(), beanClass.get().getName());
            return false;
        }
    } else if (Modifier.isAbstract(beanClass.get().getModifiers())) {
        if (!CheckClasses.isAbstractAllowed(beanClass.get())) {
            ejbModule.getValidation().fail(ejbName, "abstractAnnotatedAsBean", annotationClass.getSimpleName(), beanClass.get().getName());
            return false;
        }
    }

    return b;
}

/**
 * Replaces the meta data of the {@link ProcessAnnotatedType}.
 * 
 * <p>
 * The ProcessAnnotatedType's meta data will be replaced, if the annotated type has one of the following annotations:
 * <ul>
 * <li> {@link Stateless}
 * <li> {@link MessageDriven}
 * <li> {@link Interceptor}
 * <li> {@link Singleton}
 * </ul>
 *
 * @param <X> the type of the ProcessAnnotatedType
 * @param pat the annotated type representing the class being processed
 */
public <X> void processInjectionTarget(@Observes @WithAnnotations({Stateless.class, MessageDriven.class, Interceptor.class, Singleton.class}) ProcessAnnotatedType<X> pat) {
    if (pat.getAnnotatedType().isAnnotationPresent(Stateless.class) || pat.getAnnotatedType().isAnnotationPresent(MessageDriven.class)) {
        modifiyAnnotatedTypeMetadata(pat);
    } else if (pat.getAnnotatedType().isAnnotationPresent(Interceptor.class)) {
        processInterceptorDependencies(pat);
    } else if(pat.getAnnotatedType().isAnnotationPresent(Singleton.class)) {
        addApplicationScopedAndTransactionalToSingleton(pat);
    }
}