Пример #1
0
 public Bean(String classPackage, String clazz, ClassLoaderStrategy cls, Bean topLevelBean)
     throws Exception {
   // Get the no-arg constructor and create the bean
   try {
     Class classOfBean = ObjectXml.getClassOfBean((ClassLoader) cls, classPackage + "." + clazz);
     Constructor ct = null;
     // check whether this class is an inner class
     if (classOfBean.getEnclosingClass() != null) {
       ct = classOfBean.getConstructor(new Class[] {classOfBean.getEnclosingClass()});
       beanObject = ct.newInstance(new Object[] {topLevelBean.getBeanObject()});
     } else {
       ct = classOfBean.getConstructor((Class[]) null);
       beanObject = ct.newInstance((Object[]) null);
     }
     // Get an array of property descriptors
     beanInfo = Introspector.getBeanInfo(classOfBean);
     PropertyDescriptor[] pds = beanInfo.getPropertyDescriptors();
     // load property descriptors into hashtable
     propDesc = new Properties();
     for (int i = 0; i < pds.length; i++) {
       propDesc.put(pds[i].getName(), pds[i]);
     }
   } catch (Exception e) {
     System.err.println("Exception creating bean: " + e.getMessage());
     e.printStackTrace();
     throw e;
   }
 }
Пример #2
0
    public ParameterizedTypeImpl(Type ownerType, Type rawType, Type... typeArguments) {
      // require an owner type if the raw type needs it
      if (rawType instanceof Class<?>) {
        Class<?> rawTypeAsClass = (Class<?>) rawType;
        try {
          Assert.isTrue(ownerType != null || rawTypeAsClass.getEnclosingClass() == null);
          Assert.isTrue(ownerType == null || rawTypeAsClass.getEnclosingClass() != null);
        } catch (RuntimeException e) {
          // R][2011-09-27 21:08:14,570] [ORM._log] ownerType:null
          // [ERROR][2011-09-27 21:08:14,572] [ORM._log]
          // rawTypeAsClass:interface java.util.Map$Entry
          // [ERROR][2011-09-27 21:08:14,573] [ORM._log]
          // getEnclosingClass:interface java.util.Map

          LogUtil.error("ownerType:" + ownerType);
          LogUtil.error("rawTypeAsClass:" + rawTypeAsClass);
          LogUtil.error("getEnclosingClass:" + rawTypeAsClass.getEnclosingClass());
          throw e;
        }
      }

      this.ownerType = ownerType == null ? null : canonicalize(ownerType);
      this.rawType = canonicalize(rawType);
      this.typeArguments = typeArguments.clone();
      for (int t = 0; t < this.typeArguments.length; t++) {
        Assert.notNull(this.typeArguments[t]);
        checkNotPrimitive(this.typeArguments[t]);
        this.typeArguments[t] = canonicalize(this.typeArguments[t]);
      }
    }
Пример #3
0
 @NotNull
 public static ContractsContext getContext(@NotNull Class<?> clazz) {
   Class<?> outer = clazz;
   while (outer.getEnclosingClass() != null) {
     outer = outer.getEnclosingClass();
   }
   synchronized (CONTEXTS) {
     return getContext0(outer.getName());
   }
 }
 @Test
 public void testEnclosingType() throws Exception {
   for (Class<?> type : standardTypes) {
     assertThat(
         describe(type).getEnclosingType(),
         type.getEnclosingClass() == null
             ? nullValue(TypeDescription.class)
             : is((TypeDescription) new TypeDescription.ForLoadedType(type.getEnclosingClass())));
   }
 }
Пример #5
0
 /**
  * @return Returns the given objects enclosing container type, i.e the first class on the
  *     enclosing classes path that is abstract or the outermost enclosing class. The latter is the
  *     primary type.
  */
 public static Class<?> getEnclosingContainerType(Object o) {
   if (o == null) {
     return null;
   }
   Class<?> c = o.getClass();
   while (!Modifier.isAbstract(c.getModifiers()) && c.getEnclosingClass() != null) {
     c = c.getEnclosingClass();
   }
   return c;
 }
