Java GroovyObject.invokeMethod方法代码示例

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包/类
/**
 * 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包/类
/**
 * If something goes wrong here the returnBinding is unchanged, that is the
 * regular action commences.
 */
public static Map<String, Object> executeGroovyHandler(String handlerClass, Map<String, Object> inputBinding) {
	Map<String, Object> returnBinding = null;
	if (GroovyScriptLoader.getInstance().doesGroovyClassExist(handlerClass)) {
		try {
			// GroovyObject handler =
			// GroovyScriptLoader.getInstance().newInstance(handlerClass);
			GroovyObject handler = (GroovyObject) GroovyScriptLoader.getInstance().getGroovyClass(handlerClass).newInstance();
			returnBinding = (Map<String, Object>) handler.invokeMethod(HANDLE_METHOD_NAME, inputBinding);
		} catch (Exception e) {
			LOGGER.error("Problem calling Groovy EventHandler: " + e.getMessage());
			LOGGER.debug(ExceptionUtils.getStackTrace(e));
		}
	} else {
		LOGGER.debug("The Groovy class " + handlerClass + " was not found");
	}
	return returnBinding;
}
 

import groovy.lang.GroovyObject; //导入方法依赖的package包/类
private static Object logical(Object node, String op, final Action<Object> withNode) {
    GroovyObject groovyObject = (GroovyObject) node;
    groovyObject.invokeMethod(op, new Closure(null, null) {
        void doCall() {
            withNode.execute(getDelegate());
        }
    });
    return node;
}
 

import groovy.lang.GroovyObject; //导入方法依赖的package包/类
private static Object addFilenames(Object node, Iterable<String> filenames, boolean caseSensitive) {
    GroovyObject groovyObject = (GroovyObject) node;
    Map<String, Object> props = new HashMap<String, Object>(2);
    props.put("casesensitive", caseSensitive);
    for (String filename : filenames) {
        props.put("name", AntUtil.maskFilename(filename));
        groovyObject.invokeMethod("filename", props);
    }
    return node;
}
 

import groovy.lang.GroovyObject; //导入方法依赖的package包/类
/**
 * Execute groovy script t.
 *
 * @param <T>          the type parameter
 * @param groovyScript the groovy script
 * @param methodName   the method name
 * @param args         the args
 * @param clazz        the clazz
 * @return the t
 */
public static <T> T executeGroovyScript(final Resource groovyScript,
                                        final String methodName,
                                        final Object[] args,
                                        final Class<T> clazz) {

    if (groovyScript == null || StringUtils.isBlank(methodName)) {
        return null;
    }

    final ClassLoader parent = ScriptingUtils.class.getClassLoader();
    try (GroovyClassLoader loader = new GroovyClassLoader(parent)) {
        final File groovyFile = groovyScript.getFile();
        if (groovyFile.exists()) {                  
            final Class<?> groovyClass = loader.parseClass(groovyFile);
            LOGGER.trace("Creating groovy object instance from class [{}]", groovyFile.getCanonicalPath());

            final GroovyObject groovyObject = (GroovyObject) groovyClass.newInstance();

            LOGGER.trace("Executing groovy script's [{}] method, with parameters [{}]", methodName, args);
            final T result = (T) groovyObject.invokeMethod(methodName, args);
            LOGGER.trace("Results returned by the groovy script are [{}]", result);

            if (!clazz.isAssignableFrom(result.getClass())) {
                throw new ClassCastException("Result [" + result
                        + " is of type " + result.getClass()
                        + " when we were expecting " + clazz);
            }
            return result;
        } else {
            LOGGER.trace("Groovy script at [{}] does not exist", groovyScript);
        }
    } catch (final Exception e) {
        LOGGER.error(e.getMessage(), e);
    }
    return null;
}
 

import groovy.lang.GroovyObject; //导入方法依赖的package包/类
public static Closure<?> buildClosure(String... strings) throws IOException {

        Closure<?> closure = null;

        // Create a method returning a closure
        StringBuilder sb = new StringBuilder("def closure() { { script -> ");
        sb.append(StringUtils.join(strings, "\n"));
        sb.append(" } }");

        // Create an anonymous class for the method
        GroovyClassLoader loader = new GroovyClassLoader();
        Class<?> groovyClass = loader.parseClass(sb.toString());

        try {
            // Create an instance of the class
            GroovyObject groovyObject = (GroovyObject) groovyClass.newInstance();

            // Invoke the object's method and thus obtain the closure
            closure = (Closure<?>) groovyObject.invokeMethod("closure", null);
        } catch (Throwable e) {
            throw new RuntimeException(e);
        } finally {
            loader.close();
        }

        return closure;
    }
 

import groovy.lang.GroovyObject; //导入方法依赖的package包/类
public Object execNextHandler(GroovyObject groovyObject, String GroovyName, String methodName, Object... param){
	if(nextAop!=null){
		return nextAop.invokeMethod(groovyObject, GroovyName, methodName, param);
	}else{
		return groovyObject.invokeMethod(methodName, param);
	}
}
 

import groovy.lang.GroovyObject; //导入方法依赖的package包/类
protected static void executeMain()
{
	String scriptName = WRAPPER_MANAGER.getGroovyScript();
	if (scriptName == null)
	{
		System.out.println("script not found in configuration -> aborting");
		System.exit(999);
	}
	File scriptFile = new File(scriptName);
	if (!scriptFile.exists())
	{
		System.out.println("script not found -> aborting: "
				+ scriptFile.getAbsolutePath());
		System.exit(999);
	}
	Object[] mainMethodArgs = WRAPPER_MANAGER.getMainMethodArgs();
	try
	{
		ClassLoader parent = WrapperGroovyMain.class.getClassLoader();
		GroovyClassLoader loader = new GroovyClassLoader(parent);
		Class groovyClass = loader.parseClass(scriptFile);
		GroovyObject script = (GroovyObject) groovyClass.newInstance();
		script.invokeMethod("main", mainMethodArgs);
	}
	catch (Throwable e)
	{
		e.printStackTrace();
		exception = e;
	}
}
 

import groovy.lang.GroovyObject; //导入方法依赖的package包/类
private static Object addFilenames(Object node, Iterable<String> filenames, boolean caseSensitive) {
    GroovyObject groovyObject = (GroovyObject) node;
    Map<String, Object> props = new HashMap<String, Object>(2);
    props.put("casesensitive", caseSensitive);
    for (String filename : filenames) {
        props.put("name", filename);
        groovyObject.invokeMethod("filename", props);
    }
    return node;
}
 

import groovy.lang.GroovyObject; //导入方法依赖的package包/类
@Override
public Object invokeMethod(GroovyObject groovyObject, String groovyName, String methodName,Object... param) {
	Object retObj=groovyObject.invokeMethod(methodName, param);
	return retObj;
}
 

import groovy.lang.GroovyObject; //导入方法依赖的package包/类
public void build(final GroovyObject builder) {
    builder.getProperty("mkp");
    builder.invokeMethod("yield", new Object[]{text()});
}
 

import groovy.lang.GroovyObject; //导入方法依赖的package包/类
public void testClosureInClosureTest() throws Exception {
    GroovyObject object = compile("src/test/groovy/ClosureInClosureTest.groovy");
    object.invokeMethod("testInvisibleVariable", null);
}
 

import groovy.lang.GroovyObject; //导入方法依赖的package包/类
public void testTryCatchBug() throws Exception {
    GroovyObject object = compile("src/test/groovy/bugs/TryCatchBug.groovy");
    object.invokeMethod("testBug", null);
}