Java GroovyObject类代码示例

import groovy.lang.GroovyObject; //导入依赖的package包/类
public String determineName(Object thing) {
    Object name;
    try {
        if (thing instanceof Named) {
            name = ((Named) thing).getName();
        } else if (thing instanceof Map) {
            name = ((Map) thing).get("name");
        } else if (thing instanceof GroovyObject) {
            name = ((GroovyObject) thing).getProperty("name");
        } else {
            name = DynamicObjectUtil.asDynamicObject(thing).getProperty("name");
        }
    } catch (MissingPropertyException e) {
        throw new NoNamingPropertyException(thing);
    }

    if (name == null) {
        throw new NullNamingPropertyException(thing);
    }

    return name.toString();
}
 

import groovy.lang.GroovyObject; //导入依赖的package包/类
public GroovyObject execPlugIn(String name, GroovyObject groovyObject,
		GroovyObject proxyObject) throws Exception {
	Field[] fields=groovyObject.getClass().getDeclaredFields();
	int size=fields.length;
	for(int i=0;i<size;i++){
		Field field=fields[i];
		Resource anno=field.getAnnotation(Resource.class);
		if(anno!=null){
			String beanId=anno.name();
			if(beanId==null || "".equals(beanId)){
				beanId=field.getName();
			}
			Object beanObj=MicroContextHolder.getContext().getBean(beanId);
			field.set(groovyObject, beanObj);
		}
	}
	return proxyObject;
}
 

import groovy.lang.GroovyObject; //导入依赖的package包/类
public static boolean execGroovy(String groovyName, String methodName,
		Object... paramArray) {
	try {
		GroovyObject groovyObject = (GroovyObject) getGroovyObj(groovyName);
		//groovyObject.invokeMethod(methodName, paramArray);
		//GroovyAopInter groovyAop=(GroovyAopInter) MicroContextHolder.getContextMap().get("groovyAop");
		GroovyAopInter firstAop=GroovyAopChain.getFirstAop();
		Object retObj=null;
		if(firstAop==null){
			retObj=groovyObject.invokeMethod(methodName, paramArray);
		}else{
			retObj=firstAop.invokeMethod(groovyObject,groovyName, methodName, paramArray);
		}			
		return true;
	} catch (Throwable t) {
		logger.error(t.toString(), t);
		if(throwFlag){
			throw new RuntimeException(t);
		}
		return false;
	}
}
 

import groovy.lang.GroovyObject; //导入依赖的package包/类
public static Object execGroovyRetObj(String groovyName, String methodName,
		Object... paramArray) {
	try {
		GroovyObject groovyObject = (GroovyObject) getGroovyObj(groovyName);
		//GroovyAopInter groovyAop=(GroovyAopInter) MicroContextHolder.getContextMap().get("groovyAop");
		GroovyAopInter firstAop=GroovyAopChain.getFirstAop();
		Object retObj=null;
		if(firstAop==null){
			retObj=groovyObject.invokeMethod(methodName, paramArray);
		}else{
			retObj=firstAop.invokeMethod(groovyObject,groovyName, methodName, paramArray);
		}
		return retObj;
	} catch (Throwable t) {
		logger.error(t.toString(), t);
		if(throwFlag){
			throw new RuntimeException(t);
		}
		return null;
	}
}
 

import groovy.lang.GroovyObject; //导入依赖的package包/类
public static void loadGroovy(String name, String content) throws Exception {
	logger.info("begin load groovy name=" + name);
	logger.debug("groovy content=" + content);
	if(name.toLowerCase().contains("abstract")){
		logger.info("skip load groovy name=" + name);
		return;
	}
	ClassLoader parent = GroovyLoadUtil.class.getClassLoader();
	GroovyClassLoader loader = new GroovyClassLoader(parent);
	Class<?> groovyClass = loader.parseClass(content,name+".groovy");
	GroovyObject groovyObject = (GroovyObject) groovyClass.newInstance();
	
	GroovyObject proxyObject=groovyObject;		
	if(pluginList!=null){
		
		int size=pluginList.size();
		for(int i=0;i<size;i++){
			IGroovyLoadPlugin plugin=(IGroovyLoadPlugin) pluginList.get(i);
			proxyObject=plugin.execPlugIn(name, groovyObject, proxyObject);
		}
	}		
	GroovyExecUtil.getGroovyMap().put(name, proxyObject);		
	//GroovyExecUtil.getGroovyMap().put(name, groovyObject);
	logger.info("finish load groovy name=" + name);
}
 