Пример #6
0
 @Override
 public String shorten(Class<?> cls) {
   if (cls.getEnclosingClass() != null) {
     return shorten(cls.getEnclosingClass()) + "." + cls.getSimpleName();
   } else if (cls.getPackage() != null) {
     return getPrefixForTopLevelClass(cls.getPackage().getName(), cls.getSimpleName())
         + cls.getSimpleName();
   } else {
     return cls.getSimpleName();
   }
 }
Пример #7
0
  private static int putEnumTypeInHash(Class<?> type, Hashtable<String, Class<?>> enums) {
    Class<?> flagsType = QFlags.class.isAssignableFrom(type) ? type : null;
    Class<?> enumType = type.isEnum() ? type : null;
    if (enumType == null && flagsType != null) {
      enumType = getEnumForQFlags(flagsType);
    }

    if (enumType == null) return 0;

    // Since Qt supports enums that are not part of the meta object
    // we need to check whether the enum can actually be used in
    // a property.
    Class<?> enclosingClass = enumType.getEnclosingClass();
    if (enclosingClass != null
        && ((!QObject.class.isAssignableFrom(enclosingClass) && !Qt.class.equals(enclosingClass))
            || enumType.isAnnotationPresent(QtBlockedEnum.class))) {
      return -1;
    }

    int enumConstantCount = 0;
    if (!enums.contains(enumType.getName())) {
      enums.put(enumType.getName(), enumType);

      enumConstantCount = enumType.getEnumConstants().length;
    }

    if (flagsType != null && !enums.contains(flagsType.getName()))
      enums.put(flagsType.getName(), flagsType);

    return enumConstantCount;
  }
Пример #8
0
  public static String isLocalType(Class<?> type) {
    /* As per [JACKSON-187], GAE seems to throw SecurityExceptions
     * here and there... and GAE itself has a bug, too
     * (see []). Bah.
     */
    try {
      // one more: method locals, anonymous, are not good:
      if (type.getEnclosingMethod() != null) {
        return "local/anonymous";
      }

      /* But how about non-static inner classes? Can't construct
       * easily (theoretically, we could try to check if parent
       * happens to be enclosing... but that gets convoluted)
       */
      if (type.getEnclosingClass() != null) {
        if (!Modifier.isStatic(type.getModifiers())) {
          return "non-static member class";
        }
      }
    } catch (SecurityException e) {
    } catch (NullPointerException e) {
    }
    return null;
  }
  @Test
  public void testTwoWayFieldBridgeCanHandleNullInObjectToString() throws Exception {
    List<Class<?>> classes = getClasses("org.hibernate.search.bridge.builtin");
    assertTrue("Guarding against a package refactoring", classes.size() > 0);

    for (Class<?> clazz : classes) {
      // not interested in abstract classes
      if (Modifier.isAbstract(clazz.getModifiers())) {
        continue;
      }
      // neither in non TwoWayFieldBridge
      if (!TwoWayFieldBridge.class.isAssignableFrom(clazz)) {
        continue;
      }

      // the NumericFieldBridge is an emum (go figure) - we need special massaging here
      if (Enum.class.isAssignableFrom(clazz)) {
        assertTrue(
            "Unexpected enum class" + clazz, NumericFieldBridge.class.isAssignableFrom(clazz));
        for (Object o : clazz.getEnclosingClass().getEnumConstants()) {
          TwoWayFieldBridge bridge = (TwoWayFieldBridge) o;
          assertEquals(
              "All TwoWayFieldBridgeTest should return 'null' for 'null' passed to 'objectToString",
              null,
              bridge.objectToString(null));
        }
      } else {
        TwoWayFieldBridge bridge = (TwoWayFieldBridge) clazz.newInstance();
        assertEquals(
            "All TwoWayFieldBridgeTest should return 'null' for 'null' passed to 'objectToString",
            null,
            bridge.objectToString(null));
      }
    }
  }
 @Override
 public String getPartId(final Class<? extends PartPermission> permissionClass) {
   String permission =
       WordUtils.uncapitalize(permissionClass.getEnclosingClass().getSimpleName())
           + permissionClass.getSimpleName();
   return permission;
 }
