Java FieldInfo类代码示例

import scouter.javassist.bytecode.FieldInfo; //导入依赖的package包/类
private void atFieldRead(CtField f) throws CompileError {
    FieldInfo finfo = f.getFieldInfo2();
    String type = finfo.getDescriptor();

    int i = 0;
    int dim = 0;
    char c = type.charAt(i);
    while (c == '[') {
        ++dim;
        c = type.charAt(++i);
    }

    arrayDim = dim;
    exprType = MemberResolver.descToType(c);

    if (c == 'L')
        className = type.substring(i + 1, type.indexOf(';', i + 1));
    else
        className = null;
}
 

import scouter.javassist.bytecode.FieldInfo; //导入依赖的package包/类
private void atFieldAssignCore(CtField f, boolean is_static, int fi,
                               boolean is2byte) throws CompileError {
    if (fi != 0) {
        if (is_static) {
           bytecode.add(PUTSTATIC);
           bytecode.growStack(is2byte ? -2 : -1);
        }
        else {
            bytecode.add(PUTFIELD);
            bytecode.growStack(is2byte ? -3 : -2);
        }
    
        bytecode.addIndex(fi);
    }
    else {
        CtClass declClass = f.getDeclaringClass();
        AccessorMaker maker = declClass.getAccessorMaker();
        // make should be non null.
        FieldInfo finfo = f.getFieldInfo2();
        MethodInfo minfo = maker.getFieldSetter(finfo, is_static);
        bytecode.addInvokestatic(declClass, minfo.getName(),
                                 minfo.getDescriptor());
    }
}
 

import scouter.javassist.bytecode.FieldInfo; //导入依赖的package包/类
/**
 * Generates bytecode for reading a field value.
 * It returns a fieldref_info index or zero if the field is a private
 * one declared in an enclosing class. 
 */
private int atFieldRead(CtField f, boolean isStatic) throws CompileError {
    FieldInfo finfo = f.getFieldInfo2();
    boolean is2byte = setFieldType(finfo);
    AccessorMaker maker = isAccessibleField(f, finfo);
    if (maker != null) {
        MethodInfo minfo = maker.getFieldGetter(finfo, isStatic);
        bytecode.addInvokestatic(f.getDeclaringClass(), minfo.getName(),
                                 minfo.getDescriptor());
        return 0;
    }
    else {
        int fi = addFieldrefInfo(f, finfo);
        if (isStatic) {
            bytecode.add(GETSTATIC);
            bytecode.growStack(is2byte ? 2 : 1);
        }
        else {
            bytecode.add(GETFIELD);
            bytecode.growStack(is2byte ? 1 : 0);
        }

        bytecode.addIndex(fi);
        return fi;
    }
}
 

import scouter.javassist.bytecode.FieldInfo; //导入依赖的package包/类
/**
 * Returns null if the field is accessible.  Otherwise, it throws
 * an exception or it returns AccessorMaker if the field is a private
 * one declared in an enclosing class.
 */
private AccessorMaker isAccessibleField(CtField f, FieldInfo finfo)
    throws CompileError
{
    if (AccessFlag.isPrivate(finfo.getAccessFlags())
        && f.getDeclaringClass() != thisClass) {
        CtClass declClass = f.getDeclaringClass(); 
        if (isEnclosing(declClass, thisClass)) {
            AccessorMaker maker = declClass.getAccessorMaker();
            if (maker != null)
                return maker;
            else
                throw new CompileError("fatal error.  bug?");
        }
        else
            throw new CompileError("Field " + f.getName() + " in "
                                   + declClass.getName() + " is private.");
    }

    return null;    // accessible field
}
 

import scouter.javassist.bytecode.FieldInfo; //导入依赖的package包/类
/**
 * Sets exprType, arrayDim, and className.
 *
 * @return true if the field type is long or double. 
 */
private boolean setFieldType(FieldInfo finfo) throws CompileError {
    String type = finfo.getDescriptor();

    int i = 0;
    int dim = 0;
    char c = type.charAt(i);
    while (c == '[') {
        ++dim;
        c = type.charAt(++i);
    }

    arrayDim = dim;
    exprType = MemberResolver.descToType(c);

    if (c == 'L')
        className = type.substring(i + 1, type.indexOf(';', i + 1));
    else
        className = null;

    boolean is2byte = dim == 0 && (c == 'J' || c == 'D');
    return is2byte;
}
 

