Beispiel #1
0
 /*
  * Create a new SAX parser object using the class name provided.
  *
  * <p>The named class must exist and must implement the
  * {@link org.xml.sax.Parser Parser} interface.</p>
  *
  * @param className A string containing the name of the
  *                  SAX parser class.
  * @exception java.lang.ClassNotFoundException The SAX parser
  *            class was not found (check your CLASSPATH).
  * @exception IllegalAccessException The SAX parser class was
  *            found, but you do not have permission to load
  *            it.
  * @exception InstantiationException The SAX parser class was
  *            found but could not be instantiated.
  * @exception java.lang.ClassCastException The SAX parser class
  *            was found and instantiated, but does not implement
  *            org.xml.sax.Parser.
  * @see #makeParser()
  * @see org.xml.sax.Parser
  */
 public static Parser makeParser(String className)/*
                                                   * throws ClassNotFoundException,
                                                   * IllegalAccessException,
                                                   * InstantiationException,
                                                   * ClassCastException*/
 {
     return((Parser)NewInstance.newInstance(
                NewInstance.getClassLoader(), className));
 }
Beispiel #2
0
 private static XMLReader loadClass(java.lang.ClassLoader loader, String className)
 //throws SAXException
 {
     try {
         return((XMLReader)NewInstance.newInstance(loader, className));
     } catch (java.lang.ClassNotFoundException e1) {
         throw new SAXException("SAX2 driver class " + className +
                                " not found", e1);
     } catch (java.lang.IllegalAccessException e2) {
         throw new SAXException("SAX2 driver class " + className +
                                " found but cannot be loaded", e2);
     } catch (java.lang.InstantiationException e3) {
         throw new SAXException("SAX2 driver class " + className +
                                " loaded but cannot be instantiated (no empty public constructor?)",
                                e3);
     } catch (java.lang.ClassCastException e4) {
         throw new SAXException("SAX2 driver class " + className +
                                " does not implement XMLReader", e4);
     }
 }
Beispiel #3
0
        /*
         * 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:<p/> <ul>
         *
         * <li>If the system property <code>org.xml.sax.driver</code>
         * has a value, that is used as an XMLReader class name. </li>
         *
         * <li>The JAR "Services API" is used to look for a class name
         * in the <em>META-INF/services/org.xml.sax.driver</em> file in
         * jarfiles available to the runtime.</li>
         *
         * <li> 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.</li>
         *
         * <li>Finally, if {@link ParserFactory#makeParser()} can
         * return a system default SAX1 parser, that parser is wrapped in
         * a {@link ParserAdapter}.  (This is a migration aid for SAX1
         * environments, where the <code>org.xml.sax.parser</code> system
         * property will often be usable.) </li>
         *
         * </ul>
         *
         * <p> In environments such as small embedded systems, which can not
         * support that flexibility, other mechanisms to determine the default
         * may be used. </p>
         *
         * <p>Note that many Java environments allow system properties to be
         * initialized on a command line.  This means that <em>in most cases</em>
         * 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.
         * </p>
         *
         * @return A new XMLReader.
         * @exception org.xml.sax.SAXException If no default XMLReader class
         *            can be identified and instantiated.
         * @see #createXMLReader(java.lang.String)
         */
        public static XMLReader createXMLReader()
        //throws SAXException
        {
            String className = null;

            java.lang.ClassLoader loader = NewInstance.getClassLoader();

            // 1. try the JVM-instance-wide system property
            try { className = java.lang.SystemJ.getProperty(property); }
            catch (java.lang.RuntimeException e) { /* normally fails for applets */ }

            // 2. if that fails, try META-INF/services/
            if (className == null)
            {
                try {
                    String service = "META-INF/services/" + property;
                    java.io.InputStream    input;
                    java.io.BufferedReader reader;

                    if (loader == null)
                    {
                        input = java.lang.ClassLoader.getSystemResourceAsStream(service);
                    }
                    else
                    {
                        input = loader.getResourceAsStream(service);
                    }

                    if (input != null)
                    {
                        reader = new java.io.BufferedReader(
                            new java.io.InputStreamReader(input, "UTF8"));
                        className = reader.readLine();
                        input.close();
                    }
                } catch (Exception e) {
                }
            }

            // 3. Distro-specific fallback
            if (className == null)
            {
// BEGIN DISTRIBUTION-SPECIFIC

                // EXAMPLE:
                // className = "com.example.sax.XmlReader";
                // or a $JAVA_HOME/jre/lib/*properties setting...

                //Take a look in Java 7 shows: className = "com.sun.org.apache.xerces.internal.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 (java.lang.Exception e) {
                throw new SAXException("Can't create default XMLReader; "
                                       + "is system property org.xml.sax.driver set?");
            }
        }
Beispiel #4
0
 /*
  * Attempt to create an XML reader from a class name.
  *
  * <p>Given a class name, this method attempts to load
  * and instantiate the class as an XML reader.</p>
  *
  * <p>Note that this method will not be usable in environments where
  * the caller (perhaps an applet) is not permitted to load classes
  * dynamically.</p>
  *
  * @return A new XML reader.
  * @exception org.xml.sax.SAXException If the class cannot be
  *            loaded, instantiated, and cast to XMLReader.
  * @see #createXMLReader()
  */
 public static XMLReader createXMLReader(String className)
 //throws SAXException
 {
     return(loadClass(NewInstance.getClassLoader(), className));
 }