XMLReaderFactory.java revision 6b811c5daec1b28e6f63b57f98a032236f2c3cf7 
1// XMLReaderFactory.java - factory for creating a new reader.
2// http://www.saxproject.org
3// Written by David Megginson
4// and by David Brownell
5// NO WARRANTY!  This class is in the Public Domain.
6// $Id: XMLReaderFactory.java,v 1.10 2002/04/22 01:00:13 dbrownell Exp $
7
8package org.xml.sax.helpers;
9import java.io.BufferedReader;
10import java.io.InputStream;
11import java.io.InputStreamReader;
12import org.xml.sax.XMLReader;
13import org.xml.sax.SAXException;
14
15
16/**
17 * Factory for creating an XML reader.
18 *
19 * <blockquote>
20 * <em>This module, both source code and documentation, is in the
21 * Public Domain, and comes with <strong>NO WARRANTY</strong>.</em>
22 * See <a href='http://www.saxproject.org'>http://www.saxproject.org</a>
23 * for further information.
24 * </blockquote>
25 *
26 * <p>This class contains static methods for creating an XML reader
27 * from an explicit class name, or based on runtime defaults:</p>
28 *
29 * <pre>
30 * try {
31 *   XMLReader myReader = XMLReaderFactory.createXMLReader();
32 * } catch (SAXException e) {
33 *   System.err.println(e.getMessage());
34 * }
35 * </pre>
36 *
37 * <p><strong>Note to Distributions bundled with parsers:</strong>
38 * You should modify the implementation of the no-arguments
39 * <em>createXMLReader</em> to handle cases where the external
40 * configuration mechanisms aren't set up.  That method should do its
41 * best to return a parser when one is in the class path, even when
42 * nothing bound its class name to <code>org.xml.sax.driver</code> so
43 * those configuration mechanisms would see it.</p>
44 *
45 * @since SAX 2.0
46 * @author David Megginson, David Brownell
47 * @version 2.0.1 (sax2r2)
48 */
49final public class XMLReaderFactory
50{
51    /**
52     * Private constructor.
53     *
54     * <p>This constructor prevents the class from being instantiated.</p>
55     */
56    private XMLReaderFactory ()
57    {
58    }
59
60    private static final String property = "org.xml.sax.driver";
61
62    /**
63     * Attempt to create an XMLReader from system defaults.
64     * In environments which can support it, the name of the XMLReader
65     * class is determined by trying each these options in order, and
66     * using the first one which succeeds:</p> <ul>
67     *
68     * <li>If the system property <code>org.xml.sax.driver</code>
69     * has a value, that is used as an XMLReader class name. </li>
70     *
71     * <li>The JAR "Services API" is used to look for a class name
72     * in the <em>META-INF/services/org.xml.sax.driver</em> file in
73     * jarfiles available to the runtime.</li>
74     *
75     * <li> SAX parser distributions are strongly encouraged to provide
76     * a default XMLReader class name that will take effect only when
77     * previous options (on this list) are not successful.</li>
78     *
79     * <li>Finally, if {@link ParserFactory#makeParser()} can
80     * return a system default SAX1 parser, that parser is wrapped in
81     * a {@link ParserAdapter}.  (This is a migration aid for SAX1
82     * environments, where the <code>org.xml.sax.parser</code> system
83     * property will often be usable.) </li>
84     *
85     * </ul>
86     *
87     * <p> In environments such as small embedded systems, which can not
88     * support that flexibility, other mechanisms to determine the default
89     * may be used. </p>
90     *
91     * <p>Note that many Java environments allow system properties to be
92     * initialized on a command line.  This means that <em>in most cases</em>
93     * setting a good value for that property ensures that calls to this
94     * method will succeed, except when security policies intervene.
95     * This will also maximize application portability to older SAX
96     * environments, with less robust implementations of this method.
97     * </p>
98     *
99     * @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 (new InputStreamReader (in, "UTF8"));
128            className = reader.readLine ();
129            in.close ();
130        }
131        } catch (Exception e) {
132        }
133    }
134
135    // 3. Distro-specific fallback
136    if (className == null) {
137// BEGIN DISTRIBUTION-SPECIFIC
138
139        // EXAMPLE:
140        // className = "com.example.sax.XmlReader";
141        // or a $JAVA_HOME/jre/lib/*properties setting...
142
143// END DISTRIBUTION-SPECIFIC
144    }
145
146    // do we know the XMLReader implementation class yet?
147    if (className != null)
148        return loadClass (loader, className);
149
150    // 4. panic -- adapt any SAX1 parser
151    try {
152        return new ParserAdapter (ParserFactory.makeParser ());
153    } catch (Exception e) {
154        throw new SAXException ("Can't create default XMLReader; "
155            + "is system property org.xml.sax.driver set?");
156    }
157    }
158
159
160    /**
161     * Attempt to create an XML reader from a class name.
162     *
163     * <p>Given a class name, this method attempts to load
164     * and instantiate the class as an XML reader.</p>
165     *
166     * @param className the name of the class that should be instantiated.
167     *
168     * <p>Note that this method will not be usable in environments where
169     * the caller (perhaps an applet) is not permitted to load classes
170     * dynamically.</p>
171     *
172     * @return A new XML reader.
173     * @exception org.xml.sax.SAXException If the class cannot be
174     *            loaded, instantiated, and cast to XMLReader.
175     * @see #createXMLReader()
176     */
177    public static XMLReader createXMLReader (String className)
178    throws SAXException
179    {
180    return loadClass (NewInstance.getClassLoader (), className);
181    }
182
183    private static XMLReader loadClass (ClassLoader loader, String className)
184    throws SAXException
185    {
186    try {
187        return (XMLReader) NewInstance.newInstance (loader, className);
188    } catch (ClassNotFoundException e1) {
189        throw new SAXException("SAX2 driver class " + className +
190                   " not found", e1);
191    } catch (IllegalAccessException e2) {
192        throw new SAXException("SAX2 driver class " + className +
193                   " found but cannot be loaded", e2);
194    } catch (InstantiationException e3) {
195        throw new SAXException("SAX2 driver class " + className +
196       " loaded but cannot be instantiated (no empty public constructor?)",
197                   e3);
198    } catch (ClassCastException e4) {
199        throw new SAXException("SAX2 driver class " + className +
200                   " does not implement XMLReader", e4);
201    }
202    }
203}
204