jdk8-mips64-public/jaxws: src/share/jaxws_classes/com/sun/xml/internal/ws/model/RuntimeModeler.java@f50545b5e2f1 (annotated)

src/share/jaxws_classes/com/sun/xml/internal/ws/model/RuntimeModeler.java@f50545b5e2f1 (annotated)

src/share/jaxws_classes/com/sun/xml/internal/ws/model/RuntimeModeler.java

Tue, 06 Mar 2012 16:09:35 -0800

author: ohair
date: Tue, 06 Mar 2012 16:09:35 -0800
changeset 286: f50545b5e2f1
child 368: 0989ad8c0860
permissions: -rw-r--r--

7150322: Stop using drop source bundles in jaxws
Reviewed-by: darcy, ohrstrom

 /*
  * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */
 package com.sun.xml.internal.ws.model;
 import com.sun.istack.internal.NotNull;
 import com.sun.xml.internal.ws.api.BindingID;
 import com.sun.xml.internal.ws.api.SOAPVersion;
 import com.sun.xml.internal.ws.api.WSBinding;
 import com.sun.xml.internal.ws.api.databinding.DatabindingConfig;
 import com.sun.xml.internal.ws.api.databinding.MetadataReader;
 import com.sun.xml.internal.ws.api.model.ExceptionType;
 import com.sun.xml.internal.ws.api.model.MEP;
 import com.sun.xml.internal.ws.api.model.Parameter;
 import com.sun.xml.internal.ws.api.model.ParameterBinding;
 import com.sun.xml.internal.ws.api.model.wsdl.WSDLBoundOperation;
 import com.sun.xml.internal.ws.api.model.wsdl.WSDLInput;
 import com.sun.xml.internal.ws.api.model.wsdl.WSDLPart;
 import com.sun.xml.internal.ws.api.model.wsdl.WSDLPort;
 import com.sun.xml.internal.ws.binding.WebServiceFeatureList;
 import com.sun.xml.internal.ws.model.soap.SOAPBindingImpl;
 import com.sun.xml.internal.ws.resources.ModelerMessages;
 import com.sun.xml.internal.ws.resources.ServerMessages;
 import com.sun.xml.internal.ws.spi.db.BindingContext;
 import com.sun.xml.internal.ws.spi.db.BindingHelper;
 import com.sun.xml.internal.ws.spi.db.TypeInfo;
 import com.sun.xml.internal.ws.spi.db.WrapperComposite;
 import com.sun.xml.internal.ws.util.localization.Localizable;
 import com.sun.xml.internal.org.jvnet.ws.databinding.DatabindingMode;
 import javax.jws.*;
 import javax.jws.WebParam.Mode;
 import javax.jws.soap.SOAPBinding;
 import javax.jws.soap.SOAPBinding.Style;
 import javax.xml.bind.annotation.XmlElement;
 import javax.xml.bind.annotation.XmlSeeAlso;
 import javax.xml.namespace.QName;
 import javax.xml.ws.*;
 import javax.xml.ws.soap.MTOM;
 import javax.xml.ws.soap.MTOMFeature;
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
 import java.rmi.RemoteException;
 import java.security.AccessController;
 import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;
 import java.util.StringTokenizer;
 import java.util.TreeMap;
 import java.util.concurrent.Future;
 import java.util.logging.Logger;
 import static javax.jws.soap.SOAPBinding.ParameterStyle.WRAPPED;
 /**
  * Creates a runtime model of a SEI (portClass).
  *
  * @author WS Developement Team
  */
 public class RuntimeModeler {
     private final WebServiceFeatureList features;
     private BindingID bindingId;
     private WSBinding wsBinding;
     private final Class portClass;
     private AbstractSEIModelImpl model;
     private SOAPBindingImpl defaultBinding;
     // can be empty but never null
     private String packageName;
     private String targetNamespace;
     private boolean isWrapped = true;
     private ClassLoader classLoader;
     private final WSDLPort binding;
     private QName serviceName;
     private QName portName;
     private Set<Class> classUsesWebMethod;
     private DatabindingConfig config;
     private MetadataReader metadataReader;
     /**
      *
      */
     public static final String PD_JAXWS_PACKAGE_PD  = ".jaxws.";
     /**
      *
      */
     public static final String JAXWS_PACKAGE_PD     = "jaxws.";
     public static final String RESPONSE             = "Response";
     public static final String RETURN               = "return";
     public static final String BEAN                 = "Bean";
     public static final String SERVICE              = "Service";
     public static final String PORT                 = "Port";
     public static final Class HOLDER_CLASS = Holder.class;
     public static final Class<RemoteException> REMOTE_EXCEPTION_CLASS = RemoteException.class;
     public static final Class<RuntimeException> RUNTIME_EXCEPTION_CLASS = RuntimeException.class;
     public static final Class<Exception> EXCEPTION_CLASS = Exception.class;
   /*public RuntimeModeler(@NotNull Class portClass, @NotNull QName serviceName, @NotNull BindingID bindingId, @NotNull WebServiceFeature... features) {
         this(portClass, serviceName, null, bindingId, features);
     }*/
     /**
      *
      * creates an instance of RunTimeModeler given a <code>sei</code> and <code>binding</code>
      * @param portClass The SEI class to be modeled.
      * @param serviceName The ServiceName to use instead of one calculated from the implementation class
      * @param wsdlPort {@link com.sun.xml.internal.ws.api.model.wsdl.WSDLPort}
      * @param features web service features
      */
   /*public RuntimeModeler(@NotNull Class portClass, @NotNull QName serviceName, @NotNull WSDLPortImpl wsdlPort, @NotNull WebServiceFeature... features){
         this(portClass, serviceName, wsdlPort, wsdlPort.getBinding().getBindingId(), features);
     }*/
   /*private RuntimeModeler(@NotNull Class portClass, @NotNull QName serviceName, WSDLPortImpl binding, BindingID bindingId, @NotNull WebServiceFeature... features) {
         this.portClass = portClass;
         this.serviceName = serviceName;
         this.binding = binding;
         this.bindingId = bindingId;
         this.features = features;
     }*/
     public RuntimeModeler(@NotNull DatabindingConfig config){
         this.portClass = (config.getEndpointClass() != null)? config.getEndpointClass() : config.getContractClass();
         this.serviceName = config.getMappingInfo().getServiceName();
         this.binding = config.getWsdlPort();
         this.classLoader = config.getClassLoader();
         this.portName = config.getMappingInfo().getPortName();
         this.config = config;
         this.wsBinding = config.getWSBinding();
         metadataReader = config.getMetadataReader();
         if (metadataReader == null) metadataReader = new ReflectAnnotationReader();
         if (wsBinding != null) {
             this.bindingId = wsBinding.getBindingId();
                 if (config.getFeatures() != null) wsBinding.getFeatures().mergeFeatures(config.getFeatures(), false);
                 if (binding != null) wsBinding.getFeatures().mergeFeatures(binding.getFeatures(), false);
                 this.features = WebServiceFeatureList.toList(wsBinding.getFeatures());
         } else {
             this.bindingId = config.getMappingInfo().getBindingID();
             if (binding != null) bindingId = binding.getBinding().getBindingId();
             if (bindingId == null) bindingId = getDefaultBindingID();
             this.features = WebServiceFeatureList.toList(config.getFeatures());
             if (!features.contains(MTOMFeature.class)) {
                 MTOM mtomAn = getAnnotation(portClass, MTOM.class);
                 if (mtomAn != null) features.add(WebServiceFeatureList.getFeature(mtomAn));
             }
             this.wsBinding = bindingId.createBinding(features);
         }
     }
     private BindingID getDefaultBindingID() {
         BindingType bt = getAnnotation(portClass, BindingType.class);
         String id = (bt != null) ? bt.value() :  javax.xml.ws.soap.SOAPBinding.SOAP11HTTP_BINDING;
                 return BindingID.parse(id);
         }
         /**
      * sets the classloader to be used when loading classes by the <code>RuntimeModeler</code>.
      * @param classLoader ClassLoader used to load classes
      */
     public void setClassLoader(ClassLoader classLoader) {
         this.classLoader = classLoader;
     }
     /**
      * sets the PortName to be used by the <code>RuntimeModeler</code>.
      * @param portName The PortName to be used instead of the PortName
      * retrieved via annotations
      */
     public void setPortName(QName portName) {
         this.portName = portName;
     }
     private <T extends Annotation> T getAnnotation(final Class<?> clazz, final Class<T> T) {
         return metadataReader.getAnnotation(T, clazz);
 //        return AccessController.doPrivileged(new PrivilegedAction<T>() {
 //           public T run() {
 //               return clazz.getAnnotation(T);
 //           }
 //        });
     }
     private <T extends Annotation> T getAnnotation(final Method method, final Class<T> T) {
         return metadataReader.getAnnotation(T, method);
 //        return AccessController.doPrivileged(new PrivilegedAction<T>() {
 //           public T run() {
 //               return method.getAnnotation(T);
 //           }
 //        });
     }
     private Annotation[] getAnnotations(final Method method) {
         return metadataReader.getAnnotations(method);
     }
     private Annotation[] getAnnotations(final Class<?> c) {
         return metadataReader.getAnnotations(c);
     }
     private Annotation[][] getParamAnnotations(final Method method) {
         return metadataReader.getParameterAnnotations(method);
 //        return AccessController.doPrivileged(new PrivilegedAction<Annotation[][]>() {
 //           public Annotation[][] run() {
 //               return method.getParameterAnnotations();
 //           }
 //        });
     }
     private static final Logger logger =
         Logger.getLogger(
             com.sun.xml.internal.ws.util.Constants.LoggingDomain + ".server");
     //currently has many local vars which will be eliminated after debugging issues
     //first draft
     /**
      * builds the runtime model from the <code>portClass</code> using the binding ID <code>bindingId</code>.
      * @return the runtime model for the <code>portClass</code>.
      */
     public AbstractSEIModelImpl buildRuntimeModel() {
         model = new SOAPSEIModel(features);
         model.contractClass = config.getContractClass();
         model.endpointClass = config.getEndpointClass();
         model.classLoader = this.classLoader;
         model.wsBinding = wsBinding;
         model.databindingInfo.properties().putAll(config.properties());
         if (model.contractClass == null) model.contractClass = portClass;
         if (model.endpointClass == null && !portClass.isInterface()) model.endpointClass = portClass;
         Class<?> seiClass = portClass;
         metadataReader.getProperties(model.databindingInfo.properties(), portClass);
         WebService webService = getAnnotation(portClass, WebService.class);
         if (webService == null) {
             throw new RuntimeModelerException("runtime.modeler.no.webservice.annotation",
                 portClass.getCanonicalName());
         }
         Class<?> seiFromConfig = configEndpointInterface();
         if (webService.endpointInterface().length() > 0 || seiFromConfig != null) {
                 if (seiFromConfig != null) {
                         seiClass = seiFromConfig;
                 } else {
                         seiClass = getClass(webService.endpointInterface(), ModelerMessages.localizableRUNTIME_MODELER_CLASS_NOT_FOUND(webService.endpointInterface()));
                 }
             model.contractClass = seiClass;
                 model.endpointClass = portClass;
             WebService seiService = getAnnotation(seiClass, WebService.class);
             if (seiService == null) {
                 throw new RuntimeModelerException("runtime.modeler.endpoint.interface.no.webservice",
                     webService.endpointInterface());
             }
             //check if @SOAPBinding is defined on the impl class
             SOAPBinding sbPortClass = getAnnotation(portClass, SOAPBinding.class);
             SOAPBinding sbSei = getAnnotation(seiClass, SOAPBinding.class);
             if(sbPortClass != null){
                 if(sbSei == null || sbSei.style() != sbPortClass.style()|| sbSei.use() != sbPortClass.use()){
                     logger.warning(ServerMessages.RUNTIMEMODELER_INVALIDANNOTATION_ON_IMPL("@SOAPBinding", portClass.getName(), seiClass.getName()));
                 }
             }
         }
         if (serviceName == null)
             serviceName = getServiceName(portClass, metadataReader);
         model.setServiceQName(serviceName);
 //        String portLocalName  = portClass.getSimpleName()+PORT;
 //        if (webService.portName().length() >0) {
 //            portLocalName = webService.portName();
 //        } else if (webService.name().length() >0) {
 //            portLocalName = webService.name()+PORT;
 //        }
 //
 //        if (portName == null)
 //            portName = new QName(serviceName.getNamespaceURI(), portLocalName);
 //        if (!portName.getNamespaceURI().equals(serviceName.getNamespaceURI())) {
 //            throw new RuntimeModelerException("runtime.modeler.portname.servicename.namespace.mismatch",
 //                serviceName, portName);
 //        }
         if (portName == null) portName = getPortName(portClass, serviceName.getNamespaceURI(), metadataReader);
         model.setPortName(portName);
         // Check if databinding is overridden in annotation.
         DatabindingMode dbm = getAnnotation(portClass, DatabindingMode.class);
         if (dbm != null) model.databindingInfo.setDatabindingMode(dbm.value());
         processClass(seiClass);
         if (model.getJavaMethods().size() == 0)
             throw new RuntimeModelerException("runtime.modeler.no.operations",
                     portClass.getName());
         model.postProcess();
         // Make the configured databinding mode available to the
         // DatabindingConfig.
         config.properties().put(BindingContext.class.getName(),
                 model.bindingContext);
         // TODO: this needs to be fixed properly --
         // when we are building RuntimeModel first before building WSDLModel,
         // we still need to do this correctly
         if(binding!=null)
             model.freeze(binding);
         return model;
     }
     private Class configEndpointInterface() {
                 if (config.getEndpointClass() == null ||
                     config.getEndpointClass().isInterface()     ) return null; //client proxy Interface
                 return config.getContractClass();
         }
         /**
      * utility method to load classes
      * @param className the name of the class to load
      * @param errorMessage
      *      Error message to use when the resolution fails.
      * @return the class specified by <code>className</code>
      */
     private Class getClass(String className, Localizable errorMessage) {
         try {
             if (classLoader == null)
                 return Thread.currentThread().getContextClassLoader().loadClass(className);
             else
                 return classLoader.loadClass(className);
         } catch (ClassNotFoundException e) {
             throw new RuntimeModelerException(errorMessage);
         }
     }
     private Class getRequestWrapperClass(String className, Method method, QName reqElemName) {
         ClassLoader loader =  (classLoader == null) ? Thread.currentThread().getContextClassLoader() : classLoader;
         try {
             return loader.loadClass(className);
         } catch (ClassNotFoundException e) {
             logger.fine("Dynamically creating request wrapper Class " + className);
             return WrapperBeanGenerator.createRequestWrapperBean(className, method, reqElemName, loader);
         }
     }
     private Class getResponseWrapperClass(String className, Method method, QName resElemName) {
         ClassLoader loader =  (classLoader == null) ? Thread.currentThread().getContextClassLoader() : classLoader;
         try {
             return loader.loadClass(className);
         } catch (ClassNotFoundException e) {
             logger.fine("Dynamically creating response wrapper bean Class " + className);
             return WrapperBeanGenerator.createResponseWrapperBean(className, method, resElemName, loader);
         }
     }
     private Class getExceptionBeanClass(String className, Class exception, String name, String namespace) {
         ClassLoader loader =  (classLoader == null) ? Thread.currentThread().getContextClassLoader() : classLoader;
         try {
             return loader.loadClass(className);
         } catch (ClassNotFoundException e) {
             logger.fine("Dynamically creating exception bean Class " + className);
             return WrapperBeanGenerator.createExceptionBean(className, exception, targetNamespace, name, namespace, loader);
         }
     }
     protected void determineWebMethodUse(Class clazz) {
         if (clazz == null)
             return;
         if (!clazz.isInterface()) {
             if (clazz == Object.class)
                 return;
             WebMethod webMethod;
             for (Method method : clazz.getMethods()) {
                 if (method.getDeclaringClass()!=clazz)
                     continue;
                 webMethod = getAnnotation(method, WebMethod.class);
                 if (webMethod != null && !webMethod.exclude()) {
                     classUsesWebMethod.add(clazz);
                     break;
                 }
             }
         }
         determineWebMethodUse(clazz.getSuperclass());
     }
     void processClass(Class clazz) {
         classUsesWebMethod = new HashSet<Class>();
         determineWebMethodUse(clazz);
         WebService webService = getAnnotation(clazz, WebService.class);
         QName portTypeName = getPortTypeName(clazz, targetNamespace, metadataReader);
 //        String portTypeLocalName  = clazz.getSimpleName();
 //        if (webService.name().length() >0)
 //            portTypeLocalName = webService.name();
 //
 //        targetNamespace = webService.targetNamespace();
         packageName = "";
         if (clazz.getPackage() != null)
             packageName = clazz.getPackage().getName();
 //        if (targetNamespace.length() == 0) {
 //            targetNamespace = getNamespace(packageName);
 //        }
 //        model.setTargetNamespace(targetNamespace);
 //        QName portTypeName = new QName(targetNamespace, portTypeLocalName);
         targetNamespace = portTypeName.getNamespaceURI();
         model.setPortTypeName(portTypeName);
         model.setTargetNamespace(targetNamespace);
         model.setWSDLLocation(webService.wsdlLocation());
         SOAPBinding soapBinding = getAnnotation(clazz, SOAPBinding.class);
         if (soapBinding != null) {
             if (soapBinding.style() == SOAPBinding.Style.RPC && soapBinding.parameterStyle() == SOAPBinding.ParameterStyle.BARE) {
                 throw new RuntimeModelerException("runtime.modeler.invalid.soapbinding.parameterstyle",
                         soapBinding, clazz);
             }
             isWrapped = soapBinding.parameterStyle()== WRAPPED;
         }
         defaultBinding = createBinding(soapBinding);
         /*
          * if clazz != portClass then there is an SEI.  If there is an
          * SEI, then all methods should be processed.  However, if there is
          * no SEI, and the implementation class uses at least one
          * WebMethod annotation, then only methods with this annotation
          * will be processed.
          */
 /*        if (clazz == portClass) {
             WebMethod webMethod;
             for (Method method : clazz.getMethods()) {
                 webMethod = getPrivMethodAnnotation(method, WebMethod.class);
                 if (webMethod != null &&
                     !webMethod.exclude()) {
                     usesWebMethod = true;
                     break;
                 }
             }
         }*/
         for (Method method : clazz.getMethods()) {
             if (!clazz.isInterface()) {     // if clazz is SEI, then all methods are web methods
                 if (!getBooleanSystemProperty("com.sun.xml.internal.ws.legacyWebMethod")) {  // legacy webMethod computation behaviour to be used
                     if (!isWebMethodBySpec(method, clazz))
                         continue;
                 } else {
                     if (method.getDeclaringClass() == Object.class || !isWebMethod(method))
                         continue;
                 }
             }
             // TODO: binding can be null. We need to figure out how to post-process
             // RuntimeModel to link to WSDLModel
             processMethod(method);
         }
         //Add additional jaxb classes referenced by {@link XmlSeeAlso}
         XmlSeeAlso xmlSeeAlso = getAnnotation(clazz, XmlSeeAlso.class);
         if(xmlSeeAlso != null)
             model.addAdditionalClasses(xmlSeeAlso.value());
     }
     /*
      * Section 3.3 of spec
      * Otherwise, the class implicitly defines a service endpoint interface (SEI) which
      * comprises all of the public methods that satisfy one of the following conditions:
      *  1. They are annotated with the javax.jws.WebMethod annotation with the exclude element set to
      *     false or missing (since false is the default for this annotation element).
      *  2. They are not annotated with the javax.jws.WebMethod annotation but their declaring class has a
      *     javax.jws.WebService annotation.
      *
      * also the method should non-static or non-final
      */
     private boolean isWebMethodBySpec(Method method, Class clazz) {
         int modifiers = method.getModifiers();
         boolean staticFinal = Modifier.isStatic(modifiers) || Modifier.isFinal(modifiers);
         assert Modifier.isPublic(modifiers);
         assert !clazz.isInterface();
         WebMethod webMethod = getAnnotation(method, WebMethod.class);
         if (webMethod != null) {
             if (webMethod.exclude()) {
                 return false;       // @WebMethod(exclude="true")
             }
             if (staticFinal) {
                 throw new RuntimeModelerException(ModelerMessages.localizableRUNTIME_MODELER_WEBMETHOD_MUST_BE_NONSTATICFINAL(method));
             }
             return true;            // @WebMethod
         }
         if (staticFinal) {
             return false;
         }
         Class declClass = method.getDeclaringClass();
         return getAnnotation(declClass, WebService.class) != null;
     }
     private boolean isWebMethod(Method method) {
         int modifiers = method.getModifiers();
         if (Modifier.isStatic(modifiers) || Modifier.isFinal(modifiers))
             return false;
         Class clazz = method.getDeclaringClass();
         boolean declHasWebService = getAnnotation(clazz, WebService.class) != null;
         WebMethod webMethod = getAnnotation(method, WebMethod.class);
         if (webMethod != null && !webMethod.exclude() && declHasWebService)
             return true;
         return declHasWebService && !classUsesWebMethod.contains(clazz);
     }
     /**
      * creates a runtime model <code>SOAPBinding</code> from a <code>javax.jws.soap.SOAPBinding</code> object
      * @param soapBinding the <code>javax.jws.soap.SOAPBinding</code> to model
      * @return returns the runtime model SOAPBinding corresponding to <code>soapBinding</code>
      */
     protected SOAPBindingImpl createBinding(SOAPBinding soapBinding) {
         SOAPBindingImpl rtSOAPBinding = new SOAPBindingImpl();
         Style style = soapBinding!=null ? soapBinding.style() : Style.DOCUMENT;
         rtSOAPBinding.setStyle(style);
         assert bindingId != null;
         model.bindingId = bindingId;
         SOAPVersion soapVersion = bindingId.getSOAPVersion();
         rtSOAPBinding.setSOAPVersion(soapVersion);
         return rtSOAPBinding;
     }
     /**
      * gets the namespace <code>String</code> for a given <code>packageName</code>
      * @param packageName the name of the package used to find a namespace.
      *      can be empty.
      * @return the namespace for the specified <code>packageName</code>
      */
     public static String getNamespace(@NotNull String packageName) {
         if (packageName.length() == 0)
             return null;
         StringTokenizer tokenizer = new StringTokenizer(packageName, ".");
         String[] tokens;
         if (tokenizer.countTokens() == 0) {
             tokens = new String[0];
         } else {
             tokens = new String[tokenizer.countTokens()];
             for (int i=tokenizer.countTokens()-1; i >= 0; i--) {
                 tokens[i] = tokenizer.nextToken();
             }
         }
         StringBuilder namespace = new StringBuilder("http://");
         for (int i=0; i<tokens.length; i++) {
             if (i!=0)
                 namespace.append('.');
             namespace.append(tokens[i]);
         }
         namespace.append('/');
         return namespace.toString();
     }
     /*
      * Returns true if an exception is service specific exception as per JAX-WS rules.
      * @param exception
      * @return
      */
     private boolean isServiceException(Class<?> exception) {
         return EXCEPTION_CLASS.isAssignableFrom(exception) &&
                 !(RUNTIME_EXCEPTION_CLASS.isAssignableFrom(exception) || REMOTE_EXCEPTION_CLASS.isAssignableFrom(exception));
     }
     /**
      * creates the runtime model for a method on the <code>portClass</code>
      * @param method the method to model
      */
     private void processMethod(Method method) {
         int mods = method.getModifiers();
         WebMethod webMethod = getAnnotation(method, WebMethod.class);
 /*
         validations are already done
         if (!Modifier.isPublic(mods) || Modifier.isStatic(mods)) {
             if(webMethod != null) {
                 // if the user put @WebMethod on these non-qualifying method,
                 // it's an error
                 if(Modifier.isStatic(mods))
                     throw new RuntimeModelerException(ModelerMessages.localizableRUNTIME_MODELER_WEBMETHOD_MUST_BE_NONSTATIC(method));
                 else
                     throw new RuntimeModelerException(ModelerMessages.localizableRUNTIME_MODELER_WEBMETHOD_MUST_BE_PUBLIC(method));
             }
             return;
         }
         if (webMethod != null && webMethod.exclude())
             return;
 */
         String methodName = method.getName();
         boolean isOneway = (getAnnotation(method, Oneway.class) != null);
         //Check that oneway methods don't thorw any checked exceptions
         if (isOneway) {
             for (Class<?> exception : method.getExceptionTypes()) {
                 if(isServiceException(exception)) {
                        throw new RuntimeModelerException("runtime.modeler.oneway.operation.no.checked.exceptions",
                             portClass.getCanonicalName(), methodName, exception.getName());
                 }
             }
         }
         JavaMethodImpl javaMethod;
         //Class implementorClass = portClass;
         if (method.getDeclaringClass()==portClass) {
             javaMethod = new JavaMethodImpl(model,method,method,metadataReader);
         } else {
             try {
                 Method tmpMethod = portClass.getMethod(method.getName(),
                     method.getParameterTypes());
                 javaMethod = new JavaMethodImpl(model,tmpMethod,method,metadataReader);
             } catch (NoSuchMethodException e) {
                 throw new RuntimeModelerException("runtime.modeler.method.not.found",
                     method.getName(), portClass.getName());
             }
         }
         //set MEP -oneway, async, req/resp
         MEP mep = getMEP(method);
         javaMethod.setMEP(mep);
         String action = null;
         String operationName = method.getName();
         if (webMethod != null ) {
             action = webMethod.action();
             operationName = webMethod.operationName().length() > 0 ?
                 webMethod.operationName() :
                 operationName;
         }
         //override the @WebMethod.action value by the one from the WSDL
         if(binding != null){
             WSDLBoundOperation bo = binding.getBinding().get(new QName(targetNamespace, operationName));
             if(bo != null){
                 WSDLInput wsdlInput = bo.getOperation().getInput();
                 String wsaAction = wsdlInput.getAction();
                 if(wsaAction != null && !wsdlInput.isDefaultAction())
                     action = wsaAction;
                 else
                     action = bo.getSOAPAction();
             }
         }
         javaMethod.setOperationQName(new QName(targetNamespace,operationName));
         SOAPBinding methodBinding = getAnnotation(method, SOAPBinding.class);
         if(methodBinding != null && methodBinding.style() == SOAPBinding.Style.RPC) {
             logger.warning(ModelerMessages.RUNTIMEMODELER_INVALID_SOAPBINDING_ON_METHOD(methodBinding, method.getName(), method.getDeclaringClass().getName()));
         } else if (methodBinding == null && !method.getDeclaringClass().equals(portClass)) {
             methodBinding = getAnnotation(method.getDeclaringClass(), SOAPBinding.class);
             if (methodBinding != null && methodBinding.style() == SOAPBinding.Style.RPC && methodBinding.parameterStyle() == SOAPBinding.ParameterStyle.BARE) {
                 throw new RuntimeModelerException("runtime.modeler.invalid.soapbinding.parameterstyle",
                         methodBinding, method.getDeclaringClass());
             }
         }
         if(methodBinding!= null && defaultBinding.getStyle() != methodBinding.style()) {
              throw new RuntimeModelerException("runtime.modeler.soapbinding.conflict",
                     methodBinding.style(), method.getName(),defaultBinding.getStyle());
         }
         boolean methodIsWrapped = isWrapped;
         Style style = defaultBinding.getStyle();
         if (methodBinding != null) {
             SOAPBindingImpl mySOAPBinding = createBinding(methodBinding);
             style = mySOAPBinding.getStyle();
             if (action != null)
                 mySOAPBinding.setSOAPAction(action);
             methodIsWrapped = methodBinding.parameterStyle().equals(
                 WRAPPED);
             javaMethod.setBinding(mySOAPBinding);
         } else {
             SOAPBindingImpl sb = new SOAPBindingImpl(defaultBinding);
             if (action != null) {
                 sb.setSOAPAction(action);
             } else {
                 String defaults = SOAPVersion.SOAP_11 == sb.getSOAPVersion() ? "" : null;
                 sb.setSOAPAction(defaults);
             }
             javaMethod.setBinding(sb);
         }
         if (!methodIsWrapped) {
             processDocBareMethod(javaMethod, operationName, method);
         } else if (style.equals(Style.DOCUMENT)) {
             processDocWrappedMethod(javaMethod, methodName, operationName,
                 method);
         } else {
             processRpcMethod(javaMethod, methodName, operationName, method);
         }
         model.addJavaMethod(javaMethod);
     }
     private MEP getMEP(Method m){
         if (getAnnotation(m, Oneway.class)!= null) {
             return MEP.ONE_WAY;
         }
         if(Response.class.isAssignableFrom(m.getReturnType())){
             return MEP.ASYNC_POLL;
         }else if(Future.class.isAssignableFrom(m.getReturnType())){
             return MEP.ASYNC_CALLBACK;
         }
         return MEP.REQUEST_RESPONSE;
     }
     /**
      * models a document/literal wrapped method
      * @param javaMethod the runtime model <code>JavaMethod</code> instance being created
      * @param methodName the runtime model <code>JavaMethod</code> instance being created
      * @param operationName the runtime model <code>JavaMethod</code> instance being created
      * @param method the <code>method</code> to model
      */
     protected void processDocWrappedMethod(JavaMethodImpl javaMethod, String methodName,
                                            String operationName, Method method) {
         boolean methodHasHeaderParams = false;
         boolean isOneway = getAnnotation(method, Oneway.class)!= null;
         RequestWrapper reqWrapper = getAnnotation(method,RequestWrapper.class);
         ResponseWrapper resWrapper = getAnnotation(method,ResponseWrapper.class);
         String beanPackage = packageName + PD_JAXWS_PACKAGE_PD;
         if (packageName == null || (packageName != null && packageName.length() == 0))
             beanPackage = JAXWS_PACKAGE_PD;
         String requestClassName;
         if(reqWrapper != null && reqWrapper.className().length()>0){
             requestClassName = reqWrapper.className();
         }else{
             requestClassName = beanPackage + capitalize(method.getName());
         }
         String responseClassName;
         if(resWrapper != null && resWrapper.className().length()>0){
             responseClassName = resWrapper.className();
         }else{
             responseClassName = beanPackage + capitalize(method.getName()) + RESPONSE;
         }
         String reqName = operationName;
         String reqNamespace = targetNamespace;
         String reqPartName = "parameters";
         if (reqWrapper != null) {
             if (reqWrapper.targetNamespace().length() > 0)
                 reqNamespace = reqWrapper.targetNamespace();
             if (reqWrapper.localName().length() > 0)
                 reqName = reqWrapper.localName();
             try {
                 if (reqWrapper.partName().length() > 0)
                     reqPartName = reqWrapper.partName();
             } catch(LinkageError e) {
                 //2.1 API dopes n't have this method
                 //Do nothing, just default to "parameters"
             }
         }
         QName reqElementName = new QName(reqNamespace, reqName);
         javaMethod.setRequestPayloadName(reqElementName);
         Class requestClass = getRequestWrapperClass(requestClassName, method, reqElementName);
         Class responseClass = null;
         String resName = operationName+"Response";
         String resNamespace = targetNamespace;
         QName resElementName = null;
         String resPartName = "parameters";
         if (!isOneway) {
             if (resWrapper != null) {
                 if (resWrapper.targetNamespace().length() > 0)
                     resNamespace = resWrapper.targetNamespace();
                 if (resWrapper.localName().length() > 0)
                     resName = resWrapper.localName();
                 try {
                     if (resWrapper.partName().length() > 0)
                         resPartName = resWrapper.partName();
                 } catch (LinkageError e) {
                     //2.1 API does n't have this method
                     //Do nothing, just default to "parameters"
                 }
             }
             resElementName = new QName(resNamespace, resName);
             responseClass = getResponseWrapperClass(responseClassName, method, resElementName);
         }
         TypeInfo typeRef =
                 new TypeInfo(reqElementName, requestClass);
         typeRef.setNillable(false);
         WrapperParameter requestWrapper = new WrapperParameter(javaMethod, typeRef,
             Mode.IN, 0);
         requestWrapper.setPartName(reqPartName);
         requestWrapper.setBinding(ParameterBinding.BODY);
         javaMethod.addParameter(requestWrapper);
         WrapperParameter responseWrapper = null;
         if (!isOneway) {
             typeRef = new TypeInfo(resElementName, responseClass);
             typeRef.setNillable(false);
             responseWrapper = new WrapperParameter(javaMethod, typeRef, Mode.OUT, -1);
             javaMethod.addParameter(responseWrapper);
             responseWrapper.setBinding(ParameterBinding.BODY);
         }
         // return value
         WebResult webResult = getAnnotation(method, WebResult.class);
         XmlElement xmlElem = getAnnotation(method, XmlElement.class);
         QName resultQName = getReturnQName(method, webResult, xmlElem);
         Class returnType = method.getReturnType();
         boolean isResultHeader = false;
         if (webResult != null) {
             isResultHeader = webResult.header();
             methodHasHeaderParams = isResultHeader || methodHasHeaderParams;
             if (isResultHeader && xmlElem != null) {
                 throw new RuntimeModelerException("@XmlElement cannot be specified on method "+method+" as the return value is bound to header");
             }
             if (resultQName.getNamespaceURI().length() == 0 && webResult.header()) {
                 // headers must have a namespace
                 resultQName = new QName(targetNamespace, resultQName.getLocalPart());
             }
         }
         if(javaMethod.isAsync()){
             returnType = getAsyncReturnType(method, returnType);
             resultQName = new QName(RETURN);
         }
         if (!isOneway && (returnType != null) && (!returnType.getName().equals("void"))) {
             Annotation[] rann = getAnnotations(method);
             if (resultQName.getLocalPart() != null) {
                 TypeInfo rTypeReference = new TypeInfo(resultQName, returnType, rann);
                 metadataReader.getProperties(rTypeReference.properties(), method);
                 ParameterImpl returnParameter = new ParameterImpl(javaMethod, rTypeReference, Mode.OUT, -1);
                 if (isResultHeader) {
                     returnParameter.setBinding(ParameterBinding.HEADER);
                     javaMethod.addParameter(returnParameter);
                 } else {
                     returnParameter.setBinding(ParameterBinding.BODY);
                     responseWrapper.addWrapperChild(returnParameter);
                 }
             }
         }
         //get WebParam
         Class<?>[] parameterTypes = method.getParameterTypes();
         Type[] genericParameterTypes = method.getGenericParameterTypes();
         Annotation[][] pannotations = getParamAnnotations(method);
         int pos = 0;
         for (Class clazzType : parameterTypes) {
             String partName=null;
             String paramName = "arg"+pos;
             //String paramNamespace = "";
             boolean isHeader = false;
             if(javaMethod.isAsync() && AsyncHandler.class.isAssignableFrom(clazzType)){
                 continue;
             }
             boolean isHolder = HOLDER_CLASS.isAssignableFrom(clazzType);
             //set the actual type argument of Holder in the TypeReference
             if (isHolder) {
                 if(clazzType==Holder.class){
                     clazzType = BindingHelper.erasure(((ParameterizedType)genericParameterTypes[pos]).getActualTypeArguments()[0]);
                 }
             }
             Mode paramMode = isHolder ? Mode.INOUT : Mode.IN;
             WebParam webParam = null;
             xmlElem = null;
             for (Annotation annotation : pannotations[pos]) {
                 if (annotation.annotationType() == WebParam.class)
                     webParam = (WebParam)annotation;
                 else if (annotation.annotationType() == XmlElement.class)
                     xmlElem = (XmlElement)annotation;
             }
             QName paramQName = getParameterQName(method, webParam, xmlElem, paramName);
             if (webParam != null) {
                 isHeader = webParam.header();
                 methodHasHeaderParams = isHeader || methodHasHeaderParams;
                 if (isHeader && xmlElem != null) {
                     throw new RuntimeModelerException("@XmlElement cannot be specified on method "+method+" parameter that is bound to header");
                 }
                 if(webParam.partName().length() > 0)
                     partName = webParam.partName();
                 else
                     partName = paramQName.getLocalPart();
                 if (isHeader && paramQName.getNamespaceURI().equals("")) { // headers cannot be in empty namespace
                     paramQName = new QName(targetNamespace, paramQName.getLocalPart());
                 }
                 paramMode = webParam.mode();
                 if (isHolder && paramMode == Mode.IN)
                     paramMode = Mode.INOUT;
             }
             typeRef =
                 new TypeInfo(paramQName, clazzType, pannotations[pos]);
             metadataReader.getProperties(typeRef.properties(), method, pos);
             ParameterImpl param = new ParameterImpl(javaMethod, typeRef, paramMode, pos++);
             if (isHeader) {
                 param.setBinding(ParameterBinding.HEADER);
                 javaMethod.addParameter(param);
                 param.setPartName(partName);
             } else {
                 param.setBinding(ParameterBinding.BODY);
                 if (paramMode!=Mode.OUT) {
                     requestWrapper.addWrapperChild(param);
                 }
                 if (paramMode!=Mode.IN) {
                     if (isOneway) {
                         throw new RuntimeModelerException("runtime.modeler.oneway.operation.no.out.parameters",
                             portClass.getCanonicalName(), methodName);
                     }
                     responseWrapper.addWrapperChild(param);
                 }
             }
         }
         //If the method has any parameter or return type that is bound to a header, use "result" as part name to avoid
         // name collison of same input part name and output part name ("parameters") shown up as param names on the
         // client mapping.
         if(methodHasHeaderParams) {
             resPartName = "result";
         }
         if(responseWrapper != null)
             responseWrapper.setPartName(resPartName);
         processExceptions(javaMethod, method);
     }
     /**
      * models a rpc/literal method
      * @param javaMethod the runtime model <code>JavaMethod</code> instance being created
      * @param methodName the name of the <code>method</code> being modeled.
      * @param operationName the WSDL operation name for this <code>method</code>
      * @param method the runtime model <code>JavaMethod</code> instance being created
      */
     protected void processRpcMethod(JavaMethodImpl javaMethod, String methodName,
                                     String operationName, Method method) {
         boolean isOneway = getAnnotation(method, Oneway.class) != null;
         // use Map to build parameters in the part order when they are known.
         // if part is unbound, we just put them at the end, and for that we
         // use a large index (10000+) to avoid colliding with ordered ones.
         // this assumes that there's no operation with # of parameters > 10000,
         // but I think it's a pretty safe assumption - KK.
         Map<Integer, ParameterImpl> resRpcParams = new TreeMap<Integer, ParameterImpl>();
         Map<Integer, ParameterImpl> reqRpcParams = new TreeMap<Integer, ParameterImpl>();
         //Lets take the service namespace and overwrite it with the one we get it from wsdl
         String reqNamespace = targetNamespace;
         String respNamespace = targetNamespace;
         if(binding != null && Style.RPC.equals(binding.getBinding().getStyle())){
             QName opQName = new QName(binding.getBinding().getPortTypeName().getNamespaceURI(), operationName);
             WSDLBoundOperation op = binding.getBinding().get(opQName);
             if(op != null){
                 //it cant be null, but lets not fail and try to work with service namespce
                 if(op.getRequestNamespace() != null){
                     reqNamespace = op.getRequestNamespace();
                 }
                 //it cant be null, but lets not fail and try to work with service namespce
                 if(op.getResponseNamespace() != null){
                     respNamespace = op.getResponseNamespace();
                 }
             }
         }
         QName reqElementName = new QName(reqNamespace, operationName);
         javaMethod.setRequestPayloadName(reqElementName);
         QName resElementName = null;
         if (!isOneway) {
             resElementName = new QName(respNamespace, operationName+RESPONSE);
         }
         Class wrapperType = WrapperComposite.class;
         TypeInfo typeRef = new TypeInfo(reqElementName, wrapperType);
         WrapperParameter requestWrapper = new WrapperParameter(javaMethod, typeRef, Mode.IN, 0);
         requestWrapper.setInBinding(ParameterBinding.BODY);
         javaMethod.addParameter(requestWrapper);
         WrapperParameter responseWrapper = null;
         if (!isOneway) {
             typeRef = new TypeInfo(resElementName, wrapperType);
             responseWrapper = new WrapperParameter(javaMethod, typeRef, Mode.OUT, -1);
             responseWrapper.setOutBinding(ParameterBinding.BODY);
             javaMethod.addParameter(responseWrapper);
         }
         Class returnType = method.getReturnType();
         String resultName = RETURN;
         String resultTNS = targetNamespace;
         String resultPartName = resultName;
         boolean isResultHeader = false;
         WebResult webResult = getAnnotation(method, WebResult.class);
         if (webResult != null) {
             isResultHeader = webResult.header();
             if (webResult.name().length() > 0)
                 resultName = webResult.name();
             if (webResult.partName().length() > 0) {
                 resultPartName = webResult.partName();
                 if (!isResultHeader)
                     resultName = resultPartName;
             } else
                 resultPartName = resultName;
             if (webResult.targetNamespace().length() > 0)
                 resultTNS = webResult.targetNamespace();
             isResultHeader = webResult.header();
         }
         QName resultQName;
         if (isResultHeader)
             resultQName = new QName(resultTNS, resultName);
         else
             resultQName = new QName(resultName);
         if(javaMethod.isAsync()){
             returnType = getAsyncReturnType(method, returnType);
         }
         if (!isOneway && returnType!=null && returnType!=void.class) {
             Annotation[] rann = getAnnotations(method);
             TypeInfo rTypeReference = new TypeInfo(resultQName, returnType, rann);
             metadataReader.getProperties(rTypeReference.properties(), method);
             rTypeReference.setGenericType(method.getGenericReturnType());
             ParameterImpl returnParameter = new ParameterImpl(javaMethod, rTypeReference, Mode.OUT, -1);
             returnParameter.setPartName(resultPartName);
             if(isResultHeader){
                 returnParameter.setBinding(ParameterBinding.HEADER);
                 javaMethod.addParameter(returnParameter);
                 rTypeReference.setGlobalElement(true);
             }else{
                 ParameterBinding rb = getBinding(operationName, resultPartName, false, Mode.OUT);
                 returnParameter.setBinding(rb);
                 if(rb.isBody()){
                     rTypeReference.setGlobalElement(false);
                     WSDLPart p = getPart(new QName(targetNamespace,operationName), resultPartName, Mode.OUT);
                     if(p == null)
                         resRpcParams.put(resRpcParams.size()+10000, returnParameter);
                     else
                         resRpcParams.put(p.getIndex(), returnParameter);
                 }else{
                     javaMethod.addParameter(returnParameter);
                 }
             }
         }
         //get WebParam
         Class<?>[] parameterTypes = method.getParameterTypes();
         Type[] genericParameterTypes = method.getGenericParameterTypes();
         Annotation[][] pannotations = getParamAnnotations(method);
         int pos = 0;
         for (Class clazzType : parameterTypes) {
             String paramName = "";
             String paramNamespace = "";
             String partName = "";
             boolean isHeader = false;
             if(javaMethod.isAsync() && AsyncHandler.class.isAssignableFrom(clazzType)){
                 continue;
             }
             boolean isHolder = HOLDER_CLASS.isAssignableFrom(clazzType);
             //set the actual type argument of Holder in the TypeReference
             if (isHolder) {
                 if (clazzType==Holder.class)
                     clazzType = BindingHelper.erasure(((ParameterizedType)genericParameterTypes[pos]).getActualTypeArguments()[0]);
             }
             Mode paramMode = isHolder ? Mode.INOUT : Mode.IN;
             for (Annotation annotation : pannotations[pos]) {
                 if (annotation.annotationType() == javax.jws.WebParam.class) {
                     javax.jws.WebParam webParam = (javax.jws.WebParam) annotation;
                     paramName = webParam.name();
                     partName = webParam.partName();
                     isHeader = webParam.header();
                     WebParam.Mode mode = webParam.mode();
                     paramNamespace = webParam.targetNamespace();
                     if (isHolder && mode == Mode.IN)
                         mode = Mode.INOUT;
                     paramMode = mode;
                     break;
                 }
             }
             if (paramName.length() == 0) {
                 paramName = "arg"+pos;
             }
             if (partName.length() == 0) {
                 partName = paramName;
             } else if (!isHeader) {
                 paramName = partName;
             }
             if (partName.length() == 0) {
                 partName = paramName;
             }
             QName paramQName;
             if (!isHeader) {
                 //its rpclit body param, set namespace to ""
                 paramQName = new QName("", paramName);
             } else {
                 if (paramNamespace.length() == 0)
                     paramNamespace = targetNamespace;
                 paramQName = new QName(paramNamespace, paramName);
             }
             typeRef =
                 new TypeInfo(paramQName, clazzType, pannotations[pos]);
             metadataReader.getProperties(typeRef.properties(), method, pos);
             typeRef.setGenericType(genericParameterTypes[pos]);
             ParameterImpl param = new ParameterImpl(javaMethod, typeRef, paramMode, pos++);
             param.setPartName(partName);
             if(paramMode == Mode.INOUT){
                 ParameterBinding pb = getBinding(operationName, partName, isHeader, Mode.IN);
                 param.setInBinding(pb);
                 pb = getBinding(operationName, partName, isHeader, Mode.OUT);
                 param.setOutBinding(pb);
             }else{
                 if (isHeader) {
                     typeRef.setGlobalElement(true);
                     param.setBinding(ParameterBinding.HEADER);
                 } else {
                     ParameterBinding pb = getBinding(operationName, partName, false, paramMode);
                     param.setBinding(pb);
                 }
             }
             if(param.getInBinding().isBody()){
                 typeRef.setGlobalElement(false);
                 if(!param.isOUT()){
                     WSDLPart p = getPart(new QName(targetNamespace,operationName), partName, Mode.IN);
                     if(p == null)
                         reqRpcParams.put(reqRpcParams.size()+10000, param);
                     else
                         reqRpcParams.put(p.getIndex(), param);
                 }
                 if(!param.isIN()){
                     if (isOneway) {
                             throw new RuntimeModelerException("runtime.modeler.oneway.operation.no.out.parameters",
                                 portClass.getCanonicalName(), methodName);
                     }
                     WSDLPart p = getPart(new QName(targetNamespace,operationName), partName, Mode.OUT);
                     if(p == null)
                         resRpcParams.put(resRpcParams.size()+10000, param);
                     else
                         resRpcParams.put(p.getIndex(), param);
                 }
             }else{
                 javaMethod.addParameter(param);
             }
         }
         for (ParameterImpl p : reqRpcParams.values())
             requestWrapper.addWrapperChild(p);
         for (ParameterImpl p : resRpcParams.values())
             responseWrapper.addWrapperChild(p);
         processExceptions(javaMethod, method);
     }
     /**
      * models the exceptions thrown by <code>method</code> and adds them to the <code>javaMethod</code>
      * runtime model object
      * @param javaMethod the runtime model object to add the exception model objects to
      * @param method the <code>method</code> from which to find the exceptions to model
      */
     protected void processExceptions(JavaMethodImpl javaMethod, Method method) {
         Action actionAnn = getAnnotation(method, Action.class);
         FaultAction[] faultActions = {};
         if(actionAnn != null)
             faultActions = actionAnn.fault();
         for (Class<?> exception : method.getExceptionTypes()) {
             //Exclude RuntimeException, RemoteException and Error etc
             if (!EXCEPTION_CLASS.isAssignableFrom(exception))
                 continue;
             if (RUNTIME_EXCEPTION_CLASS.isAssignableFrom(exception) || REMOTE_EXCEPTION_CLASS.isAssignableFrom(exception))
                 continue;
             Class exceptionBean;
             Annotation[] anns;
             WebFault webFault = getAnnotation(exception, WebFault.class);
             Method faultInfoMethod = getWSDLExceptionFaultInfo(exception);
             ExceptionType exceptionType = ExceptionType.WSDLException;
             String namespace = targetNamespace;
             String name = exception.getSimpleName();
             String beanPackage = packageName + PD_JAXWS_PACKAGE_PD;
             if (packageName.length() == 0)
                 beanPackage = JAXWS_PACKAGE_PD;
             String className = beanPackage+ name + BEAN;
             String messageName = exception.getSimpleName();
             if (webFault != null) {
                 if (webFault.faultBean().length()>0)
                     className = webFault.faultBean();
                 if (webFault.name().length()>0)
                     name = webFault.name();
                 if (webFault.targetNamespace().length()>0)
                     namespace = webFault.targetNamespace();
                 if (webFault.messageName().length()>0)
                     messageName = webFault.messageName();
             }
             if (faultInfoMethod == null)  {
                 exceptionBean = getExceptionBeanClass(className, exception, name, namespace);
                 exceptionType = ExceptionType.UserDefined;
                 anns = getAnnotations(exceptionBean);
             } else {
                 exceptionBean = faultInfoMethod.getReturnType();
                 anns = getAnnotations(faultInfoMethod);
             }
             QName faultName = new QName(namespace, name);
             TypeInfo typeRef = new TypeInfo(faultName, exceptionBean, anns);
             CheckedExceptionImpl checkedException =
                 new CheckedExceptionImpl(javaMethod, exception, typeRef, exceptionType);
             checkedException.setMessageName(messageName);
             for(FaultAction fa: faultActions) {
                 if(fa.className().equals(exception) && !fa.value().equals("")) {
                     checkedException.setFaultAction(fa.value());
                     break;
                 }
             }
             javaMethod.addException(checkedException);
         }
     }
     /**
      * returns the method that corresponds to "getFaultInfo".  Returns null if this is not an
      * exception generated from a WSDL
      * @param exception the class to search for the "getFaultInfo" method
      * @return the method named "getFaultInfo" if this is an exception generated from WSDL or an
      * exception that contains the <code>WebFault</code> annotation.  Otherwise it returns null
      */
     protected Method getWSDLExceptionFaultInfo(Class exception) {
 //      if (!exception.isAnnotationPresent(WebFault.class))
         if (getAnnotation(exception, WebFault.class) == null)
             return null;
         try {
             return exception.getMethod("getFaultInfo");
         } catch (NoSuchMethodException e) {
             return null;
         }
     }
     /**
      * models a document/literal bare method
      * @param javaMethod the runtime model <code>JavaMethod</code> instance being created
      * @param operationName the runtime model <code>JavaMethod</code> instance being created
      * @param method the runtime model <code>JavaMethod</code> instance being created
      */
     protected void processDocBareMethod(JavaMethodImpl javaMethod,
                                        String operationName, Method method) {
         String resultName = operationName+RESPONSE;
         String resultTNS = targetNamespace;
         String resultPartName = null;
         boolean isResultHeader = false;
         WebResult webResult = getAnnotation(method, WebResult.class);
         if (webResult != null) {
             if (webResult.name().length() > 0)
                 resultName = webResult.name();
             if (webResult.targetNamespace().length() > 0)
                 resultTNS = webResult.targetNamespace();
             resultPartName = webResult.partName();
             isResultHeader = webResult.header();
         }
         Class returnType = method.getReturnType();
         Type gReturnType = method.getGenericReturnType();
         if(javaMethod.isAsync()){
             returnType = getAsyncReturnType(method, returnType);
         }
         if ((returnType != null) && (!returnType.getName().equals("void"))) {
             Annotation[] rann = getAnnotations(method);
             if (resultName != null) {
                 QName responseQName = new QName(resultTNS, resultName);
                 TypeInfo rTypeReference = new TypeInfo(responseQName, returnType, rann);
                 rTypeReference.setGenericType(gReturnType);
                 metadataReader.getProperties(rTypeReference.properties(), method);
                 ParameterImpl returnParameter = new ParameterImpl(javaMethod, rTypeReference, Mode.OUT, -1);
                 if(resultPartName == null || (resultPartName.length() == 0)){
                     resultPartName = resultName;
                 }
                 returnParameter.setPartName(resultPartName);
                 if(isResultHeader){
                     returnParameter.setBinding(ParameterBinding.HEADER);
                 }else{
                     ParameterBinding rb = getBinding(operationName, resultPartName, false, Mode.OUT);
                     returnParameter.setBinding(rb);
                 }
                 javaMethod.addParameter(returnParameter);
             }
         }
         //get WebParam
         Class<?>[] parameterTypes = method.getParameterTypes();
         Type[] genericParameterTypes = method.getGenericParameterTypes();
         Annotation[][] pannotations = getParamAnnotations(method);
         int pos = 0;
         for (Class clazzType : parameterTypes) {
             String paramName = operationName; //method.getName();
             String partName = null;
             String requestNamespace = targetNamespace;
             boolean isHeader = false;
             //async
             if(javaMethod.isAsync() && AsyncHandler.class.isAssignableFrom(clazzType)){
                 continue;
             }
             boolean isHolder = HOLDER_CLASS.isAssignableFrom(clazzType);
             //set the actual type argument of Holder in the TypeReference
             if (isHolder) {
                 if (clazzType==Holder.class)
                     clazzType = BindingHelper.erasure(((ParameterizedType)genericParameterTypes[pos]).getActualTypeArguments()[0]);
             }
             Mode paramMode = isHolder ? Mode.INOUT : Mode.IN;
             for (Annotation annotation : pannotations[pos]) {
                 if (annotation.annotationType() == javax.jws.WebParam.class) {
                     javax.jws.WebParam webParam = (javax.jws.WebParam) annotation;
                     paramMode = webParam.mode();
                     if (isHolder && paramMode == Mode.IN)
                         paramMode = Mode.INOUT;
                     isHeader = webParam.header();
                     if(isHeader)
                         paramName = "arg"+pos;
                     if(paramMode == Mode.OUT && !isHeader)
                         paramName = operationName+RESPONSE;
                     if (webParam.name().length() > 0)
                         paramName = webParam.name();
                     partName = webParam.partName();
                     if (!webParam.targetNamespace().equals("")) {
                         requestNamespace = webParam.targetNamespace();
                     }
                     break;
                 }
             }
             QName requestQName = new QName(requestNamespace, paramName);
             if (!isHeader) javaMethod.setRequestPayloadName(requestQName);
             //doclit/wrapped
             TypeInfo typeRef = //operationName with upper 1 char
                 new TypeInfo(requestQName, clazzType,
                     pannotations[pos]);
             metadataReader.getProperties(typeRef.properties(), method, pos);
             typeRef.setGenericType(genericParameterTypes[pos]);
             ParameterImpl param = new ParameterImpl(javaMethod, typeRef, paramMode, pos++);
             if(partName == null || (partName.length() == 0)){
                 partName = paramName;
             }
             param.setPartName(partName);
             if(paramMode == Mode.INOUT){
                 ParameterBinding pb = getBinding(operationName, partName, isHeader, Mode.IN);
                 param.setInBinding(pb);
                 pb = getBinding(operationName, partName, isHeader, Mode.OUT);
                 param.setOutBinding(pb);
             }else{
                 if (isHeader){
                     param.setBinding(ParameterBinding.HEADER);
                 }else{
                     ParameterBinding pb = getBinding(operationName, partName, false, paramMode);
                     param.setBinding(pb);
                 }
             }
             javaMethod.addParameter(param);
         }
         validateDocBare(javaMethod);
         processExceptions(javaMethod, method);
     }
     // Does a conservative check if there is only one BODY part for input
     // and output message. We are not considering INOUT parameters at this
     // time since binding information is not applied. Also, there isn't
     // anyway to represent some cases in SEI. For example, a INOUT parameter
     // could be bound to body for input message, header for OUTPUT message
     // in wsdl:binding
     private void validateDocBare(JavaMethodImpl javaMethod) {
         int numInBodyBindings = 0;
         for(Parameter param : javaMethod.getRequestParameters()){
             if(param.getBinding().equals(ParameterBinding.BODY) && param.isIN()){
                 numInBodyBindings++;
             }
             if(numInBodyBindings > 1){
                 throw new RuntimeModelerException(ModelerMessages.localizableNOT_A_VALID_BARE_METHOD(portClass.getName(), javaMethod.getMethod().getName()));
             }
         }
         int numOutBodyBindings = 0;
         for(Parameter param : javaMethod.getResponseParameters()){
             if(param.getBinding().equals(ParameterBinding.BODY) && param.isOUT()){
                 numOutBodyBindings++;
             }
             if(numOutBodyBindings > 1){
                 throw new RuntimeModelerException(ModelerMessages.localizableNOT_A_VALID_BARE_METHOD(portClass.getName(), javaMethod.getMethod().getName()));
             }
         }
     }
     private Class getAsyncReturnType(Method method, Class returnType) {
         if(Response.class.isAssignableFrom(returnType)){
             Type ret = method.getGenericReturnType();
             return BindingHelper.erasure(((ParameterizedType)ret).getActualTypeArguments()[0]);
         }else{
             Type[] types = method.getGenericParameterTypes();
             Class[] params = method.getParameterTypes();
             int i = 0;
             for(Class cls : params){
                 if(AsyncHandler.class.isAssignableFrom(cls)){
                     return BindingHelper.erasure(((ParameterizedType)types[i]).getActualTypeArguments()[0]);
                 }
                 i++;
             }
         }
         return returnType;
     }
     /**
      * utility to capitalize the first letter in a string
      * @param name the string to capitalize
      * @return the capitalized string
      */
     public static String capitalize(String name) {
         if (name == null || name.length() == 0) {
             return name;
         }
         char chars[] = name.toCharArray();
         chars[0] = Character.toUpperCase(chars[0]);
         return new String(chars);
     }
     /*
     * Return service QName
     */
     /**
      * gets the <code>wsdl:serviceName</code> for a given implementation class
      * @param implClass the implementation class
      * @return the <code>wsdl:serviceName</code> for the <code>implClass</code>
      */
     public static QName getServiceName(Class<?> implClass) {
         return getServiceName(implClass, null);
     }
     public static QName getServiceName(Class<?> implClass, boolean isStandard) {
         return getServiceName(implClass, null, isStandard);
     }
     public static QName getServiceName(Class<?> implClass, MetadataReader reader) {
         return getServiceName(implClass, reader, true);
     }
     public static QName getServiceName(Class<?> implClass, MetadataReader reader, boolean isStandard) {
         if (implClass.isInterface()) {
             throw new RuntimeModelerException("runtime.modeler.cannot.get.serviceName.from.interface",
                                     implClass.getCanonicalName());
         }
         String name = implClass.getSimpleName()+SERVICE;
         String packageName = "";
         if (implClass.getPackage() != null)
             packageName = implClass.getPackage().getName();
         WebService webService = getAnnotation(WebService.class, implClass, reader);
         if (isStandard && webService == null) {
             throw new RuntimeModelerException("runtime.modeler.no.webservice.annotation",
                 implClass.getCanonicalName());
         }
         if (webService != null && webService.serviceName().length() > 0) {
             name = webService.serviceName();
         }
         String targetNamespace = getNamespace(packageName);
         if (webService != null && webService.targetNamespace().length() > 0) {
             targetNamespace = webService.targetNamespace();
         } else if (targetNamespace == null) {
             throw new RuntimeModelerException("runtime.modeler.no.package",
                 implClass.getName());
         }
         return new QName(targetNamespace, name);
     }
     /**
      * gets the <code>wsdl:portName</code> for a given implementation class
      * @param implClass the implementation class
      * @param targetNamespace Namespace URI for service name
      * @return the <code>wsdl:portName</code> for the <code>implClass</code>
      */
     public static QName getPortName(Class<?> implClass, String targetNamespace) {
         return getPortName(implClass, targetNamespace, null);
     }
     public static QName getPortName(Class<?> implClass, String targetNamespace, boolean isStandard) {
         return getPortName(implClass, targetNamespace, null, isStandard);
     }
     public static QName getPortName(Class<?> implClass, String targetNamespace, MetadataReader reader) {
         return getPortName(implClass, targetNamespace, reader, true);
     }
     public static QName getPortName(Class<?> implClass, String targetNamespace, MetadataReader reader, boolean isStandard) {
         WebService webService = getAnnotation(WebService.class, implClass, reader);
         if (isStandard && webService == null) {
             throw new RuntimeModelerException("runtime.modeler.no.webservice.annotation",
                 implClass.getCanonicalName());
         }
         String name;
         if (webService != null && webService.portName().length() > 0) {
             name = webService.portName();
         } else if (webService != null && webService.name().length() > 0) {
             name = webService.name()+PORT;
         } else {
             name = implClass.getSimpleName()+PORT;
         }
         if (targetNamespace == null) {
             if (webService != null && webService.targetNamespace().length() > 0) {
                 targetNamespace = webService.targetNamespace();
             } else {
                 String packageName = null;
                 if (implClass.getPackage() != null) {
                     packageName = implClass.getPackage().getName();
                 }
                 targetNamespace = getNamespace(packageName);
                 if (targetNamespace == null) {
                     throw new RuntimeModelerException("runtime.modeler.no.package",
                         implClass.getName());
                 }
             }
         }
         return new QName(targetNamespace, name);
     }
     static <A extends Annotation> A getAnnotation(Class<A> t, Class<?> cls, MetadataReader reader) {
         return (reader == null)? cls.getAnnotation(t) : reader.getAnnotation(t, cls);
     }
     /**
      * Gives portType QName from implementatorClass or SEI
      * @param  implOrSeiClass cant be null
      * @return  <code>wsdl:portType@name</code>, null if it could not find the annotated class.
      */
     public static QName getPortTypeName(Class<?> implOrSeiClass){
         return getPortTypeName(implOrSeiClass, null, null);
     }
     public static QName getPortTypeName(Class<?> implOrSeiClass, String tns, MetadataReader reader){
         assert(implOrSeiClass != null);
         WebService webService = getAnnotation(WebService.class, implOrSeiClass, reader);
         Class<?> clazz = implOrSeiClass;
         if (webService == null)
                 throw new RuntimeModelerException("runtime.modeler.no.webservice.annotation",
                                            implOrSeiClass.getCanonicalName());
         if (!implOrSeiClass.isInterface()) {
             String epi = webService.endpointInterface();
             if (epi.length() > 0) {
                 try {
                     clazz = Thread.currentThread().getContextClassLoader().loadClass(epi);
                 } catch (ClassNotFoundException e) {
                     throw new RuntimeModelerException("runtime.modeler.class.not.found", epi);
                 }
                 if (!clazz.isAnnotationPresent(javax.jws.WebService.class)) {
                     throw new RuntimeModelerException("runtime.modeler.endpoint.interface.no.webservice",
                                         webService.endpointInterface());
                 }
             }
         }
         webService = getAnnotation(WebService.class, clazz, reader);
         String name = webService.name();
         if(name.length() == 0){
             name = clazz.getSimpleName();
         }
         tns = webService.targetNamespace();
         if (tns == null || "".equals(tns.trim())) tns = webService.targetNamespace();
         if (tns.length() == 0)
             tns = getNamespace(clazz.getPackage().getName());
         if (tns == null) {
             throw new RuntimeModelerException("runtime.modeler.no.package", clazz.getName());
         }
         return new QName(tns, name);
     }
     private ParameterBinding getBinding(String operation, String part, boolean isHeader, Mode mode){
         if(binding == null){
             if(isHeader)
                 return ParameterBinding.HEADER;
             else
                 return ParameterBinding.BODY;
         }
         QName opName = new QName(binding.getBinding().getPortType().getName().getNamespaceURI(), operation);
         return binding.getBinding().getBinding(opName, part, mode);
     }
     private WSDLPart getPart(QName opName, String partName, Mode mode){
         if(binding != null){
             WSDLBoundOperation bo = binding.getBinding().get(opName);
             if(bo != null)
                 return bo.getPart(partName, mode);
         }
         return null;
     }
     private static Boolean getBooleanSystemProperty(final String prop) {
         return AccessController.doPrivileged(
             new java.security.PrivilegedAction<Boolean>() {
                 public Boolean run() {
                     String value = System.getProperty(prop);
                     return value != null ? Boolean.valueOf(value) : Boolean.FALSE;
                 }
             }
         );
     }
     private static QName getReturnQName(Method method, WebResult webResult, XmlElement xmlElem) {
         String webResultName = null;
         if (webResult != null && webResult.name().length() > 0) {
             webResultName = webResult.name();
         }
         String xmlElemName = null;
         if (xmlElem != null && !xmlElem.name().equals("##default")) {
             xmlElemName = xmlElem.name();
         }
         if (xmlElemName != null && webResultName != null && !xmlElemName.equals(webResultName)) {
             throw new RuntimeModelerException("@XmlElement(name)="+xmlElemName+" and @WebResult(name)="+webResultName+" are different for method " +method);
         }
         String localPart = RETURN;
         if (webResultName != null) {
             localPart = webResultName;
         } else if (xmlElemName != null) {
             localPart =  xmlElemName;
         }
         String webResultNS = null;
         if (webResult != null && webResult.targetNamespace().length() > 0) {
             webResultNS = webResult.targetNamespace();
         }
         String xmlElemNS = null;
         if (xmlElem != null && !xmlElem.namespace().equals("##default")) {
             xmlElemNS = xmlElem.namespace();
         }
         if (xmlElemNS != null && webResultNS != null && !xmlElemNS.equals(webResultNS)) {
             throw new RuntimeModelerException("@XmlElement(namespace)="+xmlElemNS+" and @WebResult(targetNamespace)="+webResultNS+" are different for method " +method);
         }
         String ns = "";
         if (webResultNS != null) {
             ns = webResultNS;
         } else if (xmlElemNS != null) {
             ns =  xmlElemNS;
         }
         return new QName(ns, localPart);
     }
     private static QName getParameterQName(Method method, WebParam webParam, XmlElement xmlElem, String paramDefault) {
         String webParamName = null;
         if (webParam != null && webParam.name().length() > 0) {
             webParamName = webParam.name();
         }
         String xmlElemName = null;
         if (xmlElem != null && !xmlElem.name().equals("##default")) {
             xmlElemName = xmlElem.name();
         }
         if (xmlElemName != null && webParamName != null && !xmlElemName.equals(webParamName)) {
             throw new RuntimeModelerException("@XmlElement(name)="+xmlElemName+" and @WebParam(name)="+webParamName+" are different for method " +method);
         }
         String localPart = paramDefault;
         if (webParamName != null) {
             localPart = webParamName;
         } else if (xmlElemName != null) {
             localPart =  xmlElemName;
         }
         String webParamNS = null;
         if (webParam != null && webParam.targetNamespace().length() > 0) {
             webParamNS = webParam.targetNamespace();
         }
         String xmlElemNS = null;
         if (xmlElem != null && !xmlElem.namespace().equals("##default")) {
             xmlElemNS = xmlElem.namespace();
         }
         if (xmlElemNS != null && webParamNS != null && !xmlElemNS.equals(webParamNS)) {
             throw new RuntimeModelerException("@XmlElement(namespace)="+xmlElemNS+" and @WebParam(targetNamespace)="+webParamNS+" are different for method " +method);
         }
         String ns = "";
         if (webParamNS != null) {
             ns = webParamNS;
         } else if (xmlElemNS != null) {
             ns =  xmlElemNS;
         }
         return new QName(ns, localPart);
     }
 }

Mercurial > jdk8-mips64-public > jaxws / annotate

src/share/jaxws_classes/com/sun/xml/internal/ws/model/RuntimeModeler.java@f50545b5e2f1 (annotated)

src/share/jaxws_classes/com/sun/xml/internal/ws/model/RuntimeModeler.java