Java > Open Source Codes > org > apache > xalan > xsltc > dom > ObjectFactory


1 /*
2  * Copyright 2001-2004 The Apache Software Foundation.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 /*
17  * $Id: ObjectFactory.java,v 1.2 2004/02/23 10:29:35 aruny Exp $
18  */
19
20 package org.apache.xalan.xsltc.dom;
21
22 import java.io.InputStream ;
23 import java.io.IOException ;
24 import java.io.File ;
25 import java.io.FileInputStream ;
26
27 import java.util.Properties ;
28 import java.io.BufferedReader ;
29 import java.io.InputStreamReader ;
30
31 /**
32  * This class is duplicated for each JAXP subpackage so keep it in sync.
33  * It is package private and therefore is not exposed as part of the JAXP
34  * API.
35  * <p>
36  * This code is designed to implement the JAXP 1.1 spec pluggability
37  * feature and is designed to run on JDK version 1.1 and
38  * later, and to compile on JDK 1.2 and onward.
39  * The code also runs both as part of an unbundled jar file and
40  * when bundled as part of the JDK.
41  * <p>
42  * This class was moved from the <code>javax.xml.parsers.ObjectFactory</code>
43  * class and modified to be used as a general utility for creating objects
44  * dynamically.
45  *
46  * @version $Id: ObjectFactory.java,v 1.2 2004/02/23 10:29:35 aruny Exp $
47  */
48 class ObjectFactory {
49
50     //
51 // Constants
52 //
53
54     // name of default properties file to look for in JDK's jre/lib directory
55 private static final String DEFAULT_PROPERTIES_FILENAME =
56                                                      "xalan.properties";
57
58     private static final String SERVICES_PATH = "META-INF/services/";
59
60     /** Set to true for debugging */
61     private static final boolean DEBUG = false;
62
63     /** cache the contents of the xalan.properties file.
64      * Until an attempt has been made to read this file, this will
65      * be null; if the file does not exist or we encounter some other error
66      * during the read, this will be empty.
67      */
68     private static Properties fXalanProperties = null;
69
70     /***
71      * Cache the time stamp of the xalan.properties file so
72      * that we know if it's been modified and can invalidate
73      * the cache when necessary.
74      */
75     private static long fLastModified = -1;
76
77     //
78 // Public static methods
79 //
80
81     /**
82      * Finds the implementation Class object in the specified order. The
83      * specified order is the following:
84      * <ol>
85      * <li>query the system property using <code>System.getProperty</code>
86      * <li>read <code>META-INF/services/<i>factoryId</i></code> file
87      * <li>use fallback classname
88      * </ol>
89      *
90      * @return instance of factory, never null
91      *
92      * @param factoryId Name of the factory to find, same as
93      * a property name
94      * @param fallbackClassName Implementation class name, if nothing else
95      * is found. Use null to mean no fallback.
96      *
97      * @exception ObjectFactory.ConfigurationError
98      */
99     static Object createObject(String factoryId, String fallbackClassName)
100         throws ConfigurationError {
101         return createObject(factoryId, null, fallbackClassName);
102     } // createObject(String,String):Object
103
104     /**
105      * Finds the implementation Class object in the specified order. The
106      * specified order is the following:
107      * <ol>
108      * <li>query the system property using <code>System.getProperty</code>
109      * <li>read <code>$java.home/lib/<i>propertiesFilename</i></code> file
110      * <li>read <code>META-INF/services/<i>factoryId</i></code> file
111      * <li>use fallback classname
112      * </ol>
113      *
114      * @return instance of factory, never null
115      *
116      * @param factoryId Name of the factory to find, same as
117      * a property name
118      * @param propertiesFilename The filename in the $java.home/lib directory
119      * of the properties file. If none specified,
120      * ${java.home}/lib/xalan.properties will be used.
121      * @param fallbackClassName Implementation class name, if nothing else
122      * is found. Use null to mean no fallback.
123      *
124      * @exception ObjectFactory.ConfigurationError
125      */
126     static Object createObject(String factoryId,
127                                       String propertiesFilename,
128                                       String fallbackClassName)
129         throws ConfigurationError
130     {
131         Class factoryClass = lookUpFactoryClass(factoryId,
132                                                 propertiesFilename,
133                                                 fallbackClassName);
134
135         if (factoryClass == null) {
136             throw new ConfigurationError(
137                 "Provider for " + factoryId + " cannot be found", null);
138         }
139
140         try{
141             Object instance = factoryClass.newInstance();
142             debugPrintln("created new instance of factory " + factoryId);
143             return instance;
144         } catch (Exception x) {
145             throw new ConfigurationError(
146                 "Provider for factory " + factoryId
147                     + " could not be instantiated: " + x, x);
148         }
149     } // createObject(String,String,String):Object
150
151     /**
152      * Finds the implementation Class object in the specified order. The
153      * specified order is the following:
154      * <ol>
155      * <li>query the system property using <code>System.getProperty</code>
156      * <li>read <code>$java.home/lib/<i>propertiesFilename</i></code> file
157      * <li>read <code>META-INF/services/<i>factoryId</i></code> file
158      * <li>use fallback classname
159      * </ol>
160      *
161      * @return Class object of factory, never null
162      *
163      * @param factoryId Name of the factory to find, same as
164      * a property name
165      * @param propertiesFilename The filename in the $java.home/lib directory
166      * of the properties file. If none specified,
167      * ${java.home}/lib/xalan.properties will be used.
168      * @param fallbackClassName Implementation class name, if nothing else
169      * is found. Use null to mean no fallback.
170      *
171      * @exception ObjectFactory.ConfigurationError
172      */
173     static Class lookUpFactoryClass(String factoryId)
174         throws ConfigurationError
175     {
176         return lookUpFactoryClass(factoryId, null, null);
177     } // lookUpFactoryClass(String):Class
178
179     /**
180      * Finds the implementation Class object in the specified order. The
181      * specified order is the following:
182      * <ol>
183      * <li>query the system property using <code>System.getProperty</code>
184      * <li>read <code>$java.home/lib/<i>propertiesFilename</i></code> file
185      * <li>read <code>META-INF/services/<i>factoryId</i></code> file
186      * <li>use fallback classname
187      * </ol>
188      *
189      * @return Class object that provides factory service, never null
190      *
191      * @param factoryId Name of the factory to find, same as
192      * a property name
193      * @param propertiesFilename The filename in the $java.home/lib directory
194      * of the properties file. If none specified,
195      * ${java.home}/lib/xalan.properties will be used.
196      * @param fallbackClassName Implementation class name, if nothing else
197      * is found. Use null to mean no fallback.
198      *
199      * @exception ObjectFactory.ConfigurationError
200      */
201     static Class lookUpFactoryClass(String factoryId,
202                                            String propertiesFilename,
203                                            String fallbackClassName)
204         throws ConfigurationError
205     {
206         String factoryClassName = lookUpFactoryClassName(factoryId,
207                                                          propertiesFilename,
208                                                          fallbackClassName);
209         ClassLoader cl = findClassLoader();
210
211         if (factoryClassName == null) {
212             factoryClassName = fallbackClassName;
213         }
214
215         // assert(className != null);
216 try{
217             Class providerClass = findProviderClass(factoryClassName,
218                                                     cl,
219                                                     true);
220             debugPrintln("created new instance of " + providerClass +
221                    " using ClassLoader: " + cl);
222             return providerClass;
223         } catch (ClassNotFoundException x) {
224             throw new ConfigurationError(
225                 "Provider " + factoryClassName + " not found", x);
226         } catch (Exception x) {
227             throw new ConfigurationError(
228                 "Provider "+factoryClassName+" could not be instantiated: "+x,
229                 x);
230         }
231     } // lookUpFactoryClass(String,String,String):Class
232
233     /**
234      * Finds the name of the required implementation class in the specified
235      * order. The specified order is the following:
236      * <ol>
237      * <li>query the system property using <code>System.getProperty</code>
238      * <li>read <code>$java.home/lib/<i>propertiesFilename</i></code> file
239      * <li>read <code>META-INF/services/<i>factoryId</i></code> file
240      * <li>use fallback classname
241      * </ol>
242      *
243      * @return name of class that provides factory service, never null
244      *
245      * @param factoryId Name of the factory to find, same as
246      * a property name
247      * @param propertiesFilename The filename in the $java.home/lib directory
248      * of the properties file. If none specified,
249      * ${java.home}/lib/xalan.properties will be used.
250      * @param fallbackClassName Implementation class name, if nothing else
251      * is found. Use null to mean no fallback.
252      *
253      * @exception ObjectFactory.ConfigurationError
254      */
255     static String lookUpFactoryClassName(String factoryId,
256                                                 String propertiesFilename,
257                                                 String fallbackClassName)
258     {
259         SecuritySupport ss = SecuritySupport.getInstance();
260
261         // Use the system property first
262 try {
263             String systemProp = ss.getSystemProperty(factoryId);
264             if (systemProp != null) {
265                 debugPrintln("found system property, value=" + systemProp);
266                 return systemProp;
267             }
268         } catch (SecurityException se) {
269             // Ignore and continue w/ next location
270 }
271
272         // Try to read from propertiesFilename, or
273 // $java.home/lib/xalan.properties
274 String factoryClassName = null;
275         // no properties file name specified; use
276 // $JAVA_HOME/lib/xalan.properties:
277 if (propertiesFilename == null) {
278             File propertiesFile = null;
279             boolean propertiesFileExists = false;
280             try {
281                 String javah = ss.getSystemProperty("java.home");
282                 propertiesFilename = javah + File.separator +
283                     "lib" + File.separator + DEFAULT_PROPERTIES_FILENAME;
284                 propertiesFile = new File (propertiesFilename);
285                 propertiesFileExists = ss.getFileExists(propertiesFile);
286             } catch (SecurityException e) {
287                 // try again...
288 fLastModified = -1;
289                 fXalanProperties = null;
290             }
291
292             synchronized (ObjectFactory.class) {
293                 boolean loadProperties = false;
294                 try {
295                     // file existed last time
296 if(fLastModified >= 0) {
297                         if(propertiesFileExists &&
298                                 (fLastModified < (fLastModified = ss.getLastModified(propertiesFile)))) {
299                             loadProperties = true;
300                         } else {
301                             // file has stopped existing...
302 if(!propertiesFileExists) {
303                                 fLastModified = -1;
304                                 fXalanProperties = null;
305                             } // else, file wasn't modified!
306 }
307                     } else {
308                         // file has started to exist:
309 if(propertiesFileExists) {
310                             loadProperties = true;
311                             fLastModified = ss.getLastModified(propertiesFile);
312                         } // else, nothing's changed
313 }
314                     if(loadProperties) {
315                         // must never have attempted to read xalan.properties
316 // before (or it's outdeated)
317 fXalanProperties = new Properties ();
318                         FileInputStream fis =
319                                          ss.getFileInputStream(propertiesFile);
320                         fXalanProperties.load(fis);
321                         fis.close();
322                     }
323                 } catch (Exception x) {
324                     fXalanProperties = null;
325                     fLastModified = -1;
326                         // assert(x instanceof FileNotFoundException
327 // || x instanceof SecurityException)
328 // In both cases, ignore and continue w/ next location
329 }
330             }
331             if(fXalanProperties != null) {
332                 factoryClassName = fXalanProperties.getProperty(factoryId);
333             }
334         } else {
335             try {
336                 FileInputStream fis =
337                            ss.getFileInputStream(new File (propertiesFilename));
338                 Properties props = new Properties ();
339                 props.load(fis);
340                 fis.close();
341                 factoryClassName = props.getProperty(factoryId);
342             } catch (Exception x) {
343                 // assert(x instanceof FileNotFoundException
344 // || x instanceof SecurityException)
345 // In both cases, ignore and continue w/ next location
346 }
347         }
348         if (factoryClassName != null) {
349             debugPrintln("found in " + propertiesFilename + ", value="
350                           + factoryClassName);
351             return factoryClassName;
352         }
353
354         // Try Jar Service Provider Mechanism
355 return findJarServiceProviderName(factoryId);
356     } // lookUpFactoryClass(String,String):String
357
358     //
359 // Private static methods
360 //
361
362     /** Prints a message to standard error if debugging is enabled. */
363     private static void debugPrintln(String msg) {
364         if (DEBUG) {
365             System.err.println("JAXP: " + msg);
366         }
367     } // debugPrintln(String)
368
369     /**
370      * Figure out which ClassLoader to use. For JDK 1.2 and later use
371      * the context ClassLoader.
372      */
373     static ClassLoader findClassLoader()
374         throws ConfigurationError
375     {
376         SecuritySupport ss = SecuritySupport.getInstance();
377
378         // Figure out which ClassLoader to use for loading the provider
379 // class. If there is a Context ClassLoader then use it.
380 ClassLoader context = ss.getContextClassLoader();
381         ClassLoader system = ss.getSystemClassLoader();
382
383         ClassLoader chain = system;
384         while (true) {
385             if (context == chain) {
386                 // Assert: we are on JDK 1.1 or we have no Context ClassLoader
387 // or any Context ClassLoader in chain of system classloader
388 // (including extension ClassLoader) so extend to widest
389 // ClassLoader (always look in system ClassLoader if Xalan
390 // is in boot/extension/system classpath and in current
391 // ClassLoader otherwise); normal classloaders delegate
392 // back to system ClassLoader first so this widening doesn't
393 // change the fact that context ClassLoader will be consulted
394 ClassLoader current = ObjectFactory.class.getClassLoader();
395
396                 chain = system;
397                 while (true) {
398                     if (current == chain) {
399                         // Assert: Current ClassLoader in chain of
400 // boot/extension/system ClassLoaders
401 return system;
402                     }
403                     if (chain == null) {
404                         break;
405                     }
406                     chain = ss.getParentClassLoader(chain);
407                 }
408
409                 // Assert: Current ClassLoader not in chain of
410 // boot/extension/system ClassLoaders
411 return current;
412             }
413
414             if (chain == null) {
415                 // boot ClassLoader reached
416 break;
417             }
418
419             // Check for any extension ClassLoaders in chain up to
420 // boot ClassLoader
421 chain = ss.getParentClassLoader(chain);
422         };
423
424         // Assert: Context ClassLoader not in chain of
425 // boot/extension/system ClassLoaders
426 return context;
427     } // findClassLoader():ClassLoader
428
429     /**
430      * Create an instance of a class using the specified ClassLoader
431      */
432     static Object newInstance(String className, ClassLoader cl,
433                                       boolean doFallback)
434         throws ConfigurationError
435     {
436         // assert(className != null);
437 try{
438             Class providerClass = findProviderClass(className, cl, doFallback);
439             Object instance = providerClass.newInstance();
440             debugPrintln("created new instance of " + providerClass +
441                    " using ClassLoader: " + cl);
442             return instance;
443         } catch (ClassNotFoundException x) {
444             throw new ConfigurationError(
445                 "Provider " + className + " not found", x);
446         } catch (Exception x) {
447             throw new ConfigurationError(
448                 "Provider " + className + " could not be instantiated: " + x,
449                 x);
450         }
451     }
452
453     /**
454      * Find a Class using the specified ClassLoader
455      */
456     static Class findProviderClass(String className, ClassLoader cl,
457                                            boolean doFallback)
458         throws ClassNotFoundException , ConfigurationError
459     {
460         //throw security exception if the calling thread is not allowed to access the
461 //class. Restrict the access to the package classes as specified in java.security policy.
462 SecurityManager security = System.getSecurityManager();
463         try{
464             if (security != null){
465                 security.checkPackageAccess(className);
466              }
467         }catch(SecurityException e){
468             throw e;
469         }
470         
471         Class providerClass;
472         if (cl == null) {
473             // XXX Use the bootstrap ClassLoader. There is no way to
474 // load a class using the bootstrap ClassLoader that works
475 // in both JDK 1.1 and Java 2. However, this should still
476 // work b/c the following should be true:
477 //
478 // (cl == null) iff current ClassLoader == null
479 //
480 // Thus Class.forName(String) will use the current
481 // ClassLoader which will be the bootstrap ClassLoader.
482 providerClass = Class.forName(className);
483         } else {
484             try {
485                 providerClass = cl.loadClass(className);
486             } catch (ClassNotFoundException x) {
487                 if (doFallback) {
488                     // Fall back to current classloader
489 ClassLoader current = ObjectFactory.class.getClassLoader();
490                     if (current == null) {
491                         providerClass = Class.forName(className);
492                     } else if (cl != current) {
493                         cl = current;
494                         providerClass = cl.loadClass(className);
495                     } else {
496                         throw x;
497                     }
498                 } else {
499                     throw x;
500                 }
501             }
502         }
503
504         return providerClass;
505     }
506
507     /**
508      * Find the name of service provider using Jar Service Provider Mechanism
509      *
510      * @return instance of provider class if found or null
511      */
512     private static String findJarServiceProviderName(String factoryId)
513     {
514         SecuritySupport ss = SecuritySupport.getInstance();
515         String serviceId = SERVICES_PATH + factoryId;
516         InputStream is = null;
517
518         // First try the Context ClassLoader
519 ClassLoader cl = findClassLoader();
520
521         is = ss.getResourceAsStream(cl, serviceId);
522
523         // If no provider found then try the current ClassLoader
524 if (is == null) {
525             ClassLoader current = ObjectFactory.class.getClassLoader();
526             if (cl != current) {
527                 cl = current;
528                 is = ss.getResourceAsStream(cl, serviceId);
529             }
530         }
531
532         if (is == null) {
533             // No provider found
534 return null;
535         }
536
537         debugPrintln("found jar resource=" + serviceId +
538                " using ClassLoader: " + cl);
539
540         // Read the service provider name in UTF-8 as specified in
541 // the jar spec. Unfortunately this fails in Microsoft
542 // VJ++, which does not implement the UTF-8
543 // encoding. Theoretically, we should simply let it fail in
544 // that case, since the JVM is obviously broken if it
545 // doesn't support such a basic standard. But since there
546 // are still some users attempting to use VJ++ for
547 // development, we have dropped in a fallback which makes a
548 // second attempt using the platform's default encoding. In
549 // VJ++ this is apparently ASCII, which is a subset of
550 // UTF-8... and since the strings we'll be reading here are
551 // also primarily limited to the 7-bit ASCII range (at
552 // least, in English versions), this should work well
553 // enough to keep us on the air until we're ready to
554 // officially decommit from VJ++. [Edited comment from
555 // jkesselm]
556 BufferedReader rd;
557         try {
558             rd = new BufferedReader (new InputStreamReader (is, "UTF-8"));
559         } catch (java.io.UnsupportedEncodingException e) {
560             rd = new BufferedReader (new InputStreamReader (is));
561         }
562         
563         String factoryClassName = null;
564         try {
565             // XXX Does not handle all possible input as specified by the
566 // Jar Service Provider specification
567 factoryClassName = rd.readLine();
568             rd.close();
569         } catch (IOException x) {
570             // No provider found
571 return null;
572         }
573
574         if (factoryClassName != null &&
575             ! "".equals(factoryClassName)) {
576             debugPrintln("found in resource, value="
577                    + factoryClassName);
578
579             // Note: here we do not want to fall back to the current
580 // ClassLoader because we want to avoid the case where the
581 // resource file was found using one ClassLoader and the
582 // provider class was instantiated using a different one.
583 return factoryClassName;
584         }
585
586         // No provider found
587 return null;
588     }
589
590     //
591 // Classes
592 //
593
594     /**
595      * A configuration error.
596      */
597     static class ConfigurationError
598         extends Error {
599
600         //
601 // Data
602 //
603
604         /** Exception. */
605         private Exception exception;
606
607         //
608 // Constructors
609 //
610
611         /**
612          * Construct a new instance with the specified detail string and
613          * exception.
614          */
615         ConfigurationError(String msg, Exception x) {
616             super(msg);
617             this.exception = x;
618         } // <init>(String,Exception)
619
620         //
621 // Public methods
622 //
623
624         /** Returns the exception associated to this error. */
625         Exception getException() {
626             return exception;
627         } // getException():Exception
628
629     } // class ConfigurationError
630
631 } // class ObjectFactory
632

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags