org.apache.solr.util.xslt.TransformerProvider.java Source code

Introduction

Here is the source code for org.apache.solr.util.xslt.TransformerProvider.java

Source

/**
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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.solr.util.xslt;

import java.io.IOException;
import java.io.InputStream;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.commons.io.IOUtils;

import javax.xml.transform.Templates;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.stream.StreamSource;

import org.apache.solr.common.ResourceLoader;
import org.apache.solr.common.util.SystemIdResolver;
import org.apache.solr.common.util.XMLErrorLogger;
import org.apache.solr.core.SolrConfig;

/** Singleton that creates a Transformer for the XSLTServletFilter.
 *  For now, only caches the last created Transformer, but
 *  could evolve to use an LRU cache of Transformers.
 *  
 *  See http://www.javaworld.com/javaworld/jw-05-2003/jw-0502-xsl_p.html for
 *  one possible way of improving caching. 
 */

public class TransformerProvider {
    private String lastFilename;
    private Templates lastTemplates = null;
    private long cacheExpires = 0;

    private static final Logger log = LoggerFactory.getLogger(TransformerProvider.class.getName());
    private static final XMLErrorLogger xmllog = new XMLErrorLogger(log);

    public static TransformerProvider instance = new TransformerProvider();

    /** singleton */
    private TransformerProvider() {
        // tell'em: currently, we only cache the last used XSLT transform, and blindly recompile it
        // once cacheLifetimeSeconds expires
        log.warn("The TransformerProvider's simplistic XSLT caching mechanism is not appropriate "
                + "for high load scenarios, unless a single XSLT transform is used"
                + " and xsltCacheLifetimeSeconds is set to a sufficiently high value.");
    }

    /** Return a new Transformer, possibly created from our cached Templates object  
     * @throws TransformerConfigurationException 
     */
    public synchronized Transformer getTransformer(SolrConfig solrConfig, String filename, int cacheLifetimeSeconds)
            throws IOException {
        // For now, the Templates are blindly reloaded once cacheExpires is over.
        // It'd be better to check the file modification time to reload only if needed.
        if (lastTemplates != null && filename.equals(lastFilename) && System.currentTimeMillis() < cacheExpires) {
            if (log.isDebugEnabled()) {
                log.debug("Using cached Templates:" + filename);
            }
        } else {
            lastTemplates = getTemplates(solrConfig.getResourceLoader(), filename, cacheLifetimeSeconds);
        }

        Transformer result = null;

        try {
            result = lastTemplates.newTransformer();
        } catch (TransformerConfigurationException tce) {
            log.error(getClass().getName(), "getTransformer", tce);
            final IOException ioe = new IOException("newTransformer fails ( " + lastFilename + ")");
            ioe.initCause(tce);
            throw ioe;
        }

        return result;
    }

    /** Return a Templates object for the given filename */
    private Templates getTemplates(ResourceLoader loader, String filename, int cacheLifetimeSeconds)
            throws IOException {

        Templates result = null;
        lastFilename = null;
        try {
            if (log.isDebugEnabled()) {
                log.debug("compiling XSLT templates:" + filename);
            }
            final String fn = "xslt/" + filename;
            final TransformerFactory tFactory = TransformerFactory.newInstance();
            tFactory.setURIResolver(new SystemIdResolver(loader).asURIResolver());
            tFactory.setErrorListener(xmllog);
            final StreamSource src = new StreamSource(loader.openResource(fn),
                    SystemIdResolver.createSystemIdFromResourceName(fn));
            try {
                result = tFactory.newTemplates(src);
            } finally {
                // some XML parsers are broken and don't close the byte stream (but they should according to spec)
                IOUtils.closeQuietly(src.getInputStream());
            }
        } catch (Exception e) {
            log.error(getClass().getName(), "newTemplates", e);
            final IOException ioe = new IOException("Unable to initialize Templates '" + filename + "'");
            ioe.initCause(e);
            throw ioe;
        }

        lastFilename = filename;
        lastTemplates = result;
        cacheExpires = System.currentTimeMillis() + (cacheLifetimeSeconds * 1000);

        return result;
    }
}