jdk8-mips64-public/jaxws: src/share/jaxws_classes/com/sun/xml/internal/bind/v2/runtime/reflect/opt/Injector.java@b0610cd08440 (annotated)

src/share/jaxws_classes/com/sun/xml/internal/bind/v2/runtime/reflect/opt/Injector.java@b0610cd08440 (annotated)

src/share/jaxws_classes/com/sun/xml/internal/bind/v2/runtime/reflect/opt/Injector.java

Fri, 04 Oct 2013 16:21:34 +0100

author: mkos
date: Fri, 04 Oct 2013 16:21:34 +0100
changeset 408: b0610cd08440
parent 286: f50545b5e2f1
child 637: 9c07ef4934dd
permissions: -rw-r--r--

8025054: Update JAX-WS RI integration to 2.2.9-b130926.1035
Reviewed-by: chegar

 /*
  * Copyright (c) 1997, 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 com.sun.xml.internal.bind.v2.runtime.reflect.opt;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.lang.ref.WeakReference;
 import java.security.AccessController;
 import java.security.PrivilegedAction;
 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantReadWriteLock;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.WeakHashMap;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 import com.sun.xml.internal.bind.Util;
 import com.sun.xml.internal.bind.v2.runtime.reflect.Accessor;
 /**
  * A {@link ClassLoader} used to "inject" optimized accessor classes
  * into the VM.
  *
  * <p>
  * Its parent class loader needs to be set to the one that can see the user
  * class.
  *
  * @author Kohsuke Kawaguchi
  */
 final class Injector {
     /**
      * {@link Injector}s keyed by their parent {@link ClassLoader}.
      *
      * We only need one injector per one user class loader.
      */
     private static final ReentrantReadWriteLock irwl = new ReentrantReadWriteLock();
     private static final Lock ir = irwl.readLock();
     private static final Lock iw = irwl.writeLock();
     private static final Map<ClassLoader, WeakReference<Injector>> injectors =
             new WeakHashMap<ClassLoader, WeakReference<Injector>>();
     private static final Logger logger = Util.getClassLogger();
     /**
      * Injects a new class into the given class loader.
      *
      * @return null
      *      if it fails to inject.
      */
     static Class inject(ClassLoader cl, String className, byte[] image) {
         Injector injector = get(cl);
         if (injector != null) {
             return injector.inject(className, image);
         } else {
             return null;
         }
     }
     /**
      * Returns the already injected class, or null.
      */
     static Class find(ClassLoader cl, String className) {
         Injector injector = get(cl);
         if (injector != null) {
             return injector.find(className);
         } else {
             return null;
         }
     }
     /**
      * Gets or creates an {@link Injector} for the given class loader.
      *
      * @return null
      *      if it fails.
      */
     private static Injector get(ClassLoader cl) {
         Injector injector = null;
         WeakReference<Injector> wr;
         ir.lock();
         try {
             wr = injectors.get(cl);
         } finally {
             ir.unlock();
         }
         if (wr != null) {
             injector = wr.get();
         }
         if (injector == null) {
             try {
                 wr = new WeakReference<Injector>(injector = new Injector(cl));
                 iw.lock();
                 try {
                     if (!injectors.containsKey(cl)) {
                         injectors.put(cl, wr);
                     }
                 } finally {
                     iw.unlock();
                 }
             } catch (SecurityException e) {
                 logger.log(Level.FINE, "Unable to set up a back-door for the injector", e);
                 return null;
             }
         }
         return injector;
     }
     /**
      * Injected classes keyed by their names.
      */
     private final Map<String, Class> classes = new HashMap<String, Class>();
     private final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
     private final Lock r = rwl.readLock();
     private final Lock w = rwl.writeLock();
     private final ClassLoader parent;
     /**
      * True if this injector is capable of injecting accessors.
      * False otherwise, which happens if this classloader can't see {@link Accessor}.
      */
     private final boolean loadable;
     private static final Method defineClass;
     private static final Method resolveClass;
     private static final Method findLoadedClass;
     static {
         try {
             defineClass = ClassLoader.class.getDeclaredMethod("defineClass", String.class, byte[].class, Integer.TYPE, Integer.TYPE);
             resolveClass = ClassLoader.class.getDeclaredMethod("resolveClass", Class.class);
             findLoadedClass = ClassLoader.class.getDeclaredMethod("findLoadedClass", String.class);
         } catch (NoSuchMethodException e) {
             // impossible
             throw new NoSuchMethodError(e.getMessage());
         }
         AccessController.doPrivileged(new PrivilegedAction<Void>() {
             @Override
             public Void run() {
                 // TODO: check security implication
                 // do these setAccessible allow anyone to call these methods freely?s
                 defineClass.setAccessible(true);
                 resolveClass.setAccessible(true);
                 findLoadedClass.setAccessible(true);
                 return null;
             }
         });
     }
     private Injector(ClassLoader parent) {
         this.parent = parent;
         assert parent != null;
         boolean loadableCheck = false;
         try {
             loadableCheck = parent.loadClass(Accessor.class.getName()) == Accessor.class;
         } catch (ClassNotFoundException e) {
             // not loadable
         }
         this.loadable = loadableCheck;
     }
     @SuppressWarnings("LockAcquiredButNotSafelyReleased")
     private Class inject(String className, byte[] image) {
         if (!loadable) // this injector cannot inject anything
         {
             return null;
         }
         boolean wlocked = false;
         boolean rlocked = false;
         try {
             r.lock();
             rlocked = true;
             Class c = classes.get(className);
             // Unlock now during the findLoadedClass process to avoid
             // deadlocks
             r.unlock();
             rlocked = false;
             //find loaded class from classloader
             if (c == null) {
                 try {
                     c = (Class) findLoadedClass.invoke(parent, className.replace('/', '.'));
                 } catch (IllegalArgumentException e) {
                     logger.log(Level.FINE, "Unable to find " + className, e);
                 } catch (IllegalAccessException e) {
                     logger.log(Level.FINE, "Unable to find " + className, e);
                 } catch (InvocationTargetException e) {
                     Throwable t = e.getTargetException();
                     logger.log(Level.FINE, "Unable to find " + className, t);
                 }
                 if (c != null) {
                     w.lock();
                     wlocked = true;
                     classes.put(className, c);
                     w.unlock();
                     wlocked = false;
                     return c;
                 }
             }
             if (c == null) {
                 r.lock();
                 rlocked = true;
                 c = classes.get(className);
                 // Unlock now during the define/resolve process to avoid
                 // deadlocks
                 r.unlock();
                 rlocked = false;
                 if (c == null) {
                     // we need to inject a class into the
                     try {
                         c = (Class) defineClass.invoke(parent, className.replace('/', '.'), image, 0, image.length);
                         resolveClass.invoke(parent, c);
                     } catch (IllegalAccessException e) {
                         logger.log(Level.FINE, "Unable to inject " + className, e);
                         return null;
                     } catch (InvocationTargetException e) {
                         Throwable t = e.getTargetException();
                         if (t instanceof LinkageError) {
                             logger.log(Level.FINE, "duplicate class definition bug occured? Please report this : " + className, t);
                         } else {
                             logger.log(Level.FINE, "Unable to inject " + className, t);
                         }
                         return null;
                     } catch (SecurityException e) {
                         logger.log(Level.FINE, "Unable to inject " + className, e);
                         return null;
                     } catch (LinkageError e) {
                         logger.log(Level.FINE, "Unable to inject " + className, e);
                         return null;
                     }
                     w.lock();
                     wlocked = true;
                     // During the time we were unlocked, we could have tried to
                     // load the class from more than one thread. Check now to see
                     // if someone else beat us to registering this class
                     if (!classes.containsKey(className)) {
                         classes.put(className, c);
                     }
                     w.unlock();
                     wlocked = false;
                 }
             }
             return c;
         } finally {
             if (rlocked) {
                 r.unlock();
             }
             if (wlocked) {
                 w.unlock();
             }
         }
     }
     private Class find(String className) {
         r.lock();
         try {
             return classes.get(className);
         } finally {
             r.unlock();
         }
     }
 }

Mercurial > jdk8-mips64-public > jaxws / annotate

src/share/jaxws_classes/com/sun/xml/internal/bind/v2/runtime/reflect/opt/Injector.java@b0610cd08440 (annotated)

src/share/jaxws_classes/com/sun/xml/internal/bind/v2/runtime/reflect/opt/Injector.java