正文

动态生成groovy脚本（groovy 脚本）

发布时间：2023-05-23 01:28:35 稿源：创意岭阅读： 102

大家好！今天让创意岭的小编来大家介绍下关于动态生成groovy脚本的问题，以下是小编对此问题的归纳整理，让我们一起来看看吧。

开始之前先推荐一个非常厉害的Ai人工智能工具，一键生成原创文章、方案、文案、工作计划、工作报告、论文、代码、作文、做题和对话答疑等等

只需要输入关键词，就能返回你想要的内容，有小程序、在线网页版、PC客户端和批量生成器

问友Ai官网：https://ai.de1919.com。

本文目录:

如何使用gradle构建工具打包groovy脚本成jar文件
在java中使用groovy怎么搞
在java中使用groovy怎么搞

动态生成groovy脚本（groovy 脚本）

如何使用gradle构建工具打包groovy脚本成jar文件

只需要编译打包groovy脚本所以只需要创建 src/main/groovy目录结构。
例子：
gradle_groovy_archive项目结构是：
gradle_groovy_archive
创建helloWorld.groovy脚本，代码如下：
package hello
println 'Gradle compile groovy'创建Gradle构建文件：
apply plugin: 'groovy'
apply plugin: 'maven'
group = 'com.hello'
archiveBaseName = 'hello'
version = '0.1-SNAPSHOT'
defaultTasks 'clean', 'jar'
configurations {
deployerJars
}
repositories {
mavenCentral()
}
dependencies {
//使用本地groovy环境
groovy localGroovy()
//groovy group: 'org.codehaus.groovy', name: 'groovy', version: '1.8.6'
compile fileTree( dir: 'lib', include: ['*.jar'])
deployerJars 'org.apache.maven.wagon:wagon-webdav-jackrabbit:1.0-beta-7'
}
sourceSets {
main {
groovy {
srcDir 'src/main/groovy'
}
}
}
uploadArchives {
repositories.mavenDeployer {
uniqueVersion = false
configuration = configurations.deployerJars
repository(id : repositoryId, url : repositoryUrl) {
authentication (userName : 'deployment', password : 'deployment')
proxy()
}
}
}创建构建文件属性文件：
//根据不同情况修改
repositoryId=ND
repositoryUrl=ND
systemProp.http.proxyHost=ND
systemProp.http.proxyPort=8080
systemProp.http.proxyUser=ND
systemProp.http.proxyPassword=ND在命令行中敲 gradle 运行，会自动运行 defaultTasks,clean 和 jar，会把所有groovy下的脚本打成jar包。

在java中使用groovy怎么搞

1、静态编译，在java工程中直接写groovy的文件，然后可以在groovy的文件中引用java工程的类，这种方式能够有效的利用groovy自身的语言特性，例如闭包；

2、通过groovyShell类直接执行脚本，例如：

package groovy_dsl.shell;
import groovy.lang.Binding;
import groovy.lang.GroovyShell;
public class GroovyShellEx {
        public static void main(String[] args) {
                Binding bind = new Binding();
                bind.setVariable("name", "iamzhongyong");
                bind.setVariable("age", "25");
                GroovyShell shell = new GroovyShell(bind);
                Object obj = shell.evaluate("str = name+age;return str");
                System.out.println(obj);
        }
}

3、通过groovyScriptEngine执行文件或者脚本，例如：

package groovy_dsl.script;
import groovy.util.GroovyScriptEngine;
public class ScriptEngine {
        public static void main(String[] args) throws Exception {
                GroovyScriptEngine engine = new GroovyScriptEngine("");
                Object obj = engine.run("src/main/java/groovy_dsl/script/script_test.groovy", "iamzhongyong");
                System.out.println(obj);
        }
}

4、通过GroovyClassLoader来执行，例如：

package groovy_dsl.classloader;
import groovy.lang.GroovyClassLoader;
import groovy.lang.GroovyObject;
import java.io.File;
import java.io.IOException;
public class GroovyClassLoaderEx {

        public static void main(String[] args) throws Exception, IOException {
                GroovyClassLoader loader = new GroovyClassLoader();

                for(int i=0;i<100;i++){
                        Class<?> clazz = loader.parseClass(new File("src/main/java/groovy_dsl/classloader/UserDO.groovy"));

                        GroovyObject clazzObj = (GroovyObject)clazz.newInstance();

                        clazzObj.invokeMethod("setName", "iamzhongyong");
                        clazzObj.invokeMethod("setSex", "Boy");
                        clazzObj.invokeMethod("setAge", "26");

                        System.out.println(clazzObj.invokeMethod("getAllInfo", null));
                }

        }
}

动态生成groovy脚本（groovy 脚本）

在java中使用groovy怎么搞

