Example usage for javax.xml.parsers SAXParser getXMLReader

List of usage examples for javax.xml.parsers SAXParser getXMLReader

  1. HOME
  2. Java
  3. javax
  4. javax.xml.parsers.*
  5. SAXParser
  6. getXMLReader

Introduction

In this page you can find the example usage for javax.xml.parsers SAXParser getXMLReader.

Prototype


public abstract org.xml.sax.XMLReader getXMLReader() throws SAXException;

Source Link

Document

Returns the org.xml.sax.XMLReader that is encapsulated by the implementation of this class.

Usage

From source file:org.sonar.plugins.xml.parsers.DetectSchemaParser.java

/**
 * Find the Doctype (DTD or schema)./* ww  w.  j  ava  2 s  . co m*/
 */
public Doctype findDoctype(InputStream input) {
    Handler handler = new Handler();

    try {
        SAXParser parser = newSaxParser();
        XMLReader xmlReader = parser.getXMLReader();
        xmlReader.setFeature(Constants.XERCES_FEATURE_PREFIX + "continue-after-fatal-error", true);
        xmlReader.setProperty("http://xml.org/sax/properties/lexical-handler", handler);
        parser.parse(input, handler);
        return handler.doctype;
    } catch (IOException e) {
        throw new SonarException(e);
    } catch (StopParserException e) {
        return handler.doctype;
    } catch (SAXException e) {
        throw new SonarException(e);
    } finally {
        IOUtils.closeQuietly(input);
    }
}

From source file:org.sonar.plugins.xml.parsers.LineCountParser.java

private void processCommentLines(File file) throws SAXException, IOException {
    SAXParser parser = newSaxParser(false);
    XMLReader xmlReader = parser.getXMLReader();
    commentHandler = new CommentHandler();
    xmlReader.setProperty("http://xml.org/sax/properties/lexical-handler", commentHandler);
    parser.parse(FileUtils.openInputStream(file), commentHandler);
}

From source file:org.wso2.carbon.mediator.datamapper.engine.input.readers.XMLReader.java

@Override
public void read(InputStream input, InputModelBuilder inputModelBuilder, Schema inputSchema)
        throws ReaderException {

    this.modelBuilder = inputModelBuilder;
    this.inputSchema = inputSchema;
    SAXParserFactory factory = SAXParserFactory.newInstance();
    try {/*from w  w  w  .j  a  v a2 s . c o m*/
        SAXParser parser = factory.newSAXParser();
        org.xml.sax.XMLReader xmlReader = parser.getXMLReader();
        xmlReader.setContentHandler(this);
        xmlReader.setDTDHandler(this);
        xmlReader.setEntityResolver(this);
        xmlReader.setFeature(HTTP_XML_ORG_SAX_FEATURES_NAMESPACES, true);
        xmlReader.setFeature(HTTP_XML_ORG_SAX_FEATURES_NAMESPACE_PREFIXES, true);
        xmlReader.parse(new InputSource(input));
    } catch (ParserConfigurationException e) {
        throw new ReaderException("ParserConfig error. " + e.getMessage());
    } catch (SAXException e) {
        throw new ReaderException("XML not well-formed. " + e.getMessage());
    } catch (IOException e) {
        throw new ReaderException("IO Error while parsing xml input stream. " + e.getMessage());
    }
}

From source file:org.xwiki.contrib.confluence.parser.xhtml.internal.ConfluenceXHTMLParser.java

private XMLReader createXMLReader() throws Exception {
    SAXParserFactory parserFactory = SAXParserFactory.newInstance();
    SAXParser parser = parserFactory.newSAXParser();
    XMLReader xmlReader = parser.getXMLReader();

    // Ignore SAX callbacks when the parser parses the DTD
    DTDXMLFilter dtdFilter = new DTDXMLFilter(xmlReader);

    // Add a XML Filter to accumulate onCharacters() calls since SAX
    // parser may call it several times.
    AccumulationXMLFilter accumulationFilter = new AccumulationXMLFilter(dtdFilter);

    // Add a XML Filter to remove non-semantic white spaces. We need to
    // do that since all WikiModel
    // events contain only semantic information.
    return new ConfluenceXHTMLWhitespaceXMLFilter(accumulationFilter);
}

