/*
* 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.axis2.jaxws.description.builder;
import org.apache.axis2.context.ConfigurationContext;
import org.apache.axis2.java.security.AccessController;
import org.apache.axis2.jaxws.ExceptionFactory;
import org.apache.axis2.jaxws.catalog.JAXWSCatalogManager;
import org.apache.axis2.jaxws.description.xml.handler.HandlerChainsType;
import org.apache.axis2.jaxws.i18n.Messages;
import org.apache.axis2.jaxws.util.WSDL4JWrapper;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import javax.wsdl.Definition;
import javax.xml.namespace.QName;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.net.URL;
import java.security.PrivilegedAction;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.WeakHashMap;
public class DescriptionBuilderComposite implements TMAnnotationComposite, TMFAnnotationComposite {
private static final Log log = LogFactory.getLog(DescriptionBuilderComposite.class);
/*
* This structure contains the full reflected class, as well as, the
* possible annotations found for this class...the class description
* must be complete enough for full validation between class info and annotations
* The annotations will be added to the corresponding class members.
*/
public DescriptionBuilderComposite() {
this((ConfigurationContext)null);
}
public DescriptionBuilderComposite(ConfigurationContext configContext) {
myConfigContext = configContext;
methodDescriptions = new ArrayList<MethodDescriptionComposite>();
fieldDescriptions = new ArrayList<FieldDescriptionComposite>();
webServiceRefAnnotList = new ArrayList<WebServiceRefAnnot>();
interfacesList = new ArrayList<String>();
genericAnnotationInstances = new ArrayList<CustomAnnotationInstance>();
genericAnnotationProcessors = new HashMap<String, CustomAnnotationProcessor>();
properties = new HashMap<String, Object>();
}
//Note: a WSDL is not necessary
private Definition wsdlDefinition = null;
private URL wsdlURL = null;
private WSDL4JWrapper wsdlWrapper = null;
private ConfigurationContext myConfigContext;
// Class-level annotations
private WebServiceAnnot webServiceAnnot;
private WebServiceProviderAnnot webServiceProviderAnnot;
private ServiceModeAnnot serviceModeAnnot;
private WebServiceClientAnnot webServiceClientAnnot;
private WebFaultAnnot webFaultAnnot;
private HandlerChainAnnot handlerChainAnnot;
private SoapBindingAnnot soapBindingAnnot;
private List<WebServiceRefAnnot> webServiceRefAnnotList;
private BindingTypeAnnot bindingTypeAnnot;
// Collection of PortComposite objects which were created from
// this DescriptionBuilderComposite instance
private List<PortComposite> portCompositeList = new ArrayList<PortComposite>();
private List<Annotation> features;
private Map<QName, Definition> wsdlDefs = new HashMap<QName, Definition>();
private Map<QName, URL> wsdlURLs = new HashMap<QName, URL>();
private Set<QName> serviceQNames = new HashSet<QName>();
private Map<QName, List<PortComposite>> sQNameToPC = new HashMap<QName, List<PortComposite>>();
// Class information
private String className;
/**
* Get an annotation by introspecting on a class. This is wrappered to avoid a Java2Security violation.
* @param cls Class that contains annotation
* @param annotation Class of requrested Annotation
* @return annotation or null
*/
private static Annotation getAnnotationFromClass(final Class cls, final Class annotation) {
return (Annotation) AccessController.doPrivileged(new PrivilegedAction() {
public Object run() {
Annotation a = cls.getAnnotation(annotation);
return a;
}
});
}
private String[] classModifiers; //public, abstract, final, strictfp...
private String extendsClass; //Set to the name of the super class
private List<String> interfacesList; //Set this for all implemented interfaces
private boolean isInterface = false;
private QName preferredPort; // Port to use if no port QName given. May be null
private boolean isMTOMEnabled = false;
private List<MethodDescriptionComposite> methodDescriptions;
private List<FieldDescriptionComposite> fieldDescriptions;
// we can keep these in a singular list b/c for a given type-level annotation
// there can only one instance of the annotation
private List<CustomAnnotationInstance> genericAnnotationInstances;
// a map that stores all the type-targetted GenericAnnotationProcessor instances
private Map<String, CustomAnnotationProcessor> genericAnnotationProcessors;
private WsdlGenerator wsdlGenerator;
private ClassLoader classLoader;
// JAXB object used to represent handler chain configuration info
// either this or the HandlerChainAnnot may be present, but
// not both, they may both be null
private HandlerChainsType handlerChainsType = null;
// Does this composite represent a service requester or service provider.
// We default to service provider since composites were orginally not used by requesters.
private boolean isServiceProvider = true;
// For a service requester, this will be the client-side class associated with this composite;
// It could be the Service class or the SEI class. On the service provider this will be null
// unless the deprecated service construction logic in DescriptionFactory was used.
private Class theCorrespondingClass;
// Service-requesters (aka clients) can specify a sprase composite that may contain annotation
// information corresponding to information in a deployment descriptor or an injected
// resource.
private WeakHashMap<Object, DescriptionBuilderComposite> sparseCompositeMap = new WeakHashMap<Object, DescriptionBuilderComposite>();
// Allow a unique XML CatalogManager per service description.
private JAXWSCatalogManager catalogManager = null;
// This is a bag of properties that apply to the DBC. Currently these properties will be
// copied over from the DBC to the description hierarchy. This will only occur on the
// server-side for now
private Map<String, Object> properties = null;
public void setSparseComposite(Object key, DescriptionBuilderComposite sparseComposite) {
if (key != null && sparseComposite != null) {
this.sparseCompositeMap.put(key, sparseComposite);
}
}
public DescriptionBuilderComposite getSparseComposite(Object key) {
return sparseCompositeMap.get(key);
}
/**
* For a service requester, set the QName of the preferred port for this service. This
* indicates which port (i.e. which EndpointDescription) should be returned if a port QName
* isn't specified. This may be null, indicating the first valid port in the WSDL should be
* returned.
*
* @param preferredPort
*/
public void setPreferredPort(QName preferredPort) {
this.preferredPort = preferredPort;
}
/**
* For a service requester, the QName of the prefered port for this service. This indicates
* which port should be returned if a port QName wasn't specified. This may be null,
* indicating the first valid port in the WSDL should be returned.
* @return
*/
public QName getPreferredPort() {
return preferredPort;
}
public QName getPreferredPort(Object key) {
QName returnPreferredPort = null;
// See if there's a sparse composite override for this composite
if (key != null) {
DescriptionBuilderComposite sparse = getSparseComposite(key);
if (sparse != null
&& !DescriptionBuilderUtils.isEmpty(sparse.getPreferredPort())) {
returnPreferredPort = sparse.getPreferredPort();
} else {
returnPreferredPort = getPreferredPort();
}
} else {
returnPreferredPort = getPreferredPort();
}
return returnPreferredPort;
}
public void setIsMTOMEnabled(boolean isMTOMEnabled) {
this.isMTOMEnabled = isMTOMEnabled;
}
public boolean isMTOMEnabled() {
return isMTOMEnabled;
}
public boolean isMTOMEnabled(Object key) {
boolean returnIsMTOMEnabled = false;
if (key != null) {
DescriptionBuilderComposite sparseDBC = getSparseComposite(key);
if (sparseDBC != null && sparseDBC.isMTOMEnabled()) {
returnIsMTOMEnabled = sparseDBC.isMTOMEnabled();
} else {
returnIsMTOMEnabled = isMTOMEnabled();
}
} else {
returnIsMTOMEnabled = isMTOMEnabled();
}
return returnIsMTOMEnabled;
}
// Methods
public WebServiceAnnot getWebServiceAnnot() {
return webServiceAnnot =
(WebServiceAnnot) getCompositeAnnotation(webServiceAnnot,
WebServiceAnnot.class,
javax.jws.WebService.class);
}
/** @return Returns the classModifiers. */
public String[] getClassModifiers() {
return classModifiers;
}
/** @return Returns the className. */
public String getClassName() {
if (className != null) {
return className;
}
else if (theCorrespondingClass != null) {
return theCorrespondingClass.getName();
}
else {
return null;
}
}
/** @return Returns the super class name. */
public String getSuperClassName() {
return extendsClass;
}
/** @return Returns the list of implemented interfaces. */
public List<String> getInterfacesList() {
return interfacesList;
}
/** @return Returns the handlerChainAnnotImpl. */
public HandlerChainAnnot getHandlerChainAnnot() {
return handlerChainAnnot =
(HandlerChainAnnot) getCompositeAnnotation(handlerChainAnnot,
HandlerChainAnnot.class,
javax.jws.HandlerChain.class);
}
/** @return Returns the serviceModeAnnot. */
public ServiceModeAnnot getServiceModeAnnot() {
return serviceModeAnnot =
(ServiceModeAnnot) getCompositeAnnotation(serviceModeAnnot,
ServiceModeAnnot.class,
javax.xml.ws.ServiceMode.class);
}
/** @return Returns the soapBindingAnnot. */
public SoapBindingAnnot getSoapBindingAnnot() {
return soapBindingAnnot =
(SoapBindingAnnot) getCompositeAnnotation(soapBindingAnnot,
SoapBindingAnnot.class,
javax.jws.soap.SOAPBinding.class);
}
/** @return Returns the webFaultAnnot. */
public WebFaultAnnot getWebFaultAnnot() {
return webFaultAnnot =
(WebFaultAnnot) getCompositeAnnotation(webFaultAnnot,
WebFaultAnnot.class,
javax.xml.ws.WebFault.class);
}
/** @return Returns the webServiceClientAnnot. */
public WebServiceClientAnnot getWebServiceClientAnnot() {
return webServiceClientAnnot =
(WebServiceClientAnnot) getCompositeAnnotation(webServiceClientAnnot,
WebServiceClientAnnot.class,
javax.xml.ws.WebServiceClient.class);
}
public WebServiceClientAnnot getWebServiceClientAnnot(Object key) {
WebServiceClientAnnot annot = getWebServiceClientAnnot();
DescriptionBuilderComposite sparseComposite = getSparseComposite(key);
WebServiceClientAnnot sparseAnnot = null;
if (sparseComposite != null) {
sparseAnnot = sparseComposite.getWebServiceClientAnnot();
}
return WebServiceClientAnnot.createFromAnnotation(annot, sparseAnnot);
}
/**
* Return a composite annotation of the specified type. If the composite annotation is
* null, then the associated class (if not null) will be examined for the appropriate java
* annotation. If one is found, it will be used to create a new composite annotation.
*
* @param compositeAnnotation May be null. The current composite annotation. If this is
* non-null, it will simply be returned.
* @param compositeAnnotClass The class of the composite annotation. This is a subclass of
* the java annotation class.
* @param javaAnnotationClass The java annotation class. The associated class will be
* reflected on to see if this annotation exists. If so, it is used to create an instance of
* the composite annotation class.
* @return
*/
private Annotation getCompositeAnnotation(Annotation compositeAnnotation,
Class compositeAnnotClass,
Class javaAnnotationClass) {
Annotation returnAnnotation = compositeAnnotation;
if (returnAnnotation == null && theCorrespondingClass != null) {
// Get the annotation from the class and if one exists, construct a composite annot for it
Annotation annotationFromClass = getAnnotationFromClass(theCorrespondingClass, javaAnnotationClass);
if (annotationFromClass != null) {
try {
Method createAnnot = compositeAnnotClass.getMethod("createFromAnnotation", Annotation.class);
returnAnnotation = (Annotation) createAnnot.invoke(null, annotationFromClass);
} catch (Exception e) {
if (log.isDebugEnabled()) {
log.debug("Unable to create composite annotation due to exception."
+ " Composite Annotation: " + compositeAnnotation
+ "; Composite Annot class: " + compositeAnnotClass
+ "; Java Annot class: " + javaAnnotationClass, e);
}
String msg = Messages.getMessage("DescriptionBuilderErr1",
compositeAnnotClass.toString(),
e.toString());
throw ExceptionFactory.makeWebServiceException(msg, e);
}
}
}
return returnAnnotation;
}
/** @return Returns the webServiceProviderAnnot. */
public WebServiceProviderAnnot getWebServiceProviderAnnot() {
return webServiceProviderAnnot =
(WebServiceProviderAnnot) getCompositeAnnotation(webServiceProviderAnnot,
WebServiceProviderAnnot.class,
javax.xml.ws.WebServiceProvider.class);
}
/** @return Returns the webServiceRefAnnot list. */
public List<WebServiceRefAnnot> getAllWebServiceRefAnnots() {
return webServiceRefAnnotList;
}
/** @return Returns the webServiceRefAnnot. */
public WebServiceRefAnnot getWebServiceRefAnnot(String name) {
WebServiceRefAnnot wsra = null;
Iterator<WebServiceRefAnnot> iter =
webServiceRefAnnotList.iterator();
while (iter.hasNext()) {
wsra = iter.next();
if (wsra.name().equals(name))
return wsra;
}
return wsra;
}
/** @return Returns the webServiceRefAnnot. */
public BindingTypeAnnot getBindingTypeAnnot() {
return (BindingTypeAnnot) getCompositeAnnotation(bindingTypeAnnot,
BindingTypeAnnot.class,
javax.xml.ws.BindingType.class);
}
public List<Annotation> getWebServiceFeatures() {
return features;
}
public void setWebServiceFeatures(List<Annotation> list) {
features = list;
}
public void addWebServiceFeature(Annotation a) {
if (features == null)
features = new ArrayList<Annotation>();
features.add(a);
}
/** @return Returns the wsdlDefinition */
public Definition getWsdlDefinition() {
if (wsdlDefinition != null) {
return wsdlDefinition;
} else if (wsdlWrapper != null) {
wsdlDefinition = wsdlWrapper.getDefinition();
} else {
wsdlDefinition = createWsdlDefinition(wsdlURL);
}
return wsdlDefinition;
}
/** @return Returns the wsdlURL */
public URL getWsdlURL() {
return this.wsdlURL;
}
/** Returns a collection of all MethodDescriptionComposites that match the specified name */
public List<MethodDescriptionComposite> getMethodDescriptionComposite(String methodName) {
ArrayList<MethodDescriptionComposite> matchingMethods =
new ArrayList<MethodDescriptionComposite>();
Iterator<MethodDescriptionComposite> iter = methodDescriptions.iterator();
while (iter.hasNext()) {
MethodDescriptionComposite composite = iter.next();
if (composite.getMethodName() != null) {
if (composite.getMethodName().equals(methodName)) {
matchingMethods.add(composite);
}
}
}
return matchingMethods;
}
/**
* Returns the nth occurence of this MethodComposite. Since method names are not unique, we have
* to account for multiple occurrences
*
* @param methodName
* @param occurence The nth occurance to return; not this is NOT 0 based
* @return Returns the methodDescriptionComposite
*/
public MethodDescriptionComposite getMethodDescriptionComposite(
String methodName,
int occurence) {
MethodDescriptionComposite returnMDC = null;
List<MethodDescriptionComposite> matchingMethods =
getMethodDescriptionComposite(methodName);
if (matchingMethods != null && !matchingMethods.isEmpty() &&
occurence > 0 && occurence <= matchingMethods.size()) {
returnMDC = matchingMethods.get(--occurence);
}
return returnMDC;
}
public List<MethodDescriptionComposite> getMethodDescriptionsList() {
return methodDescriptions;
}
/** @return Returns the methodDescriptionComposite..null if not found */
public FieldDescriptionComposite getFieldDescriptionComposite(String fieldName) {
FieldDescriptionComposite composite = null;
Iterator<FieldDescriptionComposite> iter =
fieldDescriptions.iterator();
while (iter.hasNext()) {
composite = iter.next();
if (composite.getFieldName().equals(fieldName))
return composite;
}
return composite;
}
/** @return Returns the ModuleClassType. */
public WsdlGenerator getCustomWsdlGenerator() {
return this.wsdlGenerator;
}
/** @return Returns the ClassLoader. */
public ClassLoader getClassLoader() {
return this.classLoader;
}
/** @return Returns true if this is an interface */
public boolean isInterface() {
return isInterface;
}
//++++++++
//Setters
//++++++++
public void setWebServiceAnnot(WebServiceAnnot webServiceAnnot) {
this.webServiceAnnot = webServiceAnnot;
}
/** @param classModifiers The classModifiers to set. */
public void setClassModifiers(String[] classModifiers) {
this.classModifiers = classModifiers;
}
/** @param className The className to set. */
public void setClassName(String className) {
this.className = className;
}
/** @param extendsClass The name of the super class to set. */
public void setSuperClassName(String extendsClass) {
this.extendsClass = extendsClass;
}
/** @param interfacesList The interfacesList to set. */
public void setInterfacesList(List<String> interfacesList) {
this.interfacesList = interfacesList;
}
/** @param handlerChainAnnot The handlerChainAnnot to set. */
public void setHandlerChainAnnot(HandlerChainAnnot handlerChainAnnot) {
this.handlerChainAnnot = handlerChainAnnot;
}
/** @param serviceModeAnnot The serviceModeAnnot to set. */
public void setServiceModeAnnot(ServiceModeAnnot serviceModeAnnot) {
this.serviceModeAnnot = serviceModeAnnot;
}
/** @param soapBindingAnnot The soapBindingAnnot to set. */
public void setSoapBindingAnnot(SoapBindingAnnot soapBindingAnnot) {
this.soapBindingAnnot = soapBindingAnnot;
}
/** @param webFaultAnnot The webFaultAnnot to set. */
public void setWebFaultAnnot(WebFaultAnnot webFaultAnnot) {
this.webFaultAnnot = webFaultAnnot;
}
/** @param webServiceClientAnnot The webServiceClientAnnot to set. */
public void setWebServiceClientAnnot(
WebServiceClientAnnot webServiceClientAnnot) {
this.webServiceClientAnnot = webServiceClientAnnot;
}
/** @param webServiceProviderAnnot The webServiceProviderAnnot to set. */
public void setWebServiceProviderAnnot(
WebServiceProviderAnnot webServiceProviderAnnot) {
this.webServiceProviderAnnot = webServiceProviderAnnot;
}
/** @param webServiceRefAnnot The webServiceRefAnnot to add to the list. */
public void addWebServiceRefAnnot(
WebServiceRefAnnot webServiceRefAnnot) {
webServiceRefAnnotList.add(webServiceRefAnnot);
}
public void setWebServiceRefAnnot(WebServiceRefAnnot webServiceRefAnnot) {
addWebServiceRefAnnot(webServiceRefAnnot);
}
public void addCustomAnnotationProcessor(CustomAnnotationProcessor processor) {
genericAnnotationProcessors.put(processor.getAnnotationInstanceClassName(), processor);
}
public Map<String, CustomAnnotationProcessor> getCustomAnnotationProcessors() {
return genericAnnotationProcessors;
}
public void addCustomAnnotationInstance(CustomAnnotationInstance annotation) {
genericAnnotationInstances.add(annotation);
}
public List<CustomAnnotationInstance> getCustomAnnotationInstances() {
return genericAnnotationInstances;
}
/**
* @param wsdlDefinition The wsdlDefinition to set.
*/
public void setWsdlDefinition(Definition wsdlDef) {
Definition def = null;
if (wsdlDef != null) {
if (wsdlDef instanceof WSDL4JWrapper) {
wsdlWrapper = (WSDL4JWrapper) wsdlDef;
def = wsdlWrapper.getDefinition();
} else {
try {
if (myConfigContext != null) {
// Construct WSDL4JWrapper with configuration information
wsdlWrapper = new WSDL4JWrapper(wsdlDef,
myConfigContext);
} else {
// If there is no configuration, default to using a
// memory sensitive wrapper
wsdlWrapper = new WSDL4JWrapper(wsdlDef, true, 2);
}
def = wsdlWrapper.getDefinition();
} catch (Exception ex) {
// absorb
}
}
if (def != null) {
String wsdlDefinitionBaseURI = def.getDocumentBaseURI();
if ((wsdlDefinitionBaseURI != null) && (wsdlURL == null)) {
try {
wsdlURL = new URL(wsdlDefinitionBaseURI);
} catch (Exception e) {
if (log.isDebugEnabled()) {
log.debug("DescriptionBuilderComposite:setWsdlDefinition(): "
+"Caught exception creating WSDL URL :"
+ wsdlDefinitionBaseURI + "; exception: "
+e.toString(),e);
}
}
}
}
}
}
/** @param wsdlURL The wsdlURL to set. */
public void setwsdlURL(URL wsdlURL) {
this.wsdlURL = wsdlURL;
}
/** @param BindingTypeAnnot The BindingTypeAnnot to set. */
public void setBindingTypeAnnot(
BindingTypeAnnot bindingTypeAnnot) {
this.bindingTypeAnnot = bindingTypeAnnot;
}
/** @param isInterface Sets whether this composite represents a class or interface */
public void setIsInterface(boolean isInterface) {
this.isInterface = isInterface;
}
/** @param methodDescription The methodDescription to add to the set. */
public void addMethodDescriptionComposite(MethodDescriptionComposite methodDescription) {
methodDescriptions.add(methodDescription);
}
/** @param methodDescription The methodDescription to add to the set. */
public void addFieldDescriptionComposite(FieldDescriptionComposite fieldDescription) {
fieldDescriptions.add(fieldDescription);
}
public void setCustomWsdlGenerator(WsdlGenerator wsdlGenerator) {
this.wsdlGenerator = wsdlGenerator;
}
public void setClassLoader(ClassLoader classLoader) {
this.classLoader = classLoader;
}
public HandlerChainsType getHandlerChainsType() {
return handlerChainsType;
}
public void setHandlerChainsType(HandlerChainsType handlerChainsType) {
this.handlerChainsType = handlerChainsType;
}
/**
* Answer does this composite represent a service requester (aka client) or a service
* provider (aka server).
*
* @return true if this is a service provider (aka an endpoint or a service implementation
* or a server)
*
*/
public boolean isServiceProvider() {
return isServiceProvider;
}
/**
* Set the indication of whether this composite represents a service requester (aka client) or
* a service provider (aka server).
*/
public void setIsServiceProvider(boolean value) {
isServiceProvider = value;
}
/**
* Set the class associated with this composite. For a service requester, this could be the
* Service class or the SEI class. For a service provider this will be null (unless the
* deprecated service construction logic in DescriptionFactory is used)
* @param theClass
*/
public void setCorrespondingClass(Class theClass) {
this.theCorrespondingClass = theClass;
}
/**
* Returns the corresponding class associated with this composite, if any.
* @return
*/
public Class getCorrespondingClass() {
return theCorrespondingClass;
}
/**
* Set the Catalog Manager associated with this composite.
* @param theCatalogManger
*/
public void setCatalogManager(JAXWSCatalogManager theCatalogManager) {
this.catalogManager = theCatalogManager;
}
/**
* Returns the catalog manager associated with this composite, if any.
* @return
*/
public JAXWSCatalogManager getCatalogManager() {
return catalogManager;
}
public void setProperties(Map<String, Object> properties) {
this.properties = properties;
}
public Map<String, Object> getProperties() {
return properties;
}
/**
* Store a WSDL Definition keyed by a service QName
*/
public void setWsdlDefinition(QName serviceQName, Definition definition) {
this.wsdlDefs.put(serviceQName, definition);
}
/**
* Retrive a WSDL Definition by a service QName
*/
public Definition getWsdlDefinition(QName serviceQName) {
return wsdlDefs.get(serviceQName);
}
/**
* Store a WSDL URL keyed by a service QName
*/
public void setwsdlURL(QName serviceQName, URL url) {
wsdlURLs.put(serviceQName, url);
}
/**
* Retrive a WSDL URL by a service QName
*/
public URL getWsdlURL(QName serviceQName) {
return wsdlURLs.get(serviceQName);
}
/**
* Add the set of wsdl:service QNames that are represented by this DBC's metadata
*/
public void setServiceQNames(Set<QName> serviceQNames) {
this.serviceQNames = serviceQNames;
}
/**
* Get the set of wsdl:service QNames represented by this DBC's metadata
* @return
*/
public Set<QName> getServiceQNames() {
return serviceQNames;
}
/**
* Convenience method for unit testing. We will print all of the
* data members here.
*/
public String toString() {
StringBuffer sb = new StringBuffer();
final String newLine = "\n";
final String sameLine = "; ";
sb.append(super.toString());
sb.append(newLine);
sb.append("ClassName: " + className);
sb.append(sameLine);
sb.append("SuperClass:" + extendsClass);
sb.append(newLine);
sb.append("Class modifiers: ");
if (classModifiers != null) {
for (int i = 0; i < classModifiers.length; i++) {
sb.append(classModifiers[i]);
sb.append(sameLine);
}
}
sb.append(newLine);
sb.append("is Service Provider: " + isServiceProvider() );
sb.append(newLine);
sb.append("wsdlURL: " + getWsdlURL() );
sb.append(newLine);
sb.append("has wsdlDefinition?: ");
if (wsdlDefinition !=null) {
sb.append("true");
} else {
sb.append("false");
}
sb.append(newLine);
sb.append("Interfaces: ");
Iterator<String> intIter = interfacesList.iterator();
while (intIter.hasNext()) {
String inter = intIter.next();
sb.append(inter);
sb.append(sameLine);
}
if (webServiceAnnot != null) {
sb.append(newLine);
sb.append("WebService: ");
sb.append(webServiceAnnot.toString());
}
if (webServiceProviderAnnot != null) {
sb.append(newLine);
sb.append("WebServiceProvider: ");
sb.append(webServiceProviderAnnot.toString());
}
if (bindingTypeAnnot != null) {
sb.append(newLine);
sb.append("BindingType: ");
sb.append(bindingTypeAnnot.toString());
}
if (webServiceClientAnnot != null) {
sb.append(newLine);
sb.append("WebServiceClient: ");
sb.append(webServiceClientAnnot.toString());
}
if (webFaultAnnot != null) {
sb.append(newLine);
sb.append("WebFault: ");
sb.append(webFaultAnnot.toString());
}
if (serviceModeAnnot != null) {
sb.append(newLine);
sb.append("ServiceMode: ");
sb.append(serviceModeAnnot.toString());
}
if (soapBindingAnnot != null) {
sb.append(newLine);
sb.append("SOAPBinding: ");
sb.append(soapBindingAnnot.toString());
}
if (handlerChainAnnot != null) {
sb.append(newLine);
sb.append("HandlerChain: ");
sb.append(handlerChainAnnot.toString());
}
if (webServiceRefAnnotList.size() > 0) {
sb.append(newLine);
sb.append("Number of WebServiceRef: " + webServiceRefAnnotList.size());
Iterator<WebServiceRefAnnot> wsrIter = webServiceRefAnnotList.iterator();
while (wsrIter.hasNext()) {
WebServiceRefAnnot wsr = wsrIter.next();
sb.append(wsr.toString());
sb.append(sameLine);
}
}
sb.append(newLine);
sb.append("Number of Method Descriptions: " + methodDescriptions.size());
Iterator<MethodDescriptionComposite> mdcIter = methodDescriptions.iterator();
while (mdcIter.hasNext()) {
sb.append(newLine);
MethodDescriptionComposite mdc = mdcIter.next();
sb.append(mdc.toString());
}
sb.append(newLine);
sb.append("Number of Field Descriptions: " + fieldDescriptions.size());
Iterator<FieldDescriptionComposite> fdcIter = fieldDescriptions.iterator();
while (fdcIter.hasNext()) {
sb.append(newLine);
FieldDescriptionComposite fdc = fdcIter.next();
sb.append(fdc.toString());
}
if (features != null && !features.isEmpty()) {
sb.append(newLine);
sb.append(newLine);
sb.append("WebService Feature Objects (as annotations):");
sb.append(newLine);
for (Annotation annotation : features) {
sb.append(annotation.toString());
sb.append(newLine);
}
}
if(portCompositeList != null
&&
!portCompositeList.isEmpty()) {
sb.append(newLine);
sb.append(newLine);
sb.append("** PortComposite Objects**");
sb.append(newLine);
for(PortComposite pc : portCompositeList) {
sb.append("PortComposite");
sb.append(newLine);
sb.append(pc.toString());
sb.append(newLine);
}
}
return sb.toString();
}
/**
* Create a wsdl definition from the supplied
* location.
*
* @param _wsdlURL The URL where the wsdl is located
* @return The WSDL Definition or NULL
*/
private Definition createWsdlDefinition(URL _wsdlURL) {
if (_wsdlURL == null) {
return null;
}
Definition wsdlDef = null;
try {
if (log.isDebugEnabled() ) {
log.debug("new WSDL4JWrapper(" + _wsdlURL.toString() + ",ConfigurationContext" );
}
wsdlWrapper = new WSDL4JWrapper(_wsdlURL, myConfigContext);
if (wsdlWrapper != null) {
wsdlDef = wsdlWrapper.getDefinition();
}
} catch (Exception e) {
if (log.isDebugEnabled()) {
log.debug("DescriptionBuilderComposite:createWsdlDefinition("
+ _wsdlURL.toString()
+ "): Caught exception trying to create WSDL Definition: "
+e, e);
}
}
return wsdlDef;
}
public ConfigurationContext getConfigurationContext() {
return myConfigContext;
}
/**
* Adds a PortComposite to the generic list. This list of PortComposite objects
* is not keyed by wsdl:service QName.
*/
public void addPortComposite(PortComposite portDBC) {
portCompositeList.add(portDBC);
}
/**
* Adds a PortComposite to a list that is keyed by a wsdl:service QName.
*/
public void addPortComposite(QName serviceQName, PortComposite portDBC) {
List<PortComposite> pcList = sQNameToPC.get(serviceQName);
if(pcList == null) {
pcList = new LinkedList<PortComposite>();
sQNameToPC.put(serviceQName, pcList);
}
pcList.add(portDBC);
}
/**
* Gets the generic PortComposite instances.
*/
public List<PortComposite> getPortComposites() {
return portCompositeList;
}
/**
* Gets all the PortComposite instances associated with a particular wsdl:service QName.
* @return
*/
public List<PortComposite> getPortComposites(QName serviceQName) {
return sQNameToPC.get(serviceQName);
}
/**
* Static utility method that, given a sparse composite, returns the SERVICE_REF_NAME value from the property
* on that sparse composite or null if the property was not specified.
* @param sparseComposite The sparse composite instance to get the SERVICE_REF_NAME parameter from
* @return A String containing the Service Ref Name or null if the parameter was not found.
*/
public static String getServiceRefName(DescriptionBuilderComposite sparseComposite) {
String serviceRefName = null;
if (sparseComposite != null) {
serviceRefName = (String) sparseComposite.getProperties().get(MDQConstants.SERVICE_REF_NAME);
}
return serviceRefName;
}
/**
* For the current composite, return the serivce ref name from the sparse composite associted with the service
* delegate key.
* @param serviceDelegateKey The instance of the service delegate associated with the sparse composite from which
* the service ref name is to be retrieved.
* @return The service ref name associated with the service delegate key or null if one was not found.
*/
public String getServiceRefName(Object serviceDelegateKey) {
String serviceRefName = null;
if (serviceDelegateKey != null) {
serviceRefName = getServiceRefName(getSparseComposite(serviceDelegateKey));
}
return serviceRefName;
}
}