Example usage for javax.xml.transform Transformer setURIResolver

List of usage examples for javax.xml.transform Transformer setURIResolver

  1. HOME
  2. Java
  3. javax
  4. javax.xml.transform.*
  5. Transformer
  6. setURIResolver

Introduction

In this page you can find the example usage for javax.xml.transform Transformer setURIResolver.

Prototype

public abstract void setURIResolver(URIResolver resolver);

Source Link

Document

Set an object that will be used to resolve URIs used in document().

Usage

From source file:dk.defxws.fedoragsearch.server.GTransformer.java

public Transformer getTransformer(String xsltPath, URIResolver uriResolver, boolean checkInHome)
        throws Exception {
    if (cache.containsKey(xsltPath)) {
        return cache.get(xsltPath);
    }/*w  w w  .j  a  v  a 2 s .  com*/
    Transformer transformer = null;
    String xsltPathName = xsltPath + ".xslt";
    try {
        InputStream stylesheet;
        try {
            if (checkInHome) {
                String dirname = Constants.WORKING_DIR + File.separator + "xsl";
                File textFile = new File(dirname, xsltPathName);
                if ((textFile.exists()) && (textFile.canRead())) {
                    stylesheet = new FileInputStream(textFile);
                } else {
                    stylesheet = this.getClass()
                            .getResourceAsStream("/cz/incad/kramerius/indexer/res/" + xsltPathName);
                }
            } else {
                stylesheet = new FileInputStream(new File(xsltPath));
            }
        } catch (Exception ex) {
            throw new Exception(xsltPath + " not found");
        }
        TransformerFactory tfactory = TransformerFactory.newInstance();
        if (uriResolver != null) {
            tfactory.setURIResolver(uriResolver);
        }
        StreamSource xslt = new StreamSource(stylesheet);
        transformer = tfactory.newTransformer(xslt);
        if (uriResolver != null) {
            transformer.setURIResolver(uriResolver);
        }
    } catch (TransformerConfigurationException e) {
        throw new Exception("getTransformer " + xsltPath + ":\n", e);
    } catch (TransformerFactoryConfigurationError e) {
        throw new Exception("getTransformerFactory " + xsltPath + ":\n", e);
    }
    if (transformer != null) {
        cache.put(xsltPath, transformer);
    }
    return transformer;
}

From source file:org.alfresco.repo.template.XSLTProcessor.java

/**
 * @param templateSource// w  w  w.  ja  va  2 s.com
 * @param model
 * @param out
 */
