public static void validatePassivating(Class<?> cl, Bean<?> bean, String typeName) { Class<?> beanClass = bean.getBeanClass(); if (!Serializable.class.isAssignableFrom(beanClass) && false) { ConfigException exn = new ConfigException( L.l( "{0}: {1} is an invalid {2} because it is not serializable.", cl.getName(), bean, typeName)); throw exn; // InjectManager.create().addDefinitionError(exn); } for (InjectionPoint ip : bean.getInjectionPoints()) { if (ip.isTransient() || ip.isDelegate()) continue; Class<?> type = getRawClass(ip.getType()); if (type.isInterface()) continue; if (!Serializable.class.isAssignableFrom(type)) { ConfigException exn = new ConfigException( L.l( "{0}: {1} is an invalid {4} because its injection point '{2}' of type {3} is not serializable.", cl.getName(), bean, ip.getMember().getName(), ip.getType(), typeName)); throw exn; } } }
private void validateDecorators(BeanManagerImpl beanManager, AbstractClassBean<?> classBean) { if (classBean.getDecorators().size() > 0) { boolean passivationCapabilityCheckRequired = isPassivationCapabilityCheckRequired(beanManager, classBean); for (Decorator<?> decorator : classBean.getDecorators()) { if (passivationCapabilityCheckRequired) { boolean isSerializable = (decorator instanceof WeldDecorator<?>) ? (((WeldDecorator<?>) decorator).getWeldAnnotated().isSerializable()) : (decorator instanceof PassivationCapable); if (!isSerializable) { throw new UnserializableDependencyException( PASSIVATING_BEAN_WITH_NONSERIALIZABLE_DECORATOR, classBean, decorator); } } for (InjectionPoint ij : decorator.getInjectionPoints()) { if (!ij.isDelegate()) { Bean<?> resolvedBean = beanManager.resolve(beanManager.getBeans(ij)); validateInjectionPoint(ij, beanManager); if (passivationCapabilityCheckRequired) { validateInjectionPointPassivationCapable(ij, resolvedBean, beanManager); } } } } } }
private void validateInjectionPoints(Set<InjectionPoint> injectionPoints) { assertEquals(2, injectionPoints.size()); for (InjectionPoint ip : injectionPoints) { AnnotatedParameter<Factory> parameter = this.<AnnotatedParameter<Factory>>cast(ip.getAnnotated()); if (parameter.getPosition() == 0) { // BeanManager assertEquals(BeanManager.class, parameter.getBaseType()); } else if (parameter.getPosition() == 1) { // SpaceSuit<Toy> Type baseType = parameter.getBaseType(); if (baseType instanceof ParameterizedType && ((ParameterizedType) baseType).getRawType() instanceof Class<?>) { assertEquals(((ParameterizedType) baseType).getRawType(), SpaceSuit.class); } else { fail(); } } else { fail("Unexpected injection point " + ip); } assertFalse(ip.isDelegate()); assertFalse(ip.isTransient()); assertNull(ip.getBean()); } }
private static InjectionPoint getDelegate(Decorator<?> bean) { if (bean instanceof DecoratorBean) return ((DecoratorBean) bean).getDelegateInjectionPoint(); for (InjectionPoint ip : bean.getInjectionPoints()) { if (ip.isDelegate()) return ip; } throw new IllegalStateException(String.valueOf(bean)); }
/** * Variation of the validateInjectionPoint method which allows the bean to be defined explicitly * (used for disposer method validation) */ public void validateInjectionPoint(InjectionPoint ij, Bean<?> bean, BeanManagerImpl beanManager) { if (ij.getAnnotated().getAnnotation(New.class) != null && ij.getQualifiers().size() > 1) { throw new DefinitionException(NEW_WITH_QUALIFIERS, ij); } if (ij.getType().equals(InjectionPoint.class) && bean == null) { throw new DefinitionException(INJECTION_INTO_NON_BEAN, ij); } if (ij.getType().equals(InjectionPoint.class) && !Dependent.class.equals(bean.getScope())) { throw new DefinitionException(INJECTION_INTO_NON_DEPENDENT_BEAN, ij); } if (ij.getType() instanceof TypeVariable<?>) { throw new DefinitionException(INJECTION_POINT_WITH_TYPE_VARIABLE, ij); } if (!(ij.getMember() instanceof Field) && ij.getAnnotated().isAnnotationPresent(Named.class) && ij.getAnnotated().getAnnotation(Named.class).value().equals("")) { throw new DefinitionException(NON_FIELD_INJECTION_POINT_CANNOT_USE_NAMED, ij); } boolean newBean = (bean instanceof NewManagedBean<?>) || (bean instanceof NewSessionBean<?>); if (!newBean) { checkScopeAnnotations(ij, beanManager.getServices().get(MetaAnnotationStore.class)); } checkFacadeInjectionPoint(ij, Instance.class); checkFacadeInjectionPoint(ij, Event.class); Annotation[] bindings = ij.getQualifiers().toArray(new Annotation[0]); Set<?> resolvedBeans = beanManager.getBeanResolver().resolve(beanManager.getBeans(ij)); if (!isInjectionPointSatisfied(ij, resolvedBeans, beanManager)) { throw new DeploymentException( INJECTION_POINT_HAS_UNSATISFIED_DEPENDENCIES, ij, Formats.formatAnnotations(bindings), Formats.formatType(ij.getType())); } if (resolvedBeans.size() > 1 && !ij.isDelegate()) { throw new DeploymentException( INJECTION_POINT_HAS_AMBIGUOUS_DEPENDENCIES, ij, Formats.formatAnnotations(bindings), Formats.formatType(ij.getType()), resolvedBeans); } // Account for the case this is disabled decorator if (!resolvedBeans.isEmpty()) { Bean<?> resolvedBean = (Bean<?>) resolvedBeans.iterator().next(); if (beanManager .getServices() .get(MetaAnnotationStore.class) .getScopeModel(resolvedBean.getScope()) .isNormal()) { UnproxyableResolutionException ue = Proxies.getUnproxyableTypeException(ij.getType()); if (ue != null) { UnproxyableResolutionException exception = new UnproxyableResolutionException( INJECTION_POINT_HAS_NON_PROXYABLE_DEPENDENCIES, ij); exception.initCause(ue); throw exception; } } if (Reflections.isPrimitive(ij.getType()) && resolvedBean.isNullable()) { throw new NullableDependencyException(INJECTION_POINT_HAS_NULLABLE_DEPENDENCIES, ij); } if (bean != null && Beans.isPassivatingScope(bean, beanManager) && (!ij.isTransient()) && !Beans.isPassivationCapableBean(resolvedBean)) { validateInjectionPointPassivationCapable(ij, resolvedBean, beanManager); } } }