From source file:org.xwiki.extension.xar.internal.handler.packager.DefaultPackager.java

public void parseDocument(InputStream in, ContentHandler documentHandler)
        throws ParserConfigurationException, SAXException, IOException, NotADocumentException {
    SAXParser saxParser = this.parserFactory.newSAXParser();
    XMLReader xmlReader = saxParser.getXMLReader();

    RootHandler handler = new RootHandler(this.componentManager);
    handler.setHandler("xwikidoc", documentHandler);
    xmlReader.setContentHandler(handler);

    try {//from   w  w  w  . java  2  s . c  o  m
        xmlReader.parse(new InputSource(new CloseShieldInputStream(in)));
    } catch (UnknownRootElement e) {
        throw new NotADocumentException("Failed to parse stream", e);
    }
}

From source file:self.philbrown.droidQuery.AjaxTask.java

@Override
protected TaskResponse doInBackground(Void... arg0) {
    if (this.isCancelled())
        return null;

    //if synchronous, block on the background thread until ready. Then call beforeSend, etc, before resuming.
    if (!beforeSendIsAsync) {
        try {/* w  ww . j a v a2 s. c om*/
            mutex.acquire();
        } catch (InterruptedException e) {
            Log.w("AjaxTask", "Synchronization Error. Running Task Async");
        }
        final Thread asyncThread = Thread.currentThread();
        isLocked = true;
        mHandler.post(new Runnable() {
            @Override
            public void run() {
                if (options.beforeSend() != null) {
                    if (options.context() != null)
                        options.beforeSend().invoke($.with(options.context()), options);
                    else
                        options.beforeSend().invoke(null, options);
                }

                if (options.isAborted()) {
                    cancel(true);
                    return;
                }

                if (options.global()) {
                    synchronized (globalTasks) {
                        if (globalTasks.isEmpty()) {
                            $.ajaxStart();
                        }
                        globalTasks.add(AjaxTask.this);
                    }
                    $.ajaxSend();
                } else {
                    synchronized (localTasks) {
                        localTasks.add(AjaxTask.this);
                    }
                }
                isLocked = false;
                LockSupport.unpark(asyncThread);
            }
        });
        if (isLocked)
            LockSupport.park();
    }

    //here is where to use the mutex

    //handle cached responses
    Object cachedResponse = AjaxCache.sharedCache().getCachedResponse(options);
    //handle ajax caching option
    if (cachedResponse != null && options.cache()) {
        Success s = new Success(cachedResponse);
        s.reason = "cached response";
        s.headers = null;
        return s;

    }

    if (request == null) {
        String type = options.type();
        if (type == null)
            type = "GET";
        if (type.equalsIgnoreCase("DELETE")) {
            request = new HttpDelete(options.url());
        } else if (type.equalsIgnoreCase("GET")) {
            request = new HttpGet(options.url());
        } else if (type.equalsIgnoreCase("HEAD")) {
            request = new HttpHead(options.url());
        } else if (type.equalsIgnoreCase("OPTIONS")) {
            request = new HttpOptions(options.url());
        } else if (type.equalsIgnoreCase("POST")) {
            request = new HttpPost(options.url());
        } else if (type.equalsIgnoreCase("PUT")) {
            request = new HttpPut(options.url());
        } else if (type.equalsIgnoreCase("TRACE")) {
            request = new HttpTrace(options.url());
        } else if (type.equalsIgnoreCase("CUSTOM")) {
            try {
                request = options.customRequest();
            } catch (Exception e) {
                request = null;
            }

            if (request == null) {
                Log.w("droidQuery.ajax",
                        "CUSTOM type set, but AjaxOptions.customRequest is invalid. Defaulting to GET.");
                request = new HttpGet();
            }

        } else {
            //default to GET
            request = new HttpGet();
        }
    }

    Map<String, Object> args = new HashMap<String, Object>();
    args.put("options", options);
    args.put("request", request);
    EventCenter.trigger("ajaxPrefilter", args, null);

    if (options.headers() != null) {
        if (options.headers().authorization() != null) {
            options.headers()
                    .authorization(options.headers().authorization() + " " + options.getEncodedCredentials());
        } else if (options.username() != null) {
            //guessing that authentication is basic
            options.headers().authorization("Basic " + options.getEncodedCredentials());
        }

        for (Entry<String, String> entry : options.headers().map().entrySet()) {
            request.addHeader(entry.getKey(), entry.getValue());
        }
    }

    if (options.data() != null) {
        try {
            Method setEntity = request.getClass().getMethod("setEntity", new Class<?>[] { HttpEntity.class });
            if (options.processData() == null) {
                setEntity.invoke(request, new StringEntity(options.data().toString()));
            } else {
                Class<?> dataProcessor = Class.forName(options.processData());
                Constructor<?> constructor = dataProcessor.getConstructor(new Class<?>[] { Object.class });
                setEntity.invoke(request, constructor.newInstance(options.data()));
            }
        } catch (Throwable t) {
            Log.w("Ajax", "Could not post data");
        }
    }

    HttpParams params = new BasicHttpParams();

    if (options.timeout() != 0) {
        HttpConnectionParams.setConnectionTimeout(params, options.timeout());
        HttpConnectionParams.setSoTimeout(params, options.timeout());
    }

    SchemeRegistry schemeRegistry = new SchemeRegistry();
    schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
    if (options.trustAllSSLCertificates()) {
        X509HostnameVerifier hostnameVerifier = SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER;
        SSLSocketFactory socketFactory = SSLSocketFactory.getSocketFactory();
        socketFactory.setHostnameVerifier(hostnameVerifier);
        schemeRegistry.register(new Scheme("https", socketFactory, 443));
        Log.w("Ajax", "Warning: All SSL Certificates have been trusted!");
    } else {
        schemeRegistry.register(new Scheme("https", SSLSocketFactory.getSocketFactory(), 443));
    }

    SingleClientConnManager mgr = new SingleClientConnManager(params, schemeRegistry);
    HttpClient client = new DefaultHttpClient(mgr, params);

    HttpResponse response = null;
    try {

        if (options.cookies() != null) {
            CookieStore cookies = new BasicCookieStore();
            for (Entry<String, String> entry : options.cookies().entrySet()) {
                cookies.addCookie(new BasicClientCookie(entry.getKey(), entry.getValue()));
            }
            HttpContext httpContext = new BasicHttpContext();
            httpContext.setAttribute(ClientContext.COOKIE_STORE, cookies);
            response = client.execute(request, httpContext);
        } else {
            response = client.execute(request);
        }

        if (options.dataFilter() != null) {
            if (options.context() != null)
                options.dataFilter().invoke($.with(options.context()), response, options.dataType());
            else
                options.dataFilter().invoke(null, response, options.dataType());
        }

        final StatusLine statusLine = response.getStatusLine();

        final Function function = options.statusCode().get(statusLine.getStatusCode());
        if (function != null) {
            mHandler.post(new Runnable() {

                @Override
                public void run() {
                    if (options.context() != null)
                        function.invoke($.with(options.context()), statusLine.getStatusCode(), options.clone());
                    else
                        function.invoke(null, statusLine.getStatusCode(), options.clone());
                }

            });

        }

        //handle dataType
        String dataType = options.dataType();
        if (dataType == null)
            dataType = "text";
        if (options.debug())
            Log.i("Ajax", "dataType = " + dataType);
        Object parsedResponse = null;
        try {
            if (dataType.equalsIgnoreCase("text") || dataType.equalsIgnoreCase("html")) {
                if (options.debug())
                    Log.i("Ajax", "parsing text");
                parsedResponse = parseText(response);
            } else if (dataType.equalsIgnoreCase("xml")) {
                if (options.debug())
                    Log.i("Ajax", "parsing xml");
                if (options.customXMLParser() != null) {
                    InputStream is = response.getEntity().getContent();
                    if (options.SAXContentHandler() != null)
                        options.customXMLParser().parse(is, options.SAXContentHandler());
                    else
                        options.customXMLParser().parse(is, new DefaultHandler());
                    parsedResponse = "Response handled by custom SAX parser";
                } else if (options.SAXContentHandler() != null) {
                    InputStream is = response.getEntity().getContent();

                    SAXParserFactory factory = SAXParserFactory.newInstance();

                    factory.setFeature("http://xml.org/sax/features/namespaces", false);
                    factory.setFeature("http://xml.org/sax/features/namespace-prefixes", true);

                    SAXParser parser = factory.newSAXParser();

                    XMLReader reader = parser.getXMLReader();
                    reader.setContentHandler(options.SAXContentHandler());
                    reader.parse(new InputSource(is));
                    parsedResponse = "Response handled by custom SAX content handler";
                } else {
                    parsedResponse = parseXML(response);
                }
            } else if (dataType.equalsIgnoreCase("json")) {
                if (options.debug())
                    Log.i("Ajax", "parsing json");
                parsedResponse = parseJSON(response);
            } else if (dataType.equalsIgnoreCase("script")) {
                if (options.debug())
                    Log.i("Ajax", "parsing script");
                parsedResponse = parseScript(response);
            } else if (dataType.equalsIgnoreCase("image")) {
                if (options.debug())
                    Log.i("Ajax", "parsing image");
                parsedResponse = parseImage(response);
            } else if (dataType.equalsIgnoreCase("raw")) {
                if (options.debug())
                    Log.i("Ajax", "parsing raw data");
                parsedResponse = parseRawContent(response);
            }
        } catch (ClientProtocolException cpe) {
            if (options.debug())
                cpe.printStackTrace();
            Error e = new Error(parsedResponse);
            AjaxError error = new AjaxError();
            error.request = request;
            error.options = options;
            e.status = statusLine.getStatusCode();
            e.reason = statusLine.getReasonPhrase();
            error.status = e.status;
            error.reason = e.reason;
            error.response = e.response;
            e.headers = response.getAllHeaders();
            e.error = error;
            return e;
        } catch (Exception ioe) {
            if (options.debug())
                ioe.printStackTrace();
            Error e = new Error(parsedResponse);
            AjaxError error = new AjaxError();
            error.request = request;
            error.options = options;
            e.status = statusLine.getStatusCode();
            e.reason = statusLine.getReasonPhrase();
            error.status = e.status;
            error.reason = e.reason;
            error.response = e.response;
            e.headers = response.getAllHeaders();
            e.error = error;
            return e;
        }

        if (statusLine.getStatusCode() >= 300) {
            //an error occurred
            Error e = new Error(parsedResponse);
            Log.e("Ajax Test", parsedResponse.toString());
            //AjaxError error = new AjaxError();
            //error.request = request;
            //error.options = options;
            e.status = statusLine.getStatusCode();
            e.reason = statusLine.getReasonPhrase();
            //error.status = e.status;
            //error.reason = e.reason;
            //error.response = e.response;
            e.headers = response.getAllHeaders();
            //e.error = error;
            if (options.debug())
                Log.i("Ajax", "Error " + e.status + ": " + e.reason);
            return e;
        } else {
            //handle ajax ifModified option
            Header[] lastModifiedHeaders = response.getHeaders("last-modified");
            if (lastModifiedHeaders.length >= 1) {
                try {
                    Header h = lastModifiedHeaders[0];
                    SimpleDateFormat format = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss zzz", Locale.US);
                    Date lastModified = format.parse(h.getValue());
                    if (options.ifModified() && lastModified != null) {
                        Date lastModifiedDate;
                        synchronized (lastModifiedUrls) {
                            lastModifiedDate = lastModifiedUrls.get(options.url());
                        }

                        if (lastModifiedDate != null && lastModifiedDate.compareTo(lastModified) == 0) {
                            //request response has not been modified. 
                            //Causes an error instead of a success.
                            Error e = new Error(parsedResponse);
                            AjaxError error = new AjaxError();
                            error.request = request;
                            error.options = options;
                            e.status = statusLine.getStatusCode();
                            e.reason = statusLine.getReasonPhrase();
                            error.status = e.status;
                            error.reason = e.reason;
                            error.response = e.response;
                            e.headers = response.getAllHeaders();
                            e.error = error;
                            Function func = options.statusCode().get(304);
                            if (func != null) {
                                if (options.context() != null)
                                    func.invoke($.with(options.context()));
                                else
                                    func.invoke(null);
                            }
                            return e;
                        } else {
                            synchronized (lastModifiedUrls) {
                                lastModifiedUrls.put(options.url(), lastModified);
                            }
                        }
                    }
                } catch (Throwable t) {
                    Log.e("Ajax", "Could not parse Last-Modified Header", t);
                }

            }

            //Now handle a successful request

            Success s = new Success(parsedResponse);
            s.reason = statusLine.getReasonPhrase();
            s.headers = response.getAllHeaders();
            return s;
        }

    } catch (Throwable t) {
        if (options.debug())
            t.printStackTrace();
        if (t instanceof java.net.SocketTimeoutException) {
            Error e = new Error(null);
            AjaxError error = new AjaxError();
            error.request = request;
            error.options = options;
            error.response = e.response;
            e.status = 0;
            String reason = t.getMessage();
            if (reason == null)
                reason = "Socket Timeout";
            e.reason = reason;
            error.status = e.status;
            error.reason = e.reason;
            if (response != null)
                e.headers = response.getAllHeaders();
            else
                e.headers = new Header[0];
            e.error = error;
            return e;
        }
        return null;
    }
}

