rampart_1_1/modules/jaxws/src/org/apache/axis2/jaxws/client/proxy/DocLitProxyHandler.java - axis-axis2-java-rampart - Git at Google

 /*
  * Copyright 2004,2005 The Apache Software Foundation.
  * Copyright 2006 International Business Machines Corp.
  *
  * Licensed 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.client.proxy;

 import java.beans.IntrospectionException;
 import java.io.ByteArrayInputStream;
 import java.io.InputStreamReader;
 import java.io.Reader;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.Map;

 import javax.xml.bind.JAXBContext;
 import javax.xml.bind.JAXBElement;
 import javax.xml.bind.JAXBException;
 import javax.xml.bind.JAXBIntrospector;
 import javax.xml.bind.Unmarshaller;
 import javax.xml.bind.annotation.XmlRootElement;
 import javax.xml.namespace.QName;
 import javax.xml.stream.XMLInputFactory;
 import javax.xml.stream.XMLStreamException;
 import javax.xml.stream.XMLStreamReader;
 import javax.xml.ws.AsyncHandler;

 import org.apache.axiom.om.OMElement;
 import org.apache.axis2.jaxws.ExceptionFactory;
 import org.apache.axis2.jaxws.core.MessageContext;
 import org.apache.axis2.jaxws.i18n.Messages;
 import org.apache.axis2.jaxws.message.Block;
 import org.apache.axis2.jaxws.message.Message;
 import org.apache.axis2.jaxws.message.MessageException;
 import org.apache.axis2.jaxws.message.Protocol;
 import org.apache.axis2.jaxws.message.factory.JAXBBlockFactory;
 import org.apache.axis2.jaxws.message.factory.MessageFactory;
 import org.apache.axis2.jaxws.message.factory.XMLStringBlockFactory;
 import org.apache.axis2.jaxws.registry.FactoryRegistry;
 import org.apache.axis2.jaxws.spi.ServiceDelegate;
 import org.apache.axis2.jaxws.wrapper.JAXBWrapperTool;
 import org.apache.axis2.jaxws.wrapper.impl.JAXBWrapperException;
 import org.apache.axis2.jaxws.wrapper.impl.JAXBWrapperToolImpl;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;


 public class DocLitProxyHandler extends BaseProxyHandler {
 	private static Log log = LogFactory.getLog(DocLitProxyHandler.class);
 	private static int SIZE = 1;
 	private static String DEFAULT_ARG="arg";
 	private static QName SOAPENV_QNAME= new QName("http://schemas.xmlsoap.org/soap/envelop/", "Envelope");
 	private ArrayList<Object> argList = null;
 	/**
 	 * @param pd
 	 * @param delegate
 	 */
 	public DocLitProxyHandler(ProxyDescriptor pd, ServiceDelegate delegate) {
 		super(pd, delegate);
 	}

 	@Override
 	protected MessageContext createRequest(Method method, Object[] args) throws ClassNotFoundException, JAXBWrapperException, JAXBException, MessageException, javax.xml.stream.XMLStreamException {
 		MessageContext requestCtx = null;
 		if(isDocLitWrapped()){
 			if (log.isDebugEnabled()) {
 	            log.debug("Creating Doc Lit Wrapped Request for method : " +method.getName());
 	        }
 			return createDocLitWrappedRequest(method, args);
 		}
 		if(isDocLitBare()){
 			if (log.isDebugEnabled()) {
 	            log.debug("Creating Doc Lit Bare Request for method : " +method.getName());
 	        }
 			return createDocLitNONWrappedRequest(method, args);
 		}
 		return requestCtx;
 	}

 	@Override
 	protected Object createResponse(Method method, MessageContext responseContext) throws IllegalAccessException, ClassNotFoundException, JAXBWrapperException, JAXBException, javax.xml.stream.XMLStreamException, MessageException, IntrospectionException, NoSuchFieldException, InvocationTargetException{
 		Object result = null;
 		if(isDocLitWrapped()){
 			if (log.isDebugEnabled()) {
 	            log.debug("Creating Doc Lit Wrapped Response ");
 	        }
 			return createDocLitWrappedResponse(method, responseContext);
 		}
 		if(isDocLitBare()){
 			if (log.isDebugEnabled()) {
 	            log.debug("Creating Doc Lit Bare Request ");
 	        }
 			return createDocLitNONWrappedResponse(method, responseContext);
 		}
 		return result;
 	}

 	/**
 	 * createDocLitWrappedRequest create request message context. It reads RequestWrapper annotation from OperationDescription and reads the calss name, then reads
 	 * all the webParam annotation on the method and uses JAXBWrapTool to wrap the request as jaxbObject. Create JAXBblock from the jaxbObject and sets OMElement on
 	 * Request MessageContext, reads Biniding provider properties and set them on request message context and return request message context.
 	 * @param method
 	 * @param objects
 	 * @return
 	 * @throws ClassNotFoundException
 	 * @throws JAXBWrapperException
 	 * @throws JAXBException
 	 * @throws MessageException
 	 * @throws javax.xml.stream.XMLStreamException
 	 */
 	private MessageContext createDocLitWrappedRequest(Method method, Object[] objects)throws ClassNotFoundException, JAXBWrapperException, JAXBException, MessageException, javax.xml.stream.XMLStreamException{

 		Class wrapperClazz = proxyDescriptor.getRequestWrapperClass(isAsync());
 		ArrayList<String> names = getParamNames(objects);
 		String localName = proxyDescriptor.getRequestWrapperLocalName();
 		Map<String, Object> values = getParamValues(objects, names);
 		JAXBWrapperTool wrapTool = new JAXBWrapperToolImpl();
 		if (log.isDebugEnabled()) {
             log.debug("JAXBWrapperTool attempting to wrap propertes in WrapperClass :" + wrapperClazz);
         }
 		//TODO:if(@XmlRootElement) annotation found or defined
 		Object jaxbObject = wrapTool.wrap(wrapperClazz, localName,names, values);
 		if (log.isDebugEnabled()) {
             log.debug("JAXBWrapperTool wrapped following propertes :");
         }
 		//TODO: if (!@XmlRootElement) annotation not found or not defined then can I use JAXBElement?
 		//JAXBElement jaxbObject = wrapTool.wrapAsJAXBElement(wrapperClazz, requestWrapper.localName(),names, values);
 		JAXBContext ctx = JAXBContext.newInstance(new Class[]{wrapperClazz});
 		if (log.isDebugEnabled()) {
             log.debug("Attempting to create Block");
         }
 		XmlRootElement root = null;
 		Block reqBlock = null;
 		root =(XmlRootElement) wrapperClazz.getAnnotation(XmlRootElement.class);
 		if(root != null){
 		 reqBlock = createJAXBBlock(jaxbObject, ctx);
 		 if (log.isDebugEnabled()) {
 	            log.debug("JAXBBlock Created");
 	        }
 		}
 		else{
 			reqBlock = createJAXBBlock(localName, jaxbObject, ctx);
 			if (log.isDebugEnabled()) {
 	            log.debug("JAXBBlock Created");
 	        }
 		}

 		MessageContext requestCtx = initializeRequest(reqBlock);
 		return requestCtx;

 	}


 	/**
 	 * CreateDocLitNONWrappedRequest creates a request message context. The input object to a non wrapped wsdl will be a object (mainly a JAXB Object) that will
 	 * have all the payload data or method parameter data already setup. So the message context will be created by converting input object in to a JAXBBlock and
 	 * attaching the Block Message to soap body.
 	 * @param method
 	 * @param objects
 	 * @return
 	 */
 	private MessageContext createDocLitNONWrappedRequest(Method method, Object[] objects) throws JAXBException, MessageException, XMLStreamException{
 		MessageContext requestCtx = null;

 		ArrayList<String> names = getParamNames(objects);
 		ArrayList<String> tns = proxyDescriptor.getParamtns();
 		Map<String, Object> values = getParamValues(objects, names);
 		if(names.size()> SIZE || values.size() > SIZE){
 			if (log.isDebugEnabled()) {
 	            log.debug("As per WS-I compliance, Multi part WSDL not allowed for Doc/Lit NON Wrapped request, Method invoked has multiple input parameter");
 	        }
 			throw ExceptionFactory.makeWebServiceException(Messages.getMessage("DocLitProxyHandlerErr1"));
 		}
 		if(names.size() !=0){
 			JAXBContext ctx = null;
 			Object requestObject = null;
 			String requestObjectName = null;
 			for(String name:names){
 				requestObject = values.get(name);
 				requestObjectName = name;
 				if(requestObject == null){
 					if (log.isDebugEnabled()) {
 			            log.debug("Method Input parameter for NON Wrapped Request cannot be null");
 			        }
 					throw ExceptionFactory.makeWebServiceException(Messages.getMessage("DocLitProxyHandlerErr2"));
 				}
 			}

 			ctx = JAXBContext.newInstance(new Class[]{requestObject.getClass()});
 			if (log.isDebugEnabled()) {
 	            log.debug("Attempting to create Block");
 	        }
 			Block reqBlock = createJAXBBlock(requestObjectName, requestObject, ctx);
 			if (log.isDebugEnabled()) {
 	            log.debug("Block Created");
 	        }
 			requestCtx = initializeRequest(reqBlock);
 		}
 		if(names.size() == 0){
 			Block emptyBodyBlock = createEmptyBodyBlock();
 			requestCtx = initializeRequest(emptyBodyBlock);
 		}
 		return requestCtx;
 	}

 	/**
 	 * CreateDocLitWrappedResponse creates return result that client expects from the method call. It reads response wrapper annotation then reads OM from the
 	 * response message context and creates JAXBBlock from the OMElement on messageContext. It then reads the webresult annotation to gather the return parameter
 	 * name and creates the result object for it by reading the property object from JAXBBlock's business object using PropertyDescriptor.
 	 * @param method
 	 * @param response
 	 * @return
 	 * @throws IllegalAccessException
 	 * @throws ClassNotFoundException
 	 * @throws JAXBWrapperException
 	 * @throws JAXBException
 	 * @throws javax.xml.stream.XMLStreamException
 	 * @throws MessageException
 	 * @throws IntrospectionException
 	 * @throws NoSuchFieldException
 	 * @throws InvocationTargetException
 	 */

 	private Object createDocLitWrappedResponse(Method method, MessageContext response)throws ClassNotFoundException, JAXBWrapperException, JAXBException, javax.xml.stream.XMLStreamException, MessageException{
 		Class wrapperClazz = proxyDescriptor.getResponseWrapperClass(isAsync());
 		String resultName = proxyDescriptor.getWebResultName(isAsync());
 		JAXBContext ctx = JAXBContext.newInstance(new Class[]{wrapperClazz});

 		// Get a JAXBBlockFactory instance.  We'll need this to get the JAXBBlock
         // out of the Message
         JAXBBlockFactory factory = (JAXBBlockFactory)FactoryRegistry.getFactory(JAXBBlockFactory.class);

         Message responseMsg = response.getMessage();
         Block resBlock = responseMsg.getBodyBlock(0, ctx, factory);
 		Object bo = resBlock.getBusinessObject(true);

 		//if ReturnType/WrapperClass is assignable from bo then return bo;
 		if(resultName==null && wrapperClazz.isAssignableFrom(bo.getClass())){
 			return bo;
 		}

 		//if ReturnType is not of same type as JAXBBlock business Object then I will look for resultName in Business Object and return that.
 		return getWebResultObject(wrapperClazz, bo, resultName);

 	}

 	/**
 	 * CreateDocLitNONWrappedResponse creates return result that client expects from the method call. This method reads the method return type
 	 * or uses webResult annotation and creates JAXBBlock from the response context and returns the business object associated with the JAXBBlock.
 	 * @param method
 	 * @param response
 	 * @return
 	 */
 	private Object createDocLitNONWrappedResponse(Method method, MessageContext response) throws JAXBWrapperException, JAXBException, MessageException, XMLStreamException{

 		Message responseMsg = response.getMessage();
 		Class returnType = proxyDescriptor.getReturnType(isAsync());
 		JAXBContext ctx = JAXBContext.newInstance(returnType);
 		JAXBBlockFactory factory = (JAXBBlockFactory)FactoryRegistry.getFactory(JAXBBlockFactory.class);
 		Block resBlock = responseMsg.getBodyBlock(0, ctx, factory);
 		Object bo = null;
 		try{
 			 bo = resBlock.getBusinessObject(true);
 		}catch(Exception e){
 			//FIXME: this is the bare case where child of body is not a method but a primitive data type. Reader from Block is throwing exception.
 			OMElement om = resBlock.getOMElement();

 			XMLInputFactory xmlFactory = XMLInputFactory.newInstance();

 			Unmarshaller u = ctx.createUnmarshaller();
 			Reader inputReader = new InputStreamReader(new ByteArrayInputStream(om.toString().getBytes()));
 			XMLStreamReader sr = xmlFactory.createXMLStreamReader(inputReader);
 			JAXBElement o =u.unmarshal(sr, returnType);
 			bo = o.getValue();
 		}
 		if(returnType.isAssignableFrom(bo.getClass())){
 			return bo;
 		}
 		//If returnType is different than JAXBBlock Business Object, I will look for resultName in BusinessObject and return that.
 		String resultName = proxyDescriptor.getWebResultName(isAsync());
 		return getWebResultObject(returnType, bo, resultName);
 	}

 	private Block createJAXBBlock(Object jaxbObject, JAXBContext context) throws MessageException{
 		JAXBBlockFactory factory = (JAXBBlockFactory)FactoryRegistry.getFactory(JAXBBlockFactory.class);
 		return factory.createFrom(jaxbObject,context,null);

 	}

 	private Block createJAXBBlock(String name, Object jaxbObject, JAXBContext context) throws MessageException{
 		JAXBBlockFactory factory = (JAXBBlockFactory)FactoryRegistry.getFactory(JAXBBlockFactory.class);
 		JAXBIntrospector introspector = context.createJAXBIntrospector();
 		if(introspector.isElement(jaxbObject)){
 			return factory.createFrom(jaxbObject, context, null);
 		}
 		else{
 			Class clazz = jaxbObject.getClass();
 			String tns = proxyDescriptor.getParamtns(name);
 			JAXBElement<Object> element = new JAXBElement<Object>(new QName(tns, name), clazz, jaxbObject);
 			return factory.createFrom(element,context,null);
 		}

 	}

 	private Block createEmptyBodyBlock() throws MessageException{
 		String emptyBody = "";
 		XMLStringBlockFactory stringFactory = (XMLStringBlockFactory) FactoryRegistry.getFactory(XMLStringBlockFactory.class);
 		return stringFactory.createFrom(emptyBody, null, SOAPENV_QNAME);
 	}

 	private Block createJAXBBlock(OMElement om, JAXBContext context)throws javax.xml.stream.XMLStreamException{
 		JAXBBlockFactory factory = (JAXBBlockFactory)FactoryRegistry.getFactory(JAXBBlockFactory.class);
 		return factory.createFrom(om,context,null);

 	}


 	/**
 	 * reads PropertyDescritpr and invokes  get method on result property and returns the object.
 	 * @param wrapperClazz
 	 * @param businessObject
 	 * @param propertyName
 	 * @return
 	 * @throws NoSuchFieldException
 	 * @throws IntrospectionException
 	 * @throws InvocationTargetException
 	 * @throws IllegalAccessException
 	 */
 	private Object getWebResultObject(Class wrapperClazz, Object businessObject, String propertyName) throws JAXBWrapperException{

 		JAXBWrapperTool wrapTool = new JAXBWrapperToolImpl();
 		if (log.isDebugEnabled()) {
             log.debug("Attempting to unwrap object from WrapperClazz: "+wrapperClazz);
         }
 		Object[] webResult = wrapTool.unWrap(businessObject,new ArrayList<String>(Arrays.asList(new String[]{propertyName})));
 		if (log.isDebugEnabled()) {
             log.debug("Object unwrapped");
         }
 		return webResult[0];

 	}

 	private MessageContext initializeRequest(Block messageBlock) throws XMLStreamException, MessageException{
 		MessageContext request = new MessageContext();
 		MessageFactory mf = (MessageFactory)FactoryRegistry.getFactory(MessageFactory.class);
 		//FIXME: The protocol should actually come from the binding information included in
         // either the WSDL or an annotation.
 		Message m = mf.create(Protocol.soap11);
 		m.setBodyBlock(0,messageBlock);
 		request.setMessage(m);
 		request.getProperties().putAll(getRequestContext());

 		return request;

 	}

 	private boolean isDocLitBare(){
 		/* TODO: if(EndPoinInterfaceDescriptor.clientCall == Doc/literal) && OperationDescriptor.isWrapped() == false){
 		 * return true;
 		 * else
 		 * return false;
 		 */
 		return proxyDescriptor.isClazzDocLitBare();
 	}

 	private boolean isDocLitWrapped(){
 		/* TODO: if(EndPoinInterfaceDescriptor.clientCall == Doc/literal) && OperationDescriptor.isWrapped() == true){
 		 * return true;
 		 * else
 		 * return false;
 		 */
 		return proxyDescriptor.isClazzDocLitWrapped();
 	}

 	public ArrayList<String> getParamNames(Object[] objects){
         ArrayList<String> names = proxyDescriptor.getParamNames();
         //TODO Should this logic be moved to Operation Description.
         argList = null;
 		ArrayList<Object> paramValues = createArgList(names, objects);
 		if(names.size() == paramValues.size()){
 			return names;
 		}
 		if(names.size() > 0 && names.size() != paramValues.size()){
 			throw ExceptionFactory.makeWebServiceException(Messages.getMessage("InvalidWebParams"));
 		}
 		//if no webparams found but there method has input parameter I will create default input param names. Java reflection does not allow reading
 		//formal parameter names, hence I will create defautl argument names to be arg0, arg1 ....
 		int i=0;
 		if(names.size() ==0){
 			for(Object paramValue:paramValues){
 				names.add(DEFAULT_ARG + i++);
 			}
 		}
 		return names;
 	}
 	//TODO: Should we move this to OperationDescription.
 	public Map<String, Object> getParamValues(Object[] objects, ArrayList<String> names){
 		Map<String, Object> values = new HashMap<String, Object>();

 		if(objects == null){
 			return values;
 		}
 		//if object array not null check if there is only AsyncHandler object param, if yes then its Async call
 		//with no parameter. Lets filter AsyncHandler and check for return objects, if they are 0 return value;
 		ArrayList<Object> paramValues = createArgList(names, objects);

 		//@webparams and paramValues identified in method should match.
 		if(names.size() > 0 && names.size() != paramValues.size()){
 			throw ExceptionFactory.makeWebServiceException(Messages.getMessage("InvalidWebParams"));
 		}

 		if(paramValues.size() == 0){
 			//No method parameters
 			return values;
 		}
 		//If no webParam annotation defined read default names of the object and let's use those.
 		boolean readDefault = false;
 		if(names.size() ==0){
 			readDefault = true;
 		}
 		int i =0;
 		for(Object paramValue: paramValues){
 			if(readDefault){
 				//Java Reflection does not allow you to read names of forma parameter, so I will default the method argument names to arg0, arg1 ....
 				values.put(DEFAULT_ARG + i++, paramValue);
 			}else{
 				values.put(names.get(i++), paramValue);
 			}
 		}
 		return values;
 	}
 	//TODO Implement createNameValuePair method so we can remove getParamName and getParamObject and only call this method once.
 	private ArrayList<Object> createArgList(ArrayList<String> names, Object[] objects){
 		if(argList !=null){
 			return argList;
 		}
 		argList = new ArrayList<Object>();

 		if(objects == null){
 			return argList;
 		}
 		int i =0;
 		for(Object obj:objects){
 			//skip AsycHandler Object
 			if(obj instanceof AsyncHandler){
 				if(isAsync() && proxyDescriptor.isClazzDocLitBare()){
 					//doeble check and remove the name of AsyncHandler from names list, work around for how wsImport generates doc/lit bare art-effects.
 					names.remove(i);
 				}
 				i++;
 				continue;
 			}

 			argList.add(obj);
 			i++;
 		}
 		return argList;
 	}

 }
	/*
	* Copyright 2004,2005 The Apache Software Foundation.
	* Copyright 2006 International Business Machines Corp.
	*
	* Licensed 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.client.proxy;

	import java.beans.IntrospectionException;
	import java.io.ByteArrayInputStream;
	import java.io.InputStreamReader;
	import java.io.Reader;
	import java.lang.reflect.InvocationTargetException;
	import java.lang.reflect.Method;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.HashMap;
	import java.util.Map;

	import javax.xml.bind.JAXBContext;
	import javax.xml.bind.JAXBElement;
	import javax.xml.bind.JAXBException;
	import javax.xml.bind.JAXBIntrospector;
	import javax.xml.bind.Unmarshaller;
	import javax.xml.bind.annotation.XmlRootElement;
	import javax.xml.namespace.QName;
	import javax.xml.stream.XMLInputFactory;
	import javax.xml.stream.XMLStreamException;
	import javax.xml.stream.XMLStreamReader;
	import javax.xml.ws.AsyncHandler;

	import org.apache.axiom.om.OMElement;
	import org.apache.axis2.jaxws.ExceptionFactory;
	import org.apache.axis2.jaxws.core.MessageContext;
	import org.apache.axis2.jaxws.i18n.Messages;
	import org.apache.axis2.jaxws.message.Block;
	import org.apache.axis2.jaxws.message.Message;
	import org.apache.axis2.jaxws.message.MessageException;
	import org.apache.axis2.jaxws.message.Protocol;
	import org.apache.axis2.jaxws.message.factory.JAXBBlockFactory;
	import org.apache.axis2.jaxws.message.factory.MessageFactory;
	import org.apache.axis2.jaxws.message.factory.XMLStringBlockFactory;
	import org.apache.axis2.jaxws.registry.FactoryRegistry;
	import org.apache.axis2.jaxws.spi.ServiceDelegate;
	import org.apache.axis2.jaxws.wrapper.JAXBWrapperTool;
	import org.apache.axis2.jaxws.wrapper.impl.JAXBWrapperException;
	import org.apache.axis2.jaxws.wrapper.impl.JAXBWrapperToolImpl;
	import org.apache.commons.logging.Log;
	import org.apache.commons.logging.LogFactory;


	public class DocLitProxyHandler extends BaseProxyHandler {
	private static Log log = LogFactory.getLog(DocLitProxyHandler.class);
	private static int SIZE = 1;
	private static String DEFAULT_ARG="arg";
	private static QName SOAPENV_QNAME= new QName("http://schemas.xmlsoap.org/soap/envelop/", "Envelope");
	private ArrayList<Object> argList = null;
	/**
	* @param pd
	* @param delegate
	*/
	public DocLitProxyHandler(ProxyDescriptor pd, ServiceDelegate delegate) {
	super(pd, delegate);
	}

	@Override
	protected MessageContext createRequest(Method method, Object[] args) throws ClassNotFoundException, JAXBWrapperException, JAXBException, MessageException, javax.xml.stream.XMLStreamException {
	MessageContext requestCtx = null;
	if(isDocLitWrapped()){
	if (log.isDebugEnabled()) {
	log.debug("Creating Doc Lit Wrapped Request for method : " +method.getName());
	}
	return createDocLitWrappedRequest(method, args);
	}
	if(isDocLitBare()){
	if (log.isDebugEnabled()) {
	log.debug("Creating Doc Lit Bare Request for method : " +method.getName());
	}
	return createDocLitNONWrappedRequest(method, args);
	}
	return requestCtx;
	}

	@Override
	protected Object createResponse(Method method, MessageContext responseContext) throws IllegalAccessException, ClassNotFoundException, JAXBWrapperException, JAXBException, javax.xml.stream.XMLStreamException, MessageException, IntrospectionException, NoSuchFieldException, InvocationTargetException{
	Object result = null;
	if(isDocLitWrapped()){
	if (log.isDebugEnabled()) {
	log.debug("Creating Doc Lit Wrapped Response ");
	}
	return createDocLitWrappedResponse(method, responseContext);
	}
	if(isDocLitBare()){
	if (log.isDebugEnabled()) {
	log.debug("Creating Doc Lit Bare Request ");
	}
	return createDocLitNONWrappedResponse(method, responseContext);
	}
	return result;
	}

	/**
	* createDocLitWrappedRequest create request message context. It reads RequestWrapper annotation from OperationDescription and reads the calss name, then reads
	* all the webParam annotation on the method and uses JAXBWrapTool to wrap the request as jaxbObject. Create JAXBblock from the jaxbObject and sets OMElement on
	* Request MessageContext, reads Biniding provider properties and set them on request message context and return request message context.
	* @param method
	* @param objects
	* @return
	* @throws ClassNotFoundException
	* @throws JAXBWrapperException
	* @throws JAXBException
	* @throws MessageException
	* @throws javax.xml.stream.XMLStreamException
	*/
	private MessageContext createDocLitWrappedRequest(Method method, Object[] objects)throws ClassNotFoundException, JAXBWrapperException, JAXBException, MessageException, javax.xml.stream.XMLStreamException{

	Class wrapperClazz = proxyDescriptor.getRequestWrapperClass(isAsync());
	ArrayList<String> names = getParamNames(objects);
	String localName = proxyDescriptor.getRequestWrapperLocalName();
	Map<String, Object> values = getParamValues(objects, names);
	JAXBWrapperTool wrapTool = new JAXBWrapperToolImpl();
	if (log.isDebugEnabled()) {
	log.debug("JAXBWrapperTool attempting to wrap propertes in WrapperClass :" + wrapperClazz);
	}
	//TODO:if(@XmlRootElement) annotation found or defined
	Object jaxbObject = wrapTool.wrap(wrapperClazz, localName,names, values);
	if (log.isDebugEnabled()) {
	log.debug("JAXBWrapperTool wrapped following propertes :");
	}
	//TODO: if (!@XmlRootElement) annotation not found or not defined then can I use JAXBElement?
	//JAXBElement jaxbObject = wrapTool.wrapAsJAXBElement(wrapperClazz, requestWrapper.localName(),names, values);
	JAXBContext ctx = JAXBContext.newInstance(new Class[]{wrapperClazz});
	if (log.isDebugEnabled()) {
	log.debug("Attempting to create Block");
	}
	XmlRootElement root = null;
	Block reqBlock = null;
	root =(XmlRootElement) wrapperClazz.getAnnotation(XmlRootElement.class);
	if(root != null){
	reqBlock = createJAXBBlock(jaxbObject, ctx);
	if (log.isDebugEnabled()) {
	log.debug("JAXBBlock Created");
	}
	}
	else{
	reqBlock = createJAXBBlock(localName, jaxbObject, ctx);
	if (log.isDebugEnabled()) {
	log.debug("JAXBBlock Created");
	}
	}

	MessageContext requestCtx = initializeRequest(reqBlock);
	return requestCtx;

	}


	/**
	* CreateDocLitNONWrappedRequest creates a request message context. The input object to a non wrapped wsdl will be a object (mainly a JAXB Object) that will
	* have all the payload data or method parameter data already setup. So the message context will be created by converting input object in to a JAXBBlock and
	* attaching the Block Message to soap body.
	* @param method
	* @param objects
	* @return
	*/
	private MessageContext createDocLitNONWrappedRequest(Method method, Object[] objects) throws JAXBException, MessageException, XMLStreamException{
	MessageContext requestCtx = null;

	ArrayList<String> names = getParamNames(objects);
	ArrayList<String> tns = proxyDescriptor.getParamtns();
	Map<String, Object> values = getParamValues(objects, names);
	if(names.size()> SIZE \|\| values.size() > SIZE){
	if (log.isDebugEnabled()) {
	log.debug("As per WS-I compliance, Multi part WSDL not allowed for Doc/Lit NON Wrapped request, Method invoked has multiple input parameter");
	}
	throw ExceptionFactory.makeWebServiceException(Messages.getMessage("DocLitProxyHandlerErr1"));
	}
	if(names.size() !=0){
	JAXBContext ctx = null;
	Object requestObject = null;
	String requestObjectName = null;
	for(String name:names){
	requestObject = values.get(name);
	requestObjectName = name;
	if(requestObject == null){
	if (log.isDebugEnabled()) {
	log.debug("Method Input parameter for NON Wrapped Request cannot be null");
	}
	throw ExceptionFactory.makeWebServiceException(Messages.getMessage("DocLitProxyHandlerErr2"));
	}
	}

	ctx = JAXBContext.newInstance(new Class[]{requestObject.getClass()});
	if (log.isDebugEnabled()) {
	log.debug("Attempting to create Block");
	}
	Block reqBlock = createJAXBBlock(requestObjectName, requestObject, ctx);
	if (log.isDebugEnabled()) {
	log.debug("Block Created");
	}
	requestCtx = initializeRequest(reqBlock);
	}
	if(names.size() == 0){
	Block emptyBodyBlock = createEmptyBodyBlock();
	requestCtx = initializeRequest(emptyBodyBlock);
	}
	return requestCtx;
	}

	/**
	* CreateDocLitWrappedResponse creates return result that client expects from the method call. It reads response wrapper annotation then reads OM from the
	* response message context and creates JAXBBlock from the OMElement on messageContext. It then reads the webresult annotation to gather the return parameter
	* name and creates the result object for it by reading the property object from JAXBBlock's business object using PropertyDescriptor.
	* @param method
	* @param response
	* @return
	* @throws IllegalAccessException
	* @throws ClassNotFoundException
	* @throws JAXBWrapperException
	* @throws JAXBException
	* @throws javax.xml.stream.XMLStreamException
	* @throws MessageException
	* @throws IntrospectionException
	* @throws NoSuchFieldException
	* @throws InvocationTargetException
	*/

	private Object createDocLitWrappedResponse(Method method, MessageContext response)throws ClassNotFoundException, JAXBWrapperException, JAXBException, javax.xml.stream.XMLStreamException, MessageException{
	Class wrapperClazz = proxyDescriptor.getResponseWrapperClass(isAsync());
	String resultName = proxyDescriptor.getWebResultName(isAsync());
	JAXBContext ctx = JAXBContext.newInstance(new Class[]{wrapperClazz});

	// Get a JAXBBlockFactory instance. We'll need this to get the JAXBBlock
	// out of the Message
	JAXBBlockFactory factory = (JAXBBlockFactory)FactoryRegistry.getFactory(JAXBBlockFactory.class);

	Message responseMsg = response.getMessage();
	Block resBlock = responseMsg.getBodyBlock(0, ctx, factory);
	Object bo = resBlock.getBusinessObject(true);

	//if ReturnType/WrapperClass is assignable from bo then return bo;
	if(resultName==null && wrapperClazz.isAssignableFrom(bo.getClass())){
	return bo;
	}

	//if ReturnType is not of same type as JAXBBlock business Object then I will look for resultName in Business Object and return that.
	return getWebResultObject(wrapperClazz, bo, resultName);

	}

	/**
	* CreateDocLitNONWrappedResponse creates return result that client expects from the method call. This method reads the method return type
	* or uses webResult annotation and creates JAXBBlock from the response context and returns the business object associated with the JAXBBlock.
	* @param method
	* @param response
	* @return
	*/
	private Object createDocLitNONWrappedResponse(Method method, MessageContext response) throws JAXBWrapperException, JAXBException, MessageException, XMLStreamException{

	Message responseMsg = response.getMessage();
	Class returnType = proxyDescriptor.getReturnType(isAsync());
	JAXBContext ctx = JAXBContext.newInstance(returnType);
	JAXBBlockFactory factory = (JAXBBlockFactory)FactoryRegistry.getFactory(JAXBBlockFactory.class);
	Block resBlock = responseMsg.getBodyBlock(0, ctx, factory);
	Object bo = null;
	try{
	bo = resBlock.getBusinessObject(true);
	}catch(Exception e){
	//FIXME: this is the bare case where child of body is not a method but a primitive data type. Reader from Block is throwing exception.
	OMElement om = resBlock.getOMElement();

	XMLInputFactory xmlFactory = XMLInputFactory.newInstance();

	Unmarshaller u = ctx.createUnmarshaller();
	Reader inputReader = new InputStreamReader(new ByteArrayInputStream(om.toString().getBytes()));
	XMLStreamReader sr = xmlFactory.createXMLStreamReader(inputReader);
	JAXBElement o =u.unmarshal(sr, returnType);
	bo = o.getValue();
	}
	if(returnType.isAssignableFrom(bo.getClass())){
	return bo;
	}
	//If returnType is different than JAXBBlock Business Object, I will look for resultName in BusinessObject and return that.
	String resultName = proxyDescriptor.getWebResultName(isAsync());
	return getWebResultObject(returnType, bo, resultName);
	}

	private Block createJAXBBlock(Object jaxbObject, JAXBContext context) throws MessageException{
	JAXBBlockFactory factory = (JAXBBlockFactory)FactoryRegistry.getFactory(JAXBBlockFactory.class);
	return factory.createFrom(jaxbObject,context,null);

	}

	private Block createJAXBBlock(String name, Object jaxbObject, JAXBContext context) throws MessageException{
	JAXBBlockFactory factory = (JAXBBlockFactory)FactoryRegistry.getFactory(JAXBBlockFactory.class);
	JAXBIntrospector introspector = context.createJAXBIntrospector();
	if(introspector.isElement(jaxbObject)){
	return factory.createFrom(jaxbObject, context, null);
	}
	else{
	Class clazz = jaxbObject.getClass();
	String tns = proxyDescriptor.getParamtns(name);
	JAXBElement<Object> element = new JAXBElement<Object>(new QName(tns, name), clazz, jaxbObject);
	return factory.createFrom(element,context,null);
	}

	}

	private Block createEmptyBodyBlock() throws MessageException{
	String emptyBody = "";
	XMLStringBlockFactory stringFactory = (XMLStringBlockFactory) FactoryRegistry.getFactory(XMLStringBlockFactory.class);
	return stringFactory.createFrom(emptyBody, null, SOAPENV_QNAME);
	}

	private Block createJAXBBlock(OMElement om, JAXBContext context)throws javax.xml.stream.XMLStreamException{
	JAXBBlockFactory factory = (JAXBBlockFactory)FactoryRegistry.getFactory(JAXBBlockFactory.class);
	return factory.createFrom(om,context,null);

	}



	/**
	* reads PropertyDescritpr and invokes get method on result property and returns the object.
	* @param wrapperClazz
	* @param businessObject
	* @param propertyName
	* @return
	* @throws NoSuchFieldException
	* @throws IntrospectionException
	* @throws InvocationTargetException
	* @throws IllegalAccessException
	*/
	private Object getWebResultObject(Class wrapperClazz, Object businessObject, String propertyName) throws JAXBWrapperException{

	JAXBWrapperTool wrapTool = new JAXBWrapperToolImpl();
	if (log.isDebugEnabled()) {
	log.debug("Attempting to unwrap object from WrapperClazz: "+wrapperClazz);
	}
	Object[] webResult = wrapTool.unWrap(businessObject,new ArrayList<String>(Arrays.asList(new String[]{propertyName})));
	if (log.isDebugEnabled()) {
	log.debug("Object unwrapped");
	}
	return webResult[0];

	}

	private MessageContext initializeRequest(Block messageBlock) throws XMLStreamException, MessageException{
	MessageContext request = new MessageContext();
	MessageFactory mf = (MessageFactory)FactoryRegistry.getFactory(MessageFactory.class);
	//FIXME: The protocol should actually come from the binding information included in
	// either the WSDL or an annotation.
	Message m = mf.create(Protocol.soap11);
	m.setBodyBlock(0,messageBlock);
	request.setMessage(m);
	request.getProperties().putAll(getRequestContext());

	return request;

	}

	private boolean isDocLitBare(){
	/* TODO: if(EndPoinInterfaceDescriptor.clientCall == Doc/literal) && OperationDescriptor.isWrapped() == false){
	* return true;
	* else
	* return false;
	*/
	return proxyDescriptor.isClazzDocLitBare();
	}

	private boolean isDocLitWrapped(){
	/* TODO: if(EndPoinInterfaceDescriptor.clientCall == Doc/literal) && OperationDescriptor.isWrapped() == true){
	* return true;
	* else
	* return false;
	*/
	return proxyDescriptor.isClazzDocLitWrapped();
	}

	public ArrayList<String> getParamNames(Object[] objects){
	ArrayList<String> names = proxyDescriptor.getParamNames();
	//TODO Should this logic be moved to Operation Description.
	argList = null;
	ArrayList<Object> paramValues = createArgList(names, objects);
	if(names.size() == paramValues.size()){
	return names;
	}
	if(names.size() > 0 && names.size() != paramValues.size()){
	throw ExceptionFactory.makeWebServiceException(Messages.getMessage("InvalidWebParams"));
	}
	//if no webparams found but there method has input parameter I will create default input param names. Java reflection does not allow reading
	//formal parameter names, hence I will create defautl argument names to be arg0, arg1 ....
	int i=0;
	if(names.size() ==0){
	for(Object paramValue:paramValues){
	names.add(DEFAULT_ARG + i++);
	}
	}
	return names;
	}
	//TODO: Should we move this to OperationDescription.
	public Map<String, Object> getParamValues(Object[] objects, ArrayList<String> names){
	Map<String, Object> values = new HashMap<String, Object>();

	if(objects == null){
	return values;
	}
	//if object array not null check if there is only AsyncHandler object param, if yes then its Async call
	//with no parameter. Lets filter AsyncHandler and check for return objects, if they are 0 return value;
	ArrayList<Object> paramValues = createArgList(names, objects);

	//@webparams and paramValues identified in method should match.
	if(names.size() > 0 && names.size() != paramValues.size()){
	throw ExceptionFactory.makeWebServiceException(Messages.getMessage("InvalidWebParams"));
	}

	if(paramValues.size() == 0){
	//No method parameters
	return values;
	}
	//If no webParam annotation defined read default names of the object and let's use those.
	boolean readDefault = false;
	if(names.size() ==0){
	readDefault = true;
	}
	int i =0;
	for(Object paramValue: paramValues){
	if(readDefault){
	//Java Reflection does not allow you to read names of forma parameter, so I will default the method argument names to arg0, arg1 ....
	values.put(DEFAULT_ARG + i++, paramValue);
	}else{
	values.put(names.get(i++), paramValue);
	}
	}
	return values;
	}
	//TODO Implement createNameValuePair method so we can remove getParamName and getParamObject and only call this method once.
	private ArrayList<Object> createArgList(ArrayList<String> names, Object[] objects){
	if(argList !=null){
	return argList;
	}
	argList = new ArrayList<Object>();

	if(objects == null){
	return argList;
	}
	int i =0;
	for(Object obj:objects){
	//skip AsycHandler Object
	if(obj instanceof AsyncHandler){
	if(isAsync() && proxyDescriptor.isClazzDocLitBare()){
	//doeble check and remove the name of AsyncHandler from names list, work around for how wsImport generates doc/lit bare art-effects.
	names.remove(i);
	}
	i++;
	continue;
	}

	argList.add(obj);
	i++;
	}
	return argList;
	}

	}