Examples with ErrorHandler org.xml.sax.ErrorHandler used on opensource projects

Example 26 with ErrorHandler

use of org.xml.sax.ErrorHandler in project cobar by alibaba.

the class ConfigUtil method getDocument.

public static Document getDocument(final InputStream dtd, InputStream xml) throws ParserConfigurationException, SAXException, IOException {
    DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
    factory.setValidating(true);
    factory.setNamespaceAware(false);
    DocumentBuilder builder = factory.newDocumentBuilder();
    builder.setEntityResolver(new EntityResolver() {

        @Override
        public InputSource resolveEntity(String publicId, String systemId) {
            return new InputSource(dtd);
        }
    });
    builder.setErrorHandler(new ErrorHandler() {

        @Override
        public void warning(SAXParseException e) {
        }

        @Override
        public void error(SAXParseException e) throws SAXException {
            throw e;
        }

        @Override
        public void fatalError(SAXParseException e) throws SAXException {
            throw e;
        }
    });
    return builder.parse(xml);
}

Example 27 with ErrorHandler

use of org.xml.sax.ErrorHandler in project liquibase by liquibase.

the class XMLChangeLogSAXParser method parseToNode.

@Override
protected ParsedNode parseToNode(String physicalChangeLogLocation, ChangeLogParameters changeLogParameters, ResourceAccessor resourceAccessor) throws ChangeLogParseException {
    InputStream inputStream = null;
    try {
        SAXParser parser = saxParserFactory.newSAXParser();
        try {
            parser.setProperty("http://java.sun.com/xml/jaxp/properties/schemaLanguage", "http://www.w3.org/2001/XMLSchema");
        } catch (SAXNotRecognizedException e) {
        //ok, parser must not support it
        } catch (SAXNotSupportedException e) {
        //ok, parser must not support it
        }
        XMLReader xmlReader = parser.getXMLReader();
        LiquibaseEntityResolver resolver = new LiquibaseEntityResolver(this);
        resolver.useResoureAccessor(resourceAccessor, FilenameUtils.getFullPath(physicalChangeLogLocation));
        xmlReader.setEntityResolver(resolver);
        xmlReader.setErrorHandler(new ErrorHandler() {

            @Override
            public void warning(SAXParseException exception) throws SAXException {
                LogFactory.getLogger().warning(exception.getMessage());
                throw exception;
            }

            @Override
            public void error(SAXParseException exception) throws SAXException {
                LogFactory.getLogger().severe(exception.getMessage());
                throw exception;
            }

            @Override
            public void fatalError(SAXParseException exception) throws SAXException {
                LogFactory.getLogger().severe(exception.getMessage());
                throw exception;
            }
        });
        inputStream = StreamUtil.singleInputStream(physicalChangeLogLocation, resourceAccessor);
        if (inputStream == null) {
            if (physicalChangeLogLocation.startsWith("WEB-INF/classes/")) {
                physicalChangeLogLocation = physicalChangeLogLocation.replaceFirst("WEB-INF/classes/", "");
                inputStream = StreamUtil.singleInputStream(physicalChangeLogLocation, resourceAccessor);
            }
            if (inputStream == null) {
                throw new ChangeLogParseException(physicalChangeLogLocation + " does not exist");
            }
        }
        XMLChangeLogSAXHandler contentHandler = new XMLChangeLogSAXHandler(physicalChangeLogLocation, resourceAccessor, changeLogParameters);
        xmlReader.setContentHandler(contentHandler);
        xmlReader.parse(new InputSource(new UtfBomStripperInputStream(inputStream)));
        return contentHandler.getDatabaseChangeLogTree();
    } catch (ChangeLogParseException e) {
        throw e;
    } catch (IOException e) {
        throw new ChangeLogParseException("Error Reading Migration File: " + e.getMessage(), e);
    } catch (SAXParseException e) {
        throw new ChangeLogParseException("Error parsing line " + e.getLineNumber() + " column " + e.getColumnNumber() + " of " + physicalChangeLogLocation + ": " + e.getMessage(), e);
    } catch (SAXException e) {
        Throwable parentCause = e.getException();
        while (parentCause != null) {
            if (parentCause instanceof ChangeLogParseException) {
                throw ((ChangeLogParseException) parentCause);
            }
            parentCause = parentCause.getCause();
        }
        String reason = e.getMessage();
        String causeReason = null;
        if (e.getCause() != null) {
            causeReason = e.getCause().getMessage();
        }
        //            }
        if (reason == null) {
            if (causeReason != null) {
                reason = causeReason;
            } else {
                reason = "Unknown Reason";
            }
        }
        throw new ChangeLogParseException("Invalid Migration File: " + reason, e);
    } catch (Exception e) {
        throw new ChangeLogParseException(e);
    } finally {
        if (inputStream != null) {
            try {
                inputStream.close();
            } catch (IOException e) {
            // probably ok
            }
        }
    }
}

