/** prefix for all proxy class names */
    // #1
   private final static String proxyClassNamePrefix = "$Proxy";

   /** parameter types of a proxy class constructor */
   private final static Class[] constructorParams =
    { InvocationHandler.class };

   /** maps a class loader to the proxy class cache for that loader */
    // #2
   private static Map loaderToCache = new WeakHashMap();

   /** marks that a particular proxy class is currently being generated */
// #3
   private static Object pendingGenerationMarker = new Object();

   /** next number to use for generation of unique proxy class names */
   private static long nextUniqueNumber = 0;
   private static Object nextUniqueNumberLock = new Object();

   /** set of all generated proxy classes, for isProxyClass implementation */
// #4
   private static Map proxyClasses = Collections.synchronizedMap(new WeakHashMap());

  public static Class<?> getProxyClass(ClassLoader loader,  Class<?>... interfaces) throws IllegalArgumentException
  {
   if (interfaces.length > 65535) {
       throw new IllegalArgumentException("interface limit exceeded");
   }
   Class proxyClass = null;

   /* collect interface names to use as key for proxy class cache */
   // #1  
   String[] interfaceNames = new String[interfaces.length];
 
   Set interfaceSet = new HashSet();     // for detecting duplicates
 
   for (int i = 0; i < interfaces.length; i++) {
       /*
        * Verify that the class loader resolves the name of this
        * interface to the same Class object.
        */

       String interfaceName = interfaces[i].getName();

       Class interfaceClass = null;
       try {
              // #2 
              interfaceClass = Class.forName(interfaceName, false, loader);
       } catch (ClassNotFoundException e) {
       }
        // #3 
       if (interfaceClass != interfaces[i]) {
        throw new IllegalArgumentException(
            interfaces[i] + " is not visible from class loader");
       }

       /*
        * Verify that the Class object actually represents an
        * interface.
        */
       if (!interfaceClass.isInterface()) {
        throw new IllegalArgumentException(
            interfaceClass.getName() + " is not an interface");
       }

       /*
        * Verify that this interface is not a duplicate.
        */
        // #4 
       if (interfaceSet.contains(interfaceClass)) {
        throw new IllegalArgumentException(
            "repeated interface: " + interfaceClass.getName());
       }
       
       interfaceSet.add(interfaceClass);

       interfaceNames[i] = interfaceName;
   }

   /*
   * Using string representations of the proxy interfaces as
   * keys in the proxy class cache (instead of their Class
   * objects) is sufficient because we require the proxy
   * interfaces to be resolvable by name through the supplied
   * class loader, and it has the advantage that using a string
   * representation of a class makes for an implicit weak
   * reference to the class.
   */
   Object key = Arrays.asList(interfaceNames);

   /*
   * Find or create the proxy class cache for the class loader.
   */
   Map cache;
// #5 
   synchronized (loaderToCache) {
        // #6 
       cache = (Map) loaderToCache.get(loader);
       if (cache == null) {
             cache = new HashMap();
             loaderToCache.put(loader, cache);
       }
       /*
        * This mapping will remain valid for the duration of this
        * method, without further synchronization, because the mapping
        * will only be removed if the class loader becomes unreachable.
        */
   }

   /*
   * Look up the list of interfaces in the proxy class cache using
   * the key.  This lookup will result in one of three possible
   * kinds of values:
   *     null, if there is currently no proxy class for the list of
   *         interfaces in the class loader,
   *     the pendingGenerationMarker object, if a proxy class for the
   *         list of interfaces is currently being generated,
   *     or a weak reference to a Class object, if a proxy class for
   *         the list of interfaces has already been generated.
   */
// #7 
   synchronized (cache) {
       /*
        * Note that we need not worry about reaping the cache for
        * entries with cleared weak references because if a proxy class
        * has been garbage collected, its class loader will have been
        * garbage collected as well, so the entire cache will be reaped
        * from the loaderToCache map.
        */
       do {
             // #8 
             Object value = cache.get(key);
        if (value instanceof Reference) {
            proxyClass = (Class) ((Reference) value).get();
        }
        if (proxyClass != null) {
            // proxy class already generated: return it
            return proxyClass;
        // #9 
        } else if (value == pendingGenerationMarker) {
            // proxy class being generated: wait for it
            try {
                cache.wait();
            } catch (InterruptedException e) {
             /*
             * The class generation that we are waiting for should
             * take a small, bounded time, so we can safely ignore
             * thread interrupts here.
             */
            }
            continue;
        } else {
            /*
             * No proxy class for this list of interfaces has been
             * generated or is being generated, so we will go and
             * generate it now.  Mark it as pending generation.
             */
            // #10 
            cache.put(key, pendingGenerationMarker);
            break;
        }
       } while (true);
   }

   try {
       
       String proxyPkg = null;     // package to define proxy class in

       /*
        * Record the package of a non-public proxy interface so that the
        * proxy class will be defined in the same package.  Verify that
        * all non-public proxy interfaces are in the same package.
        */
       for (int i = 0; i < interfaces.length; i++) {
             int flags = interfaces[i].getModifiers();
             if (!Modifier.isPublic(flags)) {
                  String name = interfaces[i].getName();
                  int n = name.lastIndexOf('.');
                  String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
                  if (proxyPkg == null) {
                       proxyPkg = pkg;
                  } else if (!pkg.equals(proxyPkg)) {
                       throw new IllegalArgumentException(
                            "non-public interfaces from different packages");
                  }
             }
       }

       if (proxyPkg == null) {     // if no non-public proxy interfaces,
             proxyPkg = "";          // use the unnamed package
       }

       {
        /*
        * Choose a name for the proxy class to generate.
        */
        long num;
        synchronized (nextUniqueNumberLock) {
            num = nextUniqueNumber++;
        }
        String proxyName = proxyPkg + proxyClassNamePrefix + num;
        /*
        * Verify that the class loader hasn't already
        * defined a class with the chosen name.
        */

        /*
        * Generate the specified proxy class.
        */
        byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces);
        try {
             //native
            proxyClass = defineClass0(loader, proxyName, proxyClassFile, 0, proxyClassFile.length);
        } catch (ClassFormatError e) {
            /*
             * A ClassFormatError here means that (barring bugs in the
             * proxy class generation code) there was some other
             * invalid aspect of the arguments supplied to the proxy
             * class creation (such as virtual machine limitations
             * exceeded).
             */
            throw new IllegalArgumentException(e.toString());
        }
       }
       // add to set of all generated proxy classes, for isProxyClass
        //  #11 
       proxyClasses.put(proxyClass, null);

   } finally {
       /*
        * We must clean up the "pending generation" state of the proxy
        * class cache entry somehow.  If a proxy class was successfully
        * generated, store it in the cache (with a weak reference);
        * otherwise, remove the reserved entry.  In all cases, notify
        * all waiters on reserved entries in this cache.
        */
  //  #12 
       synchronized (cache) {
        if (proxyClass != null) {
            cache.put(key, new WeakReference(proxyClass));
        } else {
            cache.remove(key);
        }
        cache.notifyAll();
       }
   }
   return proxyClass;
  }