Пример #11
0
  private void validateClass(Class<?> source, ValidationProblemCollector problems) {
    int modifiers = source.getModifiers();

    if (Modifier.isInterface(modifiers)) {
      problems.add("Must be a class, not an interface");
    }

    if (source.getEnclosingClass() != null) {
      if (Modifier.isStatic(modifiers)) {
        if (Modifier.isPrivate(modifiers)) {
          problems.add("Class cannot be private");
        }
      } else {
        problems.add("Enclosed classes must be static and non private");
      }
    }

    Constructor<?>[] constructors = source.getDeclaredConstructors();
    for (Constructor<?> constructor : constructors) {
      if (constructor.getParameterTypes().length > 0) {
        problems.add("Cannot declare a constructor that takes arguments");
        break;
      }
    }

    Field[] fields = source.getDeclaredFields();
    for (Field field : fields) {
      int fieldModifiers = field.getModifiers();
      if (!field.isSynthetic()
          && !(Modifier.isStatic(fieldModifiers) && Modifier.isFinal(fieldModifiers))) {
        problems.add(field, "Fields must be static final.");
      }
    }
  }
Пример #12
0
  public JavaType findType(String name) {
    if (_bindings == null) {
      _resolve();
    }
    JavaType t = _bindings.get(name);
    if (t != null) {
      return t;
    }
    if (_placeholders != null && _placeholders.contains(name)) {
      return UNBOUND;
    }
    // New with 1.7: check parent context
    if (_parentBindings != null) {
      return _parentBindings.findType(name);
    }
    // nothing found, so...
    // Should we throw an exception or just return null?

    /* [JACKSON-499] 18-Feb-2011, tatu: There are some tricky type bindings within
     *   java.util, such as HashMap$KeySet; so let's punt the problem
     *   (honestly not sure what to do -- they are unbound for good, I think)
     */
    if (_contextClass != null) {
      Class<?> enclosing = _contextClass.getEnclosingClass();
      if (enclosing != null) {
        // [JACKSON-572]: Actually, let's skip this for all non-static inner classes
        //   (which will also cover 'java.util' type cases...
        if (!Modifier.isStatic(_contextClass.getModifiers())) {
          return UNBOUND;
        }

        // ... so this piece of code should not be needed any more
        /*
        Package pkg = enclosing.getPackage();
        if (pkg != null) {
            // as per [JACKSON-533], also include "java.util.concurrent":
            if (pkg.getName().startsWith("java.util")) {
                return UNBOUND;
            }
        }
        */
      }
    }

    String className;
    if (_contextClass != null) {
      className = _contextClass.getName();
    } else if (_contextType != null) {
      className = _contextType.toString();
    } else {
      className = "UNKNOWN";
    }
    throw new IllegalArgumentException(
        "Type variable '"
            + name
            + "' can not be resolved (with context of class "
            + className
            + ")");
    // t = UNBOUND;
  }
Пример #13
0
 /** What feature does this story belong to? */
 public static Class<?> getFeatureClass(Class<?> userStoryClass) {
   if (userStoryClass != null) {
     Class<?> enclosingClass = userStoryClass.getEnclosingClass();
     if (isAFeature(enclosingClass)) {
       return enclosingClass;
     }
   }
   return null;
 }
Пример #14
0
 @Nullable
 @Override
 Class<?> getOwnerType(Class<?> rawType) {
   if (rawType.isLocalClass()) {
     return null;
   } else {
     return rawType.getEnclosingClass();
   }
 }
