FWD » Core Development » Base Language

/*

** Module   : StaticProxy.java

** Abstract : Utility class to create proxies which map interface methods to

**            static methods.

**

** Copyright (c) 2013, Golden Code Development Corporation.

** ALL RIGHTS RESERVED. Use is subject to license terms.

**

**           Golden Code Development Corporation

**                      CONFIDENTIAL

**

** -#- -I- --Date-- -----------------------Description------------------------

** 001 CA  20130112 Created initial version.

** 002 CA  20131015 Added helpers to query the static methods for a given proxy.

*/

package com.goldencode.proxy;

import java.lang.reflect.*;

import java.util.*;

import com.goldencode.p2j.classloader.MultiClassLoader;

/**

 * Create a static proxy which maps all interface methods to static method

 * in the specified classes.

 * <p>

 * To {@link #obtain(Class, Class[]) obtain a static proxy use }, specify the  

 * interface and a list of classes from where the static methods will be  

 * collected and mapped.  If for an interface method an static method 

 * equivalent can not be found, then the proxy creation will fail with a

 * {@link RuntimeException}.

 * <p>

 * All proxies are saved for the life-time of the application. If you need to

 * remove a static proxy, use {@link #remove(Class)}. Else, the static proxy

 * will be built on the first {@link #obtain(Class, Class[])} call, and any 

 * subsequent calls will return the cached proxy instance for that interface

 * (from the {@link StaticProxy#staticProxies} map).

 */

public class StaticProxy

implements InvocationHandler

