/*
* Copyright 2001-2004 The Apache Software Foundation.
*
* 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.axis.message;
/**
*
* @author Glen Daniels (gdaniels@allaire.com)
*/
import org.apache.axis.AxisFault;
import org.apache.axis.Constants;
import org.apache.axis.constants.Style;
import org.apache.axis.components.logger.LogFactory;
import org.apache.axis.description.OperationDesc;
import org.apache.axis.description.ParameterDesc;
import org.apache.axis.encoding.DeserializationContext;
import org.apache.axis.encoding.Deserializer;
import org.apache.axis.encoding.DeserializerImpl;
import org.apache.axis.encoding.XMLType;
import org.apache.axis.soap.SOAPConstants;
import org.apache.axis.utils.JavaUtils;
import org.apache.axis.utils.Messages;
import org.apache.commons.logging.Log;
import org.w3c.dom.Element;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import javax.xml.namespace.QName;
/**
* This is the SOAPHandler which is called for each RPC parameter as we're
* deserializing the XML for a method call or return. In other words for
* this XML:
*
* <methodName>
* <param1 xsi:type="xsd:string">Hello!</param1>
* <param2>3.14159</param2>
* </methodName>
*
* ...we'll get onStartChild() events for <param1> and <param2>.
*
* @author Glen Daniels (gdaniels@apache.org)
*/
public class RPCHandler extends SOAPHandler
{
protected static Log log =
LogFactory.getLog(RPCHandler.class.getName());
private RPCElement rpcElem;
private RPCParam currentParam = null;
private boolean isResponse;
private OperationDesc operation;
private boolean isHeaderElement;
public RPCHandler(RPCElement rpcElem, boolean isResponse)
throws SAXException
{
this.rpcElem = rpcElem;
this.isResponse = isResponse;
}
public void setOperation(OperationDesc myOperation) {
this.operation = myOperation;
}
/**
* Indicate RPCHandler is processing header elements
* @param value boolean indicating whether
* header elements are being processed.
*/
public void setHeaderElement(boolean value) {
isHeaderElement = true;
}
/**
* This method is invoked when an element start tag is encountered.
* The purpose of this method in RPCHandler is to reset variables
* (this allows re-use of RPCHandlers)
* @param namespace is the namespace of the element
* @param localName is the name of the element
* @param prefix is the prefix of the element
* @param attributes are the attributes on the element...used to get the type
* @param context is the DeserializationContext
*/
public void startElement(String namespace, String localName,
String prefix, Attributes attributes,
DeserializationContext context)
throws SAXException
{
super.startElement(namespace, localName, prefix, attributes, context);
currentParam = null;
}
/**
* Register the start of a parameter (child element of the method call
* element).
*
* Our job here is to figure out a) which parameter this is (based on
* the QName of the element or its position), and b) what type it is
* (based on the xsi:type attribute or operation metadata) so we can
* successfully deserialize it.
*/
public SOAPHandler onStartChild(String namespace,
String localName,
String prefix,
Attributes attributes,
DeserializationContext context)
throws SAXException
{
if (log.isDebugEnabled()) {
log.debug("Enter: RPCHandler.onStartChild()");
}
if (!context.isDoneParsing()) {
try {
context.pushNewElement(new MessageElement(namespace, localName,
prefix, attributes,
context));
} catch (AxisFault axisFault) {
throw new SAXException(axisFault);
}
}
MessageElement curEl = context.getCurElement();
QName type = null;
QName qname = new QName(namespace, localName);
ParameterDesc paramDesc = null;
SOAPConstants soapConstants = context.getSOAPConstants();
if (soapConstants == SOAPConstants.SOAP12_CONSTANTS &&
Constants.QNAME_RPC_RESULT.equals(qname)) {
// TODO: fix it ... now we just skip it
return new DeserializerImpl();
}
// Create a new param if not the same element
if (currentParam == null ||
!currentParam.getQName().getNamespaceURI().equals(namespace) ||
!currentParam.getQName().getLocalPart().equals(localName)) {
currentParam = new RPCParam(namespace, localName, null);
rpcElem.addParam(currentParam);
}
// Grab xsi:type attribute if present, on either this element or
// the referent (if it's an href). MessageElement.getType() will
// automatically dig through to the referent if necessary.
type = curEl.getType();
if (type == null) {
type = context.getTypeFromAttributes(namespace,
localName,
attributes);
}
if (log.isDebugEnabled()) {
log.debug(Messages.getMessage("typeFromAttr00", "" + type));
}
Class destClass = null;
// If we have an operation descriptor, try to associate this parameter
// with the appropriate ParameterDesc
if (operation != null) {
// Try by name first
if (isResponse) {
paramDesc = operation.getOutputParamByQName(qname);
} else {
paramDesc = operation.getInputParamByQName(qname);
}
// If that didn't work, try position
// FIXME : Do we need to be in EITHER named OR positional
// mode? I.e. will it screw us up to find something
// by position if we've already looked something up
// by name? I think so...
if (paramDesc == null) {
if (isResponse) {
paramDesc = operation.getReturnParamDesc();
}
else {
paramDesc = operation.getParameter(rpcElem.getParams().size() - 1);
}
}
if (paramDesc == null) {
throw new SAXException(Messages.getMessage("noParmDesc"));
}
// Make sure that we don't find body parameters that should
// be in the header
if (!isHeaderElement &&
((isResponse && paramDesc.isOutHeader()) ||
(!isResponse && paramDesc.isInHeader()))) {
throw new SAXException(
Messages.getMessage("expectedHeaderParam",
paramDesc.getQName().toString()));
}
destClass = paramDesc.getJavaType();
if ((destClass != null) && (destClass.isArray())) {
context.setDestinationClass(destClass);
}
// Keep the association so we can use it later
// (see RPCProvider.processMessage())
currentParam.setParamDesc(paramDesc);
if (type == null) {
type = paramDesc.getTypeQName();
}
}
if (type != null && type.equals(XMLType.AXIS_VOID)) {
Deserializer nilDSer = new DeserializerImpl();
return (SOAPHandler) nilDSer;
}
// If the nil attribute is set, just
// return the base DeserializerImpl.
// Register the value target to set the value
// on the RPCParam. This is necessary for cases like
// <method>
// <foo>123</foo>
// <foo>456</foo>
// <foo xsi:nil="true" />
// </method>
// so that a list of 3 items is created.
// Failure to register the target would result in the last
// item not being added to the list
if (context.isNil(attributes)) {
Deserializer nilDSer = new DeserializerImpl();
nilDSer.registerValueTarget(new RPCParamTarget(currentParam));
return (SOAPHandler) nilDSer;
}
Deserializer dser = null;
if ((type == null) && (namespace != null) && (!namespace.equals(""))) {
dser = context.getDeserializerForType(qname);
} else {
dser = context.getDeserializer(destClass, type);
// !!!
if (dser == null && destClass != null && destClass.isArray() &&
operation.getStyle() == Style.DOCUMENT) {
dser = context.getDeserializerForClass(destClass);
}
// !!!
}
if (dser == null) {
if (type != null) {
dser = context.getDeserializerForType(type);
if(null != destClass && dser == null && Element.class.isAssignableFrom(destClass)){
//If a DOM element is expected, as last resort always allow direct mapping
// of parameter's SOAP xml to a DOM element. Support of literal parms by default.
dser = context.getDeserializerForType(Constants.SOAP_ELEMENT);
}
if (dser == null) {
dser = context.getDeserializerForClass(destClass);
}
if (dser == null) {
throw new SAXException(Messages.getMessage(
"noDeser01", localName,"" + type));
}
if (paramDesc != null && paramDesc.getJavaType() != null) {
// If we have an xsi:type, make sure it makes sense
// with the current paramDesc type
Class xsiClass =
context.getTypeMapping().getClassForQName(type);
if (null != xsiClass && !JavaUtils.isConvertable(xsiClass, destClass)) {
throw new SAXException("Bad types (" +
xsiClass + " -> " + destClass + ")"); // FIXME!
}
}
} else {
dser = context.getDeserializerForClass(destClass);
if (dser == null) {
dser = new DeserializerImpl();
}
}
}
dser.setDefaultType(type);
dser.registerValueTarget(new RPCParamTarget(currentParam));
if (log.isDebugEnabled()) {
log.debug("Exit: RPCHandler.onStartChild()");
}
return (SOAPHandler)dser;
}
public void endElement(String namespace, String localName,
DeserializationContext context)
throws SAXException
{
// endElement may not be called in all circumstances.
// In addition, onStartChild may be called after endElement
// (for header parameter/response processing).
// So please don't add important logic to this method.
if (log.isDebugEnabled()) {
log.debug(Messages.getMessage("setProp00",
"MessageContext", "RPCHandler.endElement()."));
}
context.getMessageContext().setProperty("RPC", rpcElem);
}
}
|
