<?xml version="1.0"?>
<order number="197392">
  <customer>
    <name>David Vines</name>
    <address>IBM Hursley</address>
  </customer>
  <item stocknumber="234432" description="Roborally"/>
  <item stocknumber="375647"description="Kill Doctor Lucky"/>
</order>

        
<?xml version="1.0"?>
<neworder number="197392"/>

        
<?xml version="1.0"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:template match="order">
    <neworder number="{@number}"/>
  </xsl:template>
</xsl:stylesheet>

        
public class XSLTExample
{
  private static final String stylesheet = "<?xml version=\"1.0\"?>\r\n" + 
      "<xsl:stylesheet version=\"1.0\" xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\">\r\n" +
      "  <xsl:template match=\"order\">\r\n" +
      "    <neworder number=\"{@number}\"/>\r\n" +
      "  </xsl:template>\r\n" +
      "</xsl:stylesheet>\r\n";
      
  private static final String inputString = "<?xml
version=\"1.0\"?>\r\n" +
      "<order number=\"197392\">\r\n" + 
      "  <customer>\r\n" + 
      "    <name>David Vines</name>\r\n" + 
      "     <address>IBM Hursley</address>\r\n" + 
      "  </customer>\r\n" + 
      "  <item stocknumber=\"234432\" description=\"Roborally\"/>\r\n" + 
      "  <item stocknumber=\"375647\" description=\"Doctor Lucky\"/>\r\n" + 
      "</order>\r\n"; 
 
  public static final void main(String[] args)
  {
    TransformerFactory factory = TransformerFactory.newInstance(); [1]
    try
    {
      StringReader stylereader = new StringReader(stylesheet);
      StreamSource stylesource = new StreamSource(stylereader);
      Templates translet = factory.newTemplates(stylesource);   [2]
      Transformer transformer = translet.newTransformer();      [3]
      Source source = new StreamSource(new StringReader(inputString));
      Writer writer = new StringWriter();
      Result result = new StreamResult(writer);
      transformer.transform(source, result);                    [4]
      System.out.println(writer.toString());
    }
    catch(Exception e)
    {
      e.printStackTrace();
    }
  }
}

        
/**
 * A ThreadLocalTransformer holds a transformer object for each thread.
 *
 */
public class ThreadLocalTransformer extends ThreadLocal
{
    /** The translet to be used to obtain transformers */
    private Templates _translet;
    
    /**
     * Construct a new ThreadLocalTransformer.
     *
     * @param translet         The translet from which to build the transformers
     */
    public ThreadLocalTransformer(Templates translet)
    {
      super();
      _translet = translet;
    }
    
    /**
     * Return the transformer to be used for this thread.
     *
     * @return Object The transformer to be used for this thread
     */
    protected Object initialValue()
    {
      try
      {
        return _translet.newTransformer();
      }
      catch (TransformerConfigurationException e)
      {
        // Hmm, we have to return something, so null will have to do :-(
        return null;
      }
    }
}

        
/**
 * The XSLTTransform class contains a utility method to perform 
 * an XSLT transform. It caches the Transformer objects to 
 * improve performance when the same transform is repeatedly used.
 */
public class XSLTTransform
{
  /** The factory used by this class to get transformers constructed */
  private static TransformerFactory _transformerFactory 
     = TransformerFactory.newInstance();

  /** A map from String (stylesheet) to ThreadLocalTransformer */
  private static Map _stylesheetToThreadLocalTransformer = new HashMap();