import groovy.lang.GroovyObject; //导入依赖的package包/类
@Test(groups = {"groovy"})
public void testScript() throws Exception {
    String f1 = new File("./src/test/resources/StoreProc.groovy").getCanonicalPath();
    URL url = new URL("file://"+f1);
    ExtendedGroovyLoader classLoader = new ExtendedGroovyLoader();
    Class cls = classLoader.parseClass(new File(f1));
    GroovyObject groovyObj = (GroovyObject) cls.newInstance();
    System.out.println((String) groovyObj.invokeMethod("sayHello", new Object[] { "test" }) );
    groovyObj.getMetaClass().setProperty(groovyObj, "city", "cypress");
    System.out.println( groovyObj.getMetaClass().getProperty(groovyObj,"city"));
    Method[] methods = cls.getDeclaredMethods();
    System.out.println("methods "+ methods.length);
    dumpMethod( methods);
    if ( classLoader.isSourceChange(url, cls)) {
        System.out.println("source change for f1 "+f1);
        Class cls1 = classLoader.recompile(url, groovyObj.getClass().getName(), cls);
        GroovyObject groovyObj1 = (GroovyObject) cls1.newInstance();
        System.out.println( groovyObj1.invokeMethod("sayHello", new Object[]{"test"}) );
        //assert "hello test".equals( output);

    }

}
 

import groovy.lang.GroovyObject; //导入依赖的package包/类
@Override
public void customize(GroovyObject goo) {
	DelegatingMetaClass dmc = new DelegatingMetaClass(goo.getMetaClass()) {
		@Override
		public Object invokeMethod(Object arg0, String mName, Object[] arg2) {
			if (mName.contains("Missing")) {
				throw new IllegalStateException("Gotcha");
			}
			else {
				return super.invokeMethod(arg0, mName, arg2);
			}
		}
	};
	dmc.initialize();
	goo.setMetaClass(dmc);
}
 

import groovy.lang.GroovyObject; //导入依赖的package包/类
@SuppressWarnings("resource")
private static final GroovyObject getGroovyObject(String rule)
		throws IllegalAccessException, InstantiationException {
	if (!RULE_CLASS_CACHE.containsKey(rule)) {
		synchronized (GroovyRuleEngine.class) {
			if (!RULE_CLASS_CACHE.containsKey(rule)) {
				Matcher matcher = DimensionRule.RULE_COLUMN_PATTERN.matcher(rule);
				StringBuilder engineClazzImpl = new StringBuilder(200)
						.append("class RuleEngineBaseImpl extends " + RuleEngineBase.class.getName() + "{")
						.append("Object execute(Map context) {").append(matcher.replaceAll("context.get(\"$1\")"))
						.append("}").append("}");
				GroovyClassLoader loader = new GroovyClassLoader(AbstractDimensionRule.class.getClassLoader());
				Class<?> engineClazz = loader.parseClass(engineClazzImpl.toString());
				RULE_CLASS_CACHE.put(rule, engineClazz);
			}
		}
	}
	return (GroovyObject) RULE_CLASS_CACHE.get(rule).newInstance();
}
 

import groovy.lang.GroovyObject; //导入依赖的package包/类
static Class<?> createProxyClass(Class<?> persistentClass, Class<?>[] interfaces) throws HibernateException {
    // note: interfaces is assumed to already contain HibernateProxy.class

    try {
        Set<Class<?>> allInterfaces = new HashSet<>();
        if(interfaces != null) {
            allInterfaces.addAll(Arrays.asList(interfaces));
        }
        allInterfaces.add(GroovyObject.class);
        allInterfaces.add(EntityProxy.class);
        ProxyFactory factory = createJavassistProxyFactory(persistentClass, allInterfaces.toArray(new Class<?>[allInterfaces.size()]));
        Class<?> proxyClass = factory.createClass();
        HibernateUtils.enhanceProxyClass(proxyClass);
        return proxyClass;
    }
    catch (Throwable t) {
        LogFactory.getLog(BasicLazyInitializer.class).error(
                "Javassist Enhancement failed: " + persistentClass.getName(), t);
        throw new HibernateException("Javassist Enhancement failed: " + persistentClass.getName(), t);
    }
}
 

