diff options
| author | jsdelfino <jsdelfino@13f79535-47bb-0310-9956-ffa450edef68> | 2008-09-09 20:07:50 +0000 |
|---|---|---|
| committer | jsdelfino <jsdelfino@13f79535-47bb-0310-9956-ffa450edef68> | 2008-09-09 20:07:50 +0000 |
| commit | 8ff4657da7b5a1da59a21a65b675d26bcf033417 (patch) | |
| tree | 4f3d2b3e94a35eb6fd22dd8979d55d0eb6dcecb9 /branches/sca-android/modules/interface-java-jaxws/src/main | |
| parent | bf5f54e4300a67803d53ac1b47ea2f70c1e2542e (diff) | |
Copied the android port modules under the modules directory, to match the structure in trunk as it'll help with merges, diffs etc.
git-svn-id: http://svn.us.apache.org/repos/asf/tuscany@693584 13f79535-47bb-0310-9956-ffa450edef68
Diffstat (limited to '')
2 files changed, 485 insertions, 0 deletions
diff --git a/branches/sca-android/modules/interface-java-jaxws/src/main/java/org/apache/tuscany/sca/interfacedef/java/jaxws/JAXWSFaultExceptionMapper.java b/branches/sca-android/modules/interface-java-jaxws/src/main/java/org/apache/tuscany/sca/interfacedef/java/jaxws/JAXWSFaultExceptionMapper.java new file mode 100644 index 0000000000..dbbc7b4635 --- /dev/null +++ b/branches/sca-android/modules/interface-java-jaxws/src/main/java/org/apache/tuscany/sca/interfacedef/java/jaxws/JAXWSFaultExceptionMapper.java @@ -0,0 +1,253 @@ +/*
+ * 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.tuscany.sca.interfacedef.java.jaxws;
+
+import java.beans.BeanInfo;
+import java.beans.Introspector;
+import java.beans.PropertyDescriptor;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+
+import javax.xml.namespace.QName;
+import javax.xml.ws.WebFault;
+
+import org.apache.tuscany.sca.databinding.DataBindingExtensionPoint;
+import org.apache.tuscany.sca.interfacedef.DataType;
+import org.apache.tuscany.sca.interfacedef.FaultExceptionMapper;
+import org.apache.tuscany.sca.interfacedef.util.FaultException;
+import org.apache.tuscany.sca.interfacedef.util.XMLType;
+import org.osoa.sca.ServiceRuntimeException;
+
+/**
+ * JAX-WS ExceptionHandler
+ *
+ * @version $Rev: 639821 $ $Date: 2008-03-21 12:42:37 -0800 (Fri, 21 Mar 2008) $
+ */
+public class JAXWSFaultExceptionMapper implements FaultExceptionMapper {
+ private static final Class<?>[] EMPTY_CLASS_ARRAY = new Class[0];
+ private DataBindingExtensionPoint dataBindingExtensionPoint;
+
+ public JAXWSFaultExceptionMapper(DataBindingExtensionPoint dataBindingExtensionPoint) {
+ super();
+ this.dataBindingExtensionPoint = dataBindingExtensionPoint;
+ }
+
+ /**
+ * The following is quoted from the JAX-WS Specification v2.1
+ * <ul>
+ * <li>WrapperException(String message, FaultBean faultInfo) <br>
+ * A constructor where WrapperException is replaced with the name of the
+ * generated wrapper exception and FaultBean is replaced by the name of the
+ * generated fault bean.
+ * <li> WrapperException(String message, FaultBean faultInfo, Throwable
+ * cause) <br>
+ * A constructor where WrapperException is replaced with the name of the
+ * generated wrapper exception and FaultBean is replaced by the name of the
+ * generated fault bean. The last argument, cause, may be used to convey
+ * protocol specific fault information
+ * </ul>
+ */
+ @SuppressWarnings("unchecked")
+ public Throwable wrapFaultInfo(DataType<DataType> exceptionType, String message, Object faultInfo, Throwable cause) {
+ Class<?> exceptionClass = exceptionType.getPhysical();
+ if (exceptionClass.isInstance(faultInfo)) {
+ return (Throwable)faultInfo;
+ }
+ DataType<?> faultBeanType = exceptionType.getLogical();
+ Class<?> faultBeanClass = faultBeanType.getPhysical();
+ try {
+ Exception exc = null;
+ try {
+ Constructor<?> constructor =
+ exceptionClass.getConstructor(new Class[] {String.class, faultBeanClass, Throwable.class});
+ exc = (Exception)constructor.newInstance(new Object[] {message, faultInfo, cause});
+ } catch (NoSuchMethodException e) {
+ // Create a generic fault exception
+ exc = new FaultException(message, faultInfo, cause);
+ }
+ // Include the elem name into the FaultException we build so it can be used for matching in the DataTransformationInterceptor
+ //
+ // Note this may happen even if we find a constructor above, that is the type of the non-generic fault exc may be an instance
+ // of FaultException
+ //
+ if ((exc instanceof FaultException) && (faultBeanType.getLogical() instanceof XMLType)) {
+ FaultException faultExc = (FaultException)exc;
+ DataType<XMLType> faultBeanXMLType = (DataType<XMLType>)faultBeanType;
+ XMLType faultLogical = faultBeanXMLType.getLogical();
+ faultExc.setFaultName(faultLogical.getElementName());
+ }
+ return exc;
+ } catch (Throwable e) {
+ throw new IllegalArgumentException(e);
+ }
+ }
+
+ public Object getFaultInfo(Throwable exception, Class<?> faultBeanClass) {
+ if (exception == null) {
+ return null;
+ }
+
+ // Check if it's the generic FaultException
+ if (exception instanceof FaultException) {
+ return ((FaultException)exception).getFaultInfo();
+ }
+
+ try {
+ Method method = exception.getClass().getMethod("getFaultInfo", EMPTY_CLASS_ARRAY);
+ return method.invoke(exception, (Object[])null);
+ } catch (NoSuchMethodException e) {
+ // Follow the JAX-WS v2.1 Specification section 3.7
+ return createFaultBean(exception, faultBeanClass);
+ } catch (Throwable e) {
+ throw new IllegalArgumentException(e);
+ }
+ }
+
+ private Object createFaultBean(Throwable exception, Class<?> faultBeanClass) {
+ /**
+ * For each getter in the exception and its superclasses, a property of the same
+ * type and name is added to the bean. The getCause, getLocalizedMessage and
+ * getStackTrace getters from java.lang.Throwable and the getClass getter from
+ * java.lang.Object are excluded from the list of getters to be mapped.
+ */
+ // Return the exception as-is if it's already the fault bean
+ if (faultBeanClass.isInstance(exception)) {
+ return exception;
+ }
+ try {
+ Object faultBean = null;
+ for (Constructor<?> ctor : faultBeanClass.getConstructors()) {
+ Class<?>[] params = ctor.getParameterTypes();
+ if (params.length == 1 && String.class == params[0]) {
+ faultBean = ctor.newInstance(exception.getMessage());
+ } else if (params.length == 2 && String.class == params[0]
+ && Throwable.class.isAssignableFrom(params[1])) {
+ faultBean = ctor.newInstance(exception.getMessage(), exception);
+ } else if (params.length == 0) {
+ faultBean = ctor.newInstance();
+ }
+ if (faultBean != null) {
+ break;
+ }
+ }
+ if (faultBean == null) {
+ return exception;
+ }
+ BeanInfo beanInfo = Introspector.getBeanInfo(exception.getClass());
+ for (PropertyDescriptor pd : beanInfo.getPropertyDescriptors()) {
+ Method getter = pd.getReadMethod();
+ String name = getter.getName();
+ if ("getClass".equals(name) || "getStackTrace".equals(name)
+ || "getCause".equals(name)
+ || "getLocalizedMessage".equals(name)) {
+ continue;
+ }
+ String prefix = "get";
+ if (name.startsWith("get")) {
+ prefix = "get";
+ } else if (name.startsWith("is")) {
+ prefix = "is";
+ }
+ Method setter = null;
+ try {
+ setter =
+ faultBeanClass.getMethod("set" + name.substring(prefix.length()), new Class[] {getter
+ .getReturnType()});
+ } catch (NoSuchMethodException e) {
+ continue;
+ }
+ Object prop = setter.invoke(faultBean, getter.invoke(exception, (Object[])null));
+ setter.invoke(faultBean, prop);
+ }
+ return faultBean;
+ } catch (Throwable ex) {
+ throw new IllegalArgumentException(ex);
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ public boolean introspectFaultDataType(DataType<DataType> exceptionType) {
+ QName faultName = null;
+ boolean result = false;
+
+ Class<?> cls = exceptionType.getPhysical();
+ if (cls == FaultException.class) {
+ return true;
+ }
+ DataType faultType = (DataType)exceptionType.getLogical();
+ Class<?> faultBean = null;
+ WebFault fault = cls.getAnnotation(WebFault.class);
+ if (fault != null) {
+ faultName = new QName(fault.targetNamespace(), fault.name());
+ XMLType xmlType = new XMLType(faultName, null);
+ faultType.setLogical(xmlType);
+ if (!"".equals(fault.faultBean())) {
+ try {
+ faultBean = Class.forName(fault.faultBean(), false, cls.getClassLoader());
+ } catch (ClassNotFoundException e) {
+ throw new ServiceRuntimeException(e);
+ }
+ } else {
+ Method m;
+ try {
+ m = cls.getMethod("getFaultInfo", (Class[])null);
+ faultBean = m.getReturnType();
+ } catch (NoSuchMethodException e) {
+ // Ignore
+ }
+ }
+ }
+
+ if (faultBean == null) {
+ String faultBeanClassName = cls.getPackage().getName() + ".jaxws." + cls.getSimpleName() + "Bean";
+ try {
+ faultBean = Class.forName(faultBeanClassName, false, cls.getClassLoader());
+ } catch (ClassNotFoundException e) {
+ faultBean = cls;
+ }
+ }
+
+ faultType.setPhysical(faultBean);
+ // TODO: Use the databinding framework to introspect the fault bean class
+ if (dataBindingExtensionPoint != null) {
+ result =
+ dataBindingExtensionPoint.introspectType(faultType, null, Throwable.class.isAssignableFrom(faultBean));
+ }
+
+ /*
+ The introspection of the fault DT may not have calculated the correct element name,
+ though we may have already done this in this method. Let's look at the DataType now
+ that introspection is done, and, if it has an XMLType, let's set the element to the
+ 'faultName' if we calculated one.
+ */
+ if ((faultName != null) && (faultType.getLogical() instanceof XMLType)) {
+ XMLType faultTypeXML = (XMLType)faultType.getLogical();
+ // The element name (if set) should match the fault name
+ faultTypeXML.setElementName(faultName);
+ }
+
+ return result;
+ }
+
+ public void setDataBindingExtensionPoint(DataBindingExtensionPoint dataBindingExtensionPoint) {
+ this.dataBindingExtensionPoint = dataBindingExtensionPoint;
+ }
+
+}
diff --git a/branches/sca-android/modules/interface-java-jaxws/src/main/java/org/apache/tuscany/sca/interfacedef/java/jaxws/JAXWSJavaInterfaceProcessor.java b/branches/sca-android/modules/interface-java-jaxws/src/main/java/org/apache/tuscany/sca/interfacedef/java/jaxws/JAXWSJavaInterfaceProcessor.java new file mode 100644 index 0000000000..f25425f286 --- /dev/null +++ b/branches/sca-android/modules/interface-java-jaxws/src/main/java/org/apache/tuscany/sca/interfacedef/java/jaxws/JAXWSJavaInterfaceProcessor.java @@ -0,0 +1,232 @@ +/*
+ * 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.tuscany.sca.interfacedef.java.jaxws;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+/*import javax.jws.Oneway;
+import javax.jws.WebMethod;
+import javax.jws.WebParam;
+import javax.jws.WebResult;
+import javax.jws.WebService;
+import javax.jws.soap.SOAPBinding;
+import javax.jws.soap.SOAPBinding.Style;*/
+import javax.xml.namespace.QName;
+import javax.xml.ws.RequestWrapper;
+import javax.xml.ws.ResponseWrapper;
+
+import org.apache.tuscany.sca.interfacedef.DataType;
+import org.apache.tuscany.sca.interfacedef.FaultExceptionMapper;
+import org.apache.tuscany.sca.interfacedef.InvalidInterfaceException;
+import org.apache.tuscany.sca.interfacedef.Operation;
+import org.apache.tuscany.sca.interfacedef.java.JavaInterface;
+import org.apache.tuscany.sca.interfacedef.java.JavaOperation;
+import org.apache.tuscany.sca.interfacedef.java.impl.JavaInterfaceUtil;
+import org.apache.tuscany.sca.interfacedef.java.introspect.JavaInterfaceVisitor;
+import org.apache.tuscany.sca.interfacedef.util.ElementInfo;
+import org.apache.tuscany.sca.interfacedef.util.WrapperInfo;
+import org.apache.tuscany.sca.interfacedef.util.XMLType;
+
+/**
+ * Introspect the java class/interface with JSR-181 and JAXWS annotations
+ *
+ * @version $Rev: 643696 $ $Date: 2008-04-01 19:24:11 -0800 (Tue, 01 Apr 2008) $
+ */
+public class JAXWSJavaInterfaceProcessor implements JavaInterfaceVisitor {
+ private static final String JAXB_DATABINDING = "javax.xml.bind.JAXBElement";
+ private FaultExceptionMapper faultExceptionMapper;
+
+ public JAXWSJavaInterfaceProcessor(FaultExceptionMapper faultExceptionMapper) {
+ super();
+ this.faultExceptionMapper = faultExceptionMapper;
+ }
+
+ public JAXWSJavaInterfaceProcessor() {
+ super();
+ }
+
+ public void visitInterface(JavaInterface contract) throws InvalidInterfaceException {
+
+ Class<?> clazz = contract.getJavaClass();
+ //WebService webService = clazz.getAnnotation(WebService.class);
+ String tns = JavaInterfaceUtil.getNamespace(clazz);
+ //if (webService != null) {
+ // tns = getValue(webService.targetNamespace(), tns);
+ // Mark SEI as Remotable
+ //contract.setRemotable(true);
+ //}
+ if (!contract.isRemotable()) {
+ return;
+ }
+
+ // SOAP binding (doc/lit/wrapped|bare or rpc/lit)
+ //SOAPBinding soapBinding = clazz.getAnnotation(SOAPBinding.class);
+
+ for (Iterator<Operation> it = contract.getOperations().iterator(); it.hasNext();) {
+ JavaOperation operation = (JavaOperation)it.next();
+ Method method = operation.getJavaMethod();
+ introspectFaultTypes(operation);
+
+ // SOAP binding (doc/lit/wrapped|bare or rpc/lit)
+ //SOAPBinding methodSOAPBinding = method.getAnnotation(SOAPBinding.class);
+ //if (methodSOAPBinding == null) {
+ // methodSOAPBinding = soapBinding;
+ //}
+
+ boolean documentStyle = true;
+ boolean bare = false;
+ //if (methodSOAPBinding != null) {
+ // bare = methodSOAPBinding.parameterStyle() == SOAPBinding.ParameterStyle.BARE;
+ // For BARE parameter style, the data is in the wrapped format already
+ // operation.setWrapperStyle(bare);
+ //documentStyle = methodSOAPBinding.style() == Style.DOCUMENT;
+ //}
+
+ String operationName = operation.getName();
+ // WebMethod
+ //WebMethod webMethod = method.getAnnotation(WebMethod.class);
+ //if (webMethod != null) {
+ // if (webMethod.exclude()) {
+ // Exclude the method
+ // it.remove();
+ // continue;
+ //}
+ //operationName = getValue(webMethod.operationName(), operationName);
+ //operation.setName(operationName);
+ //}
+
+ // Is one way?
+ /*Oneway oneway = method.getAnnotation(Oneway.class);
+ if (oneway != null) {
+ // JSR 181
+ assert method.getReturnType() == void.class;
+ operation.setNonBlocking(true);
+ }*/
+
+ // Handle BARE mapping
+ if (bare) {
+ for (int i = 0; i < method.getParameterTypes().length; i++) {
+ /*WebParam param = getAnnotation(method, i, WebParam.class);
+ if (param != null) {
+ String ns = getValue(param.targetNamespace(), tns);
+ // Default to <operationName> for doc-bare
+ String name = getValue(param.name(), documentStyle ? operationName : "arg" + i);
+ QName element = new QName(ns, name);
+ Object logical = operation.getInputType().getLogical().get(i).getLogical();
+ if (logical instanceof XMLType) {
+ ((XMLType)logical).setElementName(element);
+ }
+ }*/
+ }
+ /* WebResult result = method.getAnnotation(WebResult.class);
+ if (result != null) {
+ String ns = getValue(result.targetNamespace(), tns);
+ // Default to <operationName>Response for doc-bare
+ String name = getValue(result.name(), documentStyle ? operationName + "Response" : "return");
+ QName element = new QName(ns, name);
+ Object logical = operation.getOutputType().getLogical();
+ if (logical instanceof XMLType) {
+ ((XMLType)logical).setElementName(element);
+ }
+ }*/
+ // FIXME: [rfeng] For the BARE mapping, do we need to create a Wrapper?
+ // it's null at this point
+ } else {
+
+ RequestWrapper requestWrapper = method.getAnnotation(RequestWrapper.class);
+ String ns = requestWrapper == null ? tns : getValue(requestWrapper.targetNamespace(), tns);
+ String name =
+ requestWrapper == null ? operationName : getValue(requestWrapper.localName(), operationName);
+ QName inputWrapper = new QName(ns, name);
+
+ ResponseWrapper responseWrapper = method.getAnnotation(ResponseWrapper.class);
+ ns = responseWrapper == null ? tns : getValue(responseWrapper.targetNamespace(), tns);
+ name =
+ responseWrapper == null ? operationName + "Response" : getValue(responseWrapper.localName(),
+ operationName + "Response");
+ QName outputWrapper = new QName(ns, name);
+
+ List<ElementInfo> inputElements = new ArrayList<ElementInfo>();
+ for (int i = 0; i < method.getParameterTypes().length; i++) {
+// WebParam param = getAnnotation(method, i, WebParam.class);
+ ns = /*param != null ? param.targetNamespace() :*/ "";
+ // Default to "" for doc-lit-wrapped && non-header
+ ns = getValue(ns, documentStyle && (/*param == null || !param.header()*/ true) ? "" : tns);
+ name = /*param != null ? param.name() :*/ "";
+ name = getValue(name, "arg" + i);
+ QName element = new QName(ns, name);
+ Object logical = operation.getInputType().getLogical().get(i).getLogical();
+ if (logical instanceof XMLType) {
+ ((XMLType)logical).setElementName(element);
+ }
+ inputElements.add(new ElementInfo(element, null));
+ }
+
+ List<ElementInfo> outputElements = new ArrayList<ElementInfo>();
+ //WebResult result = method.getAnnotation(WebResult.class);
+ // Default to "" for doc-lit-wrapped && non-header
+ ns = /*result != null ? result.targetNamespace() :*/ "";
+ ns = getValue(ns, documentStyle && (/*result == null || !result.header()*/true) ? "" : tns);
+ name = /*result != null ? result.name() :*/ "";
+ name = getValue(name, "return");
+ QName element = new QName(ns, name);
+
+ if (operation.getOutputType() != null) {
+ Object logical = operation.getOutputType().getLogical();
+ if (logical instanceof XMLType) {
+ ((XMLType)logical).setElementName(element);
+ }
+ }
+ outputElements.add(new ElementInfo(element, null));
+
+ WrapperInfo wrapperInfo =
+ new WrapperInfo(JAXB_DATABINDING, new ElementInfo(inputWrapper, null),
+ new ElementInfo(outputWrapper, null), inputElements, outputElements);
+ operation.setWrapper(wrapperInfo);
+ }
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ private void introspectFaultTypes(Operation operation) {
+ for (DataType exceptionType : operation.getFaultTypes()) {
+ faultExceptionMapper.introspectFaultDataType(exceptionType);
+ }
+ }
+
+ private <T extends Annotation> T getAnnotation(Method method, int index, Class<T> annotationType) {
+ Annotation[] annotations = method.getParameterAnnotations()[index];
+ for (Annotation annotation : annotations) {
+ if (annotation.annotationType() == annotationType) {
+ return annotationType.cast(annotation);
+ }
+ }
+ return null;
+ }
+
+ private static String getValue(String value, String defaultValue) {
+ return "".equals(value) ? defaultValue : value;
+ }
+
+}
|