正文

動態(tài)生成groovy腳本（groovy 腳本）

發(fā)布時間：2023-05-23 01:28:35 稿源：創(chuàng)意嶺閱讀： 102

大家好！今天讓創(chuàng)意嶺的小編來大家介紹下關于動態(tài)生成groovy腳本的問題，以下是小編對此問題的歸納整理，讓我們一起來看看吧。

開始之前先推薦一個非常厲害的Ai人工智能工具，一鍵生成原創(chuàng)文章、方案、文案、工作計劃、工作報告、論文、代碼、作文、做題和對話答疑等等

只需要輸入關鍵詞，就能返回你想要的內(nèi)容，有小程序、在線網(wǎng)頁版、PC客戶端和批量生成器

問友Ai官網(wǎng)：https://ai.de1919.com。

本文目錄:

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

動態(tài)生成groovy腳本（groovy 腳本）

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

只需要編譯打包groovy腳本所以只需要創(chuàng)建 src/main/groovy目錄結構。
例子：
gradle_groovy_archive項目結構是：
gradle_groovy_archive
創(chuàng)建helloWorld.groovy腳本，代碼如下：
package hello
println 'Gradle compile groovy'創(chuàng)建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環(huán)境
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()
}
}
}創(chuàng)建構建文件屬性文件：
//根據(jù)不同情況修改
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、靜態(tài)編譯，在java工程中直接寫groovy的文件，然后可以在groovy的文件中引用java工程的類，這種方式能夠有效的利用groovy自身的語言特性，例如閉包；

2、通過groovyShell類直接執(zhí)行腳本，例如：

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執(zhí)行文件或者腳本，例如：

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來執(zhí)行，例如：

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));
                }

        }
}

動態(tài)生成groovy腳本（groovy 腳本）

在java中使用groovy怎么搞

一種基于Java虛擬機的動態(tài)語言，可以和java無縫集成，正是這個特性，很多時候把二者同時使用，把groovy作為java的有效補充。對于Java程序員來說，學習成本幾乎為零。同時支持DSL和其他簡介的語法（例如閉包），使代碼便于閱讀?？梢杂胓roovy的動態(tài)特性來做規(guī)則引擎，在DB中維護腳本，業(yè)務變化的時候讓應用系統(tǒng)動態(tài)加載。
如果引入groovy在java工程中？
這個很簡單，不需要做別的事情，僅僅把groovy的二方包加入到pom文件中即可。例如：
<dependency>
<groupId>org.codehaus.groovy</groupId>
<artifactId>groovy-all</artifactId>
<version> 1.8 . 3 </version>
</dependency>
java和groovy混合使用的方法有幾種？
1、靜態(tài)編譯，在java工程中直接寫groovy的文件，然后可以在groovy的文件中引用java工程的類，這種方式能夠有效的利用groovy自身的語言特性，例如閉包；
2、通過 groovyShell 類直接執(zhí)行腳本，例如：
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 執(zhí)行文件或者腳本，例如：
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 來執(zhí)行，例如：
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的創(chuàng)建類的地方，就能發(fā)現(xiàn)，每次執(zhí)行的時候，都會新生成一個class文件，這樣就會導致JVM的perm區(qū)持續(xù)增長，進而導致FullGCc問題，解決辦法很簡單，就是腳本文件變化了之后才去創(chuàng)建文件，之前從緩存中獲取即可。
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腳本還會經(jīng)常更新的應用，由于這些Groovy腳本在執(zhí)行了很多次后都會被JVM編譯為native進行優(yōu)化，會占據(jù)一些CodeCache空間，而如果這樣的腳本很多的話，可能會導致CodeCache被用滿，而CodeCache一旦被用滿，JVM的Compiler就會被禁用，那性能下降的就不是一點點了。
Code Cache用滿一方面是因為空間可能不夠用，另一方面是Code Cache是不會回收的，所以會累積的越來越多（其實在不采用groovy這種動態(tài)更新/裝載class的情況下的話，是不會太多的），所以解法一可以是增大code cache的size，可通過在啟動參數(shù)上增加-XX:ReservedCodeCacheSize=256m（Oracle JVM Team那邊也是推薦把code cache調大的），二是啟用code cache的回收機制（關于Code Cache flushing的具體策略請參見此文），可通過在啟動參數(shù)上增加：-XX:+UseCodeCacheFlushing來啟用。

以上就是關于動態(tài)生成groovy腳本相關問題的回答。希望能幫到你，如有更多相關問題，您也可以聯(lián)系我們的客服進行咨詢，客服也會為您講解更多精彩的知識和內(nèi)容。