Example usage for org.xml.sax XMLReader setEntityResolver

List of usage examples for org.xml.sax XMLReader setEntityResolver

Introduction

In this page you can find the example usage for org.xml.sax XMLReader setEntityResolver.

Prototype

public void setEntityResolver(EntityResolver resolver);

Source Link

Document

Allow an application to register an entity resolver.

Usage

From source file:se.kb.oai.pmh.OaiPmhServer.java

private void setupReader() {
    this.reader.setValidation(false);
    this.reader.setIncludeExternalDTDDeclarations(false);
    this.reader.setEntityResolver(EntityToEmptyResolver.INSTANCE);

    try {/*  w  w  w  . j  a  v a2  s  .  c o  m*/
        XMLReader xmlReader = this.reader.getXMLReader();
        xmlReader.setEntityResolver(EntityToEmptyResolver.INSTANCE);
    } catch (SAXException e) {
        LOGGER.warn("Can't set entity resolver of XML reader - default entity resolver might be slow!", e);
    }
}

From source file:com.wooki.services.parsers.XHTMLToFormattingObjects.java

public InputStream performTransformation(Resource xmlDocument) {
    ByteArrayOutputStream baos = new ByteArrayOutputStream();

    StreamResult toReturn = new StreamResult(baos);

    // Use the TransformerFactory to instantiate a Transformer that will
    // work with the stylesheet you specify. This method call also processes
    // the stylesheet into
    // a compiled Templates object.

    try {//from  ww  w .  java  2 s  . c om
        URL url = this.xslStylesheet.getURL();
        Element processedStylesheet = cache.get(url);
        if (processedStylesheet == null) {

            if (url.getProtocol().equals("http")) {
                GetMethod method = new GetMethod(url.toString());
                this.httpClient.executeMethod(method);
                byte[] body = method.getResponseBody();
                StreamSource input = new StreamSource(new ByteArrayInputStream(body));
                input.setSystemId(url.toString());
                tFactory.setURIResolver(this);
                transformer = tFactory.newTransformer(input);
                transformer.setURIResolver(this);
                processedStylesheet = new Element(this.xslStylesheet.getURL(), transformer);
            } else {
                StreamSource input = new StreamSource(this.xslStylesheet.getInputStream());
                input.setSystemId(this.xslStylesheet.getFile());
                transformer = tFactory.newTransformer(input);
                transformer.setURIResolver(this);
                processedStylesheet = new Element(this.xslStylesheet.getURL(), transformer);
            }
            cache.put(processedStylesheet);
        } else {
            transformer = (Transformer) processedStylesheet.getObjectValue();
        }
        XMLReader reader = XMLReaderFactory.createXMLReader();
        reader.setEntityResolver(this);

        // transformer.
        // Use the Transformer to apply the associated Templates object to
        // an
        // XML document (foo.xml) and write the output to a file.
        transformer.transform(new SAXSource(reader, new InputSource(xmlDocument.getInputStream())), toReturn);
        String result = new String(baos.toByteArray());
        return new ByteArrayInputStream(baos.toByteArray());
    } catch (TransformerConfigurationException e) {
        e.printStackTrace();
        logger.error(e.getLocalizedMessage());
        return null;
    } catch (IOException e) {
        e.printStackTrace();
        logger.error(e.getLocalizedMessage());
        return null;
    } catch (TransformerException e) {
        e.printStackTrace();
        logger.error(e.getLocalizedMessage());
        return null;
    } catch (SAXException e) {
        e.printStackTrace();
        logger.error(e.getLocalizedMessage());
        return null;
    } catch (Error e) {
        e.printStackTrace();
        logger.error(e.getLocalizedMessage());
    }
    return new ByteArrayInputStream(baos.toByteArray());
}

From source file:groovyx.net.http.ParserRegistry.java

