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來啟用。
㈡ intellij IDEA為什麼運行時不編譯grails或groovy了。
樓主問題解決了嘛，我也遇到這情況，怎麼解決的，跪求
㈢ groovy語言主要是用來干什麼，和JAVA的區別是什麼
先說區別吧：java是編譯性語言，就是得編譯後才能運行。groovy語言是動態語言。
Groovy 是 JVM 的一個替代語言 — 替代 是指可以用 Groovy 在 Java 平台上進行 Java 編程，使用方式基本與使用 Java 代碼的方式相同。
Groovy 的一個好處是，它的語法與 Java 語言的語法很相似。雖然 Groovy 的語法源於 Smalltalk 和 Ruby 這類語言的理念，但是可以將它想像成 Java 語言的一種更加簡單、表達能力更強的變體。（在這點上，Ruby 與 Groovy 不同，因為它的語法與 Java 語法差異很大。）
㈣ Jaspersoft iReport 編譯過程報錯：Too many groovy classes were generated。
表達式寫錯 如把$P{變數名} 錯寫成 ${P變數}
㈤ 如何使用groovy console
1、靜態編譯，在java工程中直接寫groovy的文件，然後可以在groovy的文件中引用java工程的類，這種方式能夠有效的利用groovy自身的語言特性，例如閉包； 2、通過groovyShell類直接執行腳本，例如： package groovy_dsl.shell;import groovy.lang....
㈥ 如何使用gradle構建工具打包groovy腳本成jar文件
准備工作安裝 gradle， groovy。
要使用gradle的groovy plugin 來打包groovy 腳本，項目結構。
目錄 含義
src/main/java Java 代碼
src/main/resources Java需要的資源文件
src/main/groovy Groovy代碼，也可以包含Java代碼
src/test/java Java 測試代碼
src/test/resources 測試需要的資源文件
src/test/groovy Groovy測試需要的資源文件
src/sourceSet/java Java代碼源
src/sourceSet/resources 資源文件源
src/sourceSet/groovy Groovy代碼源
我們只需要編譯打包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包。
㈦ 關於groovy和java混合編譯，大家有沒有更好
其實groovy需要挺好用，還有就是 kotlin
㈧ groovy classloader 和java一樣嗎
不一樣，groovy相當於java的擴展，但有些指令作了改變，在groovy中的寫法與java中的寫法不一致，這樣的代碼要改寫。
所以說，groovy不能百分百load java編譯的class。java肯定不能load groovy編譯的class.
㈨ 怎麼用ant來編譯groovy
用生成器進行構建
使 Groovy 中的 Ant 更迷人的核心之處是 生成器。實際上，生成器允許您很方便地在 Groovy 中表示樹形數據結構，例如 XML 文檔。而且，女士們先生們請看，秘密在這：使用生成器，特別是 AntBuilder，您可以毫不費力地構造 Ant 的 XML 構建文件，不必處理 XML 就可以 執行生成的行為。而這並不是在 Groovy 中使用 Ant 的惟一優點。與 XML 不同，Groovy 是非常有表現力的開發環境，在這個環境中，您可以容易地編寫循環結構、條件選擇代碼，甚至可以利用「重用」的威力，而不必像以前那樣，費力地用剪切-粘貼操作來創建新 build.xml 文件。而且您做這些工作時，完全是在 Java 平台中！
生成器的優點，尤其是 Groovy 的 AntBuilder，在於它們的語法表示完全體現了它們所代表的 XML 文件的邏輯進程。被附加在 AntBuilder實例上的方法與對應的 Ant 任務匹配；同樣的，這些方法可以接收參數（以 map 的形式），參數對應著任務的屬性。而且，嵌套標簽（例如include 和 fileset）也定義成閉包。
構建塊：示例 1
我要用一個超級簡單的示例向您介紹生成器：一個叫做 echo 的 Ant 任務。在清單 4 中，我創建了一個普通的、每天都會用到的 Ant 的 echo 標記的 XML 版本（用在這不要奇怪）：
清單 4. Ant 的 Echo 任務
<echo message="This was set via the message attribute"/>
<echo>Hello World!</echo>
事情在清單 5 中變得更有意思了：我用相同的 Ant 標簽，並在 Groovy 中用 AntBuilder 類型重新定義了它。注意，我可以使用 echo 的屬性message，也可以只傳遞一個期望的 String。
㈩ 什麼是 Groovy
● 是一個基於 Java虛擬機的敏捷 動態語言。 ● 構建在強大的Java語言之上 並 添加了從Python，Ruby和Smalltalk等語言中學到的 諸多特徵。 ●為Java開發者提供了 現代最流行的編程語言特性，而且學習成本很低（幾乎為零）。 ● 支持DSL（Domain Specific Languages領域定義語言）和其它簡潔的語法，讓你的代碼變得易於閱讀和維護。 ● Groovy擁有處理原生類型，面向對象以及一個Ant DSL，使得創建Shell Scripts變的非常簡單。 ● 在開發Web，GUI，資料庫或控制台程序時 通過 減少框架性代碼 大大提高了開發者的效率。 ● 支持單元測試和模擬（對象），可以 簡化測試。 ● 無縫集成 所有已經存在的 Java對象和類庫。 ● 直接編譯成Java位元組碼，這樣可以在任何使用Java的地方 使用Groovy。 Groovy 的一個好處是，它的語法與 Java 語言的語法很相似。雖然 Groovy 的語法源於 Smalltalk 和 Ruby 這類語言的理念，但是可以將它想像成 Java 語言的一種更加簡單、表達能力更強的變體。（在這點上，Ruby 與 Groovy 不同，因為它的語法與 Java 語法差異很大。） Groovy 快捷方式 開始使用 Groovy 時，您會發現它使日常的編程活動變得快了許多。完成本教程之後，您會了解更多的 Groovy 語法快捷方式。不過現在只需知道以下這些要點： Groovy 的鬆散的 Java 語法允許省略分號和修改符。 除非另行指定，Groovy 的所有內容都為 public。 Groovy 允許定義簡單腳本，同時無需定義正規的class 對象。 Groovy 在普通的常用 Java 對象上增加了一些獨特的方法和快捷方式，使得它們更容易使用。 Groovy 語法還允許省略變數類型。 Groovy 的新增特性 雖然Groovy 允許省略 Java 語法中的一些元素，但也增加了一些新特性，例如本地集合、內置的正則表達式和閉包。在標準的 Java 代碼中，如果想要創建一個項列表，首先要導入<code>java.util.ArrayList</code>，然後程序化地初始化 <code>ArrayList</code> 實例，然後 再向實例中添加項。在 Groovy 中，列表和映射都內置在語法中 — 無需導入任何內容。正則表達式也不需要額外的導入或對象；它們可以通過特殊的 Groovy 語法來創建。 關於閉包 對於任何 Java 開發人員來說，閉包都是一個令人興奮的新技巧。這些神奇的構造將會包含在未來的 Java 發行版（很可能是 Java 7）中，成為正式的 Java 語法，但現在已經可以在 Groovy 中使用了。可以將閉包 想像為一個代碼塊，可以現在定義，以後再執行。可以使用這些強大的構造做許多漂亮的事，不過最著名的是簡化迭代。使用 Groovy 之後，就有可能再也不需要編寫Iterator 實例了。 動態的 Groovy 從技術上講，Groovy 可能是您最近聽說過的類型最鬆散的動態語言之一。從這個角度講，Groovy 與 Java 語言的區別很大，Java 語言是一種固定類型語言。在 Groovy 中，類型是可選的，所以您不必輸入String myStr = "Hello"; 來聲明 String 變數,可以使用def myStr = "Hello";(分號可有可無)。 除此之外,Groovy 代碼還能在運行時輕松地改變自己。這實際上意味著，能夠在運行時輕松地為對象指定新方法和屬性。這一編程領域稱為元編程，Groovy 能夠很好地支持這種編程方式。在學習本教程的過程中，您將了解到關於 Groovy 的動態性質的更多內容。現在惟一要補充的是，您會驚訝地發現，在 Groovy 會使操作 XML 或普通的 java.io.File 實例變得非常輕松。 一體兩面 用Groovy 編寫的任何內容都可以編譯成標準的 Java 類文件並在 Java 代碼中重用。類似地，用標准 Java 代碼編寫的內容也可以在 Groovy 中重用。所以，可以輕易地使用 Groovy 為 Java 代碼編寫單元測試。而且，如果用 Groovy 編寫一個方便的小工具，那麼也可以在 Java 程序中使用這個小工具。 Groovy是用Java實現的開源腳本語言並且和它聯系緊密.它需要JDK 1.4. Groovy向Java添加了許多Ruby和Python腳本語言的特性. Groovy的特性包括動態類型（dynamic typing）, 閉包（closures）,簡單對象導航（ easy object navigation）和更加簡潔的Lists和Maps語法. Groovy是由James Strachan和Bob McWhirter創造的. James還參與了許多其他開源項目的開發，其中包括Jelly, dom4j, Jaxen, Betwixt和Maven. Bob是Jaxen和Drools (一個開源的面向對象的JAVA規則引擎) 的創始人. 目前最新穩定版為Groovy1.8。