  /**
   * Transform a payload using the specified transform
   * 
   * @param payload    The payload to be transformed
   * @param transform  The transform to be used
   * @return byte[] the transformed payload
   * @throws TransformerConfigurationException is thrown if 
   *         the stylesheet is not a valid stylesheet
   * @throws TransformerException if the transform fails for any reason
   */
  public static byte[] transform(byte[] payload
                                ,String transform
                                ) throws TransformerException
  {
    // Get the XSLT transformer object 
    // (one that is for use by this thread)
    Transformer transformer = transformerFor(transform);
    
    // Build an source for the transform
    ByteArrayInputStream inputStream = new ByteArrayInputStream(payload);
    InputStreamReader    reader      = new InputStreamReader(inputStream);
    StreamSource         source      = new StreamSource(reader);
    
    // Build a result for the transform
    ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
    OutputStreamWriter    writer       = new OutputStreamWriter(outputStream);
    StreamResult          result       = new StreamResult(writer);
    
    // Do the transform
    transformer.transform(source,result);
    
    // And the result is the byte[] from the output stream
    return outputStream.toByteArray();
  }

 
  /**
   * Obtain a transformer for the specified transform 
   * and for use by the current thread
   *
   * @param stylesheet The XSL stylesheet for which
   *        a transformer is required
   * @return Transformer The transformer object for the
   *         specified style-sheet and for the current 
   *         thread of execution
   * @throws TransformerConfigurationException is thrown 
   *         if the stylesheet is not a valid stylesheet
   */
  private static Transformer transformerFor(String stylesheet) 
          throws TransformerConfigurationException
  {
    ThreadLocalTransformer threadLocalTransformer;

    if (!_stylesheetToThreadLocalTransformer.containsKey(stylesheet))
    {
      threadLocalTransformer = (ThreadLocalTransformer)createThreadLocalTransformerFor(stylesheet);
      _stylesheetToThreadLocalTransformer.put(stylesheet,threadLocalTransformer);
    }
    else
    {
      threadLocalTransformer = (ThreadLocalTransformer)_stylesheetToThreadLocalTransformer.get(stylesheet);
    }

    return (Transformer) threadLocalTransformer.get();
  }

 
  /**
   * Create a thread local transformer for the
   * specified stylesheet
   *
   * @param stylesheet The stylesheet
   * @return ThreadLocalTransformer The thread local transformer 
   *         for the specified stylesheet
   * @throws TransformerConfigurationException is thrown if the 
   *         stylesheet is not a valid stylesheet
   */
  private static Object createThreadLocalTransformerFor(String stylesheet) 
          throws TransformerConfigurationException
  {
    StringReader reader = new StringReader(stylesheet);
    StreamSource source = new StreamSource(reader);
    Templates translet = _transformerFactory.newTemplates(source);
    return new ThreadLocalTransformer(translet);
  }
}

        
/**
 * This is the base class for all mediation handlers
 *
 */
public abstract class MediationHandlerBase implements MediationHandler
{
  private static final String TRACE_NAME = "trace";

  /** The current message context being processed by this instance of the mediation handler */
  private MessageContext _context;
  
  /** Cached answer to 'isTraceEnabled'. Set to null if no one has asked for the current trace setting */
  private Boolean _traceEnabled = null;
  
  /**
   * This method wraps the real handle method, so that we can dump the stack trace
   * of exceptions to System.err
   * 
   * @see com.ibm.websphere.sib.mediation.handler.MediationHandler#handle(javax.xml.rpc.handler.MessageContext)
   * @param context The message to be transformed
   * @return true if the message can continue being processed
   * @throws com.ibm.websphere.sib.mediation.handler.MessageContextException if the message cannot be handled
   * @throws IllegalArgumentException if the mediation detects that it is not correctly setup.
   */
  public boolean handle(MessageContext context) throws MessageContextException
  {
    _context = context;
    _traceEnabled = null;
    
    try
    {
      return innerHandle();
    }
    catch(MessageContextException e)
    {
      e.printStackTrace();
      throw e;
    }
    catch(RuntimeException e)
    {
      e.printStackTrace();
      throw e;
    }
    catch(Error e)
    {
      e.printStackTrace();
      throw e;
    }
  }

        
  /**
   * @return the message context passed to this mediation handler
   */
  protected SIMessageContext getContext()
  {
    return (SIMessageContext)_context;
  }
  
  /**
   * see com.ibm.websphere.sib.mediation.handler.MediationHandler#handle(javax.xml.rpc.handler.MessageContext)
   * @return true if the message can continue being processed
   * @throws com.ibm.websphere.sib.mediation.handler.MessageContextException if the message cannot be handled
   * @throws IllegalArgumentException if the mediation detects that it is not correctly setup.
   */
  public abstract boolean innerHandle() throws MessageContextException;
  