import scouter.javassist.bytecode.FieldInfo; //导入依赖的package包/类
/**
 * Creates a public getter method.  The getter method returns the value
 * of the specified field in the class to which this method is added.
 * The created method is initially not static even if the field is
 * static.  Change the modifiers if the method should be static.
 *
 * @param methodName        the name of the getter
 * @param field             the field accessed.
 */
public static CtMethod getter(String methodName, CtField field)
    throws CannotCompileException
{
    FieldInfo finfo = field.getFieldInfo2();
    String fieldType = finfo.getDescriptor();
    String desc = "()" + fieldType;
    ConstPool cp = finfo.getConstPool();
    MethodInfo minfo = new MethodInfo(cp, methodName, desc);
    minfo.setAccessFlags(AccessFlag.PUBLIC);

    Bytecode code = new Bytecode(cp, 2, 1);
    try {
        String fieldName = finfo.getName();
        if ((finfo.getAccessFlags() & AccessFlag.STATIC) == 0) {
            code.addAload(0);
            code.addGetfield(Bytecode.THIS, fieldName, fieldType);
        }
        else
            code.addGetstatic(Bytecode.THIS, fieldName, fieldType);

        code.addReturn(field.getType());
    }
    catch (NotFoundException e) {
        throw new CannotCompileException(e);
    }

    minfo.setCodeAttribute(code.toCodeAttribute());
    CtClass cc = field.getDeclaringClass();
    // a stack map is not needed.
    return new CtMethod(minfo, cc);
}
 

import scouter.javassist.bytecode.FieldInfo; //导入依赖的package包/类
/**
 * Creates a public setter method.  The setter method assigns the
 * value of the first parameter to the specified field
 * in the class to which this method is added.
 * The created method is not static even if the field is
 * static.  You may not change it to be static
 * by <code>setModifiers()</code> in <code>CtBehavior</code>.
 *
 * @param methodName        the name of the setter
 * @param field             the field accessed.
 */
public static CtMethod setter(String methodName, CtField field)
    throws CannotCompileException
{
    FieldInfo finfo = field.getFieldInfo2();
    String fieldType = finfo.getDescriptor();
    String desc = "(" + fieldType + ")V";
    ConstPool cp = finfo.getConstPool();
    MethodInfo minfo = new MethodInfo(cp, methodName, desc);
    minfo.setAccessFlags(AccessFlag.PUBLIC);

    Bytecode code = new Bytecode(cp, 3, 3);
    try {
        String fieldName = finfo.getName();
        if ((finfo.getAccessFlags() & AccessFlag.STATIC) == 0) {
            code.addAload(0);
            code.addLoad(1, field.getType());
            code.addPutfield(Bytecode.THIS, fieldName, fieldType);
        }
        else {
            code.addLoad(1, field.getType());
            code.addPutstatic(Bytecode.THIS, fieldName, fieldType);
        }

        code.addReturn(null);
    }
    catch (NotFoundException e) {
        throw new CannotCompileException(e);
    }

    minfo.setCodeAttribute(code.toCodeAttribute());
    CtClass cc = field.getDeclaringClass();
    // a stack map is not needed.
    return new CtMethod(minfo, cc);
}
 

import scouter.javassist.bytecode.FieldInfo; //导入依赖的package包/类
private CtField(String typeDesc, String name, CtClass clazz)
    throws CannotCompileException
{
    super(clazz);
    ClassFile cf = clazz.getClassFile2();
    if (cf == null)
        throw new CannotCompileException("bad declaring class: "
                                         + clazz.getName());

    fieldInfo = new FieldInfo(cf.getConstPool(), name, typeDesc);
}
 

import scouter.javassist.bytecode.FieldInfo; //导入依赖的package包/类
/**
 * Returns true if the class has the specified annotation type.
 *
 * @param typeName      the name of annotation type.
 * @return <code>true</code> if the annotation is found, otherwise <code>false</code>.
 * @since 3.21
 */
public boolean hasAnnotation(String typeName) {
    FieldInfo fi = getFieldInfo2();
    AnnotationsAttribute ainfo = (AnnotationsAttribute)
                fi.getAttribute(AnnotationsAttribute.invisibleTag);  
    AnnotationsAttribute ainfo2 = (AnnotationsAttribute)
                fi.getAttribute(AnnotationsAttribute.visibleTag);  
    return CtClassType.hasAnnotationType(typeName, getDeclaringClass().getClassPool(),
                                         ainfo, ainfo2);
}
 

