Java tutorial
/* * 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.impl; import org.apache.axis2.AxisFault; import org.apache.axis2.description.AxisService; import org.apache.axis2.description.Parameter; import org.apache.axis2.java.security.AccessController; import org.apache.axis2.jaxws.ExceptionFactory; import org.apache.axis2.jaxws.description.AttachmentDescription; import org.apache.axis2.jaxws.description.AttachmentType; import org.apache.axis2.jaxws.description.EndpointDescription; import org.apache.axis2.jaxws.description.EndpointDescriptionWSDL; import org.apache.axis2.jaxws.description.builder.DescriptionBuilderComposite; import static org.apache.axis2.jaxws.description.builder.MDQConstants.CONSTRUCTOR_METHOD; import org.apache.axis2.jaxws.description.builder.MDQConstants; import org.apache.axis2.jaxws.description.builder.MethodDescriptionComposite; import org.apache.axis2.jaxws.description.builder.WebMethodAnnot; import org.apache.axis2.jaxws.description.xml.handler.HandlerChainsType; import org.apache.axis2.jaxws.i18n.Messages; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import javax.wsdl.Binding; import javax.wsdl.BindingOperation; import javax.wsdl.Operation; import javax.wsdl.extensions.mime.MIMEContent; import javax.wsdl.extensions.mime.MIMEMultipartRelated; import javax.wsdl.extensions.mime.MIMEPart; import javax.wsdl.extensions.soap.SOAPBody; import javax.wsdl.extensions.soap.SOAPHeader; import javax.wsdl.extensions.soap12.SOAP12Body; import javax.wsdl.extensions.soap12.SOAP12Header; import javax.xml.bind.JAXBContext; import javax.xml.bind.JAXBElement; import javax.xml.bind.Unmarshaller; import javax.xml.namespace.QName; import javax.xml.ws.handler.Handler; import javax.xml.ws.handler.soap.SOAPHandler; import javax.xml.ws.soap.SOAPBinding; import java.io.IOException; import java.io.InputStream; import java.lang.reflect.Method; import java.net.MalformedURLException; import java.net.URI; import java.net.URISyntaxException; import java.net.URL; import java.security.PrivilegedAction; import java.util.ArrayList; import java.util.Iterator; import java.util.List; import java.util.Set; import java.util.StringTokenizer; /** Utilities used throughout the Description package. */ public class DescriptionUtils { private static final Log log = LogFactory.getLog(DescriptionUtils.class); static boolean isEmpty(String string) { return (string == null || "".equals(string)); } static boolean isEmpty(QName qname) { return qname == null || isEmpty(qname.getLocalPart()); } /** @return Returns TRUE if we find just one WebMethod Annotation with exclude flag set to false */ static boolean falseExclusionsExist(DescriptionBuilderComposite dbc) { MethodDescriptionComposite mdc = null; Iterator<MethodDescriptionComposite> iter = dbc.getMethodDescriptionsList().iterator(); while (iter.hasNext()) { mdc = iter.next(); WebMethodAnnot wma = mdc.getWebMethodAnnot(); if (wma != null) { if (wma.exclude() == false) return true; } } return false; } /** * Gathers all MethodDescriptionCompsite's that contain a WebMethod Annotation with the exclude * set to FALSE * * @return Returns List<MethodDescriptionComposite> */ static ArrayList<MethodDescriptionComposite> getMethodsWithFalseExclusions(DescriptionBuilderComposite dbc) { ArrayList<MethodDescriptionComposite> mdcList = new ArrayList<MethodDescriptionComposite>(); Iterator<MethodDescriptionComposite> iter = dbc.getMethodDescriptionsList().iterator(); if (DescriptionUtils.falseExclusionsExist(dbc)) { while (iter.hasNext()) { MethodDescriptionComposite mdc = iter.next(); if (mdc.getWebMethodAnnot() != null) { if (mdc.getWebMethodAnnot().exclude() == false) { mdc.setDeclaringClass(dbc.getClassName()); mdcList.add(mdc); } } } } return mdcList; } static boolean isWebmethodDefined(DescriptionBuilderComposite dbc) { if (dbc == null) { return false; } Iterator<MethodDescriptionComposite> iter = dbc.getMethodDescriptionsList().iterator(); while (iter.hasNext()) { MethodDescriptionComposite mdc = iter.next(); if (mdc != null && mdc.getWebMethodAnnot() != null) { return true; } } return false; } /* * Check whether a MethodDescriptionComposite contains a WebMethod annotation with * exlude set to true */ static boolean isExcludeTrue(MethodDescriptionComposite mdc) { if (mdc.getWebMethodAnnot() != null) { if (mdc.getWebMethodAnnot().exclude() == true) { return true; } } return false; } static String javifyClassName(String className) { if (className.indexOf("/") != -1) { return className.replaceAll("/", "."); } return className; } /** * Return the name of the class without any package qualifier. * * @param theClass * @return the name of the class sans package qualification. */ static String getSimpleJavaClassName(String name) { String returnName = null; if (name != null) { String fqName = name; // We need the "simple name", so strip off any package information from the name int endOfPackageIndex = fqName.lastIndexOf('.'); int startOfClassIndex = endOfPackageIndex + 1; returnName = fqName.substring(startOfClassIndex); } return returnName; } /** * Returns the package name from the class. If no package, then returns null * * @param theClassName * @return */ static String getJavaPackageName(String theClassName) { String returnPackage = null; if (theClassName != null) { String fqName = theClassName; // Get the package name, if there is one int endOfPackageIndex = fqName.lastIndexOf('.'); if (endOfPackageIndex >= 0) { returnPackage = fqName.substring(0, endOfPackageIndex); } } return returnPackage; } /** * Create a JAX-WS namespace based on the package name * * @param packageName * @param protocol * @return */ static final String NO_PACKAGE_HOST_NAME = "DefaultNamespace"; static String makeNamespaceFromPackageName(String packageName, String protocol) { if (DescriptionUtils.isEmpty(protocol)) { protocol = "http"; } if (DescriptionUtils.isEmpty(packageName)) { return protocol + "://" + NO_PACKAGE_HOST_NAME; } StringTokenizer st = new StringTokenizer(packageName, "."); String[] words = new String[st.countTokens()]; for (int i = 0; i < words.length; ++i) words[i] = st.nextToken(); StringBuffer sb = new StringBuffer(80); for (int i = words.length - 1; i >= 0; --i) { String word = words[i]; // seperate with dot if (i != words.length - 1) sb.append('.'); sb.append(word); } return protocol + "://" + sb.toString() + "/"; } /** * Determines whether a method should have an OperationDescription created for it based on the * name. This is a convenience method to allow us to exlude methods such as constructors. * * @param methodName * @return */ static boolean createOperationDescription(String methodName) { if (methodName.equals(CONSTRUCTOR_METHOD)) { return false; } return true; } /** * This is a helper method that will open a stream to an @HandlerChain configuration file. * * @param configFile - The path to the file * @param className - The class in which the annotation was declared. This is used in case the * file path is relative. * @param classLoader - ClassLoader used to load relative file paths. * @return */ public static InputStream openHandlerConfigStream(String configFile, String className, ClassLoader classLoader) { InputStream configStream = null; URL configURL; if (log.isDebugEnabled()) { log.debug("Attempting to load @HandlerChain configuration file: " + configFile + " relative to class: " + className); } // Attempt 1: // Try absolute loading try { if (log.isDebugEnabled()) { log.debug("Attempt 1: Try absolute load of (" + configFile + ")"); } configURL = new URL(configFile); if (configURL != null) { if (log.isDebugEnabled()) { log.debug("Found absolute @HandlerChain configuration file: " + configFile); } configStream = configURL.openStream(); } } catch (MalformedURLException e) { // try another method to obtain a stream to the configuration file if (log.isDebugEnabled()) { log.debug("Attempt 1 Failed with exception. Try Attempt 2. " + "The caught exception is : " + e); } } catch (IOException e) { // report this since it was a valid URL but the openStream caused a problem if (log.isDebugEnabled()) { log.debug("The URL was valid, but opening the stream " + "caused a problem : " + e); } throw ExceptionFactory.makeWebServiceException( Messages.getMessage("hcConfigLoadFail", configFile, className, e.toString())); } // Attempt 2: // Try relative uri loading from Classloaders if (configStream == null) { if (log.isDebugEnabled()) { log.debug("@HandlerChain.file attribute refers to a relative location: " + configFile); log.debug("Attempt 2: Try relative uri load of (" + configFile + ") " + "from the classloaders"); } className = className.replace(".", "/"); try { if (log.isDebugEnabled()) { log.debug("Resolving @HandlerChain configuration file: " + configFile + " relative to class file: " + className); } URI uri = new URI(className); uri = uri.resolve(configFile); String resolvedPath = uri.toString(); if (log.isDebugEnabled()) { log.debug("@HandlerChain.file resolved file path location: " + resolvedPath); } configStream = getInputStream_priv(resolvedPath, classLoader); } catch (Throwable e) { if (log.isDebugEnabled()) { log.debug("Attempt 2 Failed with exception. " + "The caught exception is : " + e); } throw ExceptionFactory.makeWebServiceException( Messages.getMessage("hcConfigLoadFail", configFile, className, e.toString())); } } if (configStream == null) { //throw ExceptionFactory.makeWebServiceException(Messages.getMessage("handlerChainNS", // configFile, className)); // No longer throwing an exception here. This method is best-effort, and the caller may // change the class to which the path is relative and try again. The caller is responsible // for determining when to "give up" if (log.isDebugEnabled()) { log.debug("@HandlerChain configuration fail: " + configFile + " in class: " + className + " failed to load."); } } else { if (log.isDebugEnabled()) { log.debug("@HandlerChain configuration file: " + configFile + " in class: " + className + " was successfully loaded."); } } return configStream; } /** * A doPriv version of getInputStream * @return */ private static InputStream getInputStream_priv(final String path, final ClassLoader classLoader) { return (InputStream) AccessController.doPrivileged(new PrivilegedAction() { public Object run() { return getInputStream(path, classLoader); } }); } /** * Get the InputStream from the relative path and classloader * @param path * @param classLoader * @return */ private static InputStream getInputStream(String path, ClassLoader classLoader) { if (log.isDebugEnabled()) { log.debug("Start getInputStream with (" + path + ") and classloader (" + classLoader + ")"); } InputStream configStream = classLoader.getResourceAsStream(path); if (configStream == null) { // try another classloader ClassLoader cl = System.class.getClassLoader(); if (log.isDebugEnabled()) { log.debug("Attempting with System classloader (" + cl + ")"); } if (cl != null) { configStream = cl.getResourceAsStream(path); } } if (configStream == null) { // and another classloader ClassLoader cl = Thread.currentThread().getContextClassLoader(); if (log.isDebugEnabled()) { log.debug("Attempting with current thread " + "classloader (" + cl + ")"); } if (cl != null) { configStream = cl.getResourceAsStream(path); } } return configStream; } /** * Determine is this method is an async method * @param method - The method to examine * @return */ public static boolean isAsync(Method method) { if (method == null) { return false; } String methodName = method.getName(); Class returnType = method.getReturnType(); if (methodName.endsWith("Async") && (returnType.isAssignableFrom(javax.xml.ws.Response.class) || returnType.isAssignableFrom(java.util.concurrent.Future.class))) { return true; } else { return false; } } public static HandlerChainsType loadHandlerChains(InputStream is, ClassLoader classLoader) { try { HandlerChainsParser parser = new HandlerChainsParser(); return parser.loadHandlerChains(is); } catch (Exception e) { throw ExceptionFactory .makeWebServiceException(Messages.getMessage("loadHandlerChainErr", e.getMessage())); } } /** * This method will loop through a list of extensibility elements looking for one * of four objects: SOAPBody, SOAP12Body, SOAPHeader, SOAP12Header. If any of these * objects are found the namespace URI from this object will be returned. */ public static String getNamespaceFromSOAPElement(List extElements) { Iterator extIter = extElements.iterator(); while (extIter.hasNext()) { Object extObj = extIter.next(); if (extObj instanceof SOAPBody) { if (log.isDebugEnabled()) { log.debug("Returning SOAPBody namespace: " + ((SOAPBody) extObj).getNamespaceURI()); } return ((SOAPBody) extObj).getNamespaceURI(); } else if (extObj instanceof SOAP12Body) { if (log.isDebugEnabled()) { log.debug("Returning SOAP12Body namespace: " + ((SOAP12Body) extObj).getNamespaceURI()); } return ((SOAP12Body) extObj).getNamespaceURI(); } else if (extObj instanceof SOAPHeader) { if (log.isDebugEnabled()) { log.debug("Returning SOAPHeader namespace: " + ((SOAPHeader) extObj).getNamespaceURI()); } return ((SOAPHeader) extObj).getNamespaceURI(); } else if (extObj instanceof SOAP12Header) { if (log.isDebugEnabled()) { log.debug("Returning SOAP12Header namespace: " + ((SOAP12Header) extObj).getNamespaceURI()); } return ((SOAP12Header) extObj).getNamespaceURI(); } else if (extObj instanceof MIMEMultipartRelated) { if (log.isDebugEnabled()) { log.debug("Found a MIMEMultipartRelated element. Unwrapping to get SOAP binding."); } MIMEMultipartRelated mime = (MIMEMultipartRelated) extObj; List mimeParts = mime.getMIMEParts(); Iterator itr = mimeParts.iterator(); while (itr.hasNext()) { MIMEPart mimePart = (MIMEPart) itr.next(); List elements = mimePart.getExtensibilityElements(); String ns = getNamespaceFromSOAPElement(elements); return ns; } } } return null; } /** * This method will process a WSDL Binding and build AttachmentDescription objects if the * WSDL dicatates attachments. */ public static void getAttachmentFromBinding(OperationDescriptionImpl opDesc, Binding binding) { if (binding != null) { Iterator bindingOpIter = binding.getBindingOperations().iterator(); while (bindingOpIter.hasNext()) { BindingOperation bindingOp = (BindingOperation) bindingOpIter.next(); // found the BindingOperation that matches the current OperationDescription if (bindingOp.getName().equals(opDesc.getName().getLocalPart())) { if (bindingOp.getBindingInput() != null) { if (log.isDebugEnabled()) { log.debug("Processing binding opertion input"); } processBindingForMIME(bindingOp.getBindingInput().getExtensibilityElements(), opDesc, bindingOp.getOperation(), true); } if (bindingOp.getBindingOutput() != null) { if (log.isDebugEnabled()) { log.debug("Processing binding output"); } processBindingForMIME(bindingOp.getBindingOutput().getExtensibilityElements(), opDesc, bindingOp.getOperation(), false); } } } } } /** * This method will loop through the extensibility elements for a given BindingInput or * BindingOutput element and determine if it has any MIMEMultipartRelated content. If it * does it will build up the appropriate AttachmentDescription objects. */ private static void processBindingForMIME(List extensibilityElements, OperationDescriptionImpl opDesc, Operation operation, boolean isRequest) { Iterator extensibilityIter = extensibilityElements.iterator(); while (extensibilityIter.hasNext()) { Object obj = extensibilityIter.next(); if (obj instanceof MIMEMultipartRelated) { if (log.isDebugEnabled()) { log.debug("Found a mime:multipartRelated extensiblity element."); } // Found mime information now process it and determine if we need to // create an AttachmentDescription MIMEMultipartRelated mime = (MIMEMultipartRelated) obj; Iterator partIter = mime.getMIMEParts().iterator(); while (partIter.hasNext()) { if (log.isDebugEnabled()) { log.debug("Found a mime:part child element."); } MIMEPart mimePart = (MIMEPart) partIter.next(); Iterator mExtIter = mimePart.getExtensibilityElements().iterator(); // Process each mime part to determine if there is mime content while (mExtIter.hasNext()) { Object obj2 = mExtIter.next(); // For mime content we need to potentially create an AttachmentDescription if (obj2 instanceof MIMEContent) { MIMEContent mimeContent = (MIMEContent) obj2; String part = mimeContent.getPart(); String type = mimeContent.getType(); // if we have not already processed this part for the operation if (opDesc.getPartAttachmentDescription(part) == null) { if (log.isDebugEnabled()) { log.debug("Adding new AttachmentDescription for part: " + part + " on operation: " + opDesc.getOperationName()); } AttachmentDescription attachmentDesc = new AttachmentDescriptionImpl( AttachmentType.SWA, new String[] { type }); opDesc.addPartAttachmentDescription(part, attachmentDesc); } else { if (log.isDebugEnabled()) { log.debug("Already created AttachmentDescription for part: " + part + " of type: " + type); } } } else if (obj2 instanceof SOAPBody || obj2 instanceof SOAP12Body) { if (log.isDebugEnabled()) { log.debug("Found a body element with potential nested mime content"); } // Flag whether there's a potential nested attachment. if (isRequest) { opDesc.setHasRequestSwaRefAttachments(true); } else { opDesc.setHasResponseSwaRefAttachments(true); } } } } } } } public static void registerHandlerHeaders(AxisService axisService, List<Handler> handlers) { if (handlers == null || axisService == null) { return; } ArrayList<QName> understoodHeaderQNames = new ArrayList<QName>(); for (Handler handler : handlers) { if (handler instanceof SOAPHandler) { SOAPHandler soapHandler = (SOAPHandler) handler; Set<QName> headers = soapHandler.getHeaders(); if (headers != null) { for (QName header : headers) { if (!understoodHeaderQNames.contains(header)) { understoodHeaderQNames.add(header); } } } } } if (!understoodHeaderQNames.isEmpty()) { Parameter headerQNParameter = new Parameter(EndpointDescription.HANDLER_PARAMETER_QNAMES, understoodHeaderQNames); try { axisService.addParameter(headerQNParameter); } catch (AxisFault e) { log.warn(Messages.getMessage("regHandlerHeadersErr", axisService.getName(), e.getMessage())); } } } /** * Given a binding type value based on a JAXWS anntation, return the corresponding WSDL * binding type. The JAXWS annotation values understood are those returned by * mapBindingTypeWsdltoAnnotation. * * @see #mapBindingTypeWsdlToAnnotation(String, String) * * @param annotationBindingType The binding type as represented by a JAXWS annotation value * @return The binding type as represented by a WSDL binding extension namespace value */ public static String mapBindingTypeAnnotationToWsdl(String annotationBindingType) { String wsdlBindingType = null; if (SOAPBinding.SOAP11HTTP_BINDING.equals(annotationBindingType) || MDQConstants.SOAP11JMS_BINDING.equals(annotationBindingType)) { wsdlBindingType = EndpointDescriptionWSDL.SOAP11_WSDL_BINDING; } else if (SOAPBinding.SOAP12HTTP_BINDING.equals(annotationBindingType) || MDQConstants.SOAP12JMS_BINDING.equals(annotationBindingType)) { wsdlBindingType = EndpointDescriptionWSDL.SOAP12_WSDL_BINDING; } else if (javax.xml.ws.http.HTTPBinding.HTTP_BINDING.equals(annotationBindingType)) { wsdlBindingType = EndpointDescriptionWSDL.HTTP_WSDL_BINDING; } return wsdlBindingType; } /** * Given a binding type value based on WSDL, return the corresponding JAXWS annotation value. * The WSDL binding type values are based on the namespace of the binding extension element. * The JAXWS annotation values correspond to the values to the HTTPBinding and SOAPBinding * annotations. Additionally, proprietary values for JMS bindings are supported. The JAXWS * binding type annotation values returned could be from SOAPBinding or HTTPBinding. * * @param wsdlBindingType The binding type as represnted by the WSDL binding extension namespace * @param soapTransport The WSDL transport. Used to determine if a JMS binding type should * be returned * @return The binding represented by a JAXWS Binding Type Annotation value from either * SOAPBinding or HTTPBinding. */ public static String mapBindingTypeWsdlToAnnotation(String wsdlBindingType, String soapTransport) { String soapBindingType = null; if (EndpointDescriptionWSDL.SOAP11_WSDL_BINDING.equals(wsdlBindingType)) { if (MDQConstants.SOAP11JMS_BINDING.equals(soapTransport)) { soapBindingType = MDQConstants.SOAP11JMS_BINDING; } else { //REVIEW: We are making the assumption that if not JMS, then HTTP soapBindingType = SOAPBinding.SOAP11HTTP_BINDING; } } else if (EndpointDescriptionWSDL.SOAP12_WSDL_BINDING.equals(wsdlBindingType)) { if (MDQConstants.SOAP12JMS_BINDING.equals(soapTransport)) { soapBindingType = MDQConstants.SOAP12JMS_BINDING; } else { //REVIEW: We are making the assumption that if not JMS, then HTTP soapBindingType = SOAPBinding.SOAP12HTTP_BINDING; } } else if (EndpointDescriptionWSDL.HTTP_WSDL_BINDING.equals(wsdlBindingType)) { soapBindingType = javax.xml.ws.http.HTTPBinding.HTTP_BINDING; } return soapBindingType; } /** * Dump the contents of the composite in a String for * debug trace * @param composite * @return String */ static String dumpString(DescriptionBuilderComposite composite) { try { return composite.toString(); } catch (Throwable t) { return "Cannot dump DescriptionBuilderComposite due to : " + t; } } /** * Utility method for converting a String value into a boolean. * Case-insensitive forms of true, yes, and 1 correspond to true. * Case-insensitive forms of false, no, and 0 correspond to false. * Anything else will result in a false being returned. * * @param value * the property's value * @return * true or false or null if neither */ public static Boolean getBooleanValue(String value) { Boolean b = null; if (value.equalsIgnoreCase("true") || value.equalsIgnoreCase("yes") || value.equals("1")) { b = Boolean.TRUE; } else if (value.equalsIgnoreCase("false") || value.equalsIgnoreCase("no") || value.equals("0")) { b = Boolean.FALSE; } // Anything else will result in false return b; } }