简介

Groovy 是一种基于 JVM 的敏捷开发语言，它结合了 Python、Ruby 和 Smalltalk 的许多强大的特性。

特点

• 是一个基于 Java 虚拟机的敏捷动态语言。
• 构建在强大的 Java 语言之上 并添加了从 Python、Ruby 和 Smalltalk 等语言中学到的诸多特征。
• 为 Java 开发者提供了现代最流行的编程语言特性，而且学习成本很低（几乎为零）。
• 支持 DSL（Domain Specific Languages 领域定义语言）和其它简洁的语法，让你的代码变得易于阅读和维护。
• Groovy 拥有处理原生类型，面向对象以及一个 Ant DSL ，使得创建 Shell Scripts 变的非常简单。
• 在开发 Web，GUI，数据库或控制台程序时 通过减少框架性代码 大大提高了开发者的效率。
• 支持单元测试和模拟（对象），可以简化测试。
• 无缝集成 所有已经存在的 Java 对象和类库。
• 直接编译成 Java 字节码，这样可以在任何使用 Java 的地方使用 Groovy 。

引入

<!-- groovy -->
<dependency>
    <groupId>org.codehaus.groovy</groupId>
    <artifactId>groovy-all</artifactId>
    <version>3.0.10</version>
    <type>pom</type>
</dependency>

package com.seagull.oa.groovy;

import groovy.lang.GroovyClassLoader;

import java.lang.reflect.Method;
import java.util.List;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.quartz.Job;

import com.alibaba.fastjson.JSONObject;
import com.seagull.oa.common.ResultData;
import com.seagull.oa.util.SpringContextUtils;
import com.seagull.oa.util.VerifyHandlerResult;

public class GroovyFactory {

    private static GroovyFactory groovyFactory = new GroovyFactory();

    private GroovyClassLoader groovyClassLoader = new GroovyClassLoader();

    public static GroovyFactory getInstance() {
        return groovyFactory;
    }


    /**
     * 根据脚本内容生成ICloud的实现
     *
     * @param script
     * @param method
     * @return
     * @throws Exception
     */
    public ResultData getICloudFromCode(String script, String method, Map<String, Object> params) throws Exception {
        Class<?> clazz = groovyClassLoader.parseClass(script);
    	Method execute = clazz.getMethod(method, Map.class);
        Object instance = clazz.newInstance();
    	SpringContextUtils.autowireBean(instance);
    	Object ret = execute.invoke(instance, params);
        groovyClassLoader.clearCache();
        return (ResultData) ret;
    }
}


@Transactional
    @RequestMapping("/{path}/{method}")
    public ResultData authority(@PathVariable String path, @PathVariable String method, @RequestParam Map<String, Object> params) {
    	Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint();
    	try {
        	 // 从数据库或者缓存获取代码
            String script = metaFunctionService.queryByPath(path);
            if (!StringUtils.isEmpty(script)) {
            	return GroovyFactory.getInstance().getICloudFromCode(script, method, params);
            } else {
                return ResultData.warn(ResultCode.OTHER_ERROR, "路径错误");
            }
        } catch (InvocationTargetException e) {
        	TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
			e.getTargetException().printStackTrace();
			return ResultData.warn(ResultCode.INTERNAL_SERVER_ERROR, e.getTargetException().getMessage());
		} catch (Exception e) {
			TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
			e.printStackTrace();
			return ResultData.warn(ResultCode.INTERNAL_SERVER_ERROR, e.getMessage());
		}
    }

@Component
public class SpringContextUtils implements ApplicationContextAware {

	static ApplicationContext context;

	@Override
	public void setApplicationContext(ApplicationContext context) throws BeansException {
		SpringContextUtils.context = context;
	}

	public static ApplicationContext getContext() {
		return context;
	}

	public static void autowireBean(Object bean) {
		context.getAutowireCapableBeanFactory().autowireBean(bean);
	}

	public static <T> T getBean(Class<T> clazz) {
		return context.getBean(clazz);
	}

}