import groovy.lang.MetaClass; //导入依赖的package包/类
@Nullable
private MetaMethod findPropertyMissingMethod(MetaClass metaClass) {
    if (metaClass instanceof MetaClassImpl) {
        // Reach into meta class to avoid lookup
        try {
            return (MetaMethod) MISSING_PROPERTY_GET_METHOD.get(metaClass);
        } catch (IllegalAccessException e) {
            throw UncheckedException.throwAsUncheckedException(e);
        }
    }

    // Query the declared methods of the meta class
    for (MetaMethod method : metaClass.getMethods()) {
        if (method.getName().equals("propertyMissing") && method.getParameterTypes().length == 1) {
            return method;
        }
    }
    return null;
}
 

import groovy.lang.MetaClass; //导入依赖的package包/类
/**
 * Add listeners to a specific object.  Updates the bould flags and update set
 *
 * @param listener This listener to attach.
 * @param newObject The object we should read our property off of.
 * @param updateSet The list of objects we have added listeners to
 */
public void addListeners(PropertyChangeListener listener, Object newObject, Set updateSet) {
    removeListeners();
    if (newObject != null) {
        // check for local synthetics
        TriggerBinding syntheticTrigger = getSyntheticTriggerBinding(newObject);
        MetaClass mc = InvokerHelper.getMetaClass(newObject);
        if (syntheticTrigger != null) {
            PropertyBinding psb = new PropertyBinding(newObject, propertyName);
            PropertyChangeProxyTargetBinding proxytb = new PropertyChangeProxyTargetBinding(newObject, propertyName, listener);

            syntheticFullBinding = syntheticTrigger.createBinding(psb, proxytb);
            syntheticFullBinding.bind();
            updateSet.add(newObject);
        } else if (!mc.respondsTo(newObject, "addPropertyChangeListener", NAME_PARAMS).isEmpty()) {
            InvokerHelper.invokeMethod(newObject, "addPropertyChangeListener", new Object[] {propertyName, listener});
            localListener = listener;
            updateSet.add(newObject);
        } else if (!mc.respondsTo(newObject, "addPropertyChangeListener", GLOBAL_PARAMS).isEmpty()) {
            InvokerHelper.invokeMethod(newObject, "addPropertyChangeListener", listener);
            globalListener = listener;
            updateSet.add(newObject);
        }
    }
    currentObject = newObject;
}
 

import groovy.lang.MetaClass; //导入依赖的package包/类
private static void staticMethod(final MetaClass self, List<MetaMethod> arr, final CachedMethod method) {
    CachedClass[] paramTypes = method.getParameterTypes();

    if (paramTypes.length == 0)
        return;

    NewInstanceMetaMethod metaMethod;
    if (paramTypes[0].isAssignableFrom(self.getTheClass())) {
        if (paramTypes[0].getTheClass() == self.getTheClass())
            metaMethod = new NewInstanceMetaMethod(method);
        else
            metaMethod = new NewInstanceMetaMethod(method) {
                public CachedClass getDeclaringClass() {
                    return ReflectionCache.getCachedClass(self.getTheClass());
                }
            };
        arr.add(metaMethod);
    } else {
        if (self.getTheClass().isAssignableFrom(paramTypes[0].getTheClass())) {
            metaMethod = new NewInstanceMetaMethod(method);
            arr.add(metaMethod);
        }
    }
}
 

import groovy.lang.MetaClass; //导入依赖的package包/类
public void setNewMopMethods(List<MetaMethod> arr) {
    final MetaClass metaClass = classInfo.getStrongMetaClass();
    if (metaClass != null) {
      if (metaClass.getClass() == MetaClassImpl.class) {
          classInfo.setStrongMetaClass(null);
          updateSetNewMopMethods(arr);
          classInfo.setStrongMetaClass(new MetaClassImpl(metaClass.getTheClass()));
          return;
      }

      if (metaClass.getClass() == ExpandoMetaClass.class) {
          classInfo.setStrongMetaClass(null);
          updateSetNewMopMethods(arr);
          ExpandoMetaClass newEmc = new ExpandoMetaClass(metaClass.getTheClass());
          newEmc.initialize();
          classInfo.setStrongMetaClass(newEmc);
          return;
      }

      throw new GroovyRuntimeException("Can't add methods to class " + getTheClass().getName() + ". Strong custom meta class already set.");
    }

    classInfo.setWeakMetaClass(null);
    updateSetNewMopMethods(arr);
}
 

