Package com.sap.aii.mapping.api

API for Java mapping programs.

See: Description

Interface Summary

Interface	Description
Attachment
InputAttachments	Contains methods to read the attachments of the XI message in the mapping.
MappingTrace	A mapping can use an instance of MappingTrace to add messages to the trace.
OutputAttachments	Contains methods to set, change, or remove attachments of the XI message in the mapping.
StreamTransformation	Deprecated As of SAP NetWeaver NEW YORK, replaced by AbstractTransformation.
StreamTransformationConstants	This interface contains constants that can be used in a java mapping to access runtime parameters.

Class Summary

Class	Description
AbstractHelper
AbstractTrace	A mapping can use an instance of AbstractTrace to add messages to the trace.
AbstractTransformation	Each XI Java mapping program must extends this abstract class.
DynamicConfiguration	A DynamicConfiguration is a map containing adapter specific message attributes.
DynamicConfigurationKey	A DynamicConfigurationKey denotes an adapter specific message attribute.
InputHeader	Access to fields of the message header.
InputParameters	Access to input parmeter of the mapping.
InputPayload	Access to input payload of the mapping.
OutputHeader	Access to set to fields of the message header.
OutputParameters	Access to output parmeter of the mapping.
OutputPayload	Access to input payload of the mapping.
TransformationInput	Access to all input data of the mapping.
TransformationOutput	Access to all output data of the mapping.

Exception Summary

Exception	Description
StreamTransformationException	This exception can be thrown by AbstractTransformation.transform(TransformationInput, TransformationOutput) to indicate problem during mapping.
StreamTransformationRuntimeException
UndefinedParameterException
WrongParameterTypeException

Package com.sap.aii.mapping.api Description

API for Java mapping programs. The API works with an InputStream that is mapped to an OutputStream. Depending on the use case, application developers can choose additional APIs to do the actual mapping (for example SAXParser or DocumentBuilder to parse the InputStream). Additionally the mapping API provides classes to map a special header of the XI message that allows adapters to transport adapter specific information (classes DynamicConfiguration and DynamicConfigurationKey).

Although following example just copies the input payload to the output payload, it essentially shows how to use the mapping API. For more information see the details in the corresponding interfaces and classes.

Example:

package exampleMapping;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Map;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.Result;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

import org.w3c.dom.Document;
import org.xml.sax.SAXException;

import com.sap.aii.mapping.api.MappingTrace;
import com.sap.aii.mapping.api.StreamTransformation;
import com.sap.aii.mapping.api.StreamTransformationConstants;
import com.sap.aii.mapping.api.StreamTransformationException;

/**
 * Copy XML with a DOM.
 */
public class DomCopy implements StreamTransformation {

  private MappingTrace trace;

  /**
   * Constructor for DomCopy.
   */
  public DomCopy() {
    super();
  }

  /**
   * @see com.sap.aii.mapping.api.StreamTransformation#setParameter(Map)
   */
  public void setParameter(Map param) {
    trace = (MappingTrace) param.get(StreamTransformationConstants.MAPPING_TRACE);
  }

  /**
   * @see com.sap.aii.mapping.api.StreamTransformation#execute(InputStream,
   *      OutputStream)
   */
  public void execute(InputStream in, OutputStream out) throws StreamTransformationException {
    try {
      // read XML
      DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
      DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();
      Document xml = documentBuilder.parse(in);
            
      // write XML
      TransformerFactory transformerFactory = TransformerFactory.newInstance();
      Transformer transformer = transformerFactory.newTransformer();
      Result result = new StreamResult(out);
      Source domSource = new DOMSource(xml);
      transformer.transform(domSource, result);
    } catch (ParserConfigurationException e) {
      trace.addWarning(e.getMessage());
      throw new StreamTransformationException("Can not create DocumentBuilder.", e);
    } catch (SAXException e) {
      trace.addWarning(e.getMessage());
      throw new StreamTransformationException("Can not read XML.", e);
    } catch (IOException e) {
      trace.addWarning(e.getMessage());
      throw new StreamTransformationException("Can not read XML.", e);
    } catch (TransformerConfigurationException e) {
      trace.addWarning(e.getMessage());
      throw new StreamTransformationException("Can not create Transformer.", e);
    } catch (TransformerException e) {
      trace.addWarning(e.getMessage());
      throw new StreamTransformationException("Can not write XML.", e);
    }
  }
}