private void process(TemplateSource templateSource, Object model, Writer out) {
    if ((model == null) || !XSLTemplateModel.class.isAssignableFrom(model.getClass())) {
        throw new IllegalArgumentException("\"model\" must be an XSLTemplateModel object: " + model);
    }

    XSLTemplateModel xsltModel = (XSLTemplateModel) model;
    System.setProperty("org.apache.xalan.extensions.bsf.BSFManager", BSFManager.class.getName());

    Document xslTemplate;
    try {
        xslTemplate = XMLUtil.parse(templateSource.getReader(defaultEncoding));
    } catch (IOException ex) {
        throw new TemplateException(MSG_UNABLE_TO_READ_TEMPLATE, new Object[] { ex.getMessage() }, ex);
    } catch (SAXException sax) {
        throw new TemplateException(MSG_UNABLE_TO_PARSE_TEMPLATE, new Object[] { sax.getMessage() }, sax);
    } finally {
        try {
            templateSource.close();
        } catch (IOException ex) {
            // There's little to be done here. Log it and carry on
            log.warn("Error while trying to close template stream", ex);
        }
    }

    List<String> scriptIds = addScripts(xsltModel, xslTemplate);
    addParameters(xsltModel, xslTemplate);

    final LinkedList<TransformerException> errors = new LinkedList<TransformerException>();
    final ErrorListener errorListener = new ErrorListener() {
        public void error(final TransformerException te) throws TransformerException {
            log.debug("error " + te.getMessageAndLocation());
            errors.add(te);
        }

        public void fatalError(final TransformerException te) throws TransformerException {
            log.debug("fatalError " + te.getMessageAndLocation());
            throw te;
        }

        public void warning(final TransformerException te) throws TransformerException {
            log.debug("warning " + te.getMessageAndLocation());
            errors.add(te);
        }
    };

    final TemplateSource resourceSource = templateSource;
    final URIResolver uriResolver = new URIResolver() {
        public Source resolve(final String href, String base) throws TransformerException {
            if (log.isDebugEnabled()) {
                log.debug("request to resolve href " + href + " using base " + base);
            }
            InputStream in = null;
            try {
                in = resourceSource.getResource(href);
                if (in == null) {
                    throw new TransformerException("unable to resolve href " + href);
                }

                Document d = XMLUtil.parse(in);
                if (log.isDebugEnabled()) {
                    log.debug("loaded " + XMLUtil.toString(d));
                }
                return new DOMSource(d);
            } catch (TransformerException ex) {
                throw ex;
            } catch (Exception e) {
                throw new TransformerException("unable to load " + href, e);
            }
        }
    };

    Source xmlSource = this.getXMLSource(xsltModel);

    Transformer t = null;
    try {
        final TransformerFactory tf = TransformerFactory.newInstance();
        tf.setErrorListener(errorListener);
        tf.setURIResolver(uriResolver);

        if (log.isDebugEnabled()) {
            log.debug("xslTemplate: \n" + XMLUtil.toString(xslTemplate));
        }

        t = tf.newTransformer(new DOMSource(xslTemplate));

        if (errors.size() != 0) {
            final StringBuilder msg = new StringBuilder("errors encountered creating tranformer ... \n");
            for (TransformerException te : errors) {
                msg.append(te.getMessageAndLocation()).append("\n");
            }
            throw new TemplateException(msg.toString());
        }

        t.setErrorListener(errorListener);
        t.setURIResolver(uriResolver);
        t.setParameter("versionParam", "2.0");
    } catch (TransformerConfigurationException tce) {
        log.error(tce);
        throw new TemplateException(tce.getMessage(), tce);
    }

    try {
        t.transform(xmlSource, new StreamResult(out));
    } catch (TransformerException te) {
        log.error(te.getMessageAndLocation());
        throw new TemplateException(te.getMessageAndLocation(), te);
    } catch (Exception e) {
        log.error("unexpected error " + e);
        throw new TemplateException(e.getMessage(), e);
    } finally {
        //Clear out any scripts that were created for this transform
        if (!scriptIds.isEmpty()) {
            XSLTProcessorMethodInvoker.removeMethods(scriptIds);
        }
    }

    if (errors.size() != 0) {
        final StringBuilder msg = new StringBuilder("errors encountered during transformation ... \n");
        for (TransformerException te : errors) {
            msg.append(te.getMessageAndLocation()).append("\n");
        }
        throw new TemplateException(msg.toString());
    }
}

From source file:org.alfresco.web.forms.XSLTRenderingEngine.java