import groovy.lang.MetaClass; //导入依赖的package包/类
private MetaClass getMetaClassUnderLock() {
    MetaClass answer = getStrongMetaClass();
    if (answer!=null) return answer;
    
    answer = getWeakMetaClass();
    final MetaClassRegistry metaClassRegistry = GroovySystem.getMetaClassRegistry();
    MetaClassRegistry.MetaClassCreationHandle mccHandle = metaClassRegistry.getMetaClassCreationHandler();
    
    if (isValidWeakMetaClass(answer, mccHandle)) {
        return answer;
    }

    answer = mccHandle.create(classRef.get(), metaClassRegistry);
    answer.initialize();

    if (GroovySystem.isKeepJavaMetaClasses()) {
        setStrongMetaClass(answer);
    } else {
        setWeakMetaClass(answer);
    }
    return answer;
}
 

import groovy.lang.MetaClass; //导入依赖的package包/类
private CallSite createPojoMetaClassGetPropertySite(Object receiver) {
    final MetaClass metaClass = InvokerHelper.getMetaClass(receiver);

    CallSite site;
    if (metaClass.getClass() != MetaClassImpl.class || GroovyCategorySupport.hasCategoryInCurrentThread()) {
        site = new PojoMetaClassGetPropertySite(this);
    } else {
        final MetaProperty effective = ((MetaClassImpl) metaClass).getEffectiveGetMetaProperty(receiver.getClass(), receiver, name, false);
        if (effective != null) {
            if (effective instanceof CachedField)
                site = new GetEffectivePojoFieldSite(this, (MetaClassImpl) metaClass, (CachedField) effective);
            else
                site = new GetEffectivePojoPropertySite(this, (MetaClassImpl) metaClass, effective);
        } else {
            site = new PojoMetaClassGetPropertySite(this);
        }
    }

    array.array[index] = site;
    return site;
}
 

import groovy.lang.MetaClass; //导入依赖的package包/类
private CallSite createPogoMetaClassGetPropertySite(GroovyObject receiver) {
    MetaClass metaClass = receiver.getMetaClass();

    CallSite site;
    if (metaClass.getClass() != MetaClassImpl.class || GroovyCategorySupport.hasCategoryInCurrentThread()) {
        site = new PogoMetaClassGetPropertySite(this, metaClass);
    } else {
        final MetaProperty effective = ((MetaClassImpl) metaClass).getEffectiveGetMetaProperty(this.array.owner, receiver, name, false);
        if (effective != null) {
            if (effective instanceof CachedField)
                site = new GetEffectivePogoFieldSite(this, metaClass, (CachedField) effective);
            else
                site = new GetEffectivePogoPropertySite(this, metaClass, effective);
        } else {
            site = new PogoMetaClassGetPropertySite(this, metaClass);
        }
    }

    array.array[index] = site;
    return site;
}
 

import groovy.lang.MetaClass; //导入依赖的package包/类
private static CallSite createCallStaticSite(CallSite callSite, final Class receiver, Object[] args) {
    CallSite site;
    AccessController.doPrivileged(new PrivilegedAction<Void>() {
        public Void run() {
            try {
                Class.forName(receiver.getName(), true, receiver.getClassLoader());
            } catch (Exception e) {
                // force <clinit>
            }
            return null;
        }
    });
    MetaClass metaClass = InvokerHelper.getMetaClass(receiver);
    if (metaClass instanceof MetaClassImpl) {
        site = ((MetaClassImpl)metaClass).createStaticSite(callSite, args);
    }
    else
      site = new StaticMetaClassSite(callSite, metaClass);

    replaceCallSite(callSite, site);
    return site;
}
 

