Java Error in RFC Lookup in XSLT Mapping usinf Java helper class

Question

Hi All,
I am doing RFC Lookup in XSLT Mapping using Java Helper class.
The Lookup works fine when called one RFC at a time However my requirement is I want to do 2 Lookups.
Both Lookups works when done individually however when I call both lookups in one mapping I get following error "javax.xml.transform.TransformerException: DOMSource whose Node is null."
Following is the code I have written in XSLT for the lookup:
     <xsl:template name="Lookup_1">
          <xsl:param name="STDPN"/>
               <rfc:RFC_READ_TABLE>
                    <QUERY_TABLE>KNA1</QUERY_TABLE>
                    <OPTIONS><item><TEXT>
                              <xsl:value-of select="$STDPN"/>
                         </TEXT></item>
                    </OPTIONS>
                    <FIELDS>
                         <item>
                              <FIELDNAME>KUNNR</FIELDNAME>
                         </item>
                    </FIELDS>
               </rfc:RFC_READ_TABLE>
          </xsl:variable>
          <xsl:variable name="response" xmlns:lookup="java:urn.mt.pi" select="lookup:execute($request, 'BS_D, 'cc_RfcLookup', $inputparam)"/>
          <xsl:element name="STDPN">
               <xsl:value-of select="$response//DATA/item/WA"/>
          </xsl:element>
     </xsl:template>
     <xsl:template name="Lookup_2">
          <xsl:param name="BELNR"/>
               <xsl:variable name="Query">AGMNT = '<xsl:value-of select="$BELNR"/>'</xsl:variable>
               <xsl:variable name="request1">
                    <rfc:RFC_READ_TABLE>
                         <QUERY_TABLE>ZTABLE</QUERY_TABLE>
                         <OPTIONS><item><TEXT>
                              <xsl:value-of select="$Query"/>
                              </TEXT></item>
                         </OPTIONS>
                         <FIELDS>
                              <item>
                                   <FIELDNAME>KUNAG</FIELDNAME>
                              </item>
                         </FIELDS>
                    </rfc:RFC_READ_TABLE>
               </xsl:variable>
               <xsl:variable name="response1" xmlns:lookup="java:urn.mt.pi" select="lookup:execute($request1, 'BS_D','cc_RfcLookup', $inputparam)"/>
               <xsl:element name="BELNR">
                    <xsl:value-of select="$response1//DATA/item/WA"/>
               </xsl:element>
     </xsl:template>
My Question: Am I doing anything wrong? Or Is it possible to call multiple lookups in one XSLT?
Thanks and Regards,
Atul

Answer 1

Hi Atul,
I had the same problem like you had.
The main Problem is that with the example code the request variable is created as NodeList object. In XSLT a variable is somekind of a constant and can't be changed. As the request object is empty after the first request the programm fails at the following line:
Source source = new DOMSource(request.item(0));
So I've created a workaround for this problem.
In the call of the template I've put the request as a parameter object at the template call:
<xsl:with-param name="req">
<rfc:PLM_EXPLORE_BILL_OF_MATERIAL xmlns:rfc="urn:sap-com:document:sap:rfc:functions">
  <APPLICATION>Z001</APPLICATION>
  <FLAG_NEW_EXPLOSION>X</FLAG_NEW_EXPLOSION>
  <MATERIALNUMBER><xsl:value-of select="value"/></MATERIALNUMBER>
  <PLANT>FSD0</PLANT>
  <VALIDFROM><xsl:value-of select="//Recordset/Row[name='DTM-031']/value"/></VALIDFROM>
  <BOMITEM_DATA/>
</rfc:PLM_EXPLORE_BILL_OF_MATERIAL>
</xsl:with-param>
With this change the request will be provided as a String object and not as a NodeList object.
Afterwards the RfcLookup.java has to be changed to the following:
package com.franke.mappings;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.Map;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import com.sap.aii.mapping.lookup.Channel;
import com.sap.aii.mapping.api.StreamTransformationConstants;
import com.sap.aii.mapping.api.AbstractTrace;
import com.sap.aii.mapping.lookup.RfcAccessor;
import com.sap.aii.mapping.lookup.LookupService;
import com.sap.aii.mapping.lookup.XmlPayload;
* @author Thorsten Nordholm Søbirk, AppliCon A/S
* Helper class for using the XI Lookup API with XSLT mappings for calling RFCs.
* The class is generic in that it can be used to call any remote-enabled
* function module in R/3. Generation of the XML request document and parsing of
* the XML response is left to the stylesheet, where this can be done in a very
* natural manner.
* TD:
* Changed the class that request is sent as String, because of IndexOutOfBound-exception
* When sending multiple requests in one XSLT mapping.
public class RfcLookup {
     * Execute RFC lookup.
     * @param request RFC request - TD: changed to String
     * @param service name of service
     * @param channelName name of communication channel
     * @param inputParam mapping parameters
     * @return Node containing RFC response
     public static Node execute( String request,
             String service,
             String channelName,
             Map inputParam)
          AbstractTrace trace = (AbstractTrace) inputParam.get(StreamTransformationConstants.MAPPING_TRACE);
          Node responseNode = null;
          try {
              // Get channel and accessor
              Channel channel = LookupService.getChannel(service, channelName);
              RfcAccessor accessor = LookupService.getRfcAccessor(channel);
               // Serialise request NodeList - TD: Not needed anymore as request is String
               /*TransformerFactory factory = TransformerFactory.newInstance();
               Transformer transformer = factory.newTransformer();
               Source source = new DOMSource(request.item(0));
               ByteArrayOutputStream baos = new ByteArrayOutputStream();
               StreamResult streamResult = new StreamResult(baos);
               transformer.transform(source, streamResult);*/
                // TD: Add xml header and remove linefeeds for the request string
                request = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"+request.replaceAll("[\r\n]+", ""); 
                // TD: Get byte Array from request String to send afterwards
                byte[] requestBytes = request.getBytes();
               // TD: Not used anymore as request is String
                //byte[] requestBytes = baos.toByteArray();
                trace.addDebugMessage("RFC Request: " + new String(requestBytes));
                // Create input stream representing the function module request message
                InputStream inputStream = new ByteArrayInputStream(requestBytes);
                // Create XmlPayload
                XmlPayload requestPayload =LookupService.getXmlPayload(inputStream);
                // Execute lookup
                XmlPayload responsePayload = accessor.call(requestPayload);
                InputStream responseStream = responsePayload.getContent();
                TeeInputStream tee = new TeeInputStream(responseStream);
                // Create DOM tree for response
                DocumentBuilder docBuilder =DocumentBuilderFactory.newInstance().newDocumentBuilder();
                Document document = docBuilder.parse(tee);
                trace.addDebugMessage("RFC Response: " + tee.getStringContent());
                responseNode = document.getFirstChild();
          } catch (Throwable t) {
               StringWriter sw = new StringWriter();
               t.printStackTrace(new PrintWriter(sw));
               trace.addWarning(sw.toString());
          return responseNode;
     * Helper class which collects stream input while reading.
     static class TeeInputStream extends InputStream {
           private ByteArrayOutputStream baos;
           private InputStream wrappedInputStream;
           TeeInputStream(InputStream inputStream) {
                baos = new ByteArrayOutputStream();
                wrappedInputStream = inputStream;
           * @return stream content as String
           String getStringContent() {
                return baos.toString();
          /* (non-Javadoc)
          * @see java.io.InputStream#read()
          public int read() throws IOException {
               int r = wrappedInputStream.read();
               baos.write(r);
               return r;
Then you need to compile and upload this class and it should work.
I hope that this helps you.
Best regards
Till