Esempio n. 1
0
  /** @param args */
  public static void main(String[] args) {
    String proxyName = "TempProxy";

    TempImpl t = new TempImpl("proxy");
    // TempProxy t = new TempProxy("proxy");
    Class[] interfaces = t.getClass().getInterfaces();
    byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces);

    // File f = new File("classes/TempProxy.class");
    File f =
        new File(
            "D:\\workspace\\mianshi\\WebRoot\\WEB-INF\\classes\\com\\geek\\proxy\\TempProxy.class");
    try {
      FileOutputStream fos = new FileOutputStream(f);
      fos.write(proxyClassFile);
      fos.flush();
      fos.close();
    } catch (FileNotFoundException e) {
      e.printStackTrace(); // To change body of catch statement use File | Settings | File
      // Templates.
    } catch (IOException e) {
      e.printStackTrace(); // To change body of catch statement use File | Settings | File
      // Templates.
    }
  }
Esempio n. 2
0
  public static void main(String[] args) throws Exception {
    Subject sub = new RealSubject();
    Subject proxySub =
        (Subject)
            Proxy.newProxyInstance(
                Subject.class.getClassLoader(), new Class[] {Subject.class}, new ProxyHandler(sub));
    proxySub.say("fengxiang");
    byte[] buffer = ProxyGenerator.generateProxyClass("ProxyClass", new Class[] {Subject.class});
    FileOutputStream out = new FileOutputStream("ProxyClass.class");
    out.write(buffer);
    out.close();

    // 从这里可以看到具体的接口创建代理的时候, 只会创建一个代理类, 而当前代理类的构造方法的参数就是InvocationHandler接口的对象, 所以如果
    // 想要生成不同的对象, 并且有不同的功能, 此时直接设置不同的InvocationHandler就可以了, 就可以表现出完全不一样的行为。
    // 从这里可以看到类肯定只是生成一次, 剩下的仅仅只是生成对象, 仅此而已, 所以一般情况下来说并不会有太大的性能影响的。
    Subject proxySub2 =
        (Subject)
            Proxy.newProxyInstance(
                Subject.class.getClassLoader(), new Class[] {Subject.class}, new ProxyHandler(sub));
    System.out.println(proxySub.getClass() == proxySub2.getClass()); // true
  }
Esempio n. 3
0
  /**
   * Returns the {@code java.lang.Class} object for a proxy class given a class loader and an array
   * of interfaces. The proxy class will be defined by the specified class loader and will implement
   * all of the supplied interfaces. If a proxy class for the same permutation of interfaces has
   * already been defined by the class loader, then the existing proxy class will be returned;
   * otherwise, a proxy class for those interfaces will be generated dynamically and defined by the
   * class loader.
   *
   * <p>There are several restrictions on the parameters that may be passed to {@code
   * Proxy.getProxyClass}:
   *
   * <ul>
   *   <li>All of the {@code Class} objects in the {@code interfaces} array must represent
   *       interfaces, not classes or primitive types.
   *   <li>No two elements in the {@code interfaces} array may refer to identical {@code Class}
   *       objects.
   *   <li>All of the interface types must be visible by name through the specified class loader. In
   *       other words, for class loader {@code cl} and every interface {@code i}, the following
   *       expression must be true:
   *       <pre>
   *     Class.forName(i.getName(), false, cl) == i
   * </pre>
   *   <li>All non-public interfaces must be in the same package; otherwise, it would not be
   *       possible for the proxy class to implement all of the interfaces, regardless of what
   *       package it is defined in.
   *   <li>For any set of member methods of the specified interfaces that have the same signature:
   *       <ul>
   *         <li>If the return type of any of the methods is a primitive type or void, then all of
   *             the methods must have that same return type.
   *         <li>Otherwise, one of the methods must have a return type that is assignable to all of
   *             the return types of the rest of the methods.
   *       </ul>
   *   <li>The resulting proxy class must not exceed any limits imposed on classes by the virtual
   *       machine. For example, the VM may limit the number of interfaces that a class may
   *       implement to 65535; in that case, the size of the {@code interfaces} array must not
   *       exceed 65535.
   * </ul>
   *
   * <p>If any of these restrictions are violated, {@code Proxy.getProxyClass} will throw an {@code
   * IllegalArgumentException}. If the {@code interfaces} array argument or any of its elements are
   * {@code null}, a {@code NullPointerException} will be thrown.
   *
   * <p>Note that the order of the specified proxy interfaces is significant: two requests for a
   * proxy class with the same combination of interfaces but in a different order will result in two
   * distinct proxy classes.
   *
   * @param loader the class loader to define the proxy class
   * @param interfaces the list of interfaces for the proxy class to implement
   * @return a proxy class that is defined in 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} are violated
   * @throws NullPointerException if the {@code interfaces} array argument or any of its elements
   *     are {@code null}
   */
  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 */
    String[] interfaceNames = new String[interfaces.length];

    // for detecting duplicates
    Set<Class<?>> interfaceSet = new HashSet<>();

    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 {
        interfaceClass = Class.forName(interfaceName, false, loader);
      } catch (ClassNotFoundException e) {
      }
      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.
       */
      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.
     */
    List<String> key = Arrays.asList(interfaceNames);

    /*
     * Find or create the proxy class cache for the class loader.
     */
    Map<List<String>, Object> cache;
    synchronized (loaderToCache) {
      cache = 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.
     */
    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 {
        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;
        } 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.
           */
          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 {
          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
      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.
       */
      synchronized (cache) {
        if (proxyClass != null) {
          cache.put(key, new WeakReference<Class<?>>(proxyClass));
        } else {
          cache.remove(key);
        }
        cache.notifyAll();
      }
    }
    return proxyClass;
  }