Example 28 with ErrorHandler

use of org.xml.sax.ErrorHandler in project mybatis-3 by mybatis.

the class XPathParser method createDocument.

private Document createDocument(InputSource inputSource) {
    // important: this must only be called AFTER common constructor
    try {
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        factory.setValidating(validation);
        factory.setNamespaceAware(false);
        factory.setIgnoringComments(true);
        factory.setIgnoringElementContentWhitespace(false);
        factory.setCoalescing(false);
        factory.setExpandEntityReferences(true);
        DocumentBuilder builder = factory.newDocumentBuilder();
        builder.setEntityResolver(entityResolver);
        builder.setErrorHandler(new ErrorHandler() {

            @Override
            public void error(SAXParseException exception) throws SAXException {
                throw exception;
            }

            @Override
            public void fatalError(SAXParseException exception) throws SAXException {
                throw exception;
            }

            @Override
            public void warning(SAXParseException exception) throws SAXException {
            }
        });
        return builder.parse(inputSource);
    } catch (Exception e) {
        throw new BuilderException("Error creating document instance.  Cause: " + e, e);
    }
}

Example 29 with ErrorHandler

use of org.xml.sax.ErrorHandler in project nokogiri by sparklemotion.

the class XmlSchema method validate_document_or_file.

IRubyObject validate_document_or_file(ThreadContext context, XmlDocument xmlDocument) {
    RubyArray errors = (RubyArray) this.getInstanceVariable("@errors");
    ErrorHandler errorHandler = new SchemaErrorHandler(context.runtime, errors);
    setErrorHandler(errorHandler);
    try {
        validate(xmlDocument.getDocument());
    } catch (SAXException ex) {
        XmlSyntaxError xmlSyntaxError = XmlSyntaxError.createXMLSyntaxError(context.runtime);
        xmlSyntaxError.setException(ex);
        errors.append(xmlSyntaxError);
    } catch (IOException ex) {
        throw context.runtime.newIOError(ex.getMessage());
    }
    return errors;
}

Example 30 with ErrorHandler

use of org.xml.sax.ErrorHandler in project spring-framework by spring-projects.

the class PersistenceUnitReader method readPersistenceUnitInfos.

/**
	 * Parse and build all persistence unit infos defined in the given XML files.
	 * @param persistenceXmlLocations the resource locations (can be patterns)
	 * @return the resulting PersistenceUnitInfo instances
	 */
public SpringPersistenceUnitInfo[] readPersistenceUnitInfos(String[] persistenceXmlLocations) {
    ErrorHandler handler = new SimpleSaxErrorHandler(logger);
    List<SpringPersistenceUnitInfo> infos = new LinkedList<>();
    String resourceLocation = null;
    try {
        for (String location : persistenceXmlLocations) {
            Resource[] resources = this.resourcePatternResolver.getResources(location);
            for (Resource resource : resources) {
                resourceLocation = resource.toString();
                InputStream stream = resource.getInputStream();
                try {
                    Document document = buildDocument(handler, stream);
                    parseDocument(resource, document, infos);
                } finally {
                    stream.close();
                }
            }
        }
    } catch (IOException ex) {
        throw new IllegalArgumentException("Cannot parse persistence unit from " + resourceLocation, ex);
    } catch (SAXException ex) {
        throw new IllegalArgumentException("Invalid XML in persistence unit from " + resourceLocation, ex);
    } catch (ParserConfigurationException ex) {
        throw new IllegalArgumentException("Internal error parsing persistence unit from " + resourceLocation);
    }
    return infos.toArray(new SpringPersistenceUnitInfo[infos.size()]);
}