From source file:stroom.xml.util.TestXMLWriter.java

private void processXML(final File inputFile, final File outputDir) {
    LOGGER.info("Processing file: " + inputFile.getAbsolutePath());
    FileUtil.mkdirs(outputDir);/*from  w w  w  . j av  a 2s  . co  m*/

    // First create SAXON formatted output.
    final File saxonOutput = new File(outputDir,
            inputFile.getName().substring(0, inputFile.getName().lastIndexOf('.')) + ".saxon.xml");
    try {
        // Pretty print with SAXON.
        XMLUtil.prettyPrintXML(new BufferedInputStream(new FileInputStream(inputFile)),
                new BufferedOutputStream(new FileOutputStream(saxonOutput)));

        try {
            // Pretty print with XMLWriter.
            final File xwOutput = new File(outputDir,
                    inputFile.getName().substring(0, inputFile.getName().lastIndexOf('.')) + ".xw.xml");
            final FileWriter fw = new FileWriter(xwOutput);
            final BufferedWriter bw = new BufferedWriter(fw);
            final XMLWriter xmlWriter = new XMLWriter(bw);
            xmlWriter.setOutputXMLDecl(true);
            xmlWriter.setIndentation(3);

            final SAXParser saxParser = PARSER_FACTORY.newSAXParser();
            final XMLReader xmlReader = saxParser.getXMLReader();
            xmlReader.setContentHandler(xmlWriter);
            xmlReader.parse(new InputSource(new BufferedReader(new FileReader(inputFile))));

            bw.close();

        } catch (final Throwable t) {
            Assert.fail(t.getMessage());
        }
    } catch (final Throwable t) {
        // Ignore...
    }
}

