[jboss-cvs] JBossAS SVN: r109359 - projects/metadata/common/trunk/src/main/java/org/jboss/metadata/serviceref.
jboss-cvs-commits at lists.jboss.org
jboss-cvs-commits at lists.jboss.org
Thu Nov 18 09:35:47 EST 2010
Author: richard.opalka at jboss.com
Date: 2010-11-18 09:35:47 -0500 (Thu, 18 Nov 2010)
New Revision: 109359
Modified:
projects/metadata/common/trunk/src/main/java/org/jboss/metadata/serviceref/ServiceReferenceHandler.java
Log:
fixing jboss-switchboard integration
Modified: projects/metadata/common/trunk/src/main/java/org/jboss/metadata/serviceref/ServiceReferenceHandler.java
===================================================================
--- projects/metadata/common/trunk/src/main/java/org/jboss/metadata/serviceref/ServiceReferenceHandler.java 2010-11-18 14:35:10 UTC (rev 109358)
+++ projects/metadata/common/trunk/src/main/java/org/jboss/metadata/serviceref/ServiceReferenceHandler.java 2010-11-18 14:35:47 UTC (rev 109359)
@@ -21,13 +21,26 @@
*/
package org.jboss.metadata.serviceref;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.AccessibleObject;
+import java.lang.reflect.AnnotatedElement;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
+import javax.jws.HandlerChain;
import javax.naming.Context;
import javax.naming.NamingException;
import javax.naming.Referenceable;
import javax.xml.namespace.QName;
+import javax.xml.ws.Service;
+import javax.xml.ws.WebServiceRef;
+import javax.xml.ws.WebServiceRefs;
+import javax.xml.ws.soap.MTOM;
import org.jboss.logging.Logger;
import org.jboss.metadata.javaee.jboss.CallPropertyMetaData;
@@ -37,6 +50,7 @@
import org.jboss.metadata.javaee.spec.Addressing;
import org.jboss.metadata.javaee.spec.ParamValueMetaData;
import org.jboss.metadata.javaee.spec.PortComponentRef;
+import org.jboss.metadata.javaee.spec.ResourceInjectionTargetMetaData;
import org.jboss.metadata.javaee.spec.RespectBinding;
import org.jboss.metadata.javaee.spec.ServiceReferenceHandlerChainMetaData;
import org.jboss.metadata.javaee.spec.ServiceReferenceHandlerChainsMetaData;
@@ -56,14 +70,17 @@
import org.jboss.wsf.spi.metadata.j2ee.serviceref.UnifiedServiceRefMetaData;
import org.jboss.wsf.spi.metadata.j2ee.serviceref.UnifiedStubPropertyMetaData;
import org.jboss.wsf.spi.serviceref.ServiceRefHandler;
+import org.jboss.wsf.spi.serviceref.ServiceRefHandler.Type;
import org.jboss.wsf.spi.serviceref.ServiceRefHandlerFactory;
/**
* Utility to bind service references to JNDI
+ * @Deprecated This class will be removed once switchboard/jboss-injection is in place.
*
* @author Thomas.Diesler at jboss.org
* @author <a href="mailto:ropalka at redhat.com">Richard Opalka</a>
*/
+ at Deprecated
public final class ServiceReferenceHandler
{
private static final Logger log = Logger.getLogger(ServiceReferenceHandler.class);
@@ -83,7 +100,8 @@
{
if (!sref.isProcessed())
{
- final UnifiedServiceRefMetaData spiRef = getUnifiedServiceRefMetaData(vfsRoot, sref);
+ final UnifiedServiceRefMetaData spiRef = getUnifiedServiceRefMetaData(vfsRoot, sref, loader);
+ this.processType(spiRef);
final Referenceable jndiReferenceable = delegate.createReferenceable(spiRef);
final String jndiFullName = encCtx.getNameInNamespace() + "/" + encName;
log.info("Binding service reference to [jndi=" + jndiFullName + "]");
@@ -92,23 +110,53 @@
}
}
- private UnifiedServiceRefMetaData getUnifiedServiceRefMetaData(UnifiedVirtualFile vfsRoot, ServiceReferenceMetaData sref)
+ private void processAnnotatedElement(final AnnotatedElement anElement, final UnifiedServiceRefMetaData serviceRefMD)
{
+ this.processAddressingAnnotation(anElement, serviceRefMD);
+ this.processMTOMAnnotation(anElement, serviceRefMD);
+ this.processRespectBindingAnnotation(anElement, serviceRefMD);
+ this.processHandlerChainAnnotation(anElement, serviceRefMD);
+ this.processServiceRefType(anElement, serviceRefMD);
+ }
+
+ // TODO: use classloader to detect service ref type
+ private void processType(final UnifiedServiceRefMetaData serviceRefMD)
+ {
+ final boolean isJAXRPC = serviceRefMD.getMappingFile() != null // TODO: is mappingFile check required?
+ || "javax.xml.rpc.Service".equals(serviceRefMD.getServiceInterface());
+
+ serviceRefMD.setType(isJAXRPC ? Type.JAXRPC : Type.JAXWS);
+ }
+
+ private UnifiedServiceRefMetaData getUnifiedServiceRefMetaData(UnifiedVirtualFile vfsRoot, ServiceReferenceMetaData sref, ClassLoader loader)
+ {
UnifiedServiceRefMetaData result = new UnifiedServiceRefMetaData(vfsRoot);
- result.setServiceRefName(sref.getServiceRefName());
+ result.setServiceRefName(sref.getName());
result.setServiceRefType(sref.getServiceRefType());
result.setServiceInterface(sref.getServiceInterface());
result.setWsdlFile(sref.getWsdlFile());
result.setMappingFile(sref.getJaxrpcMappingFile());
result.setServiceQName(sref.getServiceQname());
+ result.setAddressingAnnotationSpecified(sref.isAddressingAnnotationSpecified());
result.setAddressingEnabled(sref.isAddressingEnabled());
result.setAddressingRequired(sref.isAddressingRequired());
result.setAddressingResponses(sref.getAddressingResponses());
+ result.setMtomAnnotationSpecified(sref.isMtomAnnotationSpecified());
result.setMtomEnabled(sref.isMtomEnabled());
result.setMtomThreshold(sref.getMtomThreshold());
+ result.setRespectBindingAnnotationSpecified(sref.isRespectBindingAnnotationSpecified());
result.setRespectBindingEnabled(sref.isRespectBindingEnabled());
result.setHandlerChain(sref.getHandlerChain());
+ if (sref.getInjectionTargets() != null && sref.getInjectionTargets().size() > 0)
+ {
+ if (sref.getInjectionTargets().size() > 1) throw new UnsupportedOperationException("What to do in such case?");
+ final ResourceInjectionTargetMetaData injectionTarget = sref.getInjectionTargets().iterator().next();
+
+ AccessibleObject anAlement = this.findInjectionTarget(loader, injectionTarget);
+ this.processAnnotatedElement(anAlement, result);
+ }
+
List<? extends PortComponentRef> pcRefs = sref.getPortComponentRef();
if (pcRefs != null)
{
@@ -267,4 +315,194 @@
}
return result;
}
+ private void processAddressingAnnotation(final AnnotatedElement anElement, final UnifiedServiceRefMetaData serviceRefMD)
+ {
+ final javax.xml.ws.soap.Addressing addressingAnnotation = this.getAnnotation(anElement, javax.xml.ws.soap.Addressing.class);
+
+ if (addressingAnnotation != null)
+ {
+ serviceRefMD.setAddressingAnnotationSpecified(true);
+ serviceRefMD.setAddressingEnabled(addressingAnnotation.enabled());
+ serviceRefMD.setAddressingRequired(addressingAnnotation.required());
+ serviceRefMD.setAddressingResponses(addressingAnnotation.responses().toString());
+ }
+ }
+
+ private void processMTOMAnnotation(final AnnotatedElement anElement, final UnifiedServiceRefMetaData serviceRefMD)
+ {
+ final MTOM mtomAnnotation = this.getAnnotation(anElement, MTOM.class);
+
+ if (mtomAnnotation != null)
+ {
+ serviceRefMD.setMtomAnnotationSpecified(true);
+ serviceRefMD.setMtomEnabled(mtomAnnotation.enabled());
+ serviceRefMD.setMtomThreshold(mtomAnnotation.threshold());
+ }
+ }
+
+ private void processRespectBindingAnnotation(final AnnotatedElement anElement, final UnifiedServiceRefMetaData serviceRefMD)
+ {
+ final javax.xml.ws.RespectBinding respectBindingAnnotation = this.getAnnotation(anElement, javax.xml.ws.RespectBinding.class);
+
+ if (respectBindingAnnotation != null)
+ {
+ serviceRefMD.setRespectBindingAnnotationSpecified(true);
+ serviceRefMD.setRespectBindingEnabled(respectBindingAnnotation.enabled());
+ }
+ }
+
+ private void processServiceRefType(final AnnotatedElement anElement, final UnifiedServiceRefMetaData serviceRefMD)
+ {
+ if (anElement instanceof Field)
+ {
+ final Class<?> targetClass = ((Field) anElement).getType();
+ serviceRefMD.setServiceRefType(targetClass.getName());
+
+ if (Service.class.isAssignableFrom(targetClass))
+ serviceRefMD.setServiceInterface(targetClass.getName());
+ }
+ else if (anElement instanceof Method)
+ {
+ final Class<?> targetClass = ((Method) anElement).getParameterTypes()[0];
+ serviceRefMD.setServiceRefType(targetClass.getName());
+
+ if (Service.class.isAssignableFrom(targetClass))
+ serviceRefMD.setServiceInterface(targetClass.getName());
+ }
+ else
+ {
+ final WebServiceRef serviceRefAnnotation = this.getWebServiceRefAnnotation(anElement, serviceRefMD);
+ Class<?> targetClass = null;
+ if (serviceRefAnnotation != null && (serviceRefAnnotation.type() != Object.class))
+ {
+ targetClass = serviceRefAnnotation.type();
+ serviceRefMD.setServiceRefType(targetClass.getName());
+
+ if (Service.class.isAssignableFrom(targetClass))
+ serviceRefMD.setServiceInterface(targetClass.getName());
+ }
+ }
+ }
+
+ private void processHandlerChainAnnotation(final AnnotatedElement anElement, final UnifiedServiceRefMetaData serviceRefMD)
+ {
+ final HandlerChain handlerChainAnnotation = this.getAnnotation(anElement, HandlerChain.class);
+
+ if (handlerChainAnnotation != null)
+ {
+ // Set the handlerChain from @HandlerChain on the annotated element
+ String handlerChain = null;
+ if (handlerChainAnnotation.file().length() > 0)
+ handlerChain = handlerChainAnnotation.file();
+
+ // Resolve path to handler chain
+ if (handlerChain != null)
+ {
+ try
+ {
+ new URL(handlerChain);
+ }
+ catch (MalformedURLException ignored)
+ {
+ final Class<?> declaringClass = getDeclaringClass(anElement);
+
+ handlerChain = declaringClass.getPackage().getName().replace('.', '/') + "/" + handlerChain;
+ }
+
+ serviceRefMD.setHandlerChain(handlerChain);
+ }
+ }
+ }
+
+ private Class<?> getDeclaringClass(final AnnotatedElement annotatedElement)
+ {
+ Class<?> declaringClass = null;
+ if (annotatedElement instanceof Field)
+ declaringClass = ((Field) annotatedElement).getDeclaringClass();
+ else if (annotatedElement instanceof Method)
+ declaringClass = ((Method) annotatedElement).getDeclaringClass();
+ else if (annotatedElement instanceof Class)
+ declaringClass = (Class<?>) annotatedElement;
+
+ return declaringClass;
+ }
+
+ private <T extends Annotation> T getAnnotation(final AnnotatedElement anElement, final Class<T> annotationClass)
+ {
+ return anElement != null ? (T) anElement.getAnnotation(annotationClass) : null;
+ }
+
+ private WebServiceRef getWebServiceRefAnnotation(final AnnotatedElement anElement, final UnifiedServiceRefMetaData serviceRefMD)
+ {
+ final WebServiceRef webServiceRefAnnotation = this.getAnnotation(anElement, WebServiceRef.class);
+ final WebServiceRefs webServiceRefsAnnotation = this.getAnnotation(anElement, WebServiceRefs.class);
+
+ if (webServiceRefAnnotation == null && webServiceRefsAnnotation == null)
+ {
+ return null;
+ }
+
+ // Build the list of @WebServiceRef relevant annotations
+ final List<WebServiceRef> wsrefList = new ArrayList<WebServiceRef>();
+
+ if (webServiceRefAnnotation != null)
+ {
+ wsrefList.add(webServiceRefAnnotation);
+ }
+
+ if (webServiceRefsAnnotation != null)
+ {
+ for (final WebServiceRef webServiceRefAnn : webServiceRefsAnnotation.value())
+ {
+ wsrefList.add(webServiceRefAnn);
+ }
+ }
+
+ // Return effective @WebServiceRef annotation
+ WebServiceRef returnValue = null;
+ if (wsrefList.size() == 1)
+ {
+ returnValue = wsrefList.get(0);
+ }
+ else
+ {
+ for (WebServiceRef webServiceRefAnn : wsrefList)
+ {
+ if (serviceRefMD.getServiceRefName().endsWith(webServiceRefAnn.name()))
+ {
+ returnValue = webServiceRefAnn;
+ break;
+ }
+ }
+ }
+
+ return returnValue;
+ }
+
+ private AccessibleObject findInjectionTarget(ClassLoader loader, ResourceInjectionTargetMetaData target)
+ {
+ Class<?> clazz = null;
+ try
+ {
+ clazz = loader.loadClass(target.getInjectionTargetClass());
+ }
+ catch (ClassNotFoundException e)
+ {
+ throw new RuntimeException("<injection-target> class: " + target.getInjectionTargetClass() + " was not found in deployment");
+ }
+
+ for (Field field : clazz.getDeclaredFields())
+ {
+ if (target.getInjectionTargetName().equals(field.getName())) return field;
+ }
+
+ for (Method method : clazz.getDeclaredMethods())
+ {
+ if (method.getName().equals(target.getInjectionTargetName())) return method;
+ }
+
+ throw new RuntimeException("<injection-target> could not be found: " + target.getInjectionTargetClass() + "." + target.getInjectionTargetName());
+
+ }
+
}
More information about the jboss-cvs-commits
mailing list