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.runtime.description.marshal.impl; import java.lang.annotation.Annotation; import java.lang.reflect.AnnotatedElement; import java.lang.reflect.Method; import java.security.PrivilegedAction; import java.security.PrivilegedActionException; import java.security.PrivilegedExceptionAction; import java.util.HashMap; import java.util.Map; import javax.xml.bind.annotation.XmlRootElement; import javax.xml.bind.annotation.XmlType; import org.apache.axis2.java.security.AccessController; import org.apache.axis2.jaxws.Constants; import org.apache.axis2.jaxws.ExceptionFactory; import org.apache.axis2.jaxws.description.EndpointDescription; import org.apache.axis2.jaxws.description.FaultDescription; import org.apache.axis2.jaxws.description.OperationDescription; import org.apache.axis2.jaxws.description.ServiceDescription; import org.apache.axis2.jaxws.message.databinding.ClassFinder; import org.apache.axis2.jaxws.message.factory.ClassFinderFactory; import org.apache.axis2.jaxws.registry.FactoryRegistry; import org.apache.axis2.jaxws.runtime.description.marshal.AnnotationDesc; import org.apache.axis2.jaxws.runtime.description.marshal.FaultBeanDesc; import org.apache.axis2.jaxws.utility.ClassUtils; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; /** * Examines a ServiceDesc and locates and/or builds the JAX-WS artifacts. The JAX-WS artifacts are: * - request wrapper classes - response wrapper classes - fault beans for non-JAX-WS compliant * exceptions */ class ArtifactProcessor { private static final Log log = LogFactory.getLog(ArtifactProcessor.class); private ServiceDescription serviceDesc; private Map<OperationDescription, String> requestWrapperMap = new HashMap<OperationDescription, String>(); private Map<OperationDescription, String> responseWrapperMap = new HashMap<OperationDescription, String>(); private Map<OperationDescription, Method> methodMap = new HashMap<OperationDescription, Method>(); private Map<FaultDescription, FaultBeanDesc> faultBeanDescMap = new HashMap<FaultDescription, FaultBeanDesc>(); static final String JAXWS_SUBPACKAGE = "jaxws"; /** * Artifact Processor * * @param serviceDesc */ ArtifactProcessor(ServiceDescription serviceDesc) { this.serviceDesc = serviceDesc; } Map<OperationDescription, String> getRequestWrapperMap() { return requestWrapperMap; } Map<OperationDescription, String> getResponseWrapperMap() { return responseWrapperMap; } Map<FaultDescription, FaultBeanDesc> getFaultBeanDescMap() { return faultBeanDescMap; } Map<OperationDescription, Method> getMethodMap() { return methodMap; } void build() { for (EndpointDescription ed : serviceDesc.getEndpointDescriptions()) { if (ed.getEndpointInterfaceDescription() != null) { for (OperationDescription opDesc : ed.getEndpointInterfaceDescription().getOperations()) { String declaringClassName = opDesc.getJavaDeclaringClassName(); String packageName = getPackageName(declaringClassName); String simpleName = getSimpleClassName(declaringClassName); String methodName = opDesc.getJavaMethodName(); // There is no default for @RequestWrapper/@ResponseWrapper classname None is listed in Sec. 7.3 on p. 80 of // the JAX-WS spec, BUT Conformance(Using javax.xml.ws.RequestWrapper) in Sec 2.3.1.2 on p. 13 // says the entire annotation "...MAY be omitted if all its properties would have default values." // We will assume that this statement gives us the liberty to find a wrapper class/build a wrapper class or // implement an engine w/o the wrapper class. // @RequestWrapper className processing String requestWrapperName = opDesc.getRequestWrapperClassName(); String foundRequestWrapperName = getWrapperClass("@RequestWrapper", requestWrapperName, packageName, javaMethodToClassName(methodName), ed.getAxisService().getClassLoader(), serviceDesc); if (foundRequestWrapperName != null) { requestWrapperMap.put(opDesc, foundRequestWrapperName); } // @ResponseWrapper className processing String responseWrapperName = opDesc.getResponseWrapperClassName(); String foundResponseWrapperName = getWrapperClass("@ResponseWrapper", responseWrapperName, packageName, javaMethodToClassName(methodName) + "Response", ed.getAxisService().getClassLoader(), serviceDesc); if (foundResponseWrapperName != null) { responseWrapperMap.put(opDesc, foundResponseWrapperName); } for (FaultDescription faultDesc : opDesc.getFaultDescriptions()) { FaultBeanDesc faultBeanDesc = create(ed, faultDesc, opDesc); faultBeanDescMap.put(faultDesc, faultBeanDesc); } // Get the Method Class cls = null; try { cls = loadClass(declaringClassName, getContextClassLoader()); } catch (Exception e) { if (log.isDebugEnabled()) { log.debug("Class " + declaringClassName + " was not found by the Context ClassLoader. " + "Will use the ClassLoader associated with the service. The exception is: " + e); } } if (cls == null) { try { cls = loadClass(declaringClassName, ed.getAxisService().getClassLoader()); } catch (Exception e) { if (log.isDebugEnabled()) { log.debug("Class " + declaringClassName + " was not found by the AxisService ClassLoader. " + "Processing continues. The exception is:" + e); } } } if (cls != null) { Method method = getMethod(opDesc.getJavaMethodName(), cls); if (method != null) { methodMap.put(opDesc, method); } } } } } } /** * @param type "@RequestWrapper", "@ResponseWrapper", and "@WebFault" * @param providedValue String name of the Wrapper or Fault Bean from annotations * @param defaultPkg String name of the package to use for defaulting * @param defaultClassName name of the class to use if defaulting * @param altClassLoader name of the alternative classloader * @return */ static private String getWrapperClass(String type, String providedValue, String defaultPkg, String defaultClassName, ClassLoader altClassLoader, ServiceDescription serviceDesc) { if (log.isDebugEnabled()) { log.debug("getWrapperClass for " + type + " with value (" + providedValue + ")"); } String wrapperClass = null; try { ClassLoader cl = getContextClassLoader(); if (providedValue != null && providedValue.length() > 0) { Class cls = null; // If a className is provided try to load it with the context classloader // and then the alternate classloader. // If the class still cannot be loaded, then try inserting the // jaxws sub-package. if (log.isDebugEnabled()) { log.debug("Try finding the class with the name provided = " + providedValue); } cls = loadClassOrNull(providedValue, cl); if (cls != null) { wrapperClass = providedValue; } else { cls = loadClassOrNull(providedValue, altClassLoader); if (cls != null) { wrapperClass = providedValue; } } // Legacy if (cls == null) { String origPackage = getPackageName(providedValue); if (origPackage.length() > 0) { String newPackage = origPackage + "." + JAXWS_SUBPACKAGE; String clsName = getSimpleClassName(providedValue); String newValue = newPackage + "." + clsName; if (log.isDebugEnabled()) { log.debug("Did not find the name provided. Now trying " + newValue); } cls = loadClassOrNull(newValue, cl); if (cls != null) { wrapperClass = newValue; } else { cls = loadClassOrNull(newValue, altClassLoader); if (cls != null) { wrapperClass = newValue; } } if (cls == null && (type.equals("@RequestWrapper") || type.equals("@ResponseWrapper") || type.equals("@WebFault") || type.equals("faultInfo"))) { //Support for Fault Bean Generation //As per JAX-WS 2.2 Specification section 3.7 an application programmer can choose not to //package the faultBeans, if we have reached this point in the code then user has choosen //not to package the fault bean. If there is a cache of generated artifacts available then //lets look for the missing faultBean there. //Support for Wrapper Bean Generation //As per JAX-WS 2.2 Specificaiton section 3.6.2.1 pg 41 an application programmer does not use //the wrapper bean classes, so the application need not package these classes. If we have reached //this point in the code then user has choosen not to package these beans. //NOTE:If we find Generated artifacts from cache this guarantees that we will not use //DocLitWrappedMinimum marshaller code. The advantage of normal DocLitWrappedMarshaller is //that it is very robust and has support of lot more datatypes than in DocLitWrappedMinimum. if (log.isDebugEnabled()) { log.debug("Adding cache to classpath"); } ClassFinderFactory cff = (ClassFinderFactory) FactoryRegistry .getFactory(ClassFinderFactory.class); ClassFinder cf = cff.getClassFinder(); String cachePath = (String) serviceDesc.getAxisConfigContext() .getProperty(Constants.WS_CACHE); if (cachePath != null) { //lets add the cache to classpath and retry loading missing artifacts. if (log.isDebugEnabled()) { log.debug("updating classpath with cache location"); } cf.updateClassPath(cachePath, cl); if (log.isDebugEnabled()) { log.debug("trying to load class " + newValue + " from cache."); } cls = loadClassOrNull(newValue, cl); if (cls != null) { wrapperClass = newValue; } } } } } } else { // If no value is provided by the annotation, then the we try default values. // The wsgen tool generates classes in the jaxws subpackage. // The wsimport tool generates classes in the same package as the SEI. // Note that from reading the JAX-WS spec, it seems that WSGen is doing that // correctly; See the conformance requirement in JAX-WS 2.0 Spec Section 3.6.2.1 Document // Wrapped on page 36: Conformance (Default wrapper bean package): In the absence of // customizations, the wrapper beans package MUST be a generated jaxws subpackage of the SEI // package. // However, if the class is in both places the runtime should prefer the one // in the non-jaxws package. Why ? // The other classes in the non-jaxws package will cause the non-jaxws // wrapper to get pulled in first....thus the jaxws wrapper will cause a collision. // // Thus the following algorithm with check the non-jaxws package first Class cls1 = null; // Class from the non-JAXWS package Class cls2 = null; // Class from the JAX-WS package boolean cls1IsJAXB = false; boolean cls2IsJAXB = false; // Look for the class in the non-jaxws package first String defaultValue = null; if (defaultPkg.length() > 0) { defaultValue = defaultPkg + "." + defaultClassName; } else { defaultValue = defaultClassName; } if (log.isDebugEnabled()) { log.debug("No provided value. Try the default class name = " + defaultValue); } cls1 = loadClassOrNull(defaultValue, cl); if (cls1 == null) { cls1 = loadClassOrNull(defaultValue, altClassLoader); } if (cls1 != null) { cls1IsJAXB = isJAXB(cls1); } // Now try the one in the jaxws subpackage (if cls1 is missing or perhaps not a JAXB class) if (cls1 == null || !cls1IsJAXB) { if (defaultPkg.length() > 0) { defaultValue = defaultPkg + "." + JAXWS_SUBPACKAGE + "." + defaultClassName; if (log.isDebugEnabled()) { log.debug("Did not find the default name. Try a different default class name = " + defaultValue); } cls2 = loadClassOrNull(defaultValue, cl); if (cls2 == null) { cls2 = loadClassOrNull(defaultValue, altClassLoader); } if (cls2 == null && (type.equals("@RequestWrapper") || type.equals("@ResponseWrapper") || type.equals("@WebFault") || type.equals("faultInfo"))) { //Support for Fault Bean Generation //As per JAX-WS 2.2 Specification section 3.7 an application programmer can choose not to //package the faultBeans, if we have reached this point in the code then user has choosen //not to package the fault bean. If there is a cache of generated artifacts available then //lets look for the missing faultBean there. //Support for Wrapper Bean Generation //As per JAX-WS 2.2 Specificaiton section 3.6.2.1 pg 41 an application programmer does not use //the wrapper bean classes, so the application need not package these classes. If we have reached //this point in the code then user has choosen not to package these beans. //NOTE:If we find Generated artifacts from cache this guarantees that we will not use //DocLitWrappedMinimum marshaller code. The advantage of normal DocLitWrappedMarshaller is //that it is very robust and has support of lot more datatypes than in DocLitWrappedMinimum. if (log.isDebugEnabled()) { log.debug("Adding cache to classpath"); } if (log.isDebugEnabled()) { log.debug("Adding cache to classpath"); } ClassFinderFactory cff = (ClassFinderFactory) FactoryRegistry .getFactory(ClassFinderFactory.class); ClassFinder cf = cff.getClassFinder(); String cachePath = (String) serviceDesc.getAxisConfigContext() .getProperty(Constants.WS_CACHE); if (log.isDebugEnabled()) { log.debug("cachePath = " + cachePath); } if (cachePath != null) { //lets add the cache to classpath and retry loading missing artifacts. if (log.isDebugEnabled()) { log.debug("updating classpath with cache location"); } cf.updateClassPath(cachePath, cl); if (log.isDebugEnabled()) { log.debug("trying to load class " + defaultValue + " from cache."); } cls2 = loadClassOrNull(defaultValue, cl); } } } } if (cls2 != null) { cls2IsJAXB = isJAXB(cls2); } // Choose the wrapper class if (cls1 == null && cls2 == null) { if (log.isDebugEnabled()) { log.debug("Could not find a wrapper class"); } wrapperClass = null; } else if (cls1 == null) { wrapperClass = cls2.getCanonicalName(); if (log.isDebugEnabled()) { log.debug("Choosing " + wrapperClass); } } else if (cls2 == null) { wrapperClass = cls1.getCanonicalName(); if (log.isDebugEnabled()) { log.debug("Choosing " + wrapperClass); } } else { if (log.isDebugEnabled()) { log.debug("There are two classes that are present " + cls1 + " and " + cls2); } // Choose the one that is JAXB enabled if (!cls1IsJAXB && !cls2IsJAXB) { // If neither is JAXB enabled. Choose the one in the jaxws package. // This is the one most likely provided by tooling. if (log.isDebugEnabled()) { log.debug("Neither are JAXB enabled. Choosing " + cls2); } wrapperClass = cls2.getCanonicalName(); } else if (cls1IsJAXB && cls2IsJAXB) { // If both are JAXB enabled, choose the one in the non-JAXWS package. // This generally means that multiple tools generated the packages. // Choosing the one in the non-JAXWS package will avoid a JAXBContext collision. if (log.isDebugEnabled()) { log.debug("Both are JAXB enabled. Choosing " + cls1); } wrapperClass = cls1.getCanonicalName(); } else if (cls1IsJAXB) { if (log.isDebugEnabled()) { log.debug("Choosing " + cls1 + " because it is JAXB enabled"); } wrapperClass = cls1.getCanonicalName(); } else { if (log.isDebugEnabled()) { log.debug("Choosing " + cls2 + " because it is JAXB enabled"); } wrapperClass = cls2.getCanonicalName(); } } } } catch (Throwable t) { if (log.isDebugEnabled()) { log.debug("Unexpected error. Processing continues. ", t); } } if (log.isDebugEnabled()) { log.debug("exit getWrapperClass with " + wrapperClass); } return wrapperClass; } private FaultBeanDesc create(EndpointDescription ed, FaultDescription faultDesc, OperationDescription opDesc) { /* FaultBeanClass algorithm * 1) The class defined on @WebFault of the exception * 2) If not present or invalid, the class defined by getFaultInfo. * 3) If not present, the class is found using the default name and location */ String declaringClassName = opDesc.getJavaDeclaringClassName(); String type = "@WebFault"; String faultBeanClassName = faultDesc.getFaultBean(); if (faultBeanClassName == null || faultBeanClassName.length() == 0) { type = "faultInfo"; faultBeanClassName = faultDesc.getFaultInfo(); } String foundClassName = getWrapperClass(type, faultBeanClassName, getPackageName(declaringClassName), getSimpleClassName(faultDesc.getExceptionClassName()) + "Bean", ed.getAxisService().getClassLoader(), serviceDesc); if (foundClassName == null) { faultBeanClassName = missingArtifact(faultBeanClassName); } if (foundClassName != null) { faultBeanClassName = foundClassName; } /* Local NameAlgorithm: * 1) The name defined on the @WebFault of the exception. * 2) If not present, the name defined via the @XmlRootElement of the fault bean class. * 3) If not present, the <exceptionName>Bean */ String faultBeanLocalName = faultDesc.getName(); if (faultBeanLocalName == null || faultBeanLocalName.length() == 0) { if (faultBeanClassName != null && faultBeanClassName.length() > 0) { try { Class faultBean; try { faultBean = loadClass(faultBeanClassName, getContextClassLoader()); } catch (ClassNotFoundException e) { faultBean = loadClass(faultBeanClassName, ed.getAxisService().getClassLoader()); } AnnotationDesc aDesc = AnnotationDescImpl.create(faultBean); if (aDesc.hasXmlRootElement()) { faultBeanLocalName = aDesc.getXmlRootElementName(); } } catch (Throwable t) { throw ExceptionFactory.makeWebServiceException(t); } } } if (faultBeanLocalName == null || faultBeanLocalName.length() == 0) { faultBeanLocalName = getSimpleClassName(faultDesc.getExceptionClassName()) + "Bean"; } /* Algorithm for fault bean namespace * 1) The namespace defined on the @WebFault of the exception. * 2) If not present, the namespace defined via the @XmlRootElement of the class name. * 3) If not present, the namespace of the method's declared class + "/jaxws" */ String faultBeanNamespace = faultDesc.getTargetNamespace(); if (faultBeanNamespace == null || faultBeanNamespace.length() == 0) { if (faultBeanClassName != null && faultBeanClassName.length() > 0) { try { Class faultBean; try { faultBean = loadClass(faultBeanClassName, getContextClassLoader()); } catch (ClassNotFoundException e) { faultBean = loadClass(faultBeanClassName, ed.getAxisService().getClassLoader()); } AnnotationDesc aDesc = AnnotationDescImpl.create(faultBean); if (aDesc.hasXmlRootElement()) { faultBeanNamespace = aDesc.getXmlRootElementNamespace(); } } catch (Throwable t) { throw ExceptionFactory.makeWebServiceException(t); } } } if (faultBeanNamespace == null || faultBeanNamespace.length() == 0) { faultBeanNamespace = opDesc.getEndpointInterfaceDescription().getTargetNamespace(); } return new FaultBeanDescImpl(faultBeanClassName, faultBeanLocalName, faultBeanNamespace); } /** * @param className * @return package name */ private static String getPackageName(String className) { int index = className.lastIndexOf("."); if (index <= 0) { return ""; } else { return className.substring(0, index); } } /** * @param className * @return simple class name */ private static String getSimpleClassName(String className) { int index = className.lastIndexOf("."); if (index <= 0) { return className; } else { return className.substring(index + 1); } } /** * @param methodName * @return method name converted into a class name */ private static String javaMethodToClassName(String methodName) { String className = null; if (methodName != null) { StringBuffer buildClassName = new StringBuffer(methodName); buildClassName.replace(0, 1, methodName.substring(0, 1).toUpperCase()); className = buildClassName.toString(); } return className; } /** * This method is invoked if the artifact is missing * * @param artifactName * @return newly constructed name or null */ private String missingArtifact(String artifactName) { if (log.isDebugEnabled()) { log.debug("The following class was not found: " + artifactName + " Processing continues without this class."); } return null; } /** * @param className * @param classLoader * @return Class or Null */ private static Class loadClassOrNull(String className, ClassLoader classLoader) { try { return loadClass(className, classLoader); } catch (Throwable t) { return null; } } private static Class loadClass(String className, ClassLoader classLoader) throws ClassNotFoundException { // Don't make this public, its a security exposure return forName(className, true, classLoader); } /** * Return the class for this name * * @return Class */ private static Class forName(final String className, final boolean initialize, final ClassLoader classloader) throws ClassNotFoundException { // NOTE: This method must remain protected because it uses AccessController Class cl = null; try { cl = (Class) AccessController.doPrivileged(new PrivilegedExceptionAction() { public Object run() throws ClassNotFoundException { // Class.forName does not support primitives Class cls = ClassUtils.getPrimitiveClass(className); try { if (cls == null) { cls = Class.forName(className, initialize, classloader); } return cls; //Lets catch NoClassDefFoundError as its part of Throwable //Any Exception that extends Exception will be handled by doPriv method. } catch (NoClassDefFoundError e) { /** * In different jaxws scenarios, some classes may be missing. So it is normal behavior * to get to this point. The exception is swallowed and a null is returned. * The exception is not logged...as this would give servicability folks the idea that a problem occurred. */ } return cls; } }); } catch (PrivilegedActionException e) { /** * In different jaxws scenarios, some classes may be missing. So it is normal behavior * to get to this point. * The exception is not logged...as this would give servicability folks the idea that a problem occurred. */ throw (ClassNotFoundException) e.getException(); } return cl; } /** * Return the Method matching the method name or null * @param methodName String containing method name * @param cls Class of the class that declares the method * * @return Method or null */ private static Method getMethod(final String methodName, final Class cls) { // NOTE: This method must remain protected because it uses AccessController Method method = null; try { method = (Method) AccessController.doPrivileged(new PrivilegedExceptionAction() { public Object run() { Method[] methods = cls.getMethods(); if (methods != null) { for (int i = 0; i < methods.length; i++) { if (methods[i].getName().equals(methodName)) { return methods[i]; } } } return null; } }); } catch (PrivilegedActionException e) { } return method; } /** @return ClassLoader */ private static ClassLoader getContextClassLoader() { // NOTE: This method must remain private because it uses AccessController ClassLoader cl = null; try { cl = (ClassLoader) AccessController.doPrivileged(new PrivilegedExceptionAction() { public Object run() throws ClassNotFoundException { return Thread.currentThread().getContextClassLoader(); } }); } catch (PrivilegedActionException e) { if (log.isDebugEnabled()) { log.debug("Exception thrown from AccessController: " + e); } throw (RuntimeException) e.getException(); } return cl; } /** * @param cls * @return true if cls appears to be a JAXB enabled class */ private static boolean isJAXB(Class cls) { // See if the object represents a root element XmlRootElement root = (XmlRootElement) getAnnotation(cls, XmlRootElement.class); if (root != null) { if (log.isDebugEnabled()) { log.debug("isJAXB returns true due to presence of @XmlRootElement on " + cls); } return true; } // See if the object represents an type XmlType type = (XmlType) getAnnotation(cls, XmlType.class); if (type != null) { if (log.isDebugEnabled()) { log.debug("isJAXB returns true due to presence of @XmlType on " + cls); } return true; } if (log.isDebugEnabled()) { log.debug("isJAXB returns false for" + cls); } return false; } /** * Get an annotation. This is wrappered to avoid a Java2Security violation. * @param cls Class that contains annotation * @param annotation Class of requested Annotation * @return annotation or null */ private static Annotation getAnnotation(final AnnotatedElement element, final Class annotation) { Annotation anno = null; try { anno = (Annotation) AccessController.doPrivileged(new PrivilegedAction() { public Object run() { return element.getAnnotation(annotation); } }); } catch (Throwable t) { if (log.isDebugEnabled()) { log.debug("Problem occurred. Continuing. The problem is " + t); } } return anno; } }