From source file:tds.student.sbacossmerge.data.TestResponseReaderSax.java

public static TestResponseReader parseSax(InputStream xml, TestOpportunity testOpp) throws Exception {
    TestResponseReaderSax saxReader = new TestResponseReaderSax();
    saxReader._testOpp = testOpp;/*w w w .j av a 2s.  c  o m*/

    SAXParserFactory spf = SAXParserFactory.newInstance();
    spf.setNamespaceAware(true);
    SAXParser saxParser = spf.newSAXParser();
    XMLReader xmlReader = saxParser.getXMLReader();

    saxReader._xmlReader = xmlReader;
    ContentHandler defaultHandler = saxReader._parseHandlers.peek();
    xmlReader.setContentHandler(defaultHandler);

    xmlReader.parse(new InputSource(xml));

    return saxReader;
}

From source file:uk.ac.cam.caret.sakai.rwiki.component.service.impl.XSLTEntityHandler.java

public void parseToSAX(final String toRender, final ContentHandler ch) throws IOException, SAXException {
    /**//www  .j  a  v a 2  s  . com
     * create a proxy for the stream, filtering out the start element and
     * end element events
     */
    ContentHandler proxy = new ContentHandler() {
        public void setDocumentLocator(Locator arg0) {
            ch.setDocumentLocator(arg0);
        }

        public void startDocument() throws SAXException {
            // ignore
        }

        public void endDocument() throws SAXException {
            // ignore
        }

        public void startPrefixMapping(String arg0, String arg1) throws SAXException {
            ch.startPrefixMapping(arg0, arg1);
        }

        public void endPrefixMapping(String arg0) throws SAXException {
            ch.endPrefixMapping(arg0);
        }

        public void startElement(String arg0, String arg1, String arg2, Attributes arg3) throws SAXException {
            ch.startElement(arg0, arg1, arg2, arg3);
        }

        public void endElement(String arg0, String arg1, String arg2) throws SAXException {
            ch.endElement(arg0, arg1, arg2);
        }

        public void characters(char[] arg0, int arg1, int arg2) throws SAXException {
            ch.characters(arg0, arg1, arg2);
        }

        public void ignorableWhitespace(char[] arg0, int arg1, int arg2) throws SAXException {
            ch.ignorableWhitespace(arg0, arg1, arg2);
        }

        public void processingInstruction(String arg0, String arg1) throws SAXException {
            ch.processingInstruction(arg0, arg1);
        }

        public void skippedEntity(String arg0) throws SAXException {
            ch.skippedEntity(arg0);
        }

    };
    InputSource ins = new InputSource(new StringReader(toRender));
    XMLReader xmlReader;
    try {
        SAXParser saxParser = saxParserFactory.newSAXParser();

        xmlReader = saxParser.getXMLReader();
    }

    catch (Exception e) {
        log.error("SAXException when creating XMLReader", e); //$NON-NLS-1$
        // rethrow!!
        throw new SAXException(e);
    }
    xmlReader.setContentHandler(proxy);
    xmlReader.parse(ins);
}

