You are viewing a plain text version of this content. The canonical link for it is here.
Posted to scm@geronimo.apache.org by xu...@apache.org on 2011/04/06 15:32:02 UTC
svn commit: r1089448 - in /geronimo/bundles/trunk: axis2-saaj/ axis2/
axis2/src/main/java/org/apache/axis2/jaxws/description/
axis2/src/main/java/org/apache/axis2/jaxws/runtime/
axis2/src/main/java/org/apache/axis2/jaxws/runtime/description/ axis2/src/...
Author: xuhaihong
Date: Wed Apr 6 13:32:02 2011
New Revision: 1089448
URL: http://svn.apache.org/viewvc?rev=1089448&view=rev
Log:
a. Update Axis2 version to 1.6.1-SNAPSHOT
b. Remove committed changes in Axis2 from Geronimo side
c. Add some new changes on Geronimo side, check the parameter style before checking the wrapper class
Added:
geronimo/bundles/trunk/axis2/src/main/java/org/apache/axis2/jaxws/runtime/
geronimo/bundles/trunk/axis2/src/main/java/org/apache/axis2/jaxws/runtime/description/
geronimo/bundles/trunk/axis2/src/main/java/org/apache/axis2/jaxws/runtime/description/marshal/
geronimo/bundles/trunk/axis2/src/main/java/org/apache/axis2/jaxws/runtime/description/marshal/impl/
geronimo/bundles/trunk/axis2/src/main/java/org/apache/axis2/jaxws/runtime/description/marshal/impl/ArtifactProcessor.java (with props)
Removed:
geronimo/bundles/trunk/axis2/src/main/java/org/apache/axis2/jaxws/description/
Modified:
geronimo/bundles/trunk/axis2-saaj/pom.xml
geronimo/bundles/trunk/axis2/pom.xml
Modified: geronimo/bundles/trunk/axis2-saaj/pom.xml
URL: http://svn.apache.org/viewvc/geronimo/bundles/trunk/axis2-saaj/pom.xml?rev=1089448&r1=1089447&r2=1089448&view=diff
==============================================================================
--- geronimo/bundles/trunk/axis2-saaj/pom.xml (original)
+++ geronimo/bundles/trunk/axis2-saaj/pom.xml Wed Apr 6 13:32:02 2011
@@ -28,7 +28,7 @@
<groupId>org.apache.geronimo.bundles</groupId>
<artifactId>${pkgArtifactId}</artifactId>
- <version>1.6.0_1-SNAPSHOT</version>
+ <version>1.6.1_1-SNAPSHOT</version>
<packaging>bundle</packaging>
<name>Apache Geronimo Bundles: ${pkgArtifactId}-${pkgVersion}</name>
<description>
@@ -44,7 +44,7 @@
<properties>
<pkgGroupId>org.apache.axis2</pkgGroupId>
<pkgArtifactId>axis2-saaj</pkgArtifactId>
- <pkgVersion>1.6.0-SNAPSHOT</pkgVersion>
+ <pkgVersion>1.6.1-SNAPSHOT</pkgVersion>
</properties>
<dependencies>
Modified: geronimo/bundles/trunk/axis2/pom.xml
URL: http://svn.apache.org/viewvc/geronimo/bundles/trunk/axis2/pom.xml?rev=1089448&r1=1089447&r2=1089448&view=diff
==============================================================================
--- geronimo/bundles/trunk/axis2/pom.xml (original)
+++ geronimo/bundles/trunk/axis2/pom.xml Wed Apr 6 13:32:02 2011
@@ -26,13 +26,13 @@
</parent>
<groupId>org.apache.geronimo.bundles</groupId>
<artifactId>axis2</artifactId>
- <version>1.6.0_1-SNAPSHOT</version>
+ <version>1.6.1_1-SNAPSHOT</version>
<packaging>bundle</packaging>
<name>Apache Geronimo Bundles: Axis2-${pkgVersion}</name>
<description> This bundle simply wraps all required Axis2 components </description>
<properties>
<pkgGroupId>org.apache.axis2</pkgGroupId>
- <pkgVersion>1.6.0-SNAPSHOT</pkgVersion>
+ <pkgVersion>1.6.1-SNAPSHOT</pkgVersion>
</properties>
<scm>
<connection>scm:svn:http://svn.apache.org/repos/asf/geronimo/bundles/trunk/axis2</connection>
@@ -222,12 +222,6 @@
<Embed-Dependency> *;inline=META-INF/services/**|META-INF/*.xml|*.xml|org/apache/axis2**</Embed-Dependency>
<Include-Resource>
{maven-resources},
- org/apache/axis2/jaxws/description/builder/MDQConstants.class=target/classes/org/apache/axis2/jaxws/description/builder/MDQConstants.class,
- org/apache/axis2/jaxws/description/impl/EndpointInterfaceDescriptionImpl.class=target/classes/org/apache/axis2/jaxws/description/impl/EndpointInterfaceDescriptionImpl.class,
- org/apache/axis2/jaxws/description/impl/EndpointInterfaceDescriptionImpl$1.class=target/classes/org/apache/axis2/jaxws/description/impl/EndpointInterfaceDescriptionImpl$1.class,
- org/apache/axis2/jaxws/description/impl/EndpointInterfaceDescriptionImpl$2.class=target/classes/org/apache/axis2/jaxws/description/impl/EndpointInterfaceDescriptionImpl$2.class,
- org/apache/axis2/jaxws/description/impl/EndpointInterfaceDescriptionImpl$3.class=target/classes/org/apache/axis2/jaxws/description/impl/EndpointInterfaceDescriptionImpl$3.class,
- org/apache/axis2/jaxws/description/impl/EndpointInterfaceDescriptionImpl$4.class=target/classes/org/apache/axis2/jaxws/description/impl/EndpointInterfaceDescriptionImpl$4.class,
org/apache/axis2/jaxws/client/proxy/JAXWSProxyHandler.class=target/classes/org/apache/axis2/jaxws/client/proxy/JAXWSProxyHandler.class,
org/apache/axis2/jaxws/client/proxy/JAXWSProxyHandler$1.class=target/classes/org/apache/axis2/jaxws/client/proxy/JAXWSProxyHandler$1.class,
org/apache/axis2/jaxws/client/proxy/JAXWSProxyHandler$2.class=target/classes/org/apache/axis2/jaxws/client/proxy/JAXWSProxyHandler$2.class,
@@ -243,7 +237,12 @@
org/apache/axis2/jaxws/message/databinding/JAXBUtils$4.class=target/classes/org/apache/axis2/jaxws/message/databinding/JAXBUtils$4.class,
org/apache/axis2/jaxws/message/databinding/JAXBUtils$3.class=target/classes/org/apache/axis2/jaxws/message/databinding/JAXBUtils$3.class,
org/apache/axis2/jaxws/message/databinding/JAXBUtils$2.class=target/classes/org/apache/axis2/jaxws/message/databinding/JAXBUtils$2.class,
- org/apache/axis2/jaxws/message/databinding/JAXBUtils$1.class=target/classes/org/apache/axis2/jaxws/message/databinding/JAXBUtils$1.class
+ org/apache/axis2/jaxws/message/databinding/JAXBUtils$1.class=target/classes/org/apache/axis2/jaxws/message/databinding/JAXBUtils$1.class,
+ org/apache/axis2/jaxws/runtime/description/marshal/impl/ArtifactProcessor.class=target/classes/org/apache/axis2/jaxws/runtime/description/marshal/impl/ArtifactProcessor.class,
+ org/apache/axis2/jaxws/runtime/description/marshal/impl/ArtifactProcessor$1.class=target/classes/org/apache/axis2/jaxws/runtime/description/marshal/impl/ArtifactProcessor$1.class,
+ org/apache/axis2/jaxws/runtime/description/marshal/impl/ArtifactProcessor$2.class=target/classes/org/apache/axis2/jaxws/runtime/description/marshal/impl/ArtifactProcessor$2.class,
+ org/apache/axis2/jaxws/runtime/description/marshal/impl/ArtifactProcessor$3.class=target/classes/org/apache/axis2/jaxws/runtime/description/marshal/impl/ArtifactProcessor$3.class,
+ org/apache/axis2/jaxws/runtime/description/marshal/impl/ArtifactProcessor$4.class=target/classes/org/apache/axis2/jaxws/runtime/description/marshal/impl/ArtifactProcessor$4.class
</Include-Resource>
<SPI-Provider>true</SPI-Provider>
</instructions>
Added: geronimo/bundles/trunk/axis2/src/main/java/org/apache/axis2/jaxws/runtime/description/marshal/impl/ArtifactProcessor.java
URL: http://svn.apache.org/viewvc/geronimo/bundles/trunk/axis2/src/main/java/org/apache/axis2/jaxws/runtime/description/marshal/impl/ArtifactProcessor.java?rev=1089448&view=auto
==============================================================================
--- geronimo/bundles/trunk/axis2/src/main/java/org/apache/axis2/jaxws/runtime/description/marshal/impl/ArtifactProcessor.java (added)
+++ geronimo/bundles/trunk/axis2/src/main/java/org/apache/axis2/jaxws/runtime/description/marshal/impl/ArtifactProcessor.java Wed Apr 6 13:32:02 2011
@@ -0,0 +1,758 @@
+/*
+ * 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.jws.soap.SOAPBinding;
+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 && ed.getEndpointInterfaceDescription().getSoapBindingParameterStyle() == SOAPBinding.ParameterStyle.WRAPPED) {
+ 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;
+ }
+}
Propchange: geronimo/bundles/trunk/axis2/src/main/java/org/apache/axis2/jaxws/runtime/description/marshal/impl/ArtifactProcessor.java
------------------------------------------------------------------------------
svn:eol-style = native
Propchange: geronimo/bundles/trunk/axis2/src/main/java/org/apache/axis2/jaxws/runtime/description/marshal/impl/ArtifactProcessor.java
------------------------------------------------------------------------------
svn:keywords = Date Revision
Propchange: geronimo/bundles/trunk/axis2/src/main/java/org/apache/axis2/jaxws/runtime/description/marshal/impl/ArtifactProcessor.java
------------------------------------------------------------------------------
svn:mime-type = text/plain