/**
 * Parse an HTML document by passing it through the NekoHTML parser.
 * @see ContentType#HTML/*from   w  w w.  ja va 2s . c  o m*/
 * @see org.cyberneko.html.parsers.SAXParser
 * @see XmlSlurper#parse(Reader)
 * @param resp HTTP response from which to parse content
 * @return the {@link GPathResult} from calling {@link XmlSlurper#parse(Reader)}
 * @throws IOException
 * @throws SAXException
 */
public GPathResult parseHTML(HttpResponse resp) throws IOException, SAXException {
    XMLReader p = new org.cyberneko.html.parsers.SAXParser();
    p.setEntityResolver(catalogResolver);
    return new XmlSlurper(p).parse(parseText(resp));
}

From source file:com.adobe.aem.importer.impl.DocImporterImpl.java

public void doImport(String importRootPath) {
    try {//from w w w.j a  v a 2  s .  co m
        if (!initImport(importRootPath)) {
            log.info("initImport failed!");
            return;
        }

        Node xsltNode = this.session.getNode(xsltFilePath);
        log.info("xsltNode: " + xsltNode);

        XMLReader xmlReader = XMLReaderFactory.createXMLReader();
        log.info("xmlReader: " + xmlReader);

        xmlReader.setEntityResolver(new RejectingEntityResolver());

        URIResolver uriResolver = new DocImporterURIResolver(xsltNode, this.sourceFolderNode, xmlReader);
        log.info("uriResolver: " + uriResolver);

        TransformerFactoryImpl transformerFactoryImpl = new TransformerFactoryImpl();
        log.info("transformerFactoryImpl: " + transformerFactoryImpl);

        transformerFactoryImpl.setURIResolver(uriResolver);

        Transformer transformer = transformerFactoryImpl
                .newTransformer(new StreamSource(JcrUtils.readFile(xsltNode)));

        TransformerImpl transformerImpl = (TransformerImpl) transformer;
        transformerImpl.getUnderlyingController()
                .setUnparsedTextURIResolver(new DocImporterUnparsedTextURIResolver(this.sourceFolderNode));
        log.info("transformer: " + transformer);

        for (Entry<Object, Object> entry : properties.entrySet()) {
            transformer.setParameter(entry.getKey().toString(), entry.getValue());
            log.info("transformer.setParameter: " + entry.getKey().toString() + " = " + entry.getValue());
        }
        transformer.setParameter("xsltFilePath", this.xsltFilePath);
        log.info("transformer.setParameter: xsltFilePath = " + this.xsltFilePath);

        ByteArrayOutputStream output = new ByteArrayOutputStream();
        transformer
                .transform(
                        new SAXSource(xmlReader,
                                new InputSource(
                                        JcrUtils.readFile(this.sourceFolderNode.getNode(masterFileName)))),
                        new StreamResult(output));
        InputStream result = new ByteArrayInputStream(output.toByteArray());
        log.info("result: " + result);

        if (this.session.itemExists(DocImporter.CONTENT_PACKAGE_PATH)) {
            this.session.removeItem(DocImporter.CONTENT_PACKAGE_PATH);
            this.session.save();
            log.info("old package removed");
        }
        Node contentPackageNode = JcrUtils.getOrCreateByPath(DocImporter.CONTENT_PACKAGE_PATH, "nt:folder",
                "nt:folder", this.session, true);
        this.session.getWorkspace().copy(DocImporter.CONTENT_PACKAGE_TEMPLATE_PATH + "/META-INF",
                contentPackageNode.getPath() + "/META-INF");
        log.info("new package created");

        Node vaultNode = contentPackageNode.getNode("META-INF/vault");
        Node contentXMLNode = JcrUtil.createPath(contentPackageNode.getPath() + "/jcr_root" + targetPath,
                "nt:folder", "nt:folder", this.session, true);
        JcrUtils.putFile(contentXMLNode, ".content.xml", "application/xml", result);
        log.info("content.xml written");

        if (this.graphicsFolderName != null && this.sourceFolderNode.hasNode(this.graphicsFolderName)) {
            JcrUtil.copy(this.sourceFolderNode.getNode(graphicsFolderName), contentXMLNode,
                    this.graphicsFolderName);
        }
        JcrUtils.putFile(vaultNode, "filter.xml", "application/xml",
                FilterXmlBuilder.fromRoot(this.targetPath + "/").toStream(this.graphicsFolderName));
        log.info("filter.xml written");

        JcrArchive archive = new JcrArchive(contentPackageNode, "/");
        archive.open(true);
        Importer importer = new Importer();
        importer.getOptions().setImportMode(ImportMode.MERGE);
        importer.getOptions().setAccessControlHandling(AccessControlHandling.MERGE);
        importer.run(archive, contentPackageNode.getSession().getNode("/"));
        log.info("content.xml imported");

        //contentPackageNode.remove();
        this.session.save();
        log.info("session saved.");

    } catch (RepositoryException e) {
        log.error(e.toString());
    } catch (TransformerException e) {
        log.error(e.toString());
    } catch (SAXException e) {
        log.error(e.toString());
    } catch (IOException e) {
        log.error(e.toString());
    } catch (ConfigurationException e) {
        log.error(e.toString());
    }
}

From source file:net.sourceforge.fenixedu.utilTests.ParseMetadata.java

public Vector<Element> parseMetadata(String metadataFile) throws ParseException {
    SAXParserFactory spf = SAXParserFactory.newInstance();
    spf.setValidating(true);//from w ww.  ja v  a  2s  . c o  m
    try {
        SAXParser saxParser = spf.newSAXParser();
        XMLReader reader = saxParser.getXMLReader();
        reader.setContentHandler(this);
        reader.setErrorHandler(this);
        StringReader sr = new StringReader(metadataFile);
        InputSource input = new InputSource(sr);
        MetadataResolver resolver = new MetadataResolver();
        reader.setEntityResolver(resolver);
        reader.parse(input);
    } catch (Exception e) {
        throw new ParseException();
    }

    setMembers(vector);
    return vector;
}

From source file:demo.SourceHttpMessageConverter.java

private SAXSource readSAXSource(InputStream body) throws IOException {
    try {//from  w ww .j a  v  a  2  s. c o m
        XMLReader reader = XMLReaderFactory.createXMLReader();
        reader.setFeature("http://apache.org/xml/features/disallow-doctype-decl", !isSupportDtd());
        reader.setFeature("http://xml.org/sax/features/external-general-entities", isProcessExternalEntities());
        if (!isProcessExternalEntities()) {
            reader.setEntityResolver(NO_OP_ENTITY_RESOLVER);
        }
        byte[] bytes = StreamUtils.copyToByteArray(body);
        return new SAXSource(reader, new InputSource(new ByteArrayInputStream(bytes)));
    } catch (SAXException ex) {
        throw new HttpMessageNotReadableException("Could not parse document: " + ex.getMessage(), ex);
    }
}

From source file:architecture.common.util.L10NUtils.java

private void loadProps(String resource, boolean breakOnError) throws IOException {

    HashSet<URL> hashset = new HashSet<URL>();
    if (log.isDebugEnabled()) {
        log.debug((new StringBuilder()).append("Searching ").append(resource).toString());
    }//from  w ww  . j av a2 s. c  om
    Enumeration<URL> urls = Thread.currentThread().getContextClassLoader().getResources(resource);
    if (urls != null) {
        URL url;
        for (; urls.hasMoreElements(); hashset.add(url)) {
            url = urls.nextElement();
            if (log.isDebugEnabled())
                log.debug((new StringBuilder()).append("Adding ").append(url).toString());
        }
    }

    for (URL url : hashset) {
        if (log.isDebugEnabled())
            log.debug((new StringBuilder()).append("Loading from ").append(url).toString());
        InputStream is = null;
        try {
            is = url.openStream();
            InputSource input = new InputSource(is);
            SAXParserFactory factory = SAXParserFactory.newInstance();
            factory.setNamespaceAware(true);
            XMLReader xmlreader = factory.newSAXParser().getXMLReader();
            I18nParsingHandler handler = new I18nParsingHandler();
            xmlreader.setContentHandler(handler);
            xmlreader.setDTDHandler(handler);
            xmlreader.setEntityResolver(handler);
            xmlreader.setErrorHandler(handler);
            xmlreader.parse(input);
            localizers.addAll(handler.localizers);
        } catch (IOException e) {
            if (log.isDebugEnabled())
                log.debug((new StringBuilder()).append("Skipping ").append(url).toString());
            if (breakOnError)
                throw e;
        } catch (Exception e) {
            log.error(e);
        } finally {
            if (is != null)
                IOUtils.closeQuietly(is);
        }
    }

}

From source file:eionet.gdem.validation.ValidationService.java

/**
/**/*from  w w  w  .  j av a  2s.  c o  m*/
 * Validate XML. If schema is null, then read the schema or DTD from the header of XML. If schema or DTD is defined, then ignore
 * the defined schema or DTD.
 *
 * @param srcStream XML file as InputStream to be validated.
 * @param schema XML Schema URL.
 * @return Validation result as HTML snippet.
 * @throws DCMException in case of unknnown system error.
 */
public String validateSchema(InputStream srcStream, String schema) throws DCMException {

    String result = "";
    boolean isDTD = false;
    boolean isBlocker = false;

    if (Utils.isNullStr(schema)) {
        schema = null;
    }

    try {

        SAXParserFactory spfact = SAXParserFactory.newInstance();
        SAXParser parser = spfact.newSAXParser();
        XMLReader reader = parser.getXMLReader();

        reader.setErrorHandler(errHandler);
        XmlconvCatalogResolver catalogResolver = new XmlconvCatalogResolver();
        reader.setEntityResolver(catalogResolver);

        // make parser to validate
        reader.setFeature("http://xml.org/sax/features/validation", true);
        reader.setFeature("http://apache.org/xml/features/validation/schema", true);
        reader.setFeature("http://apache.org/xml/features/validation/schema-full-checking", true);

        reader.setFeature("http://xml.org/sax/features/namespaces", true);
        reader.setFeature("http://xml.org/sax/features/namespace-prefixes", true);
        reader.setFeature("http://apache.org/xml/features/continue-after-fatal-error", false);

        InputAnalyser inputAnalyser = new InputAnalyser();
        inputAnalyser.parseXML(uriXml);
        String namespace = inputAnalyser.getSchemaNamespace();

        // if schema is not in the parameter, then sniff it from the header of xml
        if (schema == null) {
            schema = inputAnalyser.getSchemaOrDTD();
            isDTD = inputAnalyser.isDTD();
        } else {
            // if the given schema ends with dtd, then don't do schema validation
            isDTD = schema.endsWith("dtd");
        }

        // schema is already given as a parameter. Read the default namespace from XML file and set external schema.
        if (schema != null) {
            if (!isDTD) {
                if (Utils.isNullStr(namespace)) {
                    // XML file does not have default namespace
                    setNoNamespaceSchemaProperty(reader, schema);
                } else {
                    setNamespaceSchemaProperty(reader, namespace, schema);
                }
            } else {
                // validate against DTD
                setLocalSchemaUrl(schema);
                LocalEntityResolver localResolver = new LocalEntityResolver(schema, getValidatedSchema());
                reader.setEntityResolver(localResolver);
            }
        } else {
            return validationFeedback.formatFeedbackText(
                    "Could not validate XML file. Unable to locate XML Schema reference.",
                    QAFeedbackType.WARNING, isBlocker);
        }
        // if schema is not available, then do not parse the XML and throw error
        if (!Utils.resourceExists(getValidatedSchema())) {
            return validationFeedback.formatFeedbackText(
                    "Failed to read schema document from the following URL: " + getValidatedSchema(),
                    QAFeedbackType.ERROR, isBlocker);
        }
        Schema schemaObj = schemaManager.getSchema(getOriginalSchema());
        if (schemaObj != null) {
            isBlocker = schemaObj.isBlocker();
        }
        validationFeedback.setSchema(getOriginalSchema());
        InputSource is = new InputSource(srcStream);
        reader.parse(is);

    } catch (SAXParseException se) {
        return validationFeedback.formatFeedbackText("Document is not well-formed. Column: "
                + se.getColumnNumber() + "; line:" + se.getLineNumber() + "; " + se.getMessage(),
                QAFeedbackType.ERROR, isBlocker);
    } catch (IOException ioe) {
        return validationFeedback.formatFeedbackText(
                "Due to an IOException, the parser could not check the document. " + ioe.getMessage(),
                QAFeedbackType.ERROR, isBlocker);
    } catch (Exception e) {
        Exception se = e;
        if (e instanceof SAXException) {
            se = ((SAXException) e).getException();
        }
        if (se != null) {
            se.printStackTrace(System.err);
        } else {
            e.printStackTrace(System.err);
        }
        return validationFeedback.formatFeedbackText(
                "The parser could not check the document. " + e.getMessage(), QAFeedbackType.ERROR, isBlocker);
    }

    validationFeedback.setValidationErrors(getErrorList());
    result = validationFeedback.formatFeedbackText(isBlocker);

    // validation post-processor
    QAResultPostProcessor postProcessor = new QAResultPostProcessor();
    result = postProcessor.processQAResult(result, schema);
    warningMessage = postProcessor.getWarningMessage(schema);

    return result;
}

From source file:net.lightbody.bmp.proxy.jetty.xml.XmlParser.java

/**
 * Parse InputStream./*from   www  .  j a v a  2  s .c  om*/
 */
public synchronized Node parse(InputStream in) throws IOException, SAXException {
    Handler handler = new Handler();
    XMLReader reader = _parser.getXMLReader();
    reader.setContentHandler(handler);
    reader.setErrorHandler(handler);
    reader.setEntityResolver(handler);
    _parser.parse(new InputSource(in), handler);
    if (handler._error != null)
        throw handler._error;
    Node doc = (Node) handler._top.get(0);
    handler.clear();
    return doc;
}