From source file:xbird.xquery.dm.instance.DocumentTableModel.java

private static final XMLReader getXMLReader(final DocumentTableBuilder handler, final boolean parseAsHtml,
        final boolean resolveEntity) {
    final XMLReader myReader;
    try {/*from   w ww .ja v  a 2s.  co  m*/
        if (parseAsHtml) {
            Class clazz = ClassResolver.get(HTML_PARSER_CLASS);
            assert (clazz != null);
            myReader = ObjectUtils.<XMLReader>instantiate(clazz);
        } else {
            final SAXParserFactory factory;
            if (hasSunXerces) {
                factory = ObjectUtils
                        .instantiate("com.sun.org.apache.xerces.internal.jaxp.SAXParserFactoryImpl", null);
            } else {
                factory = SAXParserFactory.newInstance();
            }
            factory.setNamespaceAware(true);
            SAXParser parser = factory.newSAXParser();
            myReader = parser.getXMLReader();
        }
    } catch (Exception e) {
        throw new XQRTException("Creating SAX XMLReader failed", e);
    }
    // setup handlers (requires saxHandler)
    myReader.setContentHandler(handler);
    try {
        myReader.setProperty("http://xml.org/sax/properties/lexical-handler", handler);
        myReader.setFeature("http://xml.org/sax/features/validation", true); // Validate the document and report validity errors.
        if (!parseAsHtml) {
            myReader.setFeature("http://apache.org/xml/features/validation/dynamic", true); // The parser will validate the document only if a grammar is specified.   
            myReader.setFeature("http://apache.org/xml/features/validation/schema", true); // Turn on XML Schema validation by inserting an XML Schema validator into the pipeline.   
        }
    } catch (Exception e) {
        throw new XQRTException("Configuaring SAX XMLReader failed.", e);
    }
    // setup entity resolver
    if (resolveEntity) {
        org.apache.xml.resolver.CatalogManager catalog = org.apache.xml.resolver.CatalogManager
                .getStaticManager();
        catalog.setIgnoreMissingProperties(true);
        catalog.setPreferPublic(true);
        catalog.setUseStaticCatalog(false);
        EntityResolver resolver = new org.apache.xml.resolver.tools.CatalogResolver(catalog);
        myReader.setEntityResolver(resolver);
    }
    return myReader;
}