org.apache.webbeans.component.creation.BaseProducerFactory Maven / Gradle / Ivy
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.webbeans.component.creation;
import org.apache.webbeans.annotation.AnyLiteral;
import org.apache.webbeans.config.WebBeansContext;
import org.apache.webbeans.exception.WebBeansConfigurationException;
import org.apache.webbeans.util.AnnotationUtil;
import org.apache.webbeans.util.Asserts;
import org.apache.webbeans.util.ClassUtil;
import org.apache.webbeans.util.GenericsUtil;
import javax.enterprise.event.Observes;
import javax.enterprise.inject.Default;
import javax.enterprise.inject.Disposes;
import javax.enterprise.inject.Produces;
import javax.enterprise.inject.spi.AnnotatedMember;
import javax.enterprise.inject.spi.AnnotatedMethod;
import javax.enterprise.inject.spi.AnnotatedParameter;
import javax.enterprise.inject.spi.AnnotatedType;
import javax.enterprise.inject.spi.Bean;
import javax.enterprise.inject.spi.InjectionPoint;
import javax.enterprise.inject.spi.ProducerFactory;
import javax.inject.Inject;
import javax.inject.Named;
import java.lang.annotation.Annotation;
import java.lang.reflect.Type;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
public abstract class BaseProducerFactory implements ProducerFactory
{
protected AnnotatedMethod disposalMethod;
protected Bean
parent;
protected WebBeansContext webBeansContext;
public BaseProducerFactory(Bean
parent, WebBeansContext webBeansContext)
{
Asserts.assertNotNull(webBeansContext, Asserts.PARAM_NAME_WEBBEANSCONTEXT);
this.parent = parent;
this.webBeansContext = webBeansContext;
}
protected Set getInjectionPoints(final Bean bean)
{
Set disposalIPs = null;
if (disposalMethod != null)
{
disposalIPs = new HashSet(webBeansContext.getInjectionPointFactory().buildInjectionPoints(bean, disposalMethod));
}
return disposalIPs;
}
protected void defineDisposalMethod()
{
final AnnotatedMember producer = producerType();
Set producerQualifiers = webBeansContext.getAnnotationManager().getQualifierAnnotations(producer.getAnnotations());
if (producerQualifiers.size() == 1 && producerQualifiers.iterator().next().annotationType().equals(Default.class))
{
producerQualifiers = Collections.emptySet();
}
Set producerQualifiersWithoutNamed = new HashSet();
for (Annotation qualifier: producerQualifiers)
{
if (!qualifier.annotationType().equals(Named.class))
{
producerQualifiersWithoutNamed.add(qualifier);
}
}
final AnnotatedType declaringType = producer.getDeclaringType();
final Type producerBaseType = producerType().getBaseType();
final Set> annotatedMethods =
webBeansContext.getAnnotatedElementFactory().getFilteredAnnotatedMethods(declaringType);
AnnotatedMethod anyDisposal = null;
for (AnnotatedMethod annotatedMethod : annotatedMethods)
{
if (annotatedMethod.getDeclaringType().equals(declaringType))
{
for (AnnotatedParameter annotatedParameter : annotatedMethod.getParameters())
{
if (annotatedParameter.isAnnotationPresent(Disposes.class))
{
if (!GenericsUtil.satisfiesDependency(false, true, producerBaseType, annotatedParameter.getBaseType()))
{
continue;
}
Set producerQualifiersToCompare = producerQualifiers;
Set disposalQualifiers = webBeansContext.getAnnotationManager().getQualifierAnnotations(annotatedParameter.getAnnotations());
if (disposalQualifiers.size() == 1 && disposalQualifiers.iterator().next().annotationType().equals(Default.class))
{
disposalQualifiers = Collections.emptySet();
}
if (disposalQualifiers.size() == producerQualifiersToCompare.size() - 1)
{
// when @Named is present at the producer it may be ignored at the disposal
producerQualifiersToCompare = producerQualifiersWithoutNamed;
}
if (disposalQualifiers.size() != producerQualifiersToCompare.size())
{
continue;
}
boolean same = true;
for (Annotation disposalQualifier : disposalQualifiers)
{
boolean found = false;
for (Annotation producerQualifier : producerQualifiers)
{
if (AnnotationUtil.isCdiAnnotationEqual(producerQualifier, disposalQualifier))
{
found = true;
break;
}
}
if (!found)
{
same = false;
break;
}
}
if (!same)
{
if (disposalQualifiers.size() == 1 && AnyLiteral.INSTANCE.equals(disposalQualifiers.iterator().next()))
{
anyDisposal = annotatedMethod;
}
continue;
}
if (disposalMethod != null)
{
throw new WebBeansConfigurationException("There are multiple disposal method for the producer method : "
+ disposalMethod.getJavaMember().getName() + " in class : "
+ annotatedMethod.getDeclaringType().getJavaClass());
}
validateDisposalMethod(declaringType, annotatedMethod);
disposalMethod = annotatedMethod;
}
}
}
}
if (disposalMethod == null && anyDisposal != null)
{
validateDisposalMethod(declaringType, anyDisposal);
disposalMethod = anyDisposal;
}
}
private void validateDisposalMethod(final AnnotatedType declaringType, final AnnotatedMethod annotatedMethod)
{
if (!annotatedMethod.getDeclaringType().equals(declaringType))
{
throw new WebBeansConfigurationException("Producer method component of the disposal method : "
+ annotatedMethod.getJavaMember().getName() + " in class : "
+ annotatedMethod.getDeclaringType().getJavaClass() + " must be in the same class!");
}
checkDisposalMethod(annotatedMethod);
}
protected abstract AnnotatedMember producerType();
private void checkDisposalMethod(AnnotatedMethod annotatedMethod)
{
boolean found = false;
for (AnnotatedParameter parameter : annotatedMethod.getParameters())
{
if(parameter.isAnnotationPresent(Disposes.class))
{
if(found)
{
throw new WebBeansConfigurationException("Error in definining disposal method of annotated method : " + annotatedMethod
+ ". Multiple disposes annotation.");
}
found = true;
}
}
if(annotatedMethod.isAnnotationPresent(Inject.class)
|| AnnotationUtil.hasAnnotatedMethodParameterAnnotation(annotatedMethod, Observes.class)
|| annotatedMethod.isAnnotationPresent(Produces.class))
{
throw new WebBeansConfigurationException("Error in definining disposal method of annotated method : " + annotatedMethod
+ ". Disposal methods can not be annotated with" + " @Initializer/@Destructor/@Produces annotation or has a parameter annotated with @Observes.");
}
for (AnnotatedParameter param : annotatedMethod.getParameters())
{
Type type = param.getBaseType();
if (type.equals(InjectionPoint.class))
{
throw new WebBeansConfigurationException("Error in definining disposal method of annotated method : " + annotatedMethod
+ ". Disposal methods must not have an InjectionPoint.");
}
else if (Bean.class.isAssignableFrom(ClassUtil.getClass(type)))
{
throw new WebBeansConfigurationException("Error in defining disposal method of annoted method: " + annotatedMethod +
". Disposal methods must not have a Bean parameter.");
}
}
}
}