/*
* 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 java.lang.reflect.Method;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import javax.enterprise.context.Dependent;
import javax.enterprise.event.Observes;
import javax.enterprise.event.Reception;
import javax.enterprise.inject.Disposes;
import javax.enterprise.inject.Produces;
import javax.enterprise.inject.spi.AnnotatedMethod;
import javax.enterprise.inject.spi.AnnotatedParameter;
import javax.enterprise.inject.spi.AnnotatedType;
import javax.enterprise.inject.spi.ObserverMethod;
import javax.inject.Inject;
import org.apache.webbeans.component.AbstractOwbBean;
import org.apache.webbeans.component.InjectionTargetBean;
import org.apache.webbeans.config.WebBeansContext;
import org.apache.webbeans.exception.WebBeansConfigurationException;
import org.apache.webbeans.util.AnnotationUtil;
import org.apache.webbeans.util.Asserts;
/**
* Abstract implementation of {@link AbstractBeanBuilder}.
*
* @version $Rev: 1465291 $ $Date: 2013-04-06 12:04:24 -0700 (Sat, 06 Apr 2013) $
*
* @param <T> bean class type
*/
public class ObserverMethodsBuilder<T, I extends InjectionTargetBean<T>>
{
protected final WebBeansContext webBeansContext;
protected final AnnotatedType<T> annotatedType;
/**
* Creates a new instance.
*
*/
public ObserverMethodsBuilder(WebBeansContext webBeansContext, AnnotatedType<T> annotatedType)
{
Asserts.assertNotNull(webBeansContext, "webBeansContext may not be null");
Asserts.assertNotNull(annotatedType, "annotated type may not be null");
this.webBeansContext = webBeansContext;
this.annotatedType = annotatedType;
}
/**
* {@inheritDoc}
*/
public Set<ObserverMethod<?>> defineObserverMethods(AbstractOwbBean<T> bean)
{
Set<ObserverMethod<?>> definedObservers = new HashSet<ObserverMethod<?>>();
Set<AnnotatedMethod<? super T>> annotatedMethods = annotatedType.getMethods();
for (AnnotatedMethod<? super T> annotatedMethod : annotatedMethods)
{
AnnotatedMethod<T> annt = (AnnotatedMethod<T>)annotatedMethod;
List<AnnotatedParameter<T>> parameters = annt.getParameters();
boolean found = false;
for(AnnotatedParameter<T> parameter : parameters)
{
if(parameter.isAnnotationPresent(Observes.class))
{
found = true;
break;
}
}
if(found)
{
checkObserverMethodConditions((AnnotatedMethod<T>) annotatedMethod, annotatedMethod.getDeclaringType().getJavaClass());
if (bean.getScope().equals(Dependent.class))
{
//Check Reception
AnnotationUtil.getAnnotatedMethodFirstParameterWithAnnotation(annotatedMethod, Observes.class);
Observes observes = AnnotationUtil.getAnnotatedMethodFirstParameterAnnotation(annotatedMethod, Observes.class);
Reception reception = observes.notifyObserver();
if(reception.equals(Reception.IF_EXISTS))
{
throw new WebBeansConfigurationException("Dependent Bean : " + annotatedType.getJavaClass() + " can not define observer method with @Receiver = IF_EXIST");
}
}
//Looking for ObserverMethod
ObserverMethod<?> definedObserver = webBeansContext.getBeanManagerImpl().getNotificationManager().getObservableMethodForAnnotatedMethod(annotatedMethod, bean);
if(definedObserver != null)
{
definedObservers.add(definedObserver);
}
}
}
return definedObservers;
}
private void checkObserverMethodConditions(AnnotatedMethod<T> annotatedMethod, Class<?> clazz)
{
Asserts.assertNotNull(annotatedMethod, "annotatedMethod parameter can not be null");
Asserts.nullCheckForClass(clazz);
Method candidateObserverMethod = annotatedMethod.getJavaMember();
if (AnnotationUtil.hasAnnotatedMethodMultipleParameterAnnotation(annotatedMethod, Observes.class))
{
throw new WebBeansConfigurationException("Observer method : " + candidateObserverMethod.getName() + " in class : " + clazz.getName()
+ " can not define two parameters with annotated @Observes");
}
if (annotatedMethod.isAnnotationPresent(Produces.class)
|| annotatedMethod.isAnnotationPresent(Inject.class))
{
throw new WebBeansConfigurationException("Observer method : " + candidateObserverMethod.getName() + " in class : " + clazz.getName()
+ " can not annotated with annotation in the list {@Produces, @Initializer, @Destructor}");
}
if (AnnotationUtil.hasAnnotatedMethodParameterAnnotation(annotatedMethod, Disposes.class))
{
throw new WebBeansConfigurationException("Observer method : " + candidateObserverMethod.getName() + " in class : "
+ clazz.getName() + " can not annotated with annotation @Disposes");
}
}
}