public void render(final Map<QName, Object> model, final RenderingEngineTemplate ret, final Result result)
        throws IOException, RenderingEngine.RenderingException, SAXException {
    System.setProperty("org.apache.xalan.extensions.bsf.BSFManager", BSFManager.class.getName());
    Document xslTemplate = null;//from w  ww.  j  a v a  2s.  c  o m
    try {
        xslTemplate = XMLUtil.parse(ret.getInputStream());
    } catch (final SAXException sax) {
        throw new RenderingEngine.RenderingException(sax);
    }
    this.addScripts(model, xslTemplate);
    this.addParameters(model, xslTemplate);

    final LinkedList<TransformerException> errors = new LinkedList<TransformerException>();
    final ErrorListener errorListener = new ErrorListener() {
        public void error(final TransformerException te) throws TransformerException {
            LOGGER.debug("error " + te.getMessageAndLocation());
            errors.add(te);
        }

        public void fatalError(final TransformerException te) throws TransformerException {
            LOGGER.debug("fatalError " + te.getMessageAndLocation());
            throw te;
        }

        public void warning(final TransformerException te) throws TransformerException {
            LOGGER.debug("warning " + te.getMessageAndLocation());
            errors.add(te);
        }
    };

    // create a uri resolver to resolve document() calls to the virtualized
    // web application
    final URIResolver uriResolver = new URIResolver() {
        public Source resolve(final String href, String base) throws TransformerException {
            LOGGER.debug("request to resolve href " + href + " using base " + base);
            final RenderingEngine.TemplateResourceResolver trr = (RenderingEngine.TemplateResourceResolver) model
                    .get(RenderingEngineTemplateImpl.PROP_RESOURCE_RESOLVER);

            InputStream in = null;
            try {
                in = trr.resolve(href);
            } catch (Exception e) {
                throw new TransformerException("unable to load " + href, e);
            }

            if (in == null) {
                throw new TransformerException("unable to resolve href " + href);
            }

            try {
                final Document d = XMLUtil.parse(in);
                if (LOGGER.isDebugEnabled())
                    LOGGER.debug("loaded " + XMLUtil.toString(d));
                return new DOMSource(d);
            } catch (Exception e) {
                throw new TransformerException("unable to load " + href, e);
            }
        }
    };

    Source xmlSource = this.getXMLSource(model);

    Transformer t = null;
    try {
        final TransformerFactory tf = TransformerFactory.newInstance();
        tf.setErrorListener(errorListener);
        tf.setURIResolver(uriResolver);

        if (LOGGER.isDebugEnabled()) {
            LOGGER.debug("xslTemplate: \n" + XMLUtil.toString(xslTemplate));
        }

        t = tf.newTransformer(new DOMSource(xslTemplate));

        if (errors.size() != 0) {
            final StringBuilder msg = new StringBuilder("errors encountered creating tranformer ... \n");
            for (TransformerException te : errors) {
                msg.append(te.getMessageAndLocation()).append("\n");
            }
            throw new RenderingEngine.RenderingException(msg.toString());
        }

        t.setErrorListener(errorListener);
        t.setURIResolver(uriResolver);
        t.setParameter("versionParam", "2.0");
    } catch (TransformerConfigurationException tce) {
        LOGGER.error(tce);
        throw new RenderingEngine.RenderingException(tce);
    }

    try {
        t.transform(xmlSource, result);
    } catch (TransformerException te) {
        LOGGER.error(te.getMessageAndLocation());
        throw new RenderingEngine.RenderingException(te);
    } catch (Exception e) {
        LOGGER.error("unexpected error " + e);
        throw new RenderingEngine.RenderingException(e);
    }

    if (errors.size() != 0) {
        final StringBuilder msg = new StringBuilder("errors encountered during transformation ... \n");
        for (TransformerException te : errors) {
            msg.append(te.getMessageAndLocation()).append("\n");
        }
        throw new RenderingEngine.RenderingException(msg.toString());
    }
}

From source file:org.apache.fop.tools.EventProducerCollectorTask.java

/**
 * Updates the translation file with new entries for newly found event producer methods.
 * @param modelFile the model file to use
 * @throws IOException if an I/O error occurs
 *//*from  w w  w  .j av  a2  s  . co  m*/
protected void updateTranslationFile(File modelFile) throws IOException {
    try {
        boolean resultExists = getTranslationFile().exists();
        SAXTransformerFactory tFactory = (SAXTransformerFactory) SAXTransformerFactory.newInstance();

        //Generate fresh generated translation file as template
        Source src = new StreamSource(modelFile.toURI().toURL().toExternalForm());
        StreamSource xslt1 = new StreamSource(getClass().getResourceAsStream(MODEL2TRANSLATION));
        if (xslt1.getInputStream() == null) {
            throw new FileNotFoundException(MODEL2TRANSLATION + " not found");
        }
        DOMResult domres = new DOMResult();
        Transformer transformer = tFactory.newTransformer(xslt1);
        transformer.transform(src, domres);
        final Node generated = domres.getNode();

        Node sourceDocument;
        if (resultExists) {
            //Load existing translation file into memory (because we overwrite it later)
            src = new StreamSource(getTranslationFile().toURI().toURL().toExternalForm());
            domres = new DOMResult();
            transformer = tFactory.newTransformer();
            transformer.transform(src, domres);
            sourceDocument = domres.getNode();
        } else {
            //Simply use generated as source document
            sourceDocument = generated;
        }

        //Generate translation file (with potentially new translations)
        src = new DOMSource(sourceDocument);

        //The following triggers a bug in older Xalan versions
        //Result res = new StreamResult(getTranslationFile());
        OutputStream out = new java.io.FileOutputStream(getTranslationFile());
        out = new java.io.BufferedOutputStream(out);
        Result res = new StreamResult(out);
        try {
            StreamSource xslt2 = new StreamSource(getClass().getResourceAsStream(MERGETRANSLATION));
            if (xslt2.getInputStream() == null) {
                throw new FileNotFoundException(MERGETRANSLATION + " not found");
            }
            transformer = tFactory.newTransformer(xslt2);
            transformer.setURIResolver(new URIResolver() {
                public Source resolve(String href, String base) throws TransformerException {
                    if ("my:dom".equals(href)) {
                        return new DOMSource(generated);
                    }
                    return null;
                }
            });
            if (resultExists) {
                transformer.setParameter("generated-url", "my:dom");
            }
            transformer.transform(src, res);
            if (resultExists) {
                log("Translation file updated: " + getTranslationFile());
            } else {
                log("Translation file generated: " + getTranslationFile());
            }
        } finally {
            IOUtils.closeQuietly(out);
        }
    } catch (TransformerException te) {
        throw new IOException(te.getMessage());
    }
}

