001    // XMLReaderFactory.java - factory for creating a new reader.
002    // http://www.saxproject.org
003    // Written by David Megginson
004    // and by David Brownell
005    // NO WARRANTY!  This class is in the Public Domain.
006    // $Id: XMLReaderFactory.java,v 1.1 2004/12/23 22:38:42 mark Exp $
007    
008    package org.xml.sax.helpers;
009    import java.io.BufferedReader;
010    import java.io.InputStream;
011    import java.io.InputStreamReader;
012    import org.xml.sax.XMLReader;
013    import org.xml.sax.SAXException;
014    
015    
016    /**
017     * Factory for creating an XML reader.
018     *
019     * <blockquote>
020     * <em>This module, both source code and documentation, is in the
021     * Public Domain, and comes with <strong>NO WARRANTY</strong>.</em>
022     * See <a href='http://www.saxproject.org'>http://www.saxproject.org</a>
023     * for further information.
024     * </blockquote>
025     *
026     * <p>This class contains static methods for creating an XML reader
027     * from an explicit class name, or based on runtime defaults:</p>
028     *
029     * <pre>
030     * try {
031     *   XMLReader myReader = XMLReaderFactory.createXMLReader();
032     * } catch (SAXException e) {
033     *   System.err.println(e.getMessage());
034     * }
035     * </pre>
036     *
037     * <p><strong>Note to Distributions bundled with parsers:</strong>
038     * You should modify the implementation of the no-arguments
039     * <em>createXMLReader</em> to handle cases where the external
040     * configuration mechanisms aren't set up.  That method should do its
041     * best to return a parser when one is in the class path, even when
042     * nothing bound its class name to <code>org.xml.sax.driver</code> so
043     * those configuration mechanisms would see it.</p>
044     *
045     * @since SAX 2.0
046     * @author David Megginson, David Brownell
047     * @version 2.0.1 (sax2r2)
048     */
049    final public class XMLReaderFactory
050    {
051        /**
052         * Private constructor.
053         *
054         * <p>This constructor prevents the class from being instantiated.</p>
055         */
056        private XMLReaderFactory ()
057        {
058        }
059    
060        private static final String property = "org.xml.sax.driver";
061    
062        /**
063         * Attempt to create an XMLReader from system defaults.
064         * In environments which can support it, the name of the XMLReader
065         * class is determined by trying each these options in order, and
066         * using the first one which succeeds:</p> <ul>
067         *
068         * <li>If the system property <code>org.xml.sax.driver</code>
069         * has a value, that is used as an XMLReader class name. </li>
070         *
071         * <li>The JAR "Services API" is used to look for a class name
072         * in the <em>META-INF/services/org.xml.sax.driver</em> file in
073         * jarfiles available to the runtime.</li>
074         *
075         * <li> SAX parser distributions are strongly encouraged to provide
076         * a default XMLReader class name that will take effect only when
077         * previous options (on this list) are not successful.</li>
078         *
079         * <li>Finally, if {@link ParserFactory#makeParser()} can
080         * return a system default SAX1 parser, that parser is wrapped in
081         * a {@link ParserAdapter}.  (This is a migration aid for SAX1
082         * environments, where the <code>org.xml.sax.parser</code> system
083         * property will often be usable.) </li>
084         *
085         * </ul>
086         *
087         * <p> In environments such as small embedded systems, which can not
088         * support that flexibility, other mechanisms to determine the default
089         * may be used. </p>
090         *
091         * <p>Note that many Java environments allow system properties to be
092         * initialized on a command line.  This means that <em>in most cases</em>
093         * setting a good value for that property ensures that calls to this
094         * method will succeed, except when security policies intervene.
095         * This will also maximize application portability to older SAX
096         * environments, with less robust implementations of this method.
097         * </p>
098         *
099         * @return A new XMLReader.
100         * @exception org.xml.sax.SAXException If no default XMLReader class
101         *            can be identified and instantiated.
102         * @see #createXMLReader(java.lang.String)
103         */
104        public static XMLReader createXMLReader ()
105            throws SAXException
106        {
107            String          className = null;
108            ClassLoader     loader = NewInstance.getClassLoader ();
109            
110            // 1. try the JVM-instance-wide system property
111            try { className = System.getProperty (property); }
112            catch (RuntimeException e) { /* normally fails for applets */ }
113    
114            // 2. if that fails, try META-INF/services/
115            if (className == null) {
116                try {
117                    String          service = "META-INF/services/" + property;
118                    InputStream     in;
119                    BufferedReader  reader;
120    
121                    if (loader == null)
122                        in = ClassLoader.getSystemResourceAsStream (service);
123                    else
124                        in = loader.getResourceAsStream (service);
125    
126                    if (in != null) {
127                        reader = new BufferedReader (
128                                new InputStreamReader (in, "UTF8"));
129                        className = reader.readLine ();
130                        in.close ();
131                    }
132                } catch (Exception e) {
133                }
134            }
135    
136            // 3. Distro-specific fallback
137            if (className == null) {
138    // BEGIN DISTRIBUTION-SPECIFIC
139    
140                // CLASSPATH LOCAL: have to code in the backup.
141                // Among other things, see PR 31303, and this thread:
142                // http://gcc.gnu.org/ml/java-patches/2007-q1/msg00661.html
143                className = "gnu.xml.stream.SAXParser";
144    
145                // EXAMPLE:
146                // className = "com.example.sax.XmlReader";
147                // or a $JAVA_HOME/jre/lib/*properties setting...
148    
149    // END DISTRIBUTION-SPECIFIC
150            }
151            
152            // do we know the XMLReader implementation class yet?
153            if (className != null)
154                return loadClass (loader, className);
155    
156            // 4. panic -- adapt any SAX1 parser
157            try {
158                return new ParserAdapter (ParserFactory.makeParser ());
159            } catch (Exception e) {
160                throw new SAXException ("Can't create default XMLReader; "
161                        + "is system property org.xml.sax.driver set?");
162            }
163        }
164    
165    
166        /**
167         * Attempt to create an XML reader from a class name.
168         *
169         * <p>Given a class name, this method attempts to load
170         * and instantiate the class as an XML reader.</p>
171         *
172         * <p>Note that this method will not be usable in environments where
173         * the caller (perhaps an applet) is not permitted to load classes
174         * dynamically.</p>
175         *
176         * @return A new XML reader.
177         * @exception org.xml.sax.SAXException If the class cannot be
178         *            loaded, instantiated, and cast to XMLReader.
179         * @see #createXMLReader()
180         */
181        public static XMLReader createXMLReader (String className)
182            throws SAXException
183        {
184            return loadClass (NewInstance.getClassLoader (), className);
185        }
186    
187        private static XMLReader loadClass (ClassLoader loader, String className)
188        throws SAXException
189        {
190            try {
191                return (XMLReader) NewInstance.newInstance (loader, className);
192            } catch (ClassNotFoundException e1) {
193                throw new SAXException("SAX2 driver class " + className +
194                                       " not found", e1);
195            } catch (IllegalAccessException e2) {
196                throw new SAXException("SAX2 driver class " + className +
197                                       " found but cannot be loaded", e2);
198            } catch (InstantiationException e3) {
199                throw new SAXException("SAX2 driver class " + className +
200               " loaded but cannot be instantiated (no empty public constructor?)",
201                                       e3);
202            } catch (ClassCastException e4) {
203                throw new SAXException("SAX2 driver class " + className +
204                                       " does not implement XMLReader", e4);
205            }
206        }
207    }