jdk8-mips64-public/jaxws: src/share/jaxws_classes/javax/xml/bind/ContextFinder.java@f453f4eaf8b4 (annotated)

src/share/jaxws_classes/javax/xml/bind/ContextFinder.java@f453f4eaf8b4 (annotated)

src/share/jaxws_classes/javax/xml/bind/ContextFinder.java

Tue, 07 Nov 2017 18:54:04 -0800

author: asaha
date: Tue, 07 Nov 2017 18:54:04 -0800
changeset 1528: f453f4eaf8b4
parent 397: b99d7e355d4b
child 637: 9c07ef4934dd
permissions: -rw-r--r--

Added tag jdk8u162-b06 for changeset 6095742f8034

 /*
  * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */
 package javax.xml.bind;
 import java.util.Iterator;
 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.UnsupportedEncodingException;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.net.URL;
 import java.util.Map;
 import java.util.Properties;
 import java.util.StringTokenizer;
 import java.util.logging.ConsoleHandler;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 import java.security.AccessController;
 import static javax.xml.bind.JAXBContext.JAXB_CONTEXT_FACTORY;
 /**
  * This class is package private and therefore is not exposed as part of the
  * JAXB API.
  *
  * This code is designed to implement the JAXB 1.0 spec pluggability feature
  *
  * @author <ul><li>Ryan Shoemaker, Sun Microsystems, Inc.</li></ul>
  * @see JAXBContext
  */
 class ContextFinder {
     private static final Logger logger;
     static {
         logger = Logger.getLogger("javax.xml.bind");
         try {
             if (AccessController.doPrivileged(new GetPropertyAction("jaxb.debug")) != null) {
                 // disconnect the logger from a bigger framework (if any)
                 // and take the matters into our own hands
                 logger.setUseParentHandlers(false);
                 logger.setLevel(Level.ALL);
                 ConsoleHandler handler = new ConsoleHandler();
                 handler.setLevel(Level.ALL);
                 logger.addHandler(handler);
             } else {
                 // don't change the setting of this logger
                 // to honor what other frameworks
                 // have done on configurations.
             }
         } catch(Throwable t) {
             // just to be extra safe. in particular System.getProperty may throw
             // SecurityException.
         }
     }
     /**
      * If the {@link InvocationTargetException} wraps an exception that shouldn't be wrapped,
      * throw the wrapped exception.
      */
     private static void handleInvocationTargetException(InvocationTargetException x) throws JAXBException {
         Throwable t = x.getTargetException();
         if( t != null ) {
             if( t instanceof JAXBException )
                 // one of our exceptions, just re-throw
                 throw (JAXBException)t;
             if( t instanceof RuntimeException )
                 // avoid wrapping exceptions unnecessarily
                 throw (RuntimeException)t;
             if( t instanceof Error )
                 throw (Error)t;
         }
     }
     /**
      * Determine if two types (JAXBContext in this case) will generate a ClassCastException.
      *
      * For example, (targetType)originalType
      *
      * @param originalType
      *          The Class object of the type being cast
      * @param targetType
      *          The Class object of the type that is being cast to
      * @return JAXBException to be thrown.
      */
     private static JAXBException handleClassCastException(Class originalType, Class targetType) {
         final URL targetTypeURL = which(targetType);
         return new JAXBException(Messages.format(Messages.ILLEGAL_CAST,
                 // we don't care where the impl class is, we want to know where JAXBContext lives in the impl
                 // class' ClassLoader
                 getClassClassLoader(originalType).getResource("javax/xml/bind/JAXBContext.class"),
                 targetTypeURL));
     }
     /**
      * Create an instance of a class using the specified ClassLoader
      */
     static JAXBContext newInstance( String contextPath,
                                String className,
                                ClassLoader classLoader,
                                Map properties )
         throws JAXBException {
         try {
             Class spFactory = safeLoadClass(className,classLoader);
             return newInstance(contextPath, spFactory, classLoader, properties);
         } catch (ClassNotFoundException x) {
             throw new JAXBException(
                 Messages.format( Messages.PROVIDER_NOT_FOUND, className ),
                 x);
         } catch (RuntimeException x) {
             // avoid wrapping RuntimeException to JAXBException,
             // because it indicates a bug in this code.
             throw x;
         } catch (Exception x) {
             // can't catch JAXBException because the method is hidden behind
             // reflection.  Root element collisions detected in the call to
             // createContext() are reported as JAXBExceptions - just re-throw it
             // some other type of exception - just wrap it
             throw new JAXBException(
                 Messages.format( Messages.COULD_NOT_INSTANTIATE, className, x ),
                 x);
         }
     }
     static JAXBContext newInstance( String contextPath,
                                Class spFactory,
                                ClassLoader classLoader,
                                Map properties )
         throws JAXBException
     {
         try {
             /*
              * javax.xml.bind.context.factory points to a class which has a
              * static method called 'createContext' that
              * returns a javax.xml.JAXBContext.
              */
             Object context = null;
             // first check the method that takes Map as the third parameter.
             // this is added in 2.0.
             try {
                 Method m = spFactory.getMethod("createContext",String.class,ClassLoader.class,Map.class);
                 // any failure in invoking this method would be considered fatal
                 context = m.invoke(null,contextPath,classLoader,properties);
             } catch (NoSuchMethodException e) {
                 // it's not an error for the provider not to have this method.
             }
             if(context==null) {
                 // try the old method that doesn't take properties. compatible with 1.0.
                 // it is an error for an implementation not to have both forms of the createContext method.
                 Method m = spFactory.getMethod("createContext",String.class,ClassLoader.class);
                 // any failure in invoking this method would be considered fatal
                 context = m.invoke(null,contextPath,classLoader);
             }
             if(!(context instanceof JAXBContext)) {
                 // the cast would fail, so generate an exception with a nice message
                 throw handleClassCastException(context.getClass(), JAXBContext.class);
             }
             return (JAXBContext)context;
         } catch (InvocationTargetException x) {
             handleInvocationTargetException(x);
             // for other exceptions, wrap the internal target exception
             // with a JAXBException
             Throwable e = x;
             if(x.getTargetException()!=null)
                 e = x.getTargetException();
             throw new JAXBException( Messages.format( Messages.COULD_NOT_INSTANTIATE, spFactory, e ), e );
         } catch (RuntimeException x) {
             // avoid wrapping RuntimeException to JAXBException,
             // because it indicates a bug in this code.
             throw x;
         } catch (Exception x) {
             // can't catch JAXBException because the method is hidden behind
             // reflection.  Root element collisions detected in the call to
             // createContext() are reported as JAXBExceptions - just re-throw it
             // some other type of exception - just wrap it
             throw new JAXBException(
                 Messages.format( Messages.COULD_NOT_INSTANTIATE, spFactory, x ),
                 x);
         }
     }
     /**
      * Create an instance of a class using the thread context ClassLoader
      */
     static JAXBContext newInstance(
                               Class[] classes,
                               Map properties,
                               String className) throws JAXBException {
         ClassLoader cl = getContextClassLoader();
         Class spi;
         try {
             spi = safeLoadClass(className,cl);
         } catch (ClassNotFoundException e) {
             throw new JAXBException(e);
         }
         if(logger.isLoggable(Level.FINE)) {
             // extra check to avoid costly which operation if not logged
             logger.log(Level.FINE, "loaded {0} from {1}", new Object[]{className, which(spi)});
         }
         return newInstance(classes, properties, spi);
     }
     static JAXBContext newInstance(Class[] classes,
                                    Map properties,
                                    Class spFactory) throws JAXBException {
         Method m;
         try {
             m = spFactory.getMethod("createContext", Class[].class, Map.class);
         } catch (NoSuchMethodException e) {
             throw new JAXBException(e);
         }
         try {
             Object context = m.invoke(null, classes, properties);
             if(!(context instanceof JAXBContext)) {
                 // the cast would fail, so generate an exception with a nice message
                 throw handleClassCastException(context.getClass(), JAXBContext.class);
             }
             return (JAXBContext)context;
         } catch (IllegalAccessException e) {
             throw new JAXBException(e);
         } catch (InvocationTargetException e) {
             handleInvocationTargetException(e);
             Throwable x = e;
             if (e.getTargetException() != null)
                 x = e.getTargetException();
             throw new JAXBException(x);
         }
     }
     static JAXBContext find(String factoryId, String contextPath, ClassLoader classLoader, Map properties ) throws JAXBException {
         // TODO: do we want/need another layer of searching in $java.home/lib/jaxb.properties like JAXP?
         final String jaxbContextFQCN = JAXBContext.class.getName();
         // search context path for jaxb.properties first
         StringBuilder propFileName;
         StringTokenizer packages = new StringTokenizer( contextPath, ":" );
         String factoryClassName;
         if(!packages.hasMoreTokens())
             // no context is specified
             throw new JAXBException(Messages.format(Messages.NO_PACKAGE_IN_CONTEXTPATH));
         logger.fine("Searching jaxb.properties");
         while( packages.hasMoreTokens() ) {
             String packageName = packages.nextToken(":").replace('.','/');
             // com.acme.foo - > com/acme/foo/jaxb.properties
              propFileName = new StringBuilder().append(packageName).append("/jaxb.properties");
             Properties props = loadJAXBProperties( classLoader, propFileName.toString() );
             if (props != null) {
                 if (props.containsKey(factoryId)) {
                     factoryClassName = props.getProperty(factoryId);
                     return newInstance( contextPath, factoryClassName, classLoader, properties );
                 } else {
                     throw new JAXBException(Messages.format(Messages.MISSING_PROPERTY, packageName, factoryId));
                 }
             }
         }
         logger.fine("Searching the system property");
         // search for a system property second (javax.xml.bind.JAXBContext)
         factoryClassName = AccessController.doPrivileged(new GetPropertyAction(JAXBContext.JAXB_CONTEXT_FACTORY));
         if(  factoryClassName != null ) {
             return newInstance( contextPath, factoryClassName, classLoader, properties );
         } else { // leave this here to assure compatibility
             factoryClassName = AccessController.doPrivileged(new GetPropertyAction(jaxbContextFQCN));
             if(  factoryClassName != null ) {
                 return newInstance( contextPath, factoryClassName, classLoader, properties );
             }
         }
         // OSGi search
         Class jaxbContext = lookupJaxbContextUsingOsgiServiceLoader();
         if (jaxbContext != null) {
             logger.fine("OSGi environment detected");
             return newInstance(contextPath, jaxbContext, classLoader, properties);
         }
         logger.fine("Searching META-INF/services");
         // search META-INF services next
         BufferedReader r = null;
         try {
             final StringBuilder resource = new StringBuilder().append("META-INF/services/").append(jaxbContextFQCN);
             final InputStream resourceStream =
                     classLoader.getResourceAsStream(resource.toString());
             if (resourceStream != null) {
                 r = new BufferedReader(new InputStreamReader(resourceStream, "UTF-8"));
                 factoryClassName = r.readLine();
                 if (factoryClassName != null) {
                     factoryClassName = factoryClassName.trim();
                 }
                 r.close();
                 return newInstance(contextPath, factoryClassName, classLoader, properties);
             } else {
                 logger.log(Level.FINE, "Unable to load:{0}", resource.toString());
             }
         } catch (UnsupportedEncodingException e) {
             // should never happen
             throw new JAXBException(e);
         } catch (IOException e) {
             throw new JAXBException(e);
         } finally {
             try {
                 if (r != null) {
                     r.close();
                 }
             } catch (IOException ex) {
                 Logger.getLogger(ContextFinder.class.getName()).log(Level.SEVERE, null, ex);
             }
         }
         // else no provider found
         logger.fine("Trying to create the platform default provider");
         return newInstance(contextPath, PLATFORM_DEFAULT_FACTORY_CLASS, classLoader, properties);
     }
     static JAXBContext find( Class[] classes, Map properties ) throws JAXBException {
         final String jaxbContextFQCN = JAXBContext.class.getName();
         String factoryClassName;
         // search for jaxb.properties in the class loader of each class first
         for (final Class c : classes) {
             // this classloader is used only to load jaxb.properties, so doing this should be safe.
             ClassLoader classLoader = getClassClassLoader(c);
             Package pkg = c.getPackage();
             if(pkg==null)
                 continue;       // this is possible for primitives, arrays, and classes that are loaded by poorly implemented ClassLoaders
             String packageName = pkg.getName().replace('.', '/');
             // TODO: do we want to optimize away searching the same package?  org.Foo, org.Bar, com.Baz
             //       classes from the same package might come from different class loades, so it might be a bad idea
             // TODO: it's easier to look things up from the class
             // c.getResourceAsStream("jaxb.properties");
             // build the resource name and use the property loader code
             String resourceName = packageName+"/jaxb.properties";
             logger.log(Level.FINE, "Trying to locate {0}", resourceName);
             Properties props = loadJAXBProperties(classLoader, resourceName);
             if (props == null) {
                 logger.fine("  not found");
             } else {
                 logger.fine("  found");
                 if (props.containsKey(JAXB_CONTEXT_FACTORY)) {
                     // trim() seems redundant, but adding to satisfy customer complaint
                     factoryClassName = props.getProperty(JAXB_CONTEXT_FACTORY).trim();
                     return newInstance(classes, properties, factoryClassName);
                 } else {
                     throw new JAXBException(Messages.format(Messages.MISSING_PROPERTY, packageName, JAXB_CONTEXT_FACTORY));
                 }
             }
         }
         // search for a system property second (javax.xml.bind.JAXBContext)
         logger.log(Level.FINE, "Checking system property {0}", JAXBContext.JAXB_CONTEXT_FACTORY);
         factoryClassName = AccessController.doPrivileged(new GetPropertyAction(JAXBContext.JAXB_CONTEXT_FACTORY));
         if (factoryClassName != null) {
             logger.log(Level.FINE, "  found {0}", factoryClassName);
             return newInstance( classes, properties, factoryClassName );
         } else { // leave it here for compatibility reasons
             logger.fine("  not found");
             logger.log(Level.FINE, "Checking system property {0}", jaxbContextFQCN);
             factoryClassName = AccessController.doPrivileged(new GetPropertyAction(jaxbContextFQCN));
             if (factoryClassName != null) {
                 logger.log(Level.FINE, "  found {0}", factoryClassName);
                 return newInstance( classes, properties, factoryClassName );
             } else {
                 logger.fine("  not found");
             }
         }
         // OSGi search
         Class jaxbContext = lookupJaxbContextUsingOsgiServiceLoader();
         if (jaxbContext != null) {
             logger.fine("OSGi environment detected");
             return newInstance(classes, properties, jaxbContext);
         }
         // search META-INF services next
         logger.fine("Checking META-INF/services");
         BufferedReader r = null;
         try {
             final String resource = new StringBuilder("META-INF/services/").append(jaxbContextFQCN).toString();
             ClassLoader classLoader = getContextClassLoader();
             URL resourceURL;
             if(classLoader==null)
                 resourceURL = ClassLoader.getSystemResource(resource);
             else
                 resourceURL = classLoader.getResource(resource);
             if (resourceURL != null) {
                 logger.log(Level.FINE, "Reading {0}", resourceURL);
                 r = new BufferedReader(new InputStreamReader(resourceURL.openStream(), "UTF-8"));
                 factoryClassName = r.readLine();
                 if (factoryClassName != null) {
                     factoryClassName = factoryClassName.trim();
                 }
                 return newInstance(classes, properties, factoryClassName);
             } else {
                 logger.log(Level.FINE, "Unable to find: {0}", resource);
             }
         } catch (UnsupportedEncodingException e) {
             // should never happen
             throw new JAXBException(e);
         } catch (IOException e) {
             throw new JAXBException(e);
         } finally {
             if (r != null) {
                 try {
                     r.close();
                 } catch (IOException ex) {
                     logger.log(Level.FINE, "Unable to close stream", ex);
                 }
             }
         }
         // else no provider found
         logger.fine("Trying to create the platform default provider");
         return newInstance(classes, properties, PLATFORM_DEFAULT_FACTORY_CLASS);
     }
     private static Class lookupJaxbContextUsingOsgiServiceLoader() {
         try {
             // Use reflection to avoid having any dependency on ServiceLoader class
             Class target = Class.forName("com.sun.org.glassfish.hk2.osgiresourcelocator.ServiceLoader");
             Method m = target.getMethod("lookupProviderClasses", Class.class);
             Iterator iter = ((Iterable) m.invoke(null, JAXBContext.class)).iterator();
             return iter.hasNext() ? (Class)iter.next() : null;
         } catch(Exception e) {
             logger.log(Level.FINE, "Unable to find from OSGi: javax.xml.bind.JAXBContext");
             return null;
         }
     }
     private static Properties loadJAXBProperties( ClassLoader classLoader,
                                                   String propFileName )
         throws JAXBException {
         Properties props = null;
         try {
             URL url;
             if(classLoader==null)
                 url = ClassLoader.getSystemResource(propFileName);
             else
                 url = classLoader.getResource( propFileName );
             if( url != null ) {
                 logger.log(Level.FINE, "loading props from {0}", url);
                 props = new Properties();
                 InputStream is = url.openStream();
                 props.load( is );
                 is.close();
             }
         } catch( IOException ioe ) {
             logger.log(Level.FINE,"Unable to load "+propFileName,ioe);
             throw new JAXBException( ioe.toString(), ioe );
         }
         return props;
     }
     /**
      * Search the given ClassLoader for an instance of the specified class and
      * return a string representation of the URL that points to the resource.
      *
      * @param clazz
      *          The class to search for
      * @param loader
      *          The ClassLoader to search.  If this parameter is null, then the
      *          system class loader will be searched
      * @return
      *          the URL for the class or null if it wasn't found
      */
     static URL which(Class clazz, ClassLoader loader) {
         String classnameAsResource = clazz.getName().replace('.', '/') + ".class";
         if(loader == null) {
             loader = getSystemClassLoader();
         }
         return loader.getResource(classnameAsResource);
     }
     /**
      * Get the URL for the Class from it's ClassLoader.
      *
      * Convenience method for {@link #which(Class, ClassLoader)}.
      *
      * Equivalent to calling: which(clazz, clazz.getClassLoader())
      *
      * @param clazz
      *          The class to search for
      * @return
      *          the URL for the class or null if it wasn't found
      */
     static URL which(Class clazz) {
         return which(clazz, getClassClassLoader(clazz));
     }
     /**
      * When JAXB is in J2SE, rt.jar has to have a JAXB implementation.
      * However, rt.jar cannot have META-INF/services/javax.xml.bind.JAXBContext
      * because if it has, it will take precedence over any file that applications have
      * in their jar files.
      *
      * <p>
      * When the user bundles his own JAXB implementation, we'd like to use it, and we
      * want the platform default to be used only when there's no other JAXB provider.
      *
      * <p>
      * For this reason, we have to hard-code the class name into the API.
      */
     private static final String PLATFORM_DEFAULT_FACTORY_CLASS = "com.sun.xml.internal.bind.v2.ContextFactory";
     /**
      * Loads the class, provided that the calling thread has an access to the class being loaded.
      */
     private static Class safeLoadClass(String className, ClassLoader classLoader) throws ClassNotFoundException {
        logger.log(Level.FINE, "Trying to load {0}", className);
        try {
           // make sure that the current thread has an access to the package of the given name.
           SecurityManager s = System.getSecurityManager();
           if (s != null) {
               int i = className.lastIndexOf('.');
               if (i != -1) {
                   s.checkPackageAccess(className.substring(0,i));
               }
           }
           if (classLoader == null) {
               return Class.forName(className);
           } else {
               return classLoader.loadClass(className);
           }
        } catch (SecurityException se) {
            // anyone can access the platform default factory class without permission
            if (PLATFORM_DEFAULT_FACTORY_CLASS.equals(className)) {
               return Class.forName(className);
            }
            throw se;
        }
     }
     private static ClassLoader getContextClassLoader() {
         if (System.getSecurityManager() == null) {
             return Thread.currentThread().getContextClassLoader();
         } else {
             return (ClassLoader) java.security.AccessController.doPrivileged(
                     new java.security.PrivilegedAction() {
                         public java.lang.Object run() {
                             return Thread.currentThread().getContextClassLoader();
                         }
                     });
         }
     }
     private static ClassLoader getClassClassLoader(final Class c) {
         if (System.getSecurityManager() == null) {
             return c.getClassLoader();
         } else {
             return (ClassLoader) java.security.AccessController.doPrivileged(
                     new java.security.PrivilegedAction() {
                         public java.lang.Object run() {
                             return c.getClassLoader();
                         }
                     });
         }
     }
     private static ClassLoader getSystemClassLoader() {
         if (System.getSecurityManager() == null) {
             return ClassLoader.getSystemClassLoader();
         } else {
             return (ClassLoader) java.security.AccessController.doPrivileged(
                     new java.security.PrivilegedAction() {
                         public java.lang.Object run() {
                             return ClassLoader.getSystemClassLoader();
                         }
                     });
         }
     }
 }

Mercurial > jdk8-mips64-public > jaxws / annotate

src/share/jaxws_classes/javax/xml/bind/ContextFinder.java@f453f4eaf8b4 (annotated)

src/share/jaxws_classes/javax/xml/bind/ContextFinder.java