Java ReflectionCache.getCachedClass方法代码示例

import org.codehaus.groovy.reflection.ReflectionCache; //导入方法依赖的package包/类
/**
  * Constructor
  *
  * @param theClass The class this is the metaclass dor
  * @param add The methods for this class
  */
public MetaClassImpl(final Class theClass, MetaMethod[] add) {
    this.theClass = theClass;
    theCachedClass = ReflectionCache.getCachedClass(theClass);
    this.isGroovyObject = GroovyObject.class.isAssignableFrom(theClass);
    this.isMap = Map.class.isAssignableFrom(theClass);
    this.registry = GroovySystem.getMetaClassRegistry();
    metaMethodIndex = new MetaMethodIndex(theCachedClass);
    final MetaMethod[] metaMethods = theCachedClass.getNewMetaMethods();
    if (add != null && !(add.length == 0)) {
        List<MetaMethod> arr = new ArrayList<MetaMethod>();
        arr.addAll(Arrays.asList(metaMethods));
        arr.addAll(Arrays.asList(add));
        myNewMetaMethods = arr.toArray(new MetaMethod[arr.size()]);
        additionalMetaMethods = metaMethods;
    }
    else {
        myNewMetaMethods = metaMethods;
        additionalMetaMethods = EMPTY;
    }
}
 

import org.codehaus.groovy.reflection.ReflectionCache; //导入方法依赖的package包/类
private MetaProperty getMetaProperty(Class _clazz, String name, boolean useSuper, boolean useStatic) {
    if (_clazz == theClass)
      return getMetaProperty(name, useStatic);

    CachedClass clazz = ReflectionCache.getCachedClass(_clazz);
    while (true) {
        SingleKeyHashMap propertyMap;
        if (useStatic) {
            propertyMap = staticPropertyIndex;
        } else if (useSuper) {
            propertyMap = classPropertyIndexForSuper.getNullable(clazz);
        } else {
            propertyMap = classPropertyIndex.getNullable(clazz);
        }
        if (propertyMap == null) {
            if (clazz != theCachedClass) {
                clazz = theCachedClass;
                continue;
            } else {
                return null;
            }
        }
        return (MetaProperty) propertyMap.get(name);
    }
}
 

import org.codehaus.groovy.reflection.ReflectionCache; //导入方法依赖的package包/类
private static void createMetaMethods(final Class extensionClass, final List<MetaMethod> metaMethods, final boolean isStatic) {
    CachedClass cachedClass = ReflectionCache.getCachedClass(extensionClass);
    CachedMethod[] methods = cachedClass.getMethods();
    for (CachedMethod method : methods) {
        if (method.isStatic() && method.isPublic() && method.getParamsCount() > 0) {
            // an extension method is found
            metaMethods.add(isStatic?new NewStaticMetaMethod(method) : new NewInstanceMetaMethod(method));
        }
    }
}
 

import org.codehaus.groovy.reflection.ReflectionCache; //导入方法依赖的package包/类
/**
 * Generates the bytecode to autobox the current value on the stack
 */
@Deprecated
public static boolean box(MethodVisitor mv, Class type) {
    if (ReflectionCache.getCachedClass(type).isPrimitive && type != void.class) {
        String returnString = "(" + BytecodeHelper.getTypeDescription(type) + ")Ljava/lang/Object;";
        mv.visitMethodInsn(INVOKESTATIC, DTT_CLASSNAME, "box", returnString, false);
        return true;
    }
    return false;
}
 

import org.codehaus.groovy.reflection.ReflectionCache; //导入方法依赖的package包/类
private void use(Class categoryClass) {
    CachedClass cachedClass = ReflectionCache.getCachedClass(categoryClass);
    LinkedList<CachedClass> classStack = new LinkedList<CachedClass>();
    for (CachedClass superClass = cachedClass; superClass.getTheClass()!=Object.class; superClass = superClass.getCachedSuperClass()) {
        classStack.add(superClass);
    }

    while (!classStack.isEmpty()) {
        CachedClass klazz = classStack.removeLast();
        applyUse(klazz);
    }
}
 

import org.codehaus.groovy.reflection.ReflectionCache; //导入方法依赖的package包/类
public ClosureMetaMethod(String name, Class declaringClass, Closure c, CachedMethod doCall) {
    super (doCall.getNativeParameterTypes());
    this.name = name;
    callable = c;
    this.doCall = doCall;
    this.declaringClass = ReflectionCache.getCachedClass(declaringClass);
}
 

import org.codehaus.groovy.reflection.ReflectionCache; //导入方法依赖的package包/类
public Closure(Object owner, Object thisObject) {
    this.owner = owner;
    this.delegate = owner;
    this.thisObject = thisObject;

    final CachedClosureClass cachedClass = (CachedClosureClass) ReflectionCache.getCachedClass(getClass());
    parameterTypes = cachedClass.getParameterTypes();
    maximumNumberOfParameters = cachedClass.getMaximumNumberOfParameters();
}
 

import org.codehaus.groovy.reflection.ReflectionCache; //导入方法依赖的package包/类
public ClosureStaticMetaMethod(String name, Class declaringClass, Closure c, Class[] paramTypes) {
    super(paramTypes);
    this.callable = c;
    this.declaringClass = ReflectionCache.getCachedClass(declaringClass);
    this.name = name;
}
 

import org.codehaus.groovy.reflection.ReflectionCache; //导入方法依赖的package包/类
public CachedClass getDeclaringClass() {
    return ReflectionCache.getCachedClass(declaringClass);
}