xslttransformer.java

来自「提供ESB 应用mule源代码 提供ESB 应用mule源代码」· Java 代码 · 共 531 行 · 第 1/2 页

/*
 * $Id: XsltTransformer.java 13054 2008-10-10 21:45:36Z dfeist $
 * --------------------------------------------------------------------------------------
 * Copyright (c) MuleSource, Inc.  All rights reserved.  http://www.mulesource.com
 *
 * The software in this package is published under the terms of the CPAL v1.0
 * license, a copy of which has been included with this distribution in the
 * LICENSE.txt file.
 */

package org.mule.module.xml.transformer;

import org.mule.RequestContext;
import org.mule.api.MuleEventContext;
import org.mule.api.lifecycle.InitialisationException;
import org.mule.api.transformer.Transformer;
import org.mule.api.transformer.TransformerException;
import org.mule.config.i18n.CoreMessages;
import org.mule.module.xml.util.XMLUtils;
import org.mule.util.ClassUtils;
import org.mule.util.IOUtils;
import org.mule.util.StringUtils;
import org.mule.util.expression.ExpressionEvaluatorManager;

import java.io.IOException;
import java.io.InputStream;
import java.io.StringReader;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;

import javax.xml.transform.ErrorListener;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Result;
import javax.xml.transform.Source;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.TransformerFactoryConfigurationError;
import javax.xml.transform.URIResolver;
import javax.xml.transform.stream.StreamSource;

import org.apache.commons.pool.BasePoolableObjectFactory;
import org.apache.commons.pool.impl.GenericObjectPool;

/**
 * <code>XsltTransformer</code> performs an XSLT transform on a DOM (or other XML-ish)
 * object.
 * <p/>
 * This transformer maintains a pool of {@link javax.xml.Transformer} objects to speed up processing of concurrent requests.
 * The pool can be configured using {@link #setMaxIdleTransformers(int)}.
 * <p/>
 * Parameter can also be set as part of the transformation context and these can be mapped to conent in the current message using
 * property extractors or can be fixed values.
 * <p/>
 * <p/>
 * For example, the current event's message has a property named "myproperty", also you want to generate a uuid as a
 * parameter. To do this you can define context properties that can provide an expression to be evaluated on the current
 * message.
 * </p>
 * <p>
 * Example Configuration:
 * </p>
 * <p/>
 * <pre>
 *  &lt;mxml:xslt-transformer name=&quot;MyXsltTransformer&quot; xslFile=&quot;myXslFile.xsl&quot;&amp;gt
 *      &lt;context-property name=&quot;myParameter&quot; value=&quot;#[head:myproperty]&quot;/&amp;gt
 *      &lt;context-property name=&quot;myParameter2&quot; value=&quot;#[function:uuid]&quot;/&amp;gt
 *  &lt;/mxml:xslt-transformer&amp;gt
 * </pre>
 * <p/>
 * <p>
 * The 'header' expression pulls a header from the current message and 'function' can execute a set of arbitrary functions.
 * You can also pass in static values by ommitting the expression prefix '#['.
 * </p>
 * <p/>
 * In addition to being able to pass in an XSLT file you can also define templates inline. For example -
 * <p/>
 * <pre>
 *  &lt;mxml:xslt-transformer name=&quot;MyXsltTransformer&quot;&amp;gt
 *      &lt;mxml:xslt-text&amp;gt
 *          <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns="http://test.com" version="2.0">
 * <p/>
 *                <xsl:param name="echo"/>
 * <p/>
 *               <xsl:template match="/">
 *                   <echo-value>
 *                       <xsl:value-of select="$echo"/>
 *                   </echo-value>
 *               </xsl:template>
 *           </xsl:stylesheet>
 *  &lt;/mxml:xslt-text&amp;gt
 * </pre>
 */

public class XsltTransformer extends AbstractXmlTransformer
{
    // keep at least 1 XSLT Transformer ready by default
    private static final int MIN_IDLE_TRANSFORMERS = 1;
    // keep max. 32 XSLT Transformers around by default
    private static final int MAX_IDLE_TRANSFORMERS = 32;
    // MAX_IDLE is also the total limit
    private static final int MAX_ACTIVE_TRANSFORMERS = MAX_IDLE_TRANSFORMERS;
    // Prefix to use in a parameter to specify it is an expression that must be evaluated
    private static final String PARAM_EXTRACTOR_TOKEN = ExpressionEvaluatorManager.DEFAULT_EXPRESSION_PREFIX;