import groovy.lang.MetaClass; //导入依赖的package包/类
private static CallSite createCallCurrentSite(CallSite callSite, GroovyObject receiver, Object[] args, Class sender) {
    CallSite site;
    if (receiver instanceof GroovyInterceptable)
      site = new PogoInterceptableSite(callSite);
    else {
        MetaClass metaClass = receiver.getMetaClass();
        if (receiver.getClass() != metaClass.getTheClass() && !metaClass.getTheClass().isInterface()) {
            site = new PogoInterceptableSite(callSite);
        }
        else
            if (metaClass instanceof MetaClassImpl) {
                site = ((MetaClassImpl)metaClass).createPogoCallCurrentSite(callSite, sender, args);
            }
            else
              site = new PogoMetaClassSite(callSite, metaClass);
    }

    replaceCallSite(callSite, site);
    return site;
}
 

import groovy.lang.MetaClass; //导入依赖的package包/类
/**
 * Sets the metaclass for a given class.
 *
 * @param self the class whose metaclass we wish to set
 * @param metaClass the new MetaClass
 * @since 1.6.0
 */
public static void setMetaClass(Class self, MetaClass metaClass) {
    final MetaClassRegistry metaClassRegistry = GroovySystem.getMetaClassRegistry();
    if (metaClass == null)
        metaClassRegistry.removeMetaClass(self);
    else {
        if (metaClass instanceof HandleMetaClass) {
            metaClassRegistry.setMetaClass(self, ((HandleMetaClass)metaClass).getAdaptee());
        } else {
            metaClassRegistry.setMetaClass(self, metaClass);
        }
        if (self==NullObject.class) {
            NullObject.getNullObject().setMetaClass(metaClass);
        }
    }
}
 

import groovy.lang.MetaClass; //导入依赖的package包/类
private static MetaClass hasPerInstanceMetaClass(Object object) {
    if (object instanceof GroovyObject) {
        MetaClass mc = ((GroovyObject)object).getMetaClass();
        if (mc == GroovySystem.getMetaClassRegistry().getMetaClass(object.getClass()) || mc.getClass() == MetaClassImpl.class)
            return null;
        else
            return mc;
    }
    else {
        ClassInfo info = ClassInfo.getClassInfo(object.getClass());
        info.lock();
        try {
            return info.getPerInstanceMetaClass(object);
        }
        finally {
            info.unlock();
        }
    }
}
 

import groovy.lang.MetaClass; //导入依赖的package包/类
public Object build(Script script) {
    // this used to be synchronized, but we also used to remove the
    // metaclass.  Since adding the metaclass is now a side effect, we
    // don't need to ensure the meta-class won't be observed and don't
    // need to hide the side effect.
    MetaClass scriptMetaClass = script.getMetaClass();
    script.setMetaClass(new FactoryInterceptorMetaClass(scriptMetaClass, this));
    script.setBinding(this);
    Object oldScriptName = getProxyBuilder().getVariables().get(SCRIPT_CLASS_NAME);
    try {
        getProxyBuilder().setVariable(SCRIPT_CLASS_NAME, script.getClass().getName());
        return script.run();
    } finally {
        if(oldScriptName != null) {
            getProxyBuilder().setVariable(SCRIPT_CLASS_NAME, oldScriptName);
        } else {
            getProxyBuilder().getVariables().remove(SCRIPT_CLASS_NAME);
        }
    }
}
 

import groovy.lang.MetaClass; //导入依赖的package包/类
public void setProperty(String property, Object newValue) {
    if ("metaClass".equals(property)) {
        setMetaClass((MetaClass) newValue);
    } else if ("scriptTarget".equals(property)) {
        setScriptTarget(newValue);
    } else {
        getDynamicTarget().setProperty(property, newValue);
    }
}
 