  /**
   * Return the value of a context property whose value should be a string.
   * 
   * @param propertyName The name of the context property whose value should be returned
   * @return String the value of the property
   * @throws IllegalArgumentException is thrown if the context property does not exist or is not a string
   */
  protected String getStringProperty(String propertyName) throws IllegalArgumentException
  {
    Object property = getContext().getProperty(propertyName);
    
    if (property instanceof String)
    {
      return (String)property;
    }
    else
    {
      if (property == null) 
        throw new IllegalArgumentException("Missing context property: "+propertyName);
      else
        throw new IllegalArgumentException("Context property '"+propertyName+"' not of the expected type. 
		Expecting String, got "+property.getClass().getName());
    }
  }

        
  /**
   * @return true if trace is enabled
   */
  protected boolean isTraceEnabled()
  {
    if (_traceEnabled == null)
    {
      Object traceProperty = getContext().getProperty(TRACE_NAME);

      if (traceProperty instanceof Boolean)
        _traceEnabled = (Boolean)traceProperty;
      else
        _traceEnabled = Boolean.FALSE;
    }
    
    return _traceEnabled.booleanValue();
  }
}
      

        
/**
 * The XSLTMediationHandler takes a message and converts it into a JMS
 * Bytes Message. In addition it passes the message through an XSLT 
 * Transformation.
 *
 */
public class XSLTMediationHandler extends MediationHandlerBase
{
  private static final String STYLESHEET_PROPERTY_NAME = "Stylesheet";
  private static final String TRACK_DEST_PROPERTY_NAME = "TrackingDestination";

  /**
   * This method is given the message context to be mediated and sends a new
   * message (based on the original message via an XSLT Stylesheet) to the
   * logging destination. 
   * 
   * @see MediationHandlerBase#innerHandle
   * @return true if the message has been converted
   * @throws MessageContextException is thrown if the message cannot be converted
   * (note that the original message will be rerouted to the exception destination if this
   * exception is thrown.)
   */
  public boolean innerHandle() throws MessageContextException
  {
    // Retrieve the message from the context
    SIMessage message = getContext().getSIMessage();

    // Get the message contents in the form of a JMS Bytes message
    try
    {
      // Get a new datagraph for the new message we're about to build - Point 1
      DataGraph graph = message.getNewDataGraph(SIApiConstants.JMS_FORMAT_BYTES);
      DataObject body = graph.getRootObject();
      if (body.isSet("data"))
      {
        // Grab the bytes
        byte[] payload = body.getBytes("data/value");

        // Transform the bytes
        payload = XSLTTransform.transform(payload,getStringProperty(STYLESHEET_PROPERTY_NAME));

        // Replace the payload in the data graph
        body.setBytes("data/value",payload);

        // Build a new message to send (based on the original message - Point 2
        SIMessage newMsg = SIMessageFactory.getInstance().createSIMessage(graph, SIApiConstants.JMS_FORMAT_BYTES);
        newMsg.setApiMessageId(message.getApiMessageId());
        newMsg.setCorrelationId(message.getCorrelationId());
        newMsg.setDiscriminator(message.getDiscriminator());
        newMsg.setPriority(message.getPriority());
        newMsg.setReliability(message.getReliability());
        newMsg.setRemainingTimeToLive(message.getRemainingTimeToLive());
        newMsg.setTimeToLive(message.getTimeToLive());
        newMsg.setUserId(message.getUserId());
        for(Iterator it = newMsg.getUserPropertyNames().iterator(); it.hasNext(); )
        {
          String propertyName = (String)it.next();
          newMsg.setUserProperty(propertyName, newMsg.getUserProperty(propertyName));
        }
        
        // Send the new message to the logging destination - Point 3
        String trackDest = getStringProperty(TRACK_DEST_PROPERTY_NAME);
        SIDestinationAddress target = SIDestinationAddressFactory
                                         .getInstance()
                                         .createSIDestinationAddress(trackDest, false);
        List forwardRoutingPath = new ArrayList();
        forwardRoutingPath.add(target);
        newMsg.setForwardRoutingPath(forwardRoutingPath);
        getContext().getSession().send(newMsg, true);
      }
      else
      {
        // No bytes sent, so throw an IllegalArgument so that the message
        // will be sent to the exception destination
        IllegalArgumentException e = new IllegalArgumentException("No body to the message");
        throw e;
      }
    }
    catch(Exception e)
    {
      // Hmm, we had a problem somewhere doing the transformation or maybe the send
      e.printStackTrace();
      throw new MessageContextException(e);
    }

    // If we get here, everything worked and the tracking message has been sent
    return true;
  }
}