import groovy.lang.GroovyObject; //导入依赖的package包/类
private static Class<?> getProxyFactory(Class<?> persistentClass, Class<?>[] interfaces) throws HibernateException {
    // note: interfaces is assumed to already contain HibernateProxy.class

    try {
        Set<Class<?>> allInterfaces = new HashSet<Class<?>>();
        if(interfaces != null) {
            allInterfaces.addAll(Arrays.asList(interfaces));
        }
        allInterfaces.add(GroovyObject.class);
        allInterfaces.add(EntityProxy.class);
        ProxyFactory factory = createProxyFactory(persistentClass, allInterfaces.toArray(new Class<?>[allInterfaces.size()]));
        Class<?> proxyClass = factory.createClass();
        HibernateUtils.enhanceProxyClass(proxyClass);
        return proxyClass;
    }
    catch (Throwable t) {
        LogFactory.getLog(BasicLazyInitializer.class).error(
                "Javassist Enhancement failed: " + persistentClass.getName(), t);
        throw new HibernateException("Javassist Enhancement failed: " + persistentClass.getName(), t);
    }
}
 

import groovy.lang.GroovyObject; //导入依赖的package包/类
@Override
public Class<? extends ActionBean> getActionBeanType(String path) {
    if(path.startsWith(APIRoot.PATH_PREFIX)) {
        return null; //Not an ActionBean (as far as Stripes is concerned)
    }
    Dispatch dispatch = getDispatch(path);
    if(dispatch != null) {
        Class<? extends ActionBean> actionBeanClass = dispatch.getActionBeanClass();
        if(GroovyObject.class.isAssignableFrom(actionBeanClass) &&
           !eventMappings.containsKey(actionBeanClass)) {
            synchronized (this) {
                addActionBean(actionBeanClass);
            }
        }
        return actionBeanClass;
    } else {
        return super.getActionBeanType(path);
    }
}
 

import groovy.lang.GroovyObject; //导入依赖的package包/类
/**
 * Creates a Closure representing the body of this GPathResult.
 *
 * @return the body of this GPathResult, converted to a <code>Closure</code>
 */
public Closure getBody() {
    return new Closure(this.parent,this) {
        public void doCall(Object[] args) {
            final GroovyObject delegate = (GroovyObject)getDelegate();
            final GPathResult thisObject = (GPathResult)getThisObject();

            Node node = (Node)thisObject.getAt(0);
            List children = node.children();

            for (Object child : children) {
                delegate.getProperty("mkp");
                if (child instanceof Node) {
                    delegate.invokeMethod("yield", new Object[]{new NodeChild((Node) child, thisObject, "*", null)});
                } else {
                    delegate.invokeMethod("yield", new Object[]{child});
                }
            }                
        }
    };
}
 

import groovy.lang.GroovyObject; //导入依赖的package包/类
/**
 * Invokes the given method on the object.
 */
public static Object invokeMethod(Object object, String methodName, Object arguments) {
    if (object == null) {
        object = NullObject.getNullObject();
        //throw new NullPointerException("Cannot invoke method " + methodName + "() on null object");
    }

    // if the object is a Class, call a static method from that class
    if (object instanceof Class) {
        Class theClass = (Class) object;
        MetaClass metaClass = metaRegistry.getMetaClass(theClass);
        return metaClass.invokeStaticMethod(object, methodName, asArray(arguments));
    }

    // it's an instance; check if it's a Java one
    if (!(object instanceof GroovyObject)) {
        return invokePojoMethod(object, methodName, arguments);
    }

    // a groovy instance (including builder, closure, ...)
    return invokePogoMethod(object, methodName, arguments);
}
 

import groovy.lang.GroovyObject; //导入依赖的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.GroovyObject; //导入依赖的package包/类
public final Object callCurrent(GroovyObject receiver, Object[] args) throws Throwable {
    if (checkCall(receiver)) {
        try {
            try {
                return metaClass.invokeMethod(array.owner, receiver, name, args, false, true);
            } catch (MissingMethodException e) {
                if (e instanceof MissingMethodExecutionFailed) {
                    throw (MissingMethodException)e.getCause();
                } else if (receiver.getClass() == e.getType() && e.getMethod().equals(name)) {
                    // in case there's nothing else, invoke the object's own invokeMethod()
                    return ((GroovyObject)receiver).invokeMethod(name, args);
                } else {
                    throw e;
                }
            }
        } catch (GroovyRuntimeException gre) {
            throw ScriptBytecodeAdapter.unwrap(gre);
        }
    } else {
      return CallSiteArray.defaultCallCurrent(this, receiver, args);
    }
}