import groovy.lang.MetaClass; //导入依赖的package包/类
private MetaClass getMetaClass() {
    if (bean instanceof GroovyObject) {
        return ((GroovyObject) bean).getMetaClass();
    } else {
        return GroovySystem.getMetaClassRegistry().getMetaClass(bean.getClass());
    }
}
 

import groovy.lang.MetaClass; //导入依赖的package包/类
@Nullable
protected MetaProperty lookupProperty(MetaClass metaClass, String name) {
    if (metaClass instanceof MetaClassImpl) {
        // MetaClass.getMetaProperty(name) is very expensive when the property is not known. Instead, reach into the meta class to call a much more efficient lookup method
        try {
            return (MetaProperty) META_PROP_METHOD.invoke(metaClass, name, false);
        } catch (Throwable e) {
            throw UncheckedException.throwAsUncheckedException(e);
        }
    }

    // Some other meta-class implementation - fall back to the public API
    return metaClass.getMetaProperty(name);
}
 

import groovy.lang.MetaClass; //导入依赖的package包/类
@Nullable
@Override
protected MetaMethod lookupMethod(MetaClass metaClass, String name, Class[] arguments) {
    MetaMethod metaMethod = super.lookupMethod(metaClass, name, arguments);
    if (metaMethod != null) {
        return metaMethod;
    }
    metaMethod = classMetaData.getMetaMethod(name, arguments);
    if (metaMethod != null && Modifier.isStatic(metaMethod.getModifiers())) {
        return metaMethod;
    }
    return null;
}
 

import groovy.lang.MetaClass; //导入依赖的package包/类
public void updateConstantMetaClass(final MetaClassRegistryChangeEvent cmcu) {
	log.info("!! updateConstantMetaClass: {}", cmcu);
    if (!cleaning) {
        MetaClass oldMetaClass = cmcu.getOldMetaClass();
        Class classToUpdate = cmcu.getClassToUpdate();
        Object instanceToUpdate = cmcu.getInstance();
        if (instanceToUpdate == null && (cmcu.getNewMetaClass() instanceof ExpandoMetaClass)) {
            updateMetaClassOfClass(oldMetaClass, classToUpdate);
        } else if (instanceToUpdate != null) {
            updateMetaClassOfInstance(oldMetaClass, instanceToUpdate);
        }
    }
}
 

import groovy.lang.MetaClass; //导入依赖的package包/类
private void updateMetaClassOfInstance(MetaClass oldMetaClass, Object instanceToUpdate) {
    IdentityWeakReference key = new IdentityWeakReference(instanceToUpdate);
    if (oldMetaClass != null) {
        Object current = alteredInstances.get(key);
        if (current == null || current == NO_CUSTOM_METACLASS) {
            alteredInstances.put(key, oldMetaClass);
        }
    } else {
        alteredInstances.put(key, NO_CUSTOM_METACLASS);
    }
}
 

import groovy.lang.MetaClass; //导入依赖的package包/类
private void updateMetaClassOfClass(MetaClass oldMetaClass, Class classToUpdate) {
    if (oldMetaClass != null && !(oldMetaClass instanceof MockProxyMetaClass)) {
        Object current = alteredClasses.get(classToUpdate);
        if (current == null ) {
            alteredClasses.put(classToUpdate, oldMetaClass);
        }
    }
    else {
        alteredClasses.put(classToUpdate, NO_CUSTOM_METACLASS);
    }
}
 

import groovy.lang.MetaClass; //导入依赖的package包/类
private void cleanMetaClassOfInstance(MetaClassRegistryImpl registry) {
    List<IdentityWeakReference> keys = new ArrayList<IdentityWeakReference>(alteredInstances.keySet());
    for (IdentityWeakReference key : keys) {
        Object instance = key.get();
        if (instance != null) {
            Object alteredMetaClass = alteredInstances.get(key);
            if (alteredMetaClass == NO_CUSTOM_METACLASS) {
                alteredMetaClass = null;
            }
            registry.setMetaClass(instance, (MetaClass) alteredMetaClass);
        }
    }
    alteredInstances.clear();
}