En Javassist, cómo configurar el tipo de retorno del método a la hora de crear java.lang.Double método dinámico utilizando CtMethod

javaseeker:

Tengo que crear dinámicamente una clase y el método en tiempo de ejecución. Estoy usando Javassist para esto:

El método que yo quiero crear dinámicamente es:

public Double formula1(FormulaAPI api) {  
      return api.evaluate(\"L\"); 
}

Si paso todo el método anterior como cuerpo del método utilizando CtMethod.make(..), funciona bien.

Pero quiero que sea más genérico, es decir, quiero tener solamente return api.evaluate(\"L\");como mi cuerpo del método y desea utilizar los métodos de la API JavaAssist para establecer el nombre, tipo de retorno, etc. Cuando se trata de hacer esto, estoy consiguiendo el error:

 ***Exception in thread "main" java.lang.VerifyError: 
    (class: Formulae, method: formula1 signature: (Lcom/formula/FormulaAPI;)D) Wrong return type in function***

Mi pregunta es: cuando se llama: CtMethod m = new CtMethod (...); ¿Cómo puedo configurar el tipo de retorno de CtMethod a java.lang.Double en lugar de CtPrimitiveType.doubleType?

Toda mi código fuente es:

public class JavaAssistTest {
  private static final String className = "Formulae";
  private static final String methodName = "formula1";

  public static void main(String[] args) throws Exception{
      JavaAssistTest jj = new JavaAssistTest();
    try {
      Class clazz = jj.generateClass(className, methodName);

      Object obj = clazz.newInstance();
      Method method = clazz.getDeclaredMethod(methodName,FormulaAPI.class);
      FormulaAPI api = new FormulaAPI();
      method.invoke(obj,api);
    } catch (IllegalAccessException e) {
      e.printStackTrace();
    } catch (InvocationTargetException e) {
      e.printStackTrace();
    } catch (InstantiationException e) {
      e.printStackTrace();
    } catch (NoSuchMethodException e) {
      e.printStackTrace();
    } catch (CannotCompileException e) {
      e.printStackTrace();
    }
  }
  public Class generateClass(String className, String methodName)
      throws CannotCompileException, NotFoundException{
    ClassPool pool = ClassPool.getDefault();
    CtClass cc = pool.makeClass(className);

    ClassLoader classLoader = FormulaAPI.class.getClassLoader();
    pool.appendClassPath(new LoaderClassPath(classLoader));
    pool.importPackage("com.formula");

    String methodBody = "return $1.evaluate(\"L\");";

    CtClass apiClass = pool.get("com.formula.FormulaAPI");

    CtMethod m = new CtMethod(CtPrimitiveType.doubleType,methodName,new CtClass[]{apiClass},cc);
    m.setBody(methodBody);
    cc.addMethod(m);

    return cc.toClass();
  }

}

La clase FormulaAPI es la siguiente:

public class FormulaAPI {
    public Double evaluate(String source){
        System.out.println("printing in FormulaAPI ");
        return 2.0;
    }
}

alainlompo:

Es evidente que el CtPrimitiveType.doubleTypeno es el CtClass tipo de uso ya que se necesita la clase contenedora lugar y es por eso que su están recibiendo la excepción.

Sin embargo, la solución es muy simple sólo hay que obtener el tipo doble como CtClass y utilizarla en su lugar. Así que modifique su Generar método para parecerse a:

public Class generateClass(String className, String methodName)
            throws CannotCompileException, NotFoundException {
   ClassPool pool = ClassPool.getDefault();
   CtClass cc = pool.makeClass(className);

   ClassLoader classLoader = FormulaAPI.class.getClassLoader();
   pool.appendClassPath(new LoaderClassPath(classLoader));
   pool.importPackage("com.formula");

   String methodBody = "return $1.evaluate(\"L\");";

   CtClass apiClass = pool.get("com.formula.FormulaAPI");

   CtClass doubleWrapperClass = pool.get("java.lang.Double");

   CtMethod m = new CtMethod(doubleWrapperClass,methodName,new CtClass[]{apiClass},cc);
   m.setBody(methodBody);
   cc.addMethod(m);

   return cc.toClass();
}

El funcionamiento de su código con estas modificaciones, que no debería tener excepciones.