一种基于Java虚拟机的动态语言，可以和java无缝集成，正是这个特性，很多时候把二者同时使用，把groovy作为java的有效补充。对于Java程序员来说，学习成本几乎为零。同时支持DSL和其他简介的语法（例如闭包），使代码便于阅读。可以用groovy的动态特性来做规则引擎，在DB中维护脚本，业务变化的时候让应用系统动态加载。
如果引入groovy在java工程中？
这个很简单，不需要做别的事情，仅仅把groovy的二方包加入到pom文件中即可。例如：
<dependency>
<groupId>org.codehaus.groovy</groupId>
<artifactId>groovy-all</artifactId>
<version> 1.8 . 3 </version>
</dependency>
java和groovy混合使用的方法有几种？
1、静态编译，在java工程中直接写groovy的文件，然后可以在groovy的文件中引用java工程的类，这种方式能够有效的利用groovy自身的语言特性，例如闭包；
2、通过 groovyShell 类直接执行脚本，例如：
package groovy_dsl.shell;
import groovy.lang.Binding;
import groovy.lang.GroovyShell;
public class GroovyShellEx {
public static void main(String[] args) {
Binding bind = new Binding();
bind.setVariable( "name" , "iamzhongyong" );
bind.setVariable( "age" , "25" );
GroovyShell shell = new GroovyShell(bind);
Object obj = shell.evaluate( "str = name+age;return str" );
System.out.println(obj);
}
}
3、通过 groovyScriptEngine 执行文件或者脚本，例如：
package groovy_dsl.script;
import groovy.util.GroovyScriptEngine;
public class ScriptEngine {
public static void main(String[] args) throws Exception {
GroovyScriptEngine engine = new GroovyScriptEngine( "" );
Object obj = engine.run( "src/main/java/groovy_dsl/script/script_test.groovy" , "iamzhongyong" );
System.out.println(obj);
}
}
4、通过 GroovyClassLoader 来执行，例如：
package groovy_dsl.classloader;
import groovy.lang.GroovyClassLoader;
import groovy.lang.GroovyObject;
import java.io.File;
import java.io.IOException;
public class GroovyClassLoaderEx {
public static void main(String[] args) throws Exception, IOException {
GroovyClassLoader loader = new GroovyClassLoader();
for ( int i= 0 ;i< 100 ;i++){
Class<?> clazz = loader.parseClass( new File( "src/main/java/groovy_dsl/classloader/UserDO.groovy" ));
GroovyObject clazzObj = (GroovyObject)clazz.newInstance();
clazzObj.invokeMethod( "setName" , "iamzhongyong" );
clazzObj.invokeMethod( "setSex" , "Boy" );
clazzObj.invokeMethod( "setAge" , "26" );
System.out.println(clazzObj.invokeMethod( "getAllInfo" , null ));
}
}
}
使用groovy尤其需要主要的问题？
通过看groovy的创建类的地方，就能发现，每次执行的时候，都会新生成一个class文件，这样就会导致JVM的perm区持续增长，进而导致FullGCc问题，解决办法很简单，就是脚本文件变化了之后才去创建文件，之前从缓存中获取即可。
groovy中的源码如下：
return parseClass(text, "script" + System.currentTimeMillis() + Math.abs(text.hashCode()) + ".groovy" );
这个是增加缓存的代码：
GroovyClassLoader groovyClassLoader = new GroovyClassLoader(GroovyScriptExecute. class .getClassLoader());
Class<?> groovyClass = null ;
String classKey = String.valueOf(scriptClass.hashCode());
//先从缓存里面去Class文件
if (GroovyScriptClassCache.newInstance().containsKey(classKey)){
groovyClass = GroovyScriptClassCache.newInstance().getClassByKey(classKey);
} else {
groovyClass = groovyClassLoader.parseClass(scriptClass);
GroovyScriptClassCache.newInstance().putClass(classKey, groovyClass);
}
GroovyObject go = (GroovyObject)groovyClass.newInstance();
下面这个是缓存的单例类，贴一下：
public class GroovyScriptClassCache {
private static final Map<String /*class文件的描述*/ ,Class<?>> GROOVY_SCRIPT_CLASS_CACHE = new HashMap<String,Class<?>>();
private GroovyScriptClassCache(){}
private static GroovyScriptClassCache instance = new GroovyScriptClassCache();
public static GroovyScriptClassCache newInstance(){
return instance;
}
public Class<?> getClassByKey(String key){
return GROOVY_SCRIPT_CLASS_CACHE.get(key);
}
public void putClass(String key,Class<?> clazz){
GROOVY_SCRIPT_CLASS_CACHE.put(key, clazz);
}
public boolean containsKey(String key){
return GROOVY_SCRIPT_CLASS_CACHE.containsKey(key);
}
}
为啥要每次new一个GroovyClassLoader，而不是所有的脚本持有一个？
因为如果脚本重新加载了，这时候就会有新老两个class文件，如果通过一个classloader持有的话，这样在GC扫描的时候，会认为老的类还在存活，导致回收不掉，所以每次new一个就能解决这个问题了。
注意CodeCache的设置大小
对于大量使用Groovy的应用，尤其是Groovy脚本还会经常更新的应用，由于这些Groovy脚本在执行了很多次后都会被JVM编译为native进行优化，会占据一些CodeCache空间，而如果这样的脚本很多的话，可能会导致CodeCache被用满，而CodeCache一旦被用满，JVM的Compiler就会被禁用，那性能下降的就不是一点点了。
Code Cache用满一方面是因为空间可能不够用，另一方面是Code Cache是不会回收的，所以会累积的越来越多（其实在不采用groovy这种动态更新/装载class的情况下的话，是不会太多的），所以解法一可以是增大code cache的size，可通过在启动参数上增加-XX:ReservedCodeCacheSize=256m（Oracle JVM Team那边也是推荐把code cache调大的），二是启用code cache的回收机制（关于Code Cache flushing的具体策略请参见此文），可通过在启动参数上增加：-XX:+UseCodeCacheFlushing来启用。

以上就是关于动态生成groovy脚本相关问题的回答。希望能帮到你，如有更多相关问题，您也可以联系我们的客服进行咨询，客服也会为您讲解更多精彩的知识和内容。