java类javax.xml.parsers.SAXParser的实例源码

@Override
protected Void call() throws Exception {
    Platform.runLater(this.observableList::clear);
    SAXParserFactory saxParserFactory = SAXParserFactory.newInstance();
    SAXParser saxParser = saxParserFactory.newSAXParser();
    try (ZipFile zipFile = new ZipFile(this.selectedFile)) {
        int workMax = zipFile.size();
        long workDone = 0;
        for (Enumeration<? extends ZipEntry> e = zipFile.entries(); e.hasMoreElements();) {
            ZipEntry zipEntry = e.nextElement();
            int position = zipEntry.getName().charAt(zipEntry.getName().length() - 7) - '0';
            SyantenAnalyzer analyzer = new SyantenAnalyzer(position);
            ParseHandler parseHandler = new ParseHandler(analyzer);
            try (InputStream is = zipFile.getInputStream(zipEntry);
                GZIPInputStream gzis = new GZIPInputStream(is)) {
                saxParser.parse(gzis, parseHandler);
            }
            ArrayList<MahjongScene> scenes = analyzer.getOriScenes();
            workDone++;
            Platform.runLater(() -> observableList.addAll(scenes));
            updateMessage(workDone + "/" + workMax);
            updateProgress(workDone, workMax);
        }
    }
    return null;
}

/**
 * Creates the image for the given display XML input source. (Note: The XML is an encoded
 * mxGraphView, not mxGraphModel.)
 * 
 * @param inputSource Input source that contains the display XML.
 * @return Returns an image representing the display XML input source.
 */
public static BufferedImage convert(InputSource inputSource, mxGraphViewImageReader viewReader)
    throws ParserConfigurationException, SAXException, IOException {
  BufferedImage result = null;
  SAXParser parser = SAXParserFactory.newInstance().newSAXParser();
  XMLReader reader = parser.getXMLReader();

  reader.setContentHandler(viewReader);
  reader.parse(inputSource);

  if (viewReader.getCanvas() instanceof mxImageCanvas) {
    result = ((mxImageCanvas) viewReader.getCanvas()).destroy();
  }

  return result;
}

/**
 * Loads completions from an XML input stream.  The XML should validate
 * against <code>CompletionXml.dtd</code>.
 *
 * @param in The input stream to read from.
 * @param cl The class loader to use when loading any extra classes defined
 *        in the XML, such as custom {@link FunctionCompletion}s.  This
 *        may be <code>null</code> if the default is to be used, or if no
 *        custom completions are defined in the XML.
 * @throws IOException If an IO error occurs.
 */
public void loadFromXML(InputStream in, ClassLoader cl) throws IOException {

    //long start = System.currentTimeMillis();

    SAXParserFactory factory = SAXParserFactory.newInstance();
    factory.setValidating(true);
    CompletionXMLParser handler = new CompletionXMLParser(this, cl);
    BufferedInputStream bin = new BufferedInputStream(in);
    try {
        SAXParser saxParser = factory.newSAXParser();
        saxParser.parse(bin, handler);
        List<Completion> completions =  handler.getCompletions();
        addCompletions(completions);
        char startChar = handler.getParamStartChar();
        if (startChar!=0) {
            char endChar = handler.getParamEndChar();
            String sep = handler.getParamSeparator();
            if (endChar!=0 && sep!=null && sep.length()>0) { // Sanity
                setParameterizedCompletionParams(startChar, sep, endChar);
            }
        }
    } catch (SAXException se) {
        throw new IOException(se.toString());
    } catch (ParserConfigurationException pce) {
        throw new IOException(pce.toString());
    } finally {
        //long time = System.currentTimeMillis() - start;
        //System.out.println("XML loaded in: " + time + "ms");
        bin.close();
    }

}

/**
 * Return the SAXParser we will use to parse the input stream.  If there
 * is a problem creating the parser, return <code>null</code>.
 */
public SAXParser getParser() {

    // Return the parser we already created (if any)
    if (parser != null) {
        return (parser);
    }

    // Create a new parser
    try {
        parser = getFactory().newSAXParser();
    } catch (Exception e) {
        log.error("Digester.getParser: ", e);
        return (null);
    }

    return (parser);

}

/**
 * Test an identity transform of an XML document with NS decls using a
 * non-ns-aware parser. Output result to a StreamSource. Set ns-awareness to
 * FALSE and prefixes to TRUE.
 */
