private static void addWithModifiers(CtClass target, CtClass type, String name, int modifiers, Class<?> ... annotations ) { try { final CtField f = new CtField( type, name, target ); f.setModifiers( f.getModifiers() | modifiers ); addAnnotations( f.getFieldInfo(), annotations ); target.addField( f ); } catch (CannotCompileException cce) { final String msg = String.format( "Could not enhance class [%s] to add field [%s]", target.getName(), name ); throw new EnhancementException( msg, cce ); } }
f = new CtField(classPool.get("javassist.tools.reflect.Metaobject"), metaobjectField, clazz); f.setModifiers(Modifier.PROTECTED); clazz.addField(f, CtField.Initializer.byNewWithParams(metaobject)); f.setModifiers(Modifier.PRIVATE | Modifier.STATIC); clazz.addField(f, CtField.Initializer.byNew(metaclass, new String[] { clazz.getName() }));
/** * Adds serialVersionUID if one does not already exist. Call this before * modifying a class to maintain serialization compatability. */ public static void setSerialVersionUID(CtClass clazz) throws CannotCompileException, NotFoundException { // check for pre-existing field. try { clazz.getDeclaredField("serialVersionUID"); return; } catch (NotFoundException e) {} // check if the class is serializable. if (!isSerializable(clazz)) return; // add field with default value. CtField field = new CtField(CtClass.longType, "serialVersionUID", clazz); field.setModifiers(Modifier.PRIVATE | Modifier.STATIC | Modifier.FINAL); clazz.addField(field, calculateDefault(clazz) + "L"); }
private boolean modifyClassfile(CtClass clazz, CtClass metaobject, CtClass metaclass) throws CannotCompileException, NotFoundException { if (clazz.getAttribute("Reflective") != null) return false; // this is already reflective. clazz.setAttribute("Reflective", new byte[0]); CtClass mlevel = classPool.get("javassist.tools.reflect.Metalevel"); boolean addMeta = !clazz.subtypeOf(mlevel); if (addMeta) clazz.addInterface(mlevel); processMethods(clazz, addMeta); processFields(clazz); CtField f; if (addMeta) { f = new CtField(classPool.get("javassist.tools.reflect.Metaobject"), metaobjectField, clazz); f.setModifiers(Modifier.PROTECTED); clazz.addField(f, CtField.Initializer.byNewWithParams(metaobject)); clazz.addMethod(CtNewMethod.getter(metaobjectGetter, f)); clazz.addMethod(CtNewMethod.setter(metaobjectSetter, f)); } f = new CtField(classPool.get("javassist.tools.reflect.ClassMetaobject"), classobjectField, clazz); f.setModifiers(Modifier.PRIVATE | Modifier.STATIC); clazz.addField(f, CtField.Initializer.byNew(metaclass, new String[] { clazz.getName() })); clazz.addMethod(CtNewMethod.getter(classobjectAccessor, f)); return true; }
= new CtField(classPool.get("javassist.tools.rmi.ObjectImporter"), fieldImporter, proxy); f.setModifiers(Modifier.PRIVATE); proxy.addField(f, CtField.Initializer.byParameter(0)); f.setModifiers(Modifier.PRIVATE); proxy.addField(f, CtField.Initializer.byParameter(1));
CtClass type = classPool.getOrNull(Constants.INTERFACE_NAME); CtField ctField = new CtField(type, Constants.INSERT_FIELD_NAME, ctClass); ctField.setModifiers(AccessFlag.PUBLIC | AccessFlag.STATIC); ctClass.addField(ctField);
/** * Adds serialVersionUID if one does not already exist. Call this before * modifying a class to maintain serialization compatability. */ public static void setSerialVersionUID(CtClass clazz) throws CannotCompileException, NotFoundException { // check for pre-existing field. try { clazz.getDeclaredField("serialVersionUID"); return; } catch (NotFoundException e) {} // check if the class is serializable. if (!isSerializable(clazz)) return; // add field with default value. CtField field = new CtField(CtClass.longType, "serialVersionUID", clazz); field.setModifiers(Modifier.PRIVATE | Modifier.STATIC | Modifier.FINAL); clazz.addField(field, calculateDefault(clazz) + "L"); }
CtClass type = pool.get("javassist.runtime.Cflow"); CtField field = new CtField(type, fname, cc); field.setModifiers(Modifier.PUBLIC | Modifier.STATIC); cc.addField(field, CtField.Initializer.byNew(type)); insertBefore(fname + ".enter();", false);
= new CtField(classPool.get("javassist.tools.rmi.ObjectImporter"), fieldImporter, proxy); f.setModifiers(Modifier.PRIVATE); proxy.addField(f, CtField.Initializer.byParameter(0)); f.setModifiers(Modifier.PRIVATE); proxy.addField(f, CtField.Initializer.byParameter(1));
CtClass type = pool.get("javassist.runtime.Cflow"); CtField field = new CtField(type, fname, cc); field.setModifiers(Modifier.PUBLIC | Modifier.STATIC); cc.addField(field, CtField.Initializer.byNew(type)); insertBefore(fname + ".enter();", false);
private static CtField createCtField(CtClass ctClass, FieldConfig field) throws CannotCompileException { CtField ctField = new CtField(field.getType().getCtClass(), field.getName(), ctClass); if (field.getType().hasGenericTypes()) { ctField.setGenericSignature(field.getType().getGenericSignature()); } ctField.setModifiers(Modifier.PUBLIC); return ctField; } }
// Create the class. CtClass subClass = pool.makeClass( fullName ); final CtClass superClass = pool.get( Foo.class.getName() ); subClass.setSuperclass( superClass ); // Add a static field containing the definition. // Probably unachievable. final CtClass defClass = pool.get( SomeMetaData.class.getName() ); CtField defField = new CtField( defClass, "DEF", subClass ); defField.setModifiers( Modifier.STATIC ); subClass.addField( defField, CtField.Initializer.byNew(defClass) ); return subClass.toClass();
private void addTypedCallingField()throws CannotCompileException { CtField callingField = new CtField(callingClass, TYPED_CALLER_FIELD, jp); jp.addField(callingField); callingField.setModifiers(Modifier.PROTECTED); }
private void addMethodInfoField()throws CannotCompileException { CtField infoField = new CtField(constructorInfoClass, INFO_FIELD, jp); infoField.setModifiers(javassist.Modifier.PROTECTED);//Make visible to classes in child classloaders jp.addField(infoField); }
private void addMethodInfoField()throws CannotCompileException { CtField infoField = new CtField(methodInfoClass, INFO_FIELD, jp); infoField.setModifiers(javassist.Modifier.PROTECTED);//Make visible to classes in child classloaders jp.addField(infoField); }
private void addTypedTargetField()throws CannotCompileException { CtField targetField = new CtField(targetClass, TYPED_TARGET_FIELD, jp); jp.addField(targetField); targetField.setModifiers(Modifier.PROTECTED); }
protected void defineProxyFields(ClassPool pool, CtClass cc) throws CannotCompileException, NotFoundException { CtField target = new CtField(pool.get(cc.getSuperclass().getName()), "__target", cc); target.setModifiers(AccessFlag.PUBLIC); cc.addField(target); }
private void addConstructionInfoField()throws CannotCompileException { CtField infoField = new CtField(constructionInfoClass, INFO_FIELD, jp); infoField.setModifiers(javassist.Modifier.PROTECTED);//Make visible to classes in child classloaders jp.addField(infoField); }
private static void addWithModifiers(CtClass target, CtClass type, String name, int modifiers, Class<?> ... annotations ) { try { final CtField f = new CtField( type, name, target ); f.setModifiers( f.getModifiers() | modifiers ); addAnnotations( f.getFieldInfo(), annotations ); target.addField( f ); } catch (CannotCompileException cce) { final String msg = String.format( "Could not enhance class [%s] to add field [%s]", target.getName(), name ); throw new EnhancementException( msg, cce ); } }
public void addField(String name, Class type) { CtClass ctType = convertClass(type); try { CtField field = new CtField(ctType, name, getCtClass()); field.setModifiers(Modifier.PRIVATE); getCtClass().addField(field); } catch (CannotCompileException ex) { throw new ApplicationRuntimeException(EnhanceMessages.unableToAddField(name, getCtClass(), ex), ex); } }