{

   /** Cache of created static proxyies, by interface. */

   private static Map<Class<?>, Object> staticProxies =  

                                              new HashMap<Class<?>, Object>();

   /** Map of interface methods to static equivalent. */

   private final Map<Method, Method> im2sm = new HashMap<Method, Method>();

   /** The interface for this static proxy. */

   private final Class<?> ifc;

   /**

    * Remove the static proxy for the given interface, if it exists.

    *   

    * @param    ifc

    *           The interface for which its static proxy needs to be removed. 

    */

   public static synchronized void remove(Class ifc)

   {

      staticProxies.remove(ifc);

   }

   /**

    * Check if the given instance is a static proxy. All following conditions must be met:

    * <ol>

    *    <li>The instance's class must implement exactly one interface.</li>

    *    <li>The {@link #staticProxies} must have an entry for the implemented interface.</li>

    * </ol>

    * 

    * @param    instance

    *           The instance to check.

    *           

    * @return   <code>true</code> if the instance is a static proxy.

    */

   public static synchronized boolean isStaticProxy(Object instance)

   {

      Class<?> cls = instance.getClass();

      Class<?>[] ifcs = cls.getInterfaces();

      Class<?> ifc = null;

      if (ifcs.length == 1)

      {

         ifc = ifcs[0];

      }

      return ifc != null && staticProxies.containsKey(ifc);

   }

   /**

    * Get the static methods implementing the static proxy represented by the given instance.  If

    * the instance is not a static proxy, an empty list is returned.

    * 

    * @param    instance

    *           The proxy instance for which the static methods are needed.

    *           

    * @return   The list of static methods.

    */

   public static List<Method> getStaticMethods(Object instance)

   {

      List<Method> result = new ArrayList<Method>();

      if (!isStaticProxy(instance))

      {

         // return an empty list; use StaticProxy.isStaticProxy to make sure this is a proxy

         return result;

      }

      StaticProxy proxy = (StaticProxy) Proxy.getInvocationHandler(instance);

      result.addAll(proxy.im2sm.values());

      return result;

   }

   /**

    * Get the static proxy instance for the given interface.  If it does not

    * exist, return <code>null</code>

    *   

    * @param    ifc

    *           The interface for which the proxy is needed.

    *            

    * @return   See above.

    */

   public static synchronized <T> T obtain(Class<T> ifc)

   {

      return (T) staticProxies.get(ifc);

   }

   /**

    * Get the static proxy instance for the given interface, if it was already

    * created by a previous call.  Else, create it first.

    *   

    * @param    ifc

    *           The proxy interface.

    * @param    staticClasses

    *           The classes which statically implement the proxy's methods.

    * 

    * @return   The static proxy instance.

    */

   public static synchronized <T> T obtain(Class<T> ifc,

                                           Class<?>[] staticClasses)

   {

      // for all static proxy there is only one instance

      T proxy = (T) staticProxies.get(ifc);

      if (proxy == null)

      {

         ClassLoader cl = MultiClassLoader.class.getClassLoader();

         Class<?>[] ifaces = new Class<?>[] { ifc };

         StaticProxy sp = new StaticProxy(ifc, staticClasses);

         proxy = (T) Proxy.newProxyInstance(cl, ifaces, sp);

         staticProxies.put(ifc,  proxy);

      }

      return proxy;

   }

   /**

    * Create and initialize a new static proxy for the given interface and

    * implementation classes.

    * <p>

    * If not all interface methods are implemented by the specified classes,

    * a {@link RuntimeException} is thrown.

    * 

    * @param    ifc

    *           The proxy interface.

    * @param    staticClasses

    *           The classes which statically implement the proxy's methods.

    */

   private StaticProxy(Class<?> ifc, Class<?>[] staticClasses)

   {

      this.ifc = ifc;

      init(staticClasses);

   }

   /**

    * Invokes the specified method by determining its associated static 

    * implementation from the {@link #im2sm} map. If the method is

    * {@link Object#equals(Object)}, then the proxy reference is compared to

    * the references from <code>args[0]</code>; if the method is 

    * {@link Object#hashCode()}, then the {@link #ifc}'s hashcode is returned.

    * if The method is not found in the {@link #im2sm} map, a 

    * {@link RuntimeException} is generated.

    * 

    * @param    proxy

    *           The proxy instance that the method was invoked on

    * @param    method

    *           The <code>Method</code> instance corresponding to

    *           the interface method invoked on the proxy instance.

    * @param    args

    *           An array of objects containing the values of the arguments 

    *           passed in the method invocation on the proxy instance,

    *           or <code>null</code> if interface method takes no arguments.

    *

    * @return   The value returned by the static method, depending on each 

    *           API call.

    *  

    * @throws   Throwable

    *           If any exceptions are encounted during the static call.

    */

   public Object invoke(Object proxy, Method method, Object[] args)

   throws Throwable

   {

      if (Object.class == method.getDeclaringClass())

      {

         String name = method.getName();

         if ("equals".equals(name))

         {

            return proxy == args[0];

         }

         if ("hashCode".equals(name))

         {

            return ifc.hashCode();

         }

      }

      Method mstatic = im2sm.get(method);

      if (mstatic == null)

      {

         throw new RuntimeException("Static method was not found for proxy" +

                                    " method " + method.toString() + 

                                    " in static proxy " + 

                                    proxy.getClass().getName());

      }

      return mstatic.invoke(null, args);

   }

   /**

    * Initialize this static proxy. If for an interface method there is more

    * than one static method equivalent (or no static method) in the given

    * classes, a {@link RuntimeException} is thrown. 

    *  

    * @param    staticClasses

    *           The classes which statically implement the proxy's methods.

    */

   private void init(Class<?>[] staticClasses)

   {

      // method signature to static class method

      Map<String, Method>[] s2cm = new HashMap[staticClasses.length];

      for (int i = 0; i < staticClasses.length; i++)

      {

         Method[] methods = staticClasses[i].getMethods();

         s2cm[i] = new HashMap<String, Method>();

         for (int j = 0; j < methods.length; j++)

         {

            Method m = methods[j];

            int mods = m.getModifiers();

            if (!Modifier.isStatic(mods) || !Modifier.isPublic(mods))

            {

               continue;

            }

            s2cm[i].put(getSignature(m), m);

         }

      }

      String ifcName = ifc.getName();

      Method[] methods = ifc.getMethods();

      for (int i = 0; i < methods.length; i++)

      {

         Method im = methods[i];

         String signature = getSignature(im);

         Method mstatic = null;

         for (int j = 0; j < staticClasses.length; j++)

         {

            Method m = s2cm[j].get(signature);

            if (m != null)

            {

               if (mstatic != null)

               {

                  String class1 = staticClasses[j].getName();

                  String class2 = mstatic.getDeclaringClass().getName();

                  final String msg = 

                     "Error creating static proxy for interface %s: " +

                     "ambigous static method %s (found in %s and %s).";

                  String err = String.format(msg, 

                                             ifcName, 

                                             signature, 

                                             class1, 

                                             class2);

                  throw new RuntimeException(err);

               }

               mstatic = m;

            }

         }

         if (mstatic == null)

         {

            final String msg = 

               "Error creating static proxy for interface %s: " +

               "static method %s was not found in the given classes.";

            throw new RuntimeException(String.format(msg, ifcName, signature));

         }

         im2sm.put(methods[i], mstatic);

      }

   }

   /**

    * Get a string representation of the given method, including the return

    * type, the method name and the type for all parameters.

    *  

    * @param    m

    *           The method for which the signature is neede.

    *

    * @return   See above.

    */

   private String getSignature(Method m)

   {

      StringBuilder sb = new StringBuilder();

      // emit return type

      sb.append(m.getReturnType().getName()).append(" ");

      // emit name

      sb.append(m.getName());

      // emit parameter types

      sb.append("(");

      for (int i = 0; i < m.getParameterTypes().length; i++)

      {

         if (i > 0)

         {

            sb.append(", ");

         }

         sb.append(m.getParameterTypes()[i].getName());

      }

      sb.append(")");

      return sb.toString();

   }

   public static void main(String[] args)

   {

      Object o = obtain(Ai.class, new Class[] {Bi.class});

      System.out.println(o.getClass().getInterfaces()[0].getName());

      System.out.println(isStaticProxy(o));

      System.out.println(getStaticMethods(o));

   }

   public static interface Ai

   {

      public void bla();

   }

   public static class Bi

   {

      public static void bla() {};

   }

}