Java 类javax.ejb.Stateless 实例源码

/**
 * Reads EJB {@link Stateless} bean names from appropriated archives
 *
 * @param archives
 * @return
 * @throws IOException
 */
private Set<String> readBeanNames(URL[] archives) throws IOException {

    Set<String> beanNames;

    URL[] fullArchives = getFullArchives(archives);
    annotationFinder = new AnnotationFinder();
    annotationFinder.setScanFieldAnnotations(Boolean.FALSE);
    annotationFinder.setScanParameterAnnotations(Boolean.FALSE);
    annotationFinder.setScanMethodAnnotations(Boolean.FALSE);
    annotationFinder.scanArchives(fullArchives);
    beanNames = annotationFinder.getAnnotationIndex().get(Stateless.class.getName());
    classOwnersURL = annotationFinder.getClassOwnersURLs();

    return beanNames;
}

public synchronized Collection<EjbDescriptorImpl<?>> getEjbs() {
    if (ejbs == null) {
        ejbs = classpathEntry.annotatedWith(Singleton.class, Stateless.class, Stateful.class).stream()
                .map(this::toEjbDescriptor)
                .collect(Collectors.toSet());
    }
    return ejbs;
}

@Override
public boolean isNeglectableClass(Class<?> clazz) {
    boolean isNoClass = clazz.isEnum() || clazz.isInterface()
            || Modifier.isAbstract(clazz.getModifiers());
    Stateless annotation = clazz.getAnnotation(Stateless.class);
    return !(annotation != null && !isNoClass);
}

@Override
public boolean isNeglectableClass(Class<?> clazz) {
    boolean isNoClass = clazz.isEnum() || clazz.isInterface()
            || Modifier.isAbstract(clazz.getModifiers());
    Stateless annotation = clazz.getAnnotation(Stateless.class);
    return !(annotation != null && !isNoClass);
}

private SessionType getSessionType(final Class<?> clazz) {
    if (clazz.isAnnotationPresent(Stateful.class)) {
        return SessionType.STATEFUL;
    }
    if (clazz.isAnnotationPresent(Stateless.class)) {
        return SessionType.STATELESS;
    }
    if (clazz.isAnnotationPresent(Singleton.class)) {
        return SessionType.SINGLETON;
    }
    if (clazz.isAnnotationPresent(ManagedBean.class)) {
        return SessionType.MANAGED;
    }
    return null;
}

/**
    * Gets EJB bean name from passed {@link Class} instance
    *
    * @param beanClass
    * @return {@link String} EJB bean name
    */
   public static String beanName(Class<?> beanClass) {

String beanEjbName;

Stateless annotation = beanClass.getAnnotation(Stateless.class);
beanEjbName = annotation.name();
if (StringUtils.invalid(beanEjbName)) {
    beanEjbName = beanClass.getSimpleName();
}

return beanEjbName;
   }

@Override
public boolean isStateless() {
    return getBeanClass().getAnnotation(Stateless.class) != null;
}

private String getEjbName(final Stateless stateless, final Class<?> beanClass) {
    return stateless.name().isEmpty() ? beanClass.getSimpleName() : stateless.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;
}

private static boolean isEJB(final Class<?> clazz) {
    return clazz.isAnnotationPresent(Stateless.class)
        || clazz.isAnnotationPresent(Singleton.class)
        || clazz.isAnnotationPresent(ManagedBean.class)  // what a weird idea!
        || clazz.isAnnotationPresent(Stateful.class); // what another weird idea!
}

/**
 * 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);
    }
}