/**
     * Returns an instance of a proxy class for the specified interfaces
     * that dispatches method invocations to the specified invocation
     * handler.  This method is equivalent to:
     * <pre>
     *     Proxy.getProxyClass(loader, interfaces).
     *         getConstructor(new Class[] { InvocationHandler.class }).
     *         newInstance(new Object[] { handler });
     * </pre>
     *
     * <p><code>Proxy.newProxyInstance</code> throws
     * <code>IllegalArgumentException</code> for the same reasons that
     * <code>Proxy.getProxyClass</code> does.
     *
     * @param     loader the class loader to define the proxy class
     * @param     interfaces the list of interfaces for the proxy class
     *          to implement
     * @param   h the invocation handler to dispatch method invocations to
     * @return     a proxy instance with the specified invocation handler of a
     *          proxy class that is defined by the specified class loader
     *          and that implements the specified interfaces
     * @throws     IllegalArgumentException if any of the restrictions on the
     *          parameters that may be passed to <code>getProxyClass</code>
     *          are violated
     * @throws     NullPointerException if the <code>interfaces</code> array
     *          argument or any of its elements are <code>null</code>, or
     *          if the invocation handler, <code>h</code>, is
     *          <code>null</code>
     */
    public static Object newProxyInstance(ClassLoader loader,
                           Class<?>[] interfaces,
                           InvocationHandler h)
     throws IllegalArgumentException
    {
     if (h == null) {
         throw new NullPointerException();
     }

     /*
     * Look up or generate the designated proxy class.
     */
	 // #1
     Class cl = getProxyClass(loader, interfaces);

     /*
     * Invoke its constructor with the designated invocation handler.
     */
     try {
         Constructor cons = cl.getConstructor(constructorParams);
         return (Object) cons.newInstance(new Object[] { h });
     } catch (NoSuchMethodException e) {
         throw new InternalError(e.toString());
     } catch (IllegalAccessException e) {
         throw new InternalError(e.toString());
     } catch (InstantiationException e) {
         throw new InternalError(e.toString());
     } catch (InvocationTargetException e) {
         throw new InternalError(e.toString());
     }
    }

    /**
     * Returns true if and only if the specified class was dynamically
     * generated to be a proxy class using the <code>getProxyClass</code>
     * method or the <code>newProxyInstance</code> method.
     *
     * <p>The reliability of this method is important for the ability
     * to use it to make security decisions, so its implementation should
     * not just test if the class in question extends <code>Proxy</code>.
     *
     * @param     cl the class to test
     * @return  <code>true</code> if the class is a proxy class and
     *          <code>false</code> otherwise
     * @throws     NullPointerException if <code>cl</code> is <code>null</code>
     */
    public static boolean isProxyClass(Class<?> cl) {
     if (cl == null) {
         throw new NullPointerException();
     }

     return proxyClasses.containsKey(cl);
    }