public static XMLReader createXMLReader() throws SAXException 
{
        String		className = null;
        ClassLoader	loader = NewInstance.getClassLoader ();
        // 1. try the JVM-instance-wide system property
        try { className = SecuritySupport.getSystemProperty (property); }
        catch (Exception e) { /* normally fails for applets */ }
        // 2. if that fails, try META-INF/services/
        if (className == null || className.length() == 0) {
            String      service = "META-INF/services/" + property;
            InputStream is = null;
            className = null;
            // First try the Context ClassLoader
            ClassLoader cl = SecuritySupport.getContextClassLoader();
            if (cl != null) {
                is = SecuritySupport.getResourceAsStream(cl, service);
                // If no provider found then try the current ClassLoader
                if (is == null) {
                    cl = XMLReaderFactory.class.getClassLoader();
                    is = SecuritySupport.getResourceAsStream(cl, service);
                }
            } else {
                // No Context ClassLoader or JDK 1.1 so try the current
                // ClassLoader
                cl = XMLReaderFactory.class.getClassLoader();
                is = SecuritySupport.getResourceAsStream(cl, service);
            }
            if (is != null) {
                // Read the service provider name in UTF-8 as specified in
                // the jar spec.  Unfortunately this fails in Microsoft
                // VJ++, which does not implement the UTF-8
                // encoding. Theoretically, we should simply let it fail in
                // that case, since the JVM is obviously broken if it
                // doesn't support such a basic standard.  But since there
                // are still some users attempting to use VJ++ for
                // development, we have dropped in a fallback which makes a
                // second attempt using the platform's default encoding. In
                // VJ++ this is apparently ASCII, which is a subset of
                // UTF-8... and since the strings we'll be reading here are
                // also primarily limited to the 7-bit ASCII range (at
                // least, in English versions), this should work well
                // enough to keep us on the air until we're ready to
                // officially decommit from VJ++. [Edited comment from
                // jkesselm]
                BufferedReader rd;
                try {
                    rd = new BufferedReader(new InputStreamReader(is, "UTF-8"), DEFAULT_LINE_LENGTH);
                } catch (java.io.UnsupportedEncodingException e) {
                    rd = new BufferedReader(new InputStreamReader(is), DEFAULT_LINE_LENGTH);
                }
                try {
                    // XXX Does not handle all possible input as specified by the
                    // Jar Service Provider specification
                    className = rd.readLine();
                } 
                catch (Exception x) {
                    // No provider found
                } 
                finally {
                    try { 
                        // try to close the reader. 
                        rd.close(); 
                    } 
                    // Ignore the exception. 
                    catch (IOException exc) {}
                }
            }
        }
        // 3. Distro-specific fallback
        if (className == null) {
            // BEGIN DISTRIBUTION-SPECIFIC
            // EXAMPLE:
            // className = "com.example.sax.XmlReader";
            // or a $JAVA_HOME/jre/lib/*properties setting...
            className = "org.apache.xerces.parsers.SAXParser";
            // END DISTRIBUTION-SPECIFIC
        }
        // do we know the XMLReader implementation class yet?
        if (className != null)
            return loadClass (loader, className);
        // 4. panic -- adapt any SAX1 parser
        try {
            return new ParserAdapter (ParserFactory.makeParser ());
        } catch (Exception e) {
            throw new SAXException ("Can't create default XMLReader; "
                    + "is system property org.xml.sax.driver set?");
        }
}

Attempt to create an XMLReader from system defaults. In environments which can support it, the name of the XMLReader class is determined by trying each these options in order, and using the first one which succeeds:
• If the system property org.xml.sax.driver has a value, that is used as an XMLReader class name.
• The JAR "Services API" is used to look for a class name in the META-INF/services/org.xml.sax.driver file in jarfiles available to the runtime.
• SAX parser distributions are strongly encouraged to provide a default XMLReader class name that will take effect only when previous options (on this list) are not successful.
• Finally, if ParserFactory#makeParser() can return a system default SAX1 parser, that parser is wrapped in a ParserAdapter . (This is a migration aid for SAX1 environments, where the org.xml.sax.parser system property will often be usable.)

In environments such as small embedded systems, which can not support that flexibility, other mechanisms to determine the default may be used.

Note that many Java environments allow system properties to be initialized on a command line. This means that in most cases setting a good value for that property ensures that calls to this method will succeed, except when security policies intervene. This will also maximize application portability to older SAX environments, with less robust implementations of this method.

 public static XMLReader createXMLReader(String className) throws SAXException 
{
        return loadClass (NewInstance.getClassLoader (), className);
}

Attempt to create an XML reader from a class name.

Given a class name, this method attempts to load and instantiate the class as an XML reader.

Note that this method will not be usable in environments where the caller (perhaps an applet) is not permitted to load classes dynamically.