@Test
public void testXMLNoNsAwareStreamResult2() {
    try {
        // Create SAX parser *without* enabling ns
        SAXParserFactory spf = SAXParserFactory.newInstance();
        spf.setNamespaceAware(false); // Same as default
        spf.setFeature("http://xml.org/sax/features/namespace-prefixes", true);
        SAXParser sp = spf.newSAXParser();

        // Make sure that the output is well formed
        String xml = runTransform(sp);
        checkWellFormedness(xml);
    } catch (Throwable ex) {
        Assert.fail(ex.toString());
    }
}

/**
 * Parses input stream as an RSS 2.0 feed.
 *
 * @return in-memory representation of an RSS feed
 * @throws IllegalArgumentException if either argument is {@code null}
 */
private RSSFeed parse(SAXParser parser, InputStream feed)
        throws SAXException, IOException {
    if (parser == null) {
        throw new IllegalArgumentException("RSS parser must not be null.");
    } else if (feed == null) {
        throw new IllegalArgumentException("RSS feed must not be null.");
    }

    // SAX automatically detects the correct character encoding from the stream
    // See also http://www.w3.org/TR/REC-xml/#sec-guessing
    final InputSource source = new InputSource(feed);
    final XMLReader xmlreader = parser.getXMLReader();
    final RSSHandler handler = new RSSHandler(config);

    xmlreader.setContentHandler(handler);
    xmlreader.parse(source);

    return handler.feed();
}

@Test
public void testSAX() {
    try {
        Schema schema = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI).newSchema(new StreamSource(_xsd));
        SAXParserFactory spf = SAXParserFactory.newInstance();
        spf.setNamespaceAware(true);
        spf.setValidating(true);
        spf.setSchema(schema);
        SAXParser parser = spf.newSAXParser();
        MyErrorHandler errorHandler = new MyErrorHandler();
        parser.parse(_xml, errorHandler);
        if (!errorHandler.errorOccured) {
            Assert.fail("should report error");
        }
    } catch (Exception e) {
        System.out.println(e.getMessage());
    }
}

public void parse(InputStream xml, OutputStream finf, String workingDirectory) throws Exception {
    StAXDocumentSerializer documentSerializer = new StAXDocumentSerializer();
    documentSerializer.setOutputStream(finf);

    SAX2StAXWriter saxTostax = new SAX2StAXWriter(documentSerializer);

    SAXParserFactory saxParserFactory = SAXParserFactory.newInstance();
    saxParserFactory.setNamespaceAware(true);
    SAXParser saxParser = saxParserFactory.newSAXParser();

    XMLReader reader = saxParser.getXMLReader();
    reader.setProperty("http://xml.org/sax/properties/lexical-handler", saxTostax);
    reader.setContentHandler(saxTostax);

    if (workingDirectory != null) {
        reader.setEntityResolver(createRelativePathResolver(workingDirectory));
    }
    reader.parse(new InputSource(xml));

    xml.close();
    finf.close();
}

/**
 * Reads a {@link PieDataset} from a stream.
 *
 * @param in  the input stream.
 *
 * @return A dataset.
 *
 * @throws IOException if there is an I/O error.
 */
public static PieDataset readPieDatasetFromXML(final InputStream in) throws IOException {

    PieDataset result = null;

    final SAXParserFactory factory = SAXParserFactory.newInstance();
    try {
        final SAXParser parser = factory.newSAXParser();
        final PieDatasetHandler handler = new PieDatasetHandler();
        parser.parse(in, handler);
        result = handler.getDataset();
    }
    catch (SAXException e) {
        System.out.println(e.getMessage());
    }
    catch (ParserConfigurationException e2) {
        System.out.println(e2.getMessage());
    }

    return result;

}

/**
 * Reads a {@link PieDataset} from a stream.
 *
 * @param in  the input stream.
 *
 * @return A dataset.
 *
 * @throws IOException if there is an I/O error.
 */
public static PieDataset readPieDatasetFromXML(InputStream in) 
    throws IOException {

    PieDataset result = null;
    SAXParserFactory factory = SAXParserFactory.newInstance();
    try {
        SAXParser parser = factory.newSAXParser();
        PieDatasetHandler handler = new PieDatasetHandler();
        parser.parse(in, handler);
        result = handler.getDataset();
    }
    catch (SAXException e) {
        System.out.println(e.getMessage());
    }
    catch (ParserConfigurationException e2) {
        System.out.println(e2.getMessage());
    }
    return result;

}