private static void replaceImplementation(CtMethod m, String src) throws Exception { removeNativeModifier(m); if (src == null || src.trim().length() == 0) { m.setBody(null); } else { src = src.trim(); if (!src.startsWith("{")) { if (!m.getReturnType().equals(CtClass.voidType) && !src.startsWith("return")) { src = "{ return ($r)($w) " + src; } else { src = "{ " + src; } } if (!src.endsWith("}")) { if (!src.endsWith(";")) { src = src + "; }"; } else { src = src + " }"; } } try { m.setBody(src); } catch (CannotCompileException e) { throw new RuntimeException("Unable to compile body " + src, e); } } }
private static void modifyProxyFactory() throws Exception { System.out.println("Generating method bodies for com.zaxxer.hikari.proxy.ProxyFactory"); String packageName = JavassistProxyFactory.class.getPackage().getName(); CtClass proxyCt = classPool.getCtClass("com.zaxxer.hikari.proxy.ProxyFactory"); for (CtMethod method : proxyCt.getMethods()) { switch (method.getName()) { case "getProxyConnection": method.setBody("{return new " + packageName + ".HikariConnectionProxy($$);}"); break; case "getProxyStatement": method.setBody("{return new " + packageName + ".HikariStatementProxy($$);}"); break; case "getProxyPreparedStatement": method.setBody("{return new " + packageName + ".HikariPreparedStatementProxy($$);}"); break; case "getProxyCallableStatement": method.setBody("{return new " + packageName + ".HikariCallableStatementProxy($$);}"); break; case "getProxyResultSet": method.setBody("{return new " + packageName + ".HikariResultSetProxy($$);}"); break; } } proxyCt.writeFile("target/classes"); }
public static void patch(CtClass c, IPatcher patcher) throws Exception { treatClassToPatch(c); if (patcher != null) { patcher.initClass(c); } for (CtMethod m : c.getDeclaredMethods()) { boolean wasAbstract = false; String newBody = null; if (Modifier.isAbstract(m.getModifiers())) { m.setModifiers(m.getModifiers() - Modifier.ABSTRACT); wasAbstract = true; } if (patcher != null) { newBody = patcher.getNewBody(m); } if (newBody != null) { if (newBody.startsWith(AutomaticPatcher.INSERT_BEFORE)) { GwtPatcherUtils.insertBefore( m, newBody.substring(AutomaticPatcher.INSERT_BEFORE.length())); } else if (newBody.startsWith(AutomaticPatcher.INSERT_AFTER)) { GwtPatcherUtils.insertAfter(m, newBody.substring(AutomaticPatcher.INSERT_AFTER.length())); } else { GwtPatcherUtils.replaceImplementation(m, newBody); } } else if (wasAbstract) { if (patcher != null) { m.setBody( "{ throw new " + UnsupportedOperationException.class.getName() + "(\"Abstract method '" + c.getSimpleName() + "." + m.getName() + "()' is not patched by " + patcher.getClass().getName() + "\"); }"); } else { m.setBody( "{ throw new " + UnsupportedOperationException.class.getName() + "(\"Abstract method '" + c.getSimpleName() + "." + m.getName() + "()' is not patched by any declared " + IPatcher.class.getSimpleName() + " instance\"); }"); } } } if (patcher != null) { patcher.finalizeClass(c); } }
/** initial creation of the class EnergyData and associated elements in the robot */ public static void update(ClassPool pool, CtClass robot) throws CannotCompileException, RuntimeException, NotFoundException { CtClass pgui = pool.get("fr.upmc.dtgui.gui.PersonalizedGUI"); // method createBoard CtMethod cb = pool.getMethod("fr.upmc.dtgui.gui.PersonalizedGUI", "createBoard"); cb.setBody( "{\n" + "fr.upmc.dtgui.gui.RobotTeleoperationBoard board;\n" + "board = new " + robot.getName() + "TeleoperationBoard($0, $0.sizeX - 50);\n" + "return board ;\n" + "}\n"); // method createSensorDataReceptor CtMethod csdr = pool.getMethod("fr.upmc.dtgui.gui.PersonalizedGUI", "createSensorDataReceptor"); csdr.setBody( "{\n" + "fr.upmc.dtgui.gui.SensorDataReceptorInterface sdr = null ;\n" + "sdr = $2.makeSensorDataReceptor(" + "$0.positionDisplay, $1.getSensorDataQueue()," + "$0.absoluteX, $0.absoluteY, $0.controlRadius" + ") ;\n" + "return sdr ;\n" + "}\n"); // method detectRobot CtMethod dr = new CtMethod( CtClass.voidType, "detectRobot", new CtClass[] {pool.get("fr.upmc.dtgui.robot.InstrumentedRobot")}, pgui); dr.setBody( "{\n" + "fr.upmc.dtgui.gui.RobotTeleoperationBoard board = null ;\n" + "fr.upmc.dtgui.gui.SensorDataReceptorInterface sdr = null ;\n" + "if (!this.detected($1)) {\n" + "board = $0.createBoard($1) ;\n" + "sdr = $0.createSensorDataReceptor($1, board) ;\n" + "$0.sensors.put($1, sdr) ;\n" + "$0.boards.put($1, board) ;\n" + "sdr.start() ;\n" + "this.validate() ;\n" + "}\n" + "}\n"); pgui.addMethod(dr); }
private void transformParameterizedGetMemcacheServiceMethod(CtClass clazz) throws NotFoundException, CannotCompileException { CtMethod method = clazz.getDeclaredMethod( "getMemcacheService", new CtClass[] {clazz.getClassPool().get("java.lang.String")}); method.setBody("return new org.jboss.capedwarf.memcache.InfinispanMemcacheService($1);"); }
@Override protected void doInjection(String value) { try { ctMethod.setBody("{return \"" + value + "\";}"); } catch (Throwable t) { throw new InjectionException("Unable to replace method body", t); } }
public void onWrite(ClassPool pool, String className) throws NotFoundException, CannotCompileException { CtClass cc = pool.get(className); try { if (isPersistent(className)) { CtClass base = cc.getSuperclass(); CtConstructor cons = new CtConstructor(constructorParams, cc); if (base.subclassOf(persistent) || base == object) { cons.setBody(null); cc.addConstructor(cons); if (base == object) { cc.setSuperclass(persistent); } } else { if (!isPersistent(base.getName())) { throw new NotFoundException( "Base class " + base.getName() + " was not declared as persistent"); } cons.setBody("super($0);"); cc.addConstructor(cons); } preprocessMethods(cc, true, true); if (base == persistent || base == object) { CtMethod m = new CtMethod(isRecursive, cc, null); m.setBody("return false;"); cc.addMethod(m); addSerializeMethods(cc, false); } else if (base.subtypeOf(serializable)) { addSerializeMethods(cc, true); } if ((cc.getModifiers() & Modifier.PRIVATE) == 0) { CtClass f = pool.makeClass(className + "LoadFactory"); f.addInterface(factory); CtMethod c = new CtMethod(create, f, null); c.setBody("return new " + className + "($1);"); f.addMethod(c); CtNewConstructor.defaultConstructor(f); } } else { preprocessMethods( cc, cc.subtypeOf(persistent) && cc != persistent, !className.startsWith("org.nachodb")); } } catch (Exception x) { x.printStackTrace(); } }
private void changeMethod(CtClass ctClass, CtMethod ctMethod) throws CannotCompileException { // basically your before-advice... ctMethod.insertBefore("System.out.println(\"started method at \" + new java.util.Date());"); // basically your after-advice... ctMethod.insertAfter("System.out.println(\"ended method at \" + new java.util.Date());"); // basically your around-advice... String methodName = ctMethod.getName(); String proxyName = methodName + "_$proxy"; CtMethod proxy = CtNewMethod.copy(ctMethod, proxyName, ctClass, null); ctMethod.setName(ctMethod.getName() + "_orig"); proxy.setBody( "{ System.out.println(\"hoot!\"); return $proceed($$);}", "this", ctMethod.getName()); proxy.setName(methodName); ctClass.addMethod(proxy); }
public static Getter generateGetter(OgnlContext context, String code) throws OgnlException { String className = NAME_FACTORY.getNewClassName(); try { ClassPool pool = (ClassPool) pools.get(context.getClassResolver()); EnhancedClassLoader loader = (EnhancedClassLoader) loaders.get(context.getClassResolver()); CtClass newClass; CtClass ognlContextClass; CtClass objectClass; CtClass stringClass; CtMethod method; byte[] byteCode; Class compiledClass; if ((pool == null) || (loader == null)) { ClassLoader classLoader = new ContextClassLoader(OgnlContext.class.getClassLoader(), context); pool = ClassPool.getDefault(); pool.insertClassPath(new LoaderClassPath(classLoader)); pools.put(context.getClassResolver(), pool); loader = new EnhancedClassLoader(classLoader); loaders.put(context.getClassResolver(), loader); } newClass = pool.makeClass(className); ognlContextClass = pool.get(OgnlContext.class.getName()); objectClass = pool.get(Object.class.getName()); stringClass = pool.get(String.class.getName()); newClass.addInterface(pool.get(Getter.class.getName())); method = new CtMethod( objectClass, "get", new CtClass[] {ognlContextClass, objectClass, stringClass}, newClass); method.setBody("{" + code + "}"); newClass.addMethod(method); byteCode = newClass.toBytecode(); compiledClass = loader.defineClass(className, byteCode); return (Getter) compiledClass.newInstance(); } catch (Throwable ex) { throw new OgnlException("Cannot create class", ex); } }
/** * Creates a map of concrete json request handler invokers keyed by <b><code> * <service-name>/<op-name></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); } }
protected void transform(CtClass clazz) throws Exception { CtMethod method = clazz.getDeclaredMethod("createRawGcsService"); method.setBody( "{return com.google.appengine.tools.cloudstorage.dev.LocalRawGcsServiceFactory.createLocalRawGcsService();}"); }
private boolean addSerializeMethods(CtClass cc, boolean callSuper) throws NotFoundException, CannotCompileException { CtField[] fields = cc.getDeclaredFields(); int size = 0; StringBuffer sb = new StringBuffer(); sb.append(callSuper ? "{$2=super.pack($1, $2);$1.extend($2" : "{$1.extend($2"); for (int i = 0; i < fields.length; i++) { CtField f = fields[i]; if ((f.getModifiers() & (Modifier.STATIC | Modifier.TRANSIENT)) == 0) { CtClass type = f.getType(); if (type.isPrimitive()) { if (type == CtClass.booleanType || type == CtClass.byteType) { size += 1; } else if (type == CtClass.charType || type == CtClass.shortType) { size += 2; } else if (type == CtClass.longType || type == CtClass.doubleType) { size += 8; } else { size += 4; } } else if (type.getName().equals("java.lang.String")) { sb.append("+org.nachodb.impl.Bytes#sizeof("); sb.append(f.getName()); sb.append(",$3)"); } else { return false; } } } cc.addInterface(serializable); CtMethod m = new CtMethod(pack, cc, null); sb.append('+'); sb.append(size); sb.append(");"); for (int i = 0; i < fields.length; i++) { CtField f = fields[i]; if ((f.getModifiers() & (Modifier.STATIC | Modifier.TRANSIENT)) == 0) { CtClass type = f.getType(); String name = f.getName(); if (type == CtClass.booleanType) { sb.append("$1.arr[$2++]=(byte)("); sb.append(name); sb.append("?1:0);"); } else if (type == CtClass.charType) { sb.append("org.nachodb.impl.Bytes#pack2($1.arr,$2,(short)"); sb.append(name); sb.append(");$2+=2;"); } else if (type == CtClass.byteType) { sb.append("$1.arr[$2++]="); sb.append(name); sb.append(";"); } else if (type == CtClass.shortType) { sb.append("org.nachodb.impl.Bytes#pack2($1.arr,$2,"); sb.append(name); sb.append(");$2+=2;"); } else if (type == CtClass.intType) { sb.append("org.nachodb.impl.Bytes#pack4($1.arr,$2,"); sb.append(name); sb.append(");$2+=4;"); } else if (type == CtClass.longType) { sb.append("org.nachodb.impl.Bytes#pack8($1.arr,$2,"); sb.append(name); sb.append(");$2+=8;"); } else if (type == CtClass.doubleType) { sb.append("org.nachodb.impl.Bytes#packF8($1.arr,$2,"); sb.append(name); sb.append(");$2+=8;"); } else if (type == CtClass.floatType) { sb.append("org.nachodb.impl.Bytes#packF4($1.arr,$2,"); sb.append(name); sb.append(");$2+=4;"); } else { sb.append("$2=org.nachodb.impl.Bytes#packStr($1.arr,$2,"); sb.append(name); sb.append(",$3);"); } } } sb.append("return $2;}"); m.setBody(sb.toString()); cc.addMethod(m); m = new CtMethod(unpack, cc, null); sb = new StringBuffer(); sb.append(callSuper ? "{$2=super.unpack($1, $2);" : "{"); for (int i = 0; i < fields.length; i++) { CtField f = fields[i]; if ((f.getModifiers() & (Modifier.STATIC | Modifier.TRANSIENT)) == 0) { CtClass type = f.getType(); String name = f.getName(); sb.append(name); sb.append('='); if (type == CtClass.booleanType) { sb.append("$1[$2++]!=0;"); } else if (type == CtClass.charType) { sb.append("(char)org.nachodb.impl.Bytes#unpack2($1,$2);$2+=2;"); } else if (type == CtClass.byteType) { sb.append("$1[$2++];"); } else if (type == CtClass.shortType) { sb.append("org.nachodb.impl.Bytes#unpack2($1,$2);$2+=2;"); } else if (type == CtClass.intType) { sb.append("org.nachodb.impl.Bytes#unpack4($1,$2);$2+=4;"); } else if (type == CtClass.longType) { sb.append("org.nachodb.impl.Bytes#unpack8($1,$2);$2+=8;"); } else if (type == CtClass.doubleType) { sb.append("org.nachodb.impl.Bytes#unpackF8($1,$2);$2+=8;"); } else if (type == CtClass.floatType) { sb.append("org.nachodb.impl.Bytes#unpackF4($1,$2);$2+=4;"); } else { sb.append( "org.nachodb.impl.Bytes#unpackStr($1,$2,$3);$2+=org.nachodb.impl.Bytes#sizeof($1,$2);"); } } } sb.append("return $2;}"); m.setBody(sb.toString()); cc.addMethod(m); return true; }
public ClazzInfo classProcessing(String clazzName) throws NotFoundException, CannotCompileException { ClassPool classPool = ClassPool.getDefault(); CtClass cz = classPool.get(clazzName); classPool.importPackage(clazzName); // 继承 classPool.importPackage("java.lang.reflect.Method"); // 添加反射引用 CtClass newClass = classPool.makeClass(clazzName + "$MC_IMPL"); // 新建代理类 newClass.setSuperclass(cz); // 继承 // 构造块 CtConstructor tempC; CtConstructor[] ctConstructors = cz.getDeclaredConstructors(); newClass.addConstructor(CtNewConstructor.defaultConstructor(newClass)); for (CtConstructor c : ctConstructors) { try { tempC = CtNewConstructor.copy(c, newClass, null); tempC.setBody("{super($$);}"); newClass.addConstructor(tempC); } catch (Exception e) { // e.printStackTrace(); } } // 字段块 // CtField[] ctFields = cz.getDeclaredFields(); // for (CtField f : ctFields) // System.out.println(f.getFieldInfo().getConstantValue()); // 方法块 CtMethod[] ctMethods = cz.getDeclaredMethods(); CtMethod tempM; // 复制方法名 Map<String, Method> tempMethod = new HashMap<String, Method>(); for (CtMethod m : ctMethods) { tempMethod.put( String.format( "%s %s %s(%s);", Modifier.toString(m.getModifiers()), m.getReturnType().getName(), m.getName(), Util.getParameterTypes(m.getParameterTypes())), null); // System.err.println(String.format("%s %s %s(%s);", Modifier.toString(m.getModifiers()), // m.getReturnType().getName(), m.getName(), Util.getParameterTypes(m.getParameterTypes()))); tempM = CtNewMethod.copy(m, newClass, null); if ("void".equals(tempM.getReturnType().getName())) tempM.setBody("{super." + tempM.getName() + "($$);}"); else tempM.setBody("{ return super." + tempM.getName() + "($$);}"); // CtNewMethod.make(src, declaring, delegateObj, delegateMethod) // 方法修改 // if (m.getName().equals("x")) { // //tempM.setBody("{$proceed($$);}", "this", "mba"); // //tempM.setBody("{n nn = new n();" + "Method a = n.class.getDeclaredMethod(\"a\", new // Class[] { Integer.TYPE });" + "a.invoke(nn, new Object[] { Integer.valueOf(1) });}"); // tempM.setBody("{Method a = n.class.getDeclaredMethod(\"axx\", new Class[] { Integer.TYPE // });}"); // } newClass.addMethod(tempM); } // 测试输出 try { newClass.writeFile("D:/Desktop"); } catch (IOException e) { e.printStackTrace(); } // Class clazz = newClass.toClass(); // System.out.println(clazz.getCanonicalName()); // DefaultCachePoolFactory.newInstance().addNFloop4Map(new ClazzInfo(clazz, tempMethod), // DefaultPool.NORNAL_BEAN, clazz.getCanonicalName()); // return clazz; return new ClazzInfo(newClass.toClass(), tempMethod); }
protected void transform(CtClass clazz) throws Exception { final CtMethod method = clazz.getDeclaredMethod("getQuotaService", new CtClass[] {}); method.setBody( toProxy(QuotaService.class, "new org.jboss.capedwarf.quota.CapedwarfQuotaService()")); }
public DirectoryTestReader(Class<?> clazz) { CsvDirectory csvDirectoryAnnotation = ReflectionUtils.getAnnotation(clazz, CsvDirectory.class); if (csvDirectoryAnnotation == null) { throw new RuntimeException( "Missing annotation \'@CsvDirectory\' on class [" + clazz.getCanonicalName() + "]"); } csvDirectory = csvDirectoryAnnotation.value(); csvShortName = csvDirectory.substring(csvDirectory.lastIndexOf('/') + 1); CsvMacros csvMacrosAnnotation = ReflectionUtils.getAnnotation(clazz, CsvMacros.class); if (csvMacrosAnnotation == null) { throw new RuntimeException( "Missing annotation \'@CsvMacros\' on class [" + clazz.getCanonicalName() + "]"); } this.csvMacros = new ArrayList<String>(); for (String s : csvMacrosAnnotation.value()) { csvMacros.add(s); } File directory = new File(this.csvDirectory); if (!directory.exists()) { throw new RuntimeException("Firectory [" + this.csvDirectory + "] does not exist"); } testMethods = new ArrayList<Method>(); try { tests = new HashMap<String, List<List<String>>>(); macroFiles = new HashMap<String, List<List<String>>>(); for (File f : directory.listFiles()) { if (f.getName().endsWith(".csv")) { String s = f.getName(); s = s.substring(0, s.length() - 4); FileReader reader = new FileReader(f); List<List<String>> sheet = CsvReader.readCsv(reader); if (csvMacros.contains(s)) { macroFiles.put(s, sheet); } else { tests.put(s, sheet); } } } ClassPool cp = ClassPool.getDefault(); CtClass newClazz = cp.makeClass(clazz.getCanonicalName() + ".generated" + System.currentTimeMillis()); newClazz.setSuperclass(cp.get(clazz.getCanonicalName())); List<String> methodList = new ArrayList<String>(); for (Entry<String, List<List<String>>> entry : tests.entrySet()) { String methodName = "run_" + csvShortName + "_" + entry.getKey(); CtMethod m = new CtMethod(CtClass.voidType, methodName, new CtClass[0], newClazz); methodList.add(methodName); m.setBody("launchTest(\"" + entry.getKey() + "\");"); newClazz.addMethod(m); } generatedClazz = newClazz.toClass(); for (String methodName : methodList) { Method m = generatedClazz.getMethod(methodName); testMethods.add(m); } } catch (Exception e) { throw new RuntimeException(e); } }
private void transformGetAsyncMemcacheServiceMethod(CtClass clazz) throws NotFoundException, CannotCompileException { CtMethod method = clazz.getDeclaredMethod("getAsyncMemcacheService"); method.setBody("return new org.jboss.capedwarf.memcache.JBossAsyncMemcacheService();"); }
/** Generate Javassist Proxy Classes */ private static <T> void generateProxyClass( Class<T> primaryInterface, String superClassName, String methodBody) throws Exception { String newClassName = superClassName.replaceAll("(.+)\\.(\\w+)", "$1.Hikari$2"); CtClass superCt = classPool.getCtClass(superClassName); CtClass targetCt = classPool.makeClass(newClassName, superCt); targetCt.setModifiers(Modifier.FINAL); System.out.println("Generating " + newClassName); targetCt.setModifiers(Modifier.PUBLIC); // Make a set of method signatures we inherit implementation for, so we don't generate delegates // for these Set<String> superSigs = new HashSet<>(); for (CtMethod method : superCt.getMethods()) { if ((method.getModifiers() & Modifier.FINAL) == Modifier.FINAL) { superSigs.add(method.getName() + method.getSignature()); } } Set<String> methods = new HashSet<>(); Set<Class<?>> interfaces = getAllInterfaces(primaryInterface); for (Class<?> intf : interfaces) { CtClass intfCt = classPool.getCtClass(intf.getName()); targetCt.addInterface(intfCt); for (CtMethod intfMethod : intfCt.getDeclaredMethods()) { final String signature = intfMethod.getName() + intfMethod.getSignature(); // don't generate delegates for methods we override if (superSigs.contains(signature)) { continue; } // Ignore already added methods that come from other interfaces if (methods.contains(signature)) { continue; } // Ignore default methods (only for Jre8 or later) if (isDefaultMethod(intf, intfCt, intfMethod)) { continue; } // Track what methods we've added methods.add(signature); // Clone the method we want to inject into CtMethod method = CtNewMethod.copy(intfMethod, targetCt, null); String modifiedBody = methodBody; // If the super-Proxy has concrete methods (non-abstract), transform the call into a simple // super.method() call CtMethod superMethod = superCt.getMethod(intfMethod.getName(), intfMethod.getSignature()); if ((superMethod.getModifiers() & Modifier.ABSTRACT) != Modifier.ABSTRACT) { modifiedBody = modifiedBody.replace("((cast) ", ""); modifiedBody = modifiedBody.replace("delegate", "super"); modifiedBody = modifiedBody.replace("super)", "super"); } modifiedBody = modifiedBody.replace("cast", primaryInterface.getName()); // Generate a method that simply invokes the same method on the delegate if (isThrowsSqlException(intfMethod)) { modifiedBody = modifiedBody.replace("method", method.getName()); } else { modifiedBody = "{ return ((cast) delegate).method($$); }" .replace("method", method.getName()) .replace("cast", primaryInterface.getName()); } if (method.getReturnType() == CtClass.voidType) { modifiedBody = modifiedBody.replace("return", ""); } method.setBody(modifiedBody); targetCt.addMethod(method); } } targetCt.writeFile("target/classes"); }