Java 类javax.xml.transform.sax.TransformerHandler 实例源码

项目：stroom-stats 文件：XMLUtil.java

public static TransformerHandler createTransformerHandler(final ErrorListener errorListener,
                                                          final boolean indentOutput) throws TransformerConfigurationException {
    final SAXTransformerFactory stf = (SAXTransformerFactory) TransformerFactoryFactory.newInstance();
    if (errorListener != null) {
        stf.setErrorListener(errorListener);
    }

    final TransformerHandler th = stf.newTransformerHandler();
    final Transformer transformer = th.getTransformer();
    setCommonOutputProperties(transformer, indentOutput);

    if (errorListener != null) {
        transformer.setErrorListener(errorListener);
    }

    return th;
}

项目：stroom-stats 文件：XMLMarshallerUtil.java

public static <T> String marshal(final JAXBContext context, final T obj, final XmlAdapter<?, ?>... adapters) {
    if (obj == null) {
        return null;
    }

    try {
        final ByteArrayOutputStream out = new ByteArrayOutputStream();
        final Marshaller marshaller = context.createMarshaller();

        if (adapters != null) {
            for (final XmlAdapter<?, ?> adapter : adapters) {
                marshaller.setAdapter(adapter);
            }
        }

        final TransformerHandler transformerHandler = XMLUtil.createTransformerHandler(true);
        transformerHandler.setResult(new StreamResult(out));
        marshaller.marshal(obj, transformerHandler);

        return out.toString(String.valueOf(StandardCharsets.UTF_8));
    } catch (final Throwable t) {
        throw new RuntimeException(t.getMessage(), t);
    }
}

项目：fluentxml4j 文件：SerializerConfigurerAdapter.java

@Override
public TransformerHandler getSerializer()
{
    try
    {
        SAXTransformerFactory transformerFactory = buildTransformerFactory();
        configure(transformerFactory);
        TransformerHandler transformer = buildTransformer(transformerFactory);
        configure(transformer.getTransformer());
        return transformer;
    }
    catch (TransformerConfigurationException ex)
    {
        throw new FluentXmlConfigurationException(ex);
    }
}

项目：fluentxml4j 文件：TransformationChain.java

private Result buildSingleTransformerPipeline(Result result)
{
    try
    {
        SAXTransformerFactory saxTransformerFactory = (SAXTransformerFactory) SAXTransformerFactory.newInstance();
        TransformerHandler transformerHandler = saxTransformerFactory.newTransformerHandler();
        if (result != null)
        {
            transformerHandler.setResult(result);
        }
        return new SAXResult(transformerHandler);
    }
    catch (TransformerConfigurationException ex)
    {
        throw new FluentXmlConfigurationException(ex);
    }
}

项目：fluentxml4j 文件：AbstractSAXFilter.java

private SAXResult toSAXResult(Result result)
{
    if (result instanceof SAXResult)
    {
        return (SAXResult) result;
    }

    try
    {
        SAXTransformerFactory transformerFactory = (SAXTransformerFactory) SAXTransformerFactory.newInstance();
        TransformerHandler transformerHandler = transformerFactory.newTransformerHandler();
        transformerHandler.setResult(result);
        return new SAXResult(transformerHandler);
    }
    catch (TransformerConfigurationException ex)
    {
        throw new FluentXmlConfigurationException(ex);
    }
}

项目：OpenJSharp 文件：XmlUtil.java

/**
 * Performs identity transformation.
 */
public static <T extends Result>
T identityTransform(Source src, T result) throws TransformerException, SAXException, ParserConfigurationException, IOException {
    if (src instanceof StreamSource) {
        // work around a bug in JAXP in JDK6u4 and earlier where the namespace processing
        // is not turned on by default
        StreamSource ssrc = (StreamSource) src;
        TransformerHandler th = ((SAXTransformerFactory) transformerFactory.get()).newTransformerHandler();
        th.setResult(result);
        XMLReader reader = saxParserFactory.get().newSAXParser().getXMLReader();
        reader.setContentHandler(th);
        reader.setProperty(LEXICAL_HANDLER_PROPERTY, th);
        reader.parse(toInputSource(ssrc));
    } else {
        newTransformer().transform(src, result);
    }
    return result;
}

项目：openjdk-jdk10 文件：XmlUtil.java

/**
 * Performs identity transformation.
 * @param <T>
 * @param src
 * @param result
 * @return
 * @throws javax.xml.transform.TransformerException
 * @throws java.io.IOException
 * @throws org.xml.sax.SAXException
 * @throws javax.xml.parsers.ParserConfigurationException
 */
public static <T extends Result> T identityTransform(Source src, T result)
        throws TransformerException, SAXException, ParserConfigurationException, IOException {
    if (src instanceof StreamSource) {
        // work around a bug in JAXP in JDK6u4 and earlier where the namespace processing
        // is not turned on by default
        StreamSource ssrc = (StreamSource) src;
        TransformerHandler th = ((SAXTransformerFactory) transformerFactory.get()).newTransformerHandler();
        th.setResult(result);
        XMLReader reader = saxParserFactory.get().newSAXParser().getXMLReader();
        reader.setContentHandler(th);
        reader.setProperty(LEXICAL_HANDLER_PROPERTY, th);
        reader.parse(toInputSource(ssrc));
    } else {
        newTransformer().transform(src, result);
    }
    return result;
}

项目：openjdk-jdk10 文件：OpenJDK100017Test.java

@Test
public final void testXMLStackOverflowBug() throws TransformerConfigurationException, IOException, SAXException {
    try {
        SAXTransformerFactory stf = (SAXTransformerFactory) TransformerFactory.newInstance();
        TransformerHandler ser = stf.newTransformerHandler();
        ser.setResult(new StreamResult(System.out));

        StringBuilder sb = new StringBuilder(4096);
        for (int x = 4096; x > 0; x--) {
            sb.append((char) x);
        }
        ser.characters(sb.toString().toCharArray(), 0, sb.toString().toCharArray().length);
        ser.endDocument();
    } catch (StackOverflowError se) {
        se.printStackTrace();
        Assert.fail("StackOverflow");
    }
}

项目：openjdk-jdk10 文件：Bug6451633.java

@Test
public void test() throws Exception {
    TransformerHandler th = ((SAXTransformerFactory) TransformerFactory.newInstance()).newTransformerHandler();

    DOMResult result = new DOMResult();
    th.setResult(result);

    th.startDocument();
    th.startElement("", "root", "root", new AttributesImpl());
    th.characters(new char[0], 0, 0);
    th.endElement("", "root", "root");
    th.endDocument();

    // there's no point in having empty text --- we should remove it
    Assert.assertEquals(0, ((Document) result.getNode()).getDocumentElement().getChildNodes().getLength());
}