import scouter.javassist.bytecode.FieldInfo; //导入依赖的package包/类
private Object[] getAnnotations(boolean ignoreNotFound) throws ClassNotFoundException {
    FieldInfo fi = getFieldInfo2();
    AnnotationsAttribute ainfo = (AnnotationsAttribute)
                fi.getAttribute(AnnotationsAttribute.invisibleTag);  
    AnnotationsAttribute ainfo2 = (AnnotationsAttribute)
                fi.getAttribute(AnnotationsAttribute.visibleTag);  
    return CtClassType.toAnnotationType(ignoreNotFound, getDeclaringClass().getClassPool(),
                                        ainfo, ainfo2);
}
 

import scouter.javassist.bytecode.FieldInfo; //导入依赖的package包/类
private void makeFieldCache(CtMember.Cache cache) {
    List list = getClassFile3(false).getFields();
    int n = list.size();
    for (int i = 0; i < n; ++i) {
        FieldInfo finfo = (FieldInfo)list.get(i);
        CtField newField = new CtField(finfo, this);
        cache.addField(newField);
    }
}
 

import scouter.javassist.bytecode.FieldInfo; //导入依赖的package包/类
public void removeField(CtField f) throws NotFoundException {
    checkModify();
    FieldInfo fi = f.getFieldInfo2();
    ClassFile cf = getClassFile2();
    if (cf.getFields().remove(fi)) {
        getMembers().remove(f);
        gcConstPool = true;
    }
    else
        throw new NotFoundException(f.toString());
}
 

import scouter.javassist.bytecode.FieldInfo; //导入依赖的package包/类
private int addFieldrefInfo(CtField f, FieldInfo finfo) {
    ConstPool cp = bytecode.getConstPool();
    String cname = f.getDeclaringClass().getName();
    int ci = cp.addClassInfo(cname);
    String name = finfo.getName();
    String type = finfo.getDescriptor();
    return cp.addFieldrefInfo(ci, name, type);
}
 

import scouter.javassist.bytecode.FieldInfo; //导入依赖的package包/类
/**
 * Returns the FieldInfo representing the field in the class file.
 */
public FieldInfo getFieldInfo() {
    declaringClass.checkModify();
    return fieldInfo;
}
 

import scouter.javassist.bytecode.FieldInfo; //导入依赖的package包/类
private ClassFile make() throws CannotCompileException {
    ClassFile cf = new ClassFile(false, classname, superName);
    cf.setAccessFlags(AccessFlag.PUBLIC);
    setInterfaces(cf, interfaces, hasGetHandler ? Proxy.class : ProxyObject.class);
    ConstPool pool = cf.getConstPool();

    // legacy: we only add the static field for the default interceptor if caching is disabled
    if  (!factoryUseCache) {
        FieldInfo finfo = new FieldInfo(pool, DEFAULT_INTERCEPTOR, HANDLER_TYPE);
        finfo.setAccessFlags(AccessFlag.PUBLIC | AccessFlag.STATIC);
        cf.addField(finfo);
    }

    // handler is per instance
    FieldInfo finfo2 = new FieldInfo(pool, HANDLER, HANDLER_TYPE);
    finfo2.setAccessFlags(AccessFlag.PRIVATE);
    cf.addField(finfo2);

    // filter signature is per class
    FieldInfo finfo3 = new FieldInfo(pool, FILTER_SIGNATURE_FIELD, FILTER_SIGNATURE_TYPE);
    finfo3.setAccessFlags(AccessFlag.PUBLIC | AccessFlag.STATIC);
    cf.addField(finfo3);

    // the proxy class serial uid must always be a fixed value
    FieldInfo finfo4 = new FieldInfo(pool, SERIAL_VERSION_UID_FIELD, SERIAL_VERSION_UID_TYPE);
    finfo4.setAccessFlags(AccessFlag.PUBLIC | AccessFlag.STATIC| AccessFlag.FINAL);
    cf.addField(finfo4);
    
    // HashMap allMethods = getMethods(superClass, interfaces);
    // int size = allMethods.size();
    makeConstructors(classname, cf, pool, classname);

    ArrayList forwarders = new ArrayList();
    int s = overrideMethods(cf, pool, classname, forwarders);
    addClassInitializer(cf, pool, classname, s, forwarders);
    addSetter(classname, cf, pool);
    if (!hasGetHandler)
        addGetter(classname, cf, pool);

    if (factoryWriteReplace) {
        try {
            cf.addMethod(makeWriteReplace(pool));
        }
        catch (DuplicateMemberException e) {
            // writeReplace() is already declared in the super class/interfaces.
        }
    }

    thisClass = null;
    return cf;
}