Java Singleton类代码示例

import javax.ejb.Singleton; //导入依赖的package包/类
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;
}
 

import javax.ejb.Singleton; //导入依赖的package包/类
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;
}
 

import javax.ejb.Singleton; //导入依赖的package包/类
@Override
public boolean isSingleton() {
    return getBeanClass().getAnnotation(Singleton.class) != null;
}
 

import javax.ejb.Singleton; //导入依赖的package包/类
private String getEjbName(final Singleton singleton, final Class<?> beanClass) {
    return singleton.name().isEmpty() ? beanClass.getSimpleName() : singleton.name();
}
 

import javax.ejb.Singleton; //导入依赖的package包/类
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;
}
 

import javax.ejb.Singleton; //导入依赖的package包/类
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!
}
 

import javax.ejb.Singleton; //导入依赖的package包/类
/**
 * 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);
    }
}