From source file:org.apache.ode.utils.xsl.XslTransformHandler.java

/**
 * Transforms a Source document to a result using the XSL stylesheet referenced
 * by the provided URI. The stylesheet MUST have been parsed previously.
 * @param uri referencing the stylesheet
 * @param source XML document/*from   ww  w .j av  a2  s  .  c om*/
 * @param parameters passed to the stylesheet
 * @param resolver used to resolve includes and imports
 * @return result of the transformation (XSL, HTML or text depending of the output method specified in stylesheet.
 */
public Object transform(QName processQName, URI uri, Source source, Map<QName, Object> parameters,
        URIResolver resolver) {
    Templates tm;
    synchronized (_templateCache) {
        tm = (Templates) _templateCache.get(processQName, uri);
    }
    if (tm == null)
        throw new XslTransformException("XSL sheet" + uri + " has not been parsed before transformation!");
    try {
        Transformer tf = tm.newTransformer();
        tf.setURIResolver(resolver);
        if (parameters != null) {
            for (Map.Entry<QName, Object> param : parameters.entrySet()) {
                tf.setParameter(param.getKey().getLocalPart(), param.getValue());
            }
        }
        String method = tf.getOutputProperties().getProperty("method");
        if (method == null || "xml".equals(method)) {
            DOMResult result = new DOMResult();
            tf.transform(source, result);
            Node node = result.getNode();
            if (node.getNodeType() == Node.DOCUMENT_NODE)
                node = ((Document) node).getDocumentElement();
            if (__log.isDebugEnabled())
                __log.debug("Returned node: type=" + node.getNodeType() + ", " + DOMUtils.domToString(node));
            return node;
        } else {
            // text and html outputs are handled the same way
            StringWriter writerResult = new StringWriter();
            StreamResult result = new StreamResult(writerResult);
            tf.transform(source, result);
            writerResult.flush();
            String output = writerResult.toString();
            if (__log.isDebugEnabled())
                __log.debug("Returned string: " + output);
            return output;
        }
    } catch (TransformerConfigurationException e) {
        throw new XslTransformException(e);
    } catch (TransformerException e) {
        throw new XslTransformException("XSL Transformation failed!", e);
    }
}

From source file:org.apache.struts2.views.xslt.XSLTResult.java

public void execute(ActionInvocation invocation) throws Exception {
    long startTime = System.currentTimeMillis();
    String location = getStylesheetLocation();

    if (location == null) {
        throw new IllegalArgumentException("Parameter 'stylesheetLocation' cannot be null!");
    }/*from  ww  w  . java2  s .  c  om*/

    if (parse) {
        ValueStack stack = ActionContext.getContext().getValueStack();
        location = TextParseUtil.translateVariables(location, stack);
    }

    try {
        HttpServletResponse response = ServletActionContext.getResponse();
        response.setStatus(status);
        response.setCharacterEncoding(encoding);
        PrintWriter writer = response.getWriter();

        // Create a transformer for the stylesheet.
        Templates templates = null;
        Transformer transformer;
        if (location != null) {
            templates = getTemplates(location);
            transformer = templates.newTransformer();
        } else {
            transformer = TransformerFactory.newInstance().newTransformer();
        }

        transformer.setURIResolver(getURIResolver());
        transformer.setErrorListener(buildErrorListener());

        String mimeType;
        if (templates == null) {
            mimeType = "text/xml"; // no stylesheet, raw xml
        } else {
            mimeType = templates.getOutputProperties().getProperty(OutputKeys.MEDIA_TYPE);
        }

        if (mimeType == null) {
            // guess (this is a servlet, so text/html might be the best guess)
            mimeType = "text/html";
        }

        response.setContentType(mimeType);

        Object result = invocation.getAction();
        if (exposedValue != null) {
            ValueStack stack = invocation.getStack();
            result = stack.findValue(exposedValue);
        }

        Source xmlSource = getDOMSourceForStack(result);

        // Transform the source XML to System.out.
        LOG.debug("xmlSource = {}", xmlSource);
        transformer.transform(xmlSource, new StreamResult(writer));

        writer.flush(); // ...and flush...

        LOG.debug("Time: {}ms", (System.currentTimeMillis() - startTime));

    } catch (Exception e) {
        LOG.error("Unable to render XSLT Template, '{}'", location, e);
        throw e;
    }
}

From source file:org.apereo.portal.rendering.xslt.XSLTComponent.java

@Override
public PipelineEventReader<XMLEventReader, XMLEvent> getEventReader(HttpServletRequest request,
        HttpServletResponse response) {/*from   w  ww .  j ava 2s  .  c om*/
    final PipelineEventReader<XMLEventReader, XMLEvent> pipelineEventReader = this.wrappedComponent
            .getEventReader(request, response);

    final Transformer transformer = this.transformerSource.getTransformer(request, response);

    //Setup a URIResolver based on the current resource loader
    transformer.setURIResolver(this.uriResolver);

    //Configure the Transformer via injected class
    if (this.xsltParameterSource != null) {
        final Map<String, Object> transformerParameters = this.xsltParameterSource.getParameters(request,
                response);
        if (transformerParameters != null) {
            this.logger.debug("{} - Setting Transformer Parameters: ", this.beanName, transformerParameters);
            for (final Map.Entry<String, Object> transformerParametersEntry : transformerParameters
                    .entrySet()) {
                final String name = transformerParametersEntry.getKey();
                final Object value = transformerParametersEntry.getValue();
                if (value != null) {
                    transformer.setParameter(name, value);
                }
            }
        }

        final Properties outputProperties = this.xsltParameterSource.getOutputProperties(request, response);
        if (outputProperties != null) {
            this.logger.debug("{} - Setting Transformer Output Properties: ", this.beanName, outputProperties);
            transformer.setOutputProperties(outputProperties);
        }
    }

    //The event reader from the previous component in the pipeline
    final XMLEventReader eventReader = pipelineEventReader.getEventReader();

    //Wrap the event reader in a stream reader to avoid a JDK bug
    final XMLStreamReader streamReader;
    try {
        streamReader = new FixedXMLEventStreamReader(eventReader);
    } catch (XMLStreamException e) {
        throw new RuntimeException("Failed to create XMLStreamReader from XMLEventReader", e);
    }
    final Source xmlReaderSource = new StAXSource(streamReader);

    //Setup logging for the transform
    transformer.setErrorListener(this.errorListener);

    //Transform to a SAX ContentHandler to avoid JDK bug: http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6775588
    final XMLEventBufferWriter eventWriterBuffer = new XMLEventBufferWriter();
    final ContentHandler contentHandler = StaxUtils.createLexicalContentHandler(eventWriterBuffer);
    contentHandler.setDocumentLocator(new LocatorImpl());

    final SAXResult outputTarget = new SAXResult(contentHandler);
    try {
        this.logger.debug("{} - Begining XML Transformation", this.beanName);
        transformer.transform(xmlReaderSource, outputTarget);
        this.logger.debug("{} - XML Transformation complete", this.beanName);
    } catch (TransformerException e) {
        throw new RuntimeException("Failed to transform document", e);
    }

    final String mediaType = transformer.getOutputProperty(OutputKeys.MEDIA_TYPE);

    final List<XMLEvent> eventBuffer = eventWriterBuffer.getEventBuffer();
    final XMLEventReader outputEventReader = new XMLEventBufferReader(eventBuffer.listIterator());

    final Map<String, String> outputProperties = pipelineEventReader.getOutputProperties();
    final PipelineEventReaderImpl<XMLEventReader, XMLEvent> pipelineEventReaderImpl = new PipelineEventReaderImpl<XMLEventReader, XMLEvent>(
            outputEventReader, outputProperties);
    pipelineEventReaderImpl.setOutputProperty(OutputKeys.MEDIA_TYPE, mediaType);
    return pipelineEventReaderImpl;
}

From source file:org.codehaus.enunciate.modules.docs.DocumentationDeploymentModule.java

protected void doXSLT(URL xsltURL) throws IOException, EnunciateException {
    debug("Using stylesheet %s", xsltURL);
    StreamSource source = new StreamSource(xsltURL.openStream());

    try {/*from   w w w .j a va2s  . co  m*/
        Transformer transformer = SAXTransformerFactory.newInstance().newTransformer(source);
        transformer.setURIResolver(new URIResolver() {
            public Source resolve(String href, String base) throws TransformerException {
                return new StreamSource(new File(getGenerateDir(), href));
            }
        });
        transformer.setParameter("downloads-exists", new File(getGenerateDir(), "downloads.xml").exists());
        debug("Extra downloads exist: %b", transformer.getParameter("downloads-exists"));

        File docsXml = new File(getGenerateDir(), "docs.xml");
        File buildDir = getDocsBuildDir();
        buildDir.mkdirs();
        transformer.setParameter("output-dir", buildDir.getAbsolutePath() + File.separator);
        transformer.setParameter("api-relative-path", getRelativePathToRootDir());
        transformer.setParameter("index-page-name", getIndexPageName());
        transformer.setParameter("disable-rest-mountpoint", isDisableRestMountpoint());
        transformer.setParameter("group-rest-resources", getGroupRestResources());
        File indexPage = new File(buildDir, getIndexPageName());
        debug("Transforming %s to %s.", docsXml, indexPage);
        transformer.transform(new StreamSource(docsXml), new StreamResult(indexPage));
    } catch (TransformerException e) {
        throw new EnunciateException("Error during transformation of the documentation (stylesheet " + xsltURL
                + ", document " + new File(getGenerateDir(), "docs.xml") + ")", e);
    }
}

From source file:org.easysoa.preview.WSDLTransformer.java

public static void generateHtmlView(InputStream xmlStream, OutputStream out) throws Exception {
    TransformerFactory tFactory = TransformerFactory.newInstance();
    Transformer transformer = tFactory.newTransformer(new StreamSource(getXLST()));
    transformer.setErrorListener(new ErrorListener() {

        @Override/*from w w w.  j a va 2s .  com*/
        public void warning(TransformerException exception) throws TransformerException {
            log.warn("Problem during transformation", exception);
        }

        @Override
        public void fatalError(TransformerException exception) throws TransformerException {
            log.error("Fatal error during transformation", exception);
        }

        @Override
        public void error(TransformerException exception) throws TransformerException {
            log.error("Error during transformation", exception);
        }
    });
    transformer.setURIResolver(null);
    transformer.transform(new StreamSource(xmlStream), new StreamResult(out));
}

From source file:org.eclipse.wst.xsl.jaxp.debug.invoker.internal.JAXPSAXProcessorInvoker.java

protected Transformer addStylesheet(Source source, URIResolver resolver, Map parameters,
        Properties outputProperties) throws TransformerConfigurationException {
    if (tFactory == null)
        createTransformerFactory();/*from   w  ww  .  ja  v  a  2  s  . co m*/

    TransformerHandler newTh = tFactory.newTransformerHandler(source);
    Transformer transformer = newTh.getTransformer();

    if (resolver != null)
        transformer.setURIResolver(resolver);

    if (parameters != null) {
        for (Iterator iter = parameters.entrySet().iterator(); iter.hasNext();) {
            Map.Entry entry = (Map.Entry) iter.next();
            String name = (String) entry.getKey();
            Object value = entry.getValue();
            log.info(Messages.getString("JAXPSAXProcessorInvoker.2") + name //$NON-NLS-1$
                    + Messages.getString("JAXPSAXProcessorInvoker.3") + value); //$NON-NLS-1$
            transformer.setParameter(name, value);
        }
    }
    if (outputProperties != null) {
        StringBuffer sb = new StringBuffer();
        for (Iterator iter = outputProperties.entrySet().iterator(); iter.hasNext();) {
            Map.Entry entry = (Map.Entry) iter.next();
            sb.append(entry.getKey()).append("=").append(entry.getValue()).append(" "); //$NON-NLS-1$ //$NON-NLS-2$
        }
        if (outputProperties.size() > 0) {
            log.info(Messages.getString("JAXPSAXProcessorInvoker.6") + sb.toString()); //$NON-NLS-1$
            transformer.setOutputProperties(outputProperties);
        }
    }

    if (th != null)
        th.setResult(new SAXResult(newTh));
    else {
        reader.setContentHandler(newTh);
        try {
            reader.setProperty("http://xml.org/sax/properties/lexical-handler", newTh); //$NON-NLS-1$
        } catch (SAXNotRecognizedException ex) {
            log.warn(Messages.getString("JAXPSAXProcessorInvoker_4")); //$NON-NLS-1$
        } catch (SAXNotSupportedException e) {
            log.warn(Messages.getString("JAXPSAXProcessorInvoker_5")); //$NON-NLS-1$
        }
    }
    th = newTh;
    return th.getTransformer();
}