    protected final GenericObjectPool transformerPool;

    /** Default to Saxon */
    private volatile String xslTransformerFactoryClassName = "net.sf.saxon.TransformerFactoryImpl";
    private volatile String xslFile;
    private volatile String xslt;
    private volatile Map contextProperties;

    private URIResolver uriResolver;

    public XsltTransformer()
    {
        super();
        transformerPool = new GenericObjectPool(new PooledXsltTransformerFactory());
        transformerPool.setMinIdle(MIN_IDLE_TRANSFORMERS);
        transformerPool.setMaxIdle(MAX_IDLE_TRANSFORMERS);
        transformerPool.setMaxActive(MAX_ACTIVE_TRANSFORMERS);
        uriResolver = new LocalURIResolver();
    }

    public void initialise() throws InitialisationException
    {
        try
        {
            transformerPool.addObject();
        }
        catch (Throwable te)
        {
            throw new InitialisationException(te, this);
        }
    }

    /**
     * Transform, using XSLT, a XML String to another String.
     *
     * @param src The source XML (String, byte[], DOM, etc.)
     * @return The result in the type specified by the user
     */
    public Object doTransform(Object src, String encoding) throws TransformerException
    {
        try
        {
            Source sourceDoc = XMLUtils.toXmlSource(getXMLInputFactory(), isUseStaxSource(), src);
            if (sourceDoc == null)
            {
                return null;
            }

            ResultHolder holder = getResultHolder(returnClass);

            // If the users hasn't specified a class, lets return the same type they gave us
            if (holder == null)
            {
                holder = getResultHolder(src.getClass());
            }
            
            // If we still don't have a result type, lets fall back to using a DelayedResult
            // as it is the most efficient.
            if (holder == null || DelayedResult.class.equals(returnClass))
            {
                return getDelayedResult(encoding, sourceDoc);
            }
            
            doTransform(encoding, sourceDoc, holder.getResult());
            
            return holder.getResultObject();
        }
        catch (Exception e)
        {
            throw new TransformerException(this, e);
        }
    }

    protected Object getDelayedResult(final String encoding, final Source sourceDoc)
    {
        return new DelayedResult()
        {
            private String systemId;
            
            public void write(Result result) throws Exception
            {
                doTransform(encoding, sourceDoc, result);
            }

            public String getSystemId()
            {
                return systemId;
            }

            public void setSystemId(String systemId)
            {
                this.systemId = systemId;
            }
        };
    }

    protected void doTransform(String encoding, Source sourceDoc, Result result)
        throws Exception
    {
        DefaultErrorListener errorListener = new DefaultErrorListener(this);
        javax.xml.transform.Transformer transformer = null;

        try
        {
            transformer = (javax.xml.transform.Transformer) transformerPool.borrowObject();

            transformer.setErrorListener(errorListener);
            transformer.setOutputProperty(OutputKeys.ENCODING, encoding);

            // set transformation parameters
            if (contextProperties != null)
            {
                for (Iterator i = contextProperties.entrySet().iterator(); i.hasNext();)
                {
                    Map.Entry parameter = (Entry) i.next();
                    String key = (String) parameter.getKey();
                    transformer.setParameter(key, evaluateTransformParameter(key, parameter.getValue()));
                }
            }

            transformer.transform(sourceDoc, result);
            
            if (errorListener.isError())
            {
                throw errorListener.getException();
            }
        }
        finally
        {
            if (transformer != null)
            {
                // clear transformation parameters before returning transformer to the
                // pool
                transformer.clearParameters();

                transformerPool.returnObject(transformer);
            }
        }
    }

    /**
     * Returns the name of the currently configured javax.xml.transform.Transformer
     * factory class used to create XSLT Transformers.
     *
     * @return a TransformerFactory class name or <code>null</code> if none has been
     *         configured
     */
    public String getXslTransformerFactory()
    {
        return xslTransformerFactoryClassName;
    }

    /**
     * Configures the javax.xml.transform.Transformer factory class
     *
     * @param xslTransformerFactory the name of the TransformerFactory class to use
     */
    public void setXslTransformerFactory(String xslTransformerFactory)
    {
        this.xslTransformerFactoryClassName = xslTransformerFactory;
    }