Пример #15
0
 public static <E extends Enum<E>> E enumValue(final String value, final E defaultValue) {
   requireNonNull(defaultValue, "No default value provided");
   E enumValue;
   if (value == null) {
     enumValue = defaultValue;
   } else {
     try {
       Class<?> enumClass = defaultValue.getClass();
       if (enumClass.getEnclosingClass() != null) {
         enumClass = enumClass.getEnclosingClass();
       }
       enumValue = Enum.valueOf((Class<E>) enumClass, value);
     } catch (final Exception e) {
       enumValue = defaultValue;
     }
   }
   return enumValue;
 }
    private boolean isEnclosingClassParameter() {

      if (enclosingClassCache == null) {
        Class<T> owningType = entity.getType();
        this.enclosingClassCache =
            owningType.isMemberClass() && type.getType().equals(owningType.getEnclosingClass());
      }

      return enclosingClassCache;
    }
Пример #17
0
 /**
  * Returns a type where {@code rawType} is parameterized by {@code arguments} and is owned by
  * {@code ownerType}.
  */
 static ParameterizedType newParameterizedTypeWithOwner(
     @Nullable Type ownerType, Class<?> rawType, Type... arguments) {
   if (ownerType == null) {
     return newParameterizedType(rawType, arguments);
   }
   // ParameterizedTypeImpl constructor already checks, but we want to throw NPE before IAE
   checkNotNull(arguments);
   checkArgument(rawType.getEnclosingClass() != null, "Owner type for unenclosed %s", rawType);
   return new ParameterizedTypeImpl(ownerType, rawType, arguments);
 }
Пример #18
0
 static ParameterizedType newParameterizedTypeWithOwner(
     @Nullable Type var0, Class<?> var1, Type... var2) {
   if (var0 == null) {
     return newParameterizedType(var1, var2);
   } else {
     Preconditions.checkNotNull(var2);
     Preconditions.checkArgument(
         var1.getEnclosingClass() != null, "Owner type for unenclosed %s", new Object[] {var1});
     return new Types.ParameterizedTypeImpl(var0, var1, var2);
   }
 }
Пример #19
0
  private static String getClassName(Class<?> clazz) {
    if (clazz != null) {
      if (!TextUtils.isEmpty(clazz.getSimpleName())) {
        return clazz.getSimpleName();
      }

      return getClassName(clazz.getEnclosingClass());
    }

    return "";
  }
Пример #20
0
  private static String[] getTypeMetadata(Class<?> clazz, int index) {
    Class<?> mostOuterClass = clazz.getEnclosingClass();
    ArrayList<Class<?>> outerClasses = new ArrayList<Class<?>>();
    while (mostOuterClass != null) {
      outerClasses.add(0, mostOuterClass);
      Class<?> nextOuterClass = mostOuterClass.getEnclosingClass();
      if (nextOuterClass == null) break;
      mostOuterClass = nextOuterClass;
    }

    Package p = (mostOuterClass != null) ? mostOuterClass.getPackage() : clazz.getPackage();

    int packageCount = 1;
    String pname = p.getName();
    for (int i = 0; i < pname.length(); i++) {
      if (pname.charAt(i) == '.') ++packageCount;
    }

    String name = clazz.getName();
    String[] parts = name.split("[\\.\\$]");

    int endIdx = parts.length;
    int len = endIdx - index;
    String[] result = new String[len];

    int endOuterTypeIdx = packageCount + outerClasses.size();

    for (int i = index; i < endIdx; i++) {
      if (i < packageCount) {
        result[i - index] = "P";
      } else {
        if (i < endOuterTypeIdx) {
          result[i - index] = getTypeMetadata(outerClasses.get(i - packageCount));
        } else {
          result[i - index] = getTypeMetadata(clazz);
        }
      }
    }

    return result;
  }
Пример #21
0
 /**
  * Creates a new Instance of the <code>sectionClass</code> using its default-constructor
  *
  * <p>the <code>parent</code> is needed when trying to instantiating a non-static inner-class
  * Section
  *
  * @param sectionClass the class of the Section to instantiate
  * @param parent an instance of the enclosing class of the <code>sectionClass</code>
  * @return the instantiated Section
  */
 public static Section newSectionInstance(Class<? extends Section> sectionClass, Object parent) {
   try {
     if (sectionClass.getEnclosingClass() == null) {
       return sectionClass.newInstance();
     } else if (Modifier.isStatic(sectionClass.getModifiers())) {
       return sectionClass.newInstance();
     } else {
       return sectionClass
           .getDeclaredConstructor(sectionClass.getEnclosingClass())
           .newInstance(parent);
     }
   } catch (InstantiationException e) {
     throw new ReflectedInstantiationException(sectionClass, e);
   } catch (InvocationTargetException e) {
     throw new ReflectedInstantiationException(sectionClass, e);
   } catch (NoSuchMethodException e) {
     throw new ReflectedInstantiationException(sectionClass, e);
   } catch (IllegalAccessException e) {
     throw new ReflectedInstantiationException(sectionClass, e);
   }
 }
