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$
18   */
19  
20  package org.apache.xml.utils;
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:  $
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