Пример #22
0
  /**
   * 批量将 fromObject 中的数据使用 targetClass的set方法,传入targetObject中
   *
   * @param fromObject
   * @param targetClss
   * @param targetObject
   */
  public static void batchSetter(Object fromObject, Class<?> targetClss, Object targetObject) {
    try {

      for (Field field : fromObject.getClass().getDeclaredFields()) {
        GenerateClassSetter nestSetter = field.getType().getAnnotation(GenerateClassSetter.class);
        if (nestSetter != null) {
          boolean sameTypeWithEnclosingObj = false;
          for (TargetClassDefine targetClass : nestSetter.targetType()) {
            sameTypeWithEnclosingObj = targetClass.name().equals(targetClss.getCanonicalName());
            if (sameTypeWithEnclosingObj) {
              break;
            }
          }
          if (sameTypeWithEnclosingObj) {
            if (!Modifier.isPublic(field.getModifiers())) {
              if (Debug)
                System.out.println(
                    fromObject.getClass().getSimpleName()
                        + "."
                        + field.getName()
                        + ", not public, ignored");
            } else {
              if (field.get(fromObject) != null) {
                batchSetter(field.get(fromObject), targetClss, targetObject);
                if (Debug) System.out.println("recursive invoke: " + field.getName());
              }
            }
          }
        }
      }

      String packageLoc = fromObject.getClass().getPackage().getName();
      String enclosingClassPrefix = "";
      Class<?> enclosingClass = fromObject.getClass().getEnclosingClass();
      while (enclosingClass != null) {
        enclosingClassPrefix = enclosingClass.getSimpleName() + "_" + enclosingClassPrefix;
        enclosingClass = enclosingClass.getEnclosingClass();
      }
      Class<?> injectorClass =
          Class.forName(
              packageLoc
                  + "."
                  + enclosingClassPrefix
                  + fromObject.getClass().getSimpleName()
                  + "Setter");
      injectorClass
          .getMethod("set", fromObject.getClass(), targetClss)
          .invoke(null, fromObject, targetObject);
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }
Пример #23
0
 private void assertValid(final Class<?> clazz) {
   if (clazz.getEnclosingClass() == null) {
     throw new OpenGammaRuntimeException("AutoFudgable can be used only with inner classes");
   }
   if (clazz.getSuperclass().getEnclosingClass() != null) {
     throw new OpenGammaRuntimeException(
         "AutoFudgable can be used only with inner classes which enclosing classes are not inner themselves.");
   }
   if (!hasSingleZeroArgConstructor(clazz.getSuperclass())) {
     throw new OpenGammaRuntimeException(
         "AutoFudgable can be used only with inner classes which enclosing classes have single, zero argument constructor.");
   }
 }
Пример #24
0
  public static <ItemDataType> ViewHolderCreator<ItemDataType> create(
      final Object enclosingInstance, final Class<?> cls, final Object... args) {
    if (cls == null) {
      throw new IllegalArgumentException("ViewHolderClass is null.");
    }

    // top class
    boolean isEnclosingInstanceClass = false;
    if (cls.getEnclosingClass() != null && !Modifier.isStatic(cls.getModifiers())) {
      isEnclosingInstanceClass = true;
    }

    // inner instance class should pass enclosing class, so +1
    int argsLen = isEnclosingInstanceClass ? args.length + 1 : args.length;

    final Object[] instanceObjects = new Object[argsLen];

    int copyStart = 0;
    // if it is inner instance class, first argument should be the enclosing class instance
    if (isEnclosingInstanceClass) {
      instanceObjects[0] = enclosingInstance;
      copyStart = 1;
    }

    // has copy construction parameters
    if (args.length > 0) {
      System.arraycopy(args, 0, instanceObjects, copyStart, args.length);
    }

    // fill the types
    final Class[] parameterTypes = new Class[argsLen];
    for (int i = 0; i < instanceObjects.length; i++) {
      parameterTypes[i] = instanceObjects[i].getClass();
    }

    Constructor<?> constructor = null;
    try {
      constructor = cls.getDeclaredConstructor(parameterTypes);
    } catch (NoSuchMethodException e) {
      e.printStackTrace();
    }

    if (constructor == null) {
      throw new IllegalArgumentException("ViewHolderClass can not be initiated");
    }

    ViewHolderCreator lazyCreator = new LazyViewHolderCreator(constructor, instanceObjects);
    return lazyCreator;
  }
Пример #25
0
    public ParameterizedTypeImpl(Type ownerType, Type rawType, Type... typeArguments) {
      // require an owner type if the raw type needs it
      if (rawType instanceof Class<?>) {
        Class<?> rawTypeAsClass = (Class<?>) rawType;
        boolean isStaticOrTopLevelClass =
            Modifier.isStatic(rawTypeAsClass.getModifiers())
                || rawTypeAsClass.getEnclosingClass() == null;
        checkArgument(ownerType != null || isStaticOrTopLevelClass);
      }

      this.ownerType = ownerType == null ? null : canonicalize(ownerType);
      this.rawType = canonicalize(rawType);
      this.typeArguments = typeArguments.clone();
      for (int t = 0; t < this.typeArguments.length; t++) {
        checkNotNull(this.typeArguments[t]);
        checkNotPrimitive(this.typeArguments[t]);
        this.typeArguments[t] = canonicalize(this.typeArguments[t]);
      }
    }
Пример #26
0
 @Override
 public <TAggregate extends AggregateRoot, TEvent extends AggregateDomainEvent<TAggregate>>
     Future<TAggregate> submit(final TEvent domainEvent, final String uri) {
   if (uri == null) throw new IllegalArgumentException("uri can't be null.");
   final Class<?> eventClazz = domainEvent.getClass();
   @SuppressWarnings("unchecked")
   final Class<TAggregate> manifest = (Class<TAggregate>) eventClazz.getEnclosingClass();
   final String domainName = client.getDslName(manifest);
   return client.sendRequest(
       manifest,
       DOMAIN_URI
           + "submit/"
           + domainName
           + "/"
           + eventClazz.getSimpleName()
           + "?uri="
           + encode(uri),
       "POST",
       domainEvent,
       new int[] {201});
 }
Пример #27
0
  /**
   * @param aParserClass
   * @param aDelimiter
   * @param aThreadPoolSize
   * @throws AppException
   */
  public FileParserBatch(Class<T> aParserClass, String aDelimiter, int aThreadPoolSize)
      throws AppException {
    super(aThreadPoolSize);

    try {
      this.parserClass = aParserClass;

      if (InnerLogParser.class.isAssignableFrom(aParserClass)) {
        this.constructor =
            aParserClass.getConstructor(
                new Class[] {aParserClass.getEnclosingClass(), File.class, String.class});
      } else {
        this.constructor = aParserClass.getConstructor(new Class[] {File.class, String.class});
      }
    } catch (Exception error) {
      killListner();
      throw new AppException(error);
    }

    this.delimiter = aDelimiter;
  }
Пример #28
0
  private String canonicalName(Class<?> clazz) {
    if (clazz.isArray()) {
      Class<?> leafType = clazz;
      do {
        leafType = leafType.getComponentType();
      } while (leafType.isArray());

      Class<?> enclosing = leafType.getEnclosingClass();
      if (enclosing != null) {
        // com.foo.Enclosing$Name[]
        return canonicalName(enclosing) + "$" + clazz.getSimpleName();
      } else if (leafType.getPackage() == null) {
        // Name0[
        return clazz.getSimpleName();
      } else {
        // com.foo.Name[]
        return leafType.getPackage().getName() + "." + clazz.getSimpleName();
      }
    } else {
      return clazz.getName();
    }
  }
Пример #29
0
 /** Finds the editor message bundle for the supplied class. */
 protected static String findMessageBundle(Class<?> clazz) {
   EditorMessageBundle annotation = clazz.getAnnotation(EditorMessageBundle.class);
   if (annotation != null) {
     return annotation.value();
   }
   Class<?> eclazz = clazz.getEnclosingClass();
   if (eclazz != null) {
     return getMessageBundle(eclazz);
   }
   String name = clazz.getName();
   int idx;
   while ((idx = name.lastIndexOf('.')) != -1) {
     name = name.substring(0, idx);
     Package pkg = Package.getPackage(name);
     if (pkg != null) {
       annotation = pkg.getAnnotation(EditorMessageBundle.class);
       if (annotation != null) {
         return annotation.value();
       }
     }
   }
   return EditorMessageBundle.DEFAULT;
 }
  /**
   * Creates a map of concrete json request handler invokers keyed by <b><code>
   * &lt;service-name&gt;/&lt;op-name&gt;</code></b>.
   *
   * @param handlerInstance The request handler instance to generate invokers for
   * @return the map of generated invokers
   */
  public static Map<String, Map<String, AbstractJSONRequestHandlerInvoker>> createInvokers(
      Object handlerInstance) {
    if (handlerInstance == null)
      throw new IllegalArgumentException("The passed handlerInstance was null");
    Map<String, AbstractJSONRequestHandlerInvoker> subInvokerMap =
        new HashMap<String, AbstractJSONRequestHandlerInvoker>();
    Map<String, Map<String, AbstractJSONRequestHandlerInvoker>> invokerMap =
        invokerCache.get(handlerInstance.getClass());
    if (invokerMap != null) {
      LOG.info("Found Cached Invokers for [{}]", handlerInstance.getClass().getName());
      return invokerMap;
    }
    invokerMap = new HashMap<String, Map<String, AbstractJSONRequestHandlerInvoker>>(1);

    LOG.info("Generating Invokers for [{}]", handlerInstance.getClass().getName());
    JSONRequestService svc = handlerInstance.getClass().getAnnotation(JSONRequestService.class);
    final String invokerServiceKey = svc.name();
    final String invokerServiceDescription = svc.description();

    invokerMap.put(invokerServiceKey, subInvokerMap);

    ClassPool cp = new ClassPool();
    cp.appendClassPath(new ClassClassPath(handlerInstance.getClass()));
    cp.appendClassPath(new ClassClassPath(AbstractJSONRequestHandlerInvoker.class));
    cp.importPackage(handlerInstance.getClass().getPackage().getName());
    Set<ClassLoader> classPathsAdded = new HashSet<ClassLoader>();
    Set<String> packagesImported = new HashSet<String>();
    try {
      final CtClass jsonRequestCtClass = cp.get(JSONRequest.class.getName());
      final CtClass parent = cp.get(AbstractJSONRequestHandlerInvoker.class.getName());
      CtClass targetClass = cp.get(handlerInstance.getClass().getName());
      Collection<Method> methods = getTargetMethods(handlerInstance.getClass());
      for (Method m : methods) {
        final JSONRequestHandler jsonHandler = m.getAnnotation(JSONRequestHandler.class);
        final String opName = jsonHandler.name();
        final String opDescription = jsonHandler.description();
        final RequestType opType = jsonHandler.type();

        int targetMethodHashCode = m.toGenericString().hashCode();
        final String className =
            String.format(
                "%s-%s%s-%s-%s",
                handlerInstance.getClass().getName(),
                invokerServiceKey,
                opName,
                "ServiceInvoker",
                targetMethodHashCode);

        final CtClass invokerClass = cp.makeClass(className, parent);
        CtField ctf = new CtField(targetClass, "typedTarget", invokerClass);
        ctf.setModifiers(ctf.getModifiers() | Modifier.FINAL);
        invokerClass.addField(ctf);
        for (CtConstructor parentCtor : parent.getConstructors()) {
          CtConstructor invokerCtor = CtNewConstructor.copy(parentCtor, invokerClass, null);
          invokerCtor.setBody(
              "{ super($$); typedTarget = (" + handlerInstance.getClass().getName() + ")$1; }");
          invokerClass.addConstructor(invokerCtor);
        }
        CtMethod invokerMethod =
            CtNewMethod.copy(
                parent.getDeclaredMethod("doInvoke", new CtClass[] {jsonRequestCtClass}),
                invokerClass,
                null);
        StringBuilder b = new StringBuilder("{this.typedTarget.").append(m.getName()).append("($1");
        final Class<?>[] ptypes = m.getParameterTypes();
        final int remainingParamCount = ptypes.length - 1;
        //				Set<Class<?>> classPathsAdded = new HashSet<Class<?>>();
        //				Set<String> packagesImported = new HashSet<String>();
        if (remainingParamCount > 0) {
          for (int i = 0; i < remainingParamCount; i++) {
            final Class<?> type = ptypes[i + 1];
            if (type.getName().contains("UniqueIdType")) {
              System.err.println("Comin Up....");
            }
            if (type.isPrimitive()) {
              b.append(", (").append(type.getName()).append(") null");
            } else {
              if (classPathsAdded.add(type.getClassLoader())) {
                cp.appendClassPath(new LoaderClassPath(type.getClassLoader()));
              }
              try {
                Package p = type.getPackage();
                if (p == null) {
                  if (type.isArray()) {
                    if (!type.getComponentType().isPrimitive()) {
                      p = type.getComponentType().getPackage();
                    }
                  }
                }
                if (type.isEnum()) {
                  final String f = type.getEnclosingClass().getName() + "." + type.getSimpleName();
                  b.append(", (").append(f).append(") null");
                  String pack = type.getEnclosingClass().getPackage().getName();
                  if (packagesImported.add(pack)) {
                    cp.importPackage(pack);
                  }
                  continue;
                }

                if (p != null) {
                  if (packagesImported.add(p.getName())) {
                    cp.importPackage(p.getName());
                  }
                }
              } catch (Exception ex) {
                ex.printStackTrace(System.err);
              }
              b.append(", (").append(type.getSimpleName()).append(") null");
            }
          }
        }

        b.append(");}");
        System.out.println("[" + m.getName() + "]: [" + b.toString() + "]");
        // invokerMethod.setBody("{this.typedTarget." + m.getName() + "($1);}");
        invokerMethod.setBody(b.toString());
        invokerMethod.setModifiers(invokerMethod.getModifiers() & ~Modifier.ABSTRACT);
        invokerClass.addMethod(invokerMethod);
        // invokerClass.writeFile(System.getProperty("java.io.tmpdir") + File.separator +
        // "jsoninvokers");
        Class<?> clazz =
            invokerClass.toClass(
                handlerInstance.getClass().getClassLoader(),
                handlerInstance.getClass().getProtectionDomain());
        Constructor<?> ctor =
            clazz.getDeclaredConstructor(
                Object.class,
                String.class,
                String.class,
                String.class,
                String.class,
                RequestType.class);
        AbstractJSONRequestHandlerInvoker invokerInstance =
            (AbstractJSONRequestHandlerInvoker)
                ctor.newInstance(
                    handlerInstance,
                    invokerServiceKey,
                    invokerServiceDescription,
                    opName,
                    opDescription,
                    opType);
        subInvokerMap.put(opName, invokerInstance);
      }
      invokerCache.put(handlerInstance.getClass(), invokerMap);
      return invokerMap;
    } catch (Exception ex) {
      LOG.error(
          "Failed to create RequestHandlerInvoker for [{}]",
          handlerInstance.getClass().getName(),
          ex);
      throw new RuntimeException(
          "Failed to create RequestHandlerInvoker [" + handlerInstance.getClass().getName() + "]",
          ex);
    }
  }