groovyjava調用

❶ java如何調用 groovy

groovy代碼

[java] view plain
package com.ingping.core

import org.codehaus.groovy.grails.commons.ConfigurationHolder

/**
* Created by IntelliJ IDEA.
* User: Web-03
* Date: 11-4-21
* Time: 下午3:43
* To change this template use File | Settings | File Templates.
*/
class SystemConfigRead {

/*
* 讀取郵件驗證訪問路徑
*/
static String readEmailCodeUrl(){
ConfigurationHolder.config.site.emailCodeUrl
}
}

-------------------------------------------------------------------------------------
第一種，網上大部分都是這種
[java] view plain
/**
* JAVA調用GROOVY
* @throws IOException
* @throws IllegalAccessException
* @throws InstantiationException
* 添加人：**
* 添加時間：211-08-30 14:27
*/
public void groovyToJava() throws IOException, IllegalAccessException, InstantiationException {
ClassLoader parent = getClass().getClassLoader();
GroovyClassLoader loader = new GroovyClassLoader(parent);
//找到指定的groovy類
Class groovyClass = loader.parseClass(new File("site/grails-app/utils/com/ingping/core/SystemConfigRead.groovy"));
//將對象實例化並且強制轉換為GroovyObject對象
GroovyObject groovyObject = (GroovyObject) groovyClass.newInstance();
//readEmailCodeUrl方法名，null 參數值，沒有為null
System.out.println("" + groovyObject.invokeMethod("readEmailCodeUrl", null));
}

第二種，真正常用，有用的是這樣的，不要被蒙蔽了，JAVA類是可以直接調用GROOVY類的。

[java] view plain
SystemConfigRead.readEmailCodeUrl();

❷ java調用groovy執行.java文件問題

用JDK自帶的javax.tools.JavaCompiler

❸ java程序員為什麼使用Groovy

正如Groovy對Java很多特性進行的包裝優化一樣，基於Groovy的HttpBuilder也包裹了HttpClient，使網路編程變得更加的方便易用，下面稍微來用一個例子看一下。
尋找各種依賴的jar包有時候會讓我們失去耐心，不過值得慶幸的是我們有Maven和Gradle這樣的工具，可以根據配置輕松的幫我們配置好我們需要的數據。下面我們來敘述一下整個過程。
1. 創建文件夾httpbuildertest
2. 創建gradle配置文件，build.gradle，內容如下：
apply plugin: "groovy"
apply plugin: "eclipse"

repositories {
mavenCentral()
}

dependencies {
compile "org.codehaus.groovy:http-builder:0.4.0"
compile "org.codehaus.groovy:groovy-all:2.3.3"
testCompile "org.spockframework:spock-core:0.7-groovy-2.0"
}

gradle我們將做另文介紹
3. 執行gralde eclipse（當然必須先安裝gradle），就可以生成eclipse所需要的.classpath和.project文件，這時候就可以使用eclipse導入功能來import->Existing Projects Into WorkSpace。
4. 創建我們的一個測試，試試看是不是可以使用httpbuilder了
import groovyx.net.http.HTTPBuilder
import spock.lang.Specification;
import static groovyx.net.http.Method.*
import static groovyx.net.http.ContentType.*

class HttpbuildLabSpec extends Specification{
HTTPBuilder http = new HTTPBuilder( 'http://m.weather.com.cn' )
public void testRequestWeather(){
when:
def info =""
http.request( GET, JSON ) {
url.path = '/data/101290401.html'
headers.'User-Agent' = 'Mozilla/5.0 Ubuntu/8.10 Firefox/3.0.4'
response.success = { resp, json ->
info = json.weatherinfo.city
}
response.failure = { resp -> println "Unexpected error: ${resp.statusLine.statusCode} : ${resp.statusLine.reasonPhrase}" }
}
then: "曲靖"==info
}
}

打完收工，通過這個小例子我們可以了解到這么一些內容：
（1）HTTPBuilder 是這個框架的核心類（要不然怎麼和框架一個名字），構建這個類的對象的時候，指定要請求的baseUrl。
（2）request方法可以指定請求的method和返回的數據格式，method對應的是GET/PUT/POST/DELETE/HEAD幾個常量，而數據格式目前有JSON/XML/HTML/BINARY/URLENC/ANY幾種。
（3）一個比較有意思的地方是，在http的request方法裡面，彷彿是無根之水一樣突然冒出來了幾個沒有聲明過的變數，看起來連編譯也不會通過的方法，那麼是如何能正常運作的呢？這個我們就要研究到Groovy的Closure（閉包）。Groovy的閉包里包含有一個delegate屬性，一般來說，這個delegate里保存的是閉包使用上下文的對象引用，比如a調用了一個閉包b，則b的delegate就是a的this對象。而在HTTPBuilder對象調用request方法的時候，它把傳入閉包的delegate改成了一個叫做SendDelegate的類對象（這是HTTPBuilder的內部類，他們都是用Java寫的，在新版的HttpBuilder里，已經改名為RequestConfigDelegate），這個類裡面，分別包含了一個叫做getHeaders()的方法，一個叫做getUrL()的方法，一個叫做getResponse()的方法。稍微思索一下我們就可以想到，Groovy里有這樣的特性，如果直接使用一個識別不出來的變數，Groovy會假設它是getter的一種簡寫形式，自動進行補全（當然這也是DSL的常用伎倆，把方法偽裝成短語），而getter並沒有參數，所以其括弧是可以簡寫的，實際上上面的代碼可以寫作getUrl().path = '/data/101290401.html'，這樣就非常符合程序員的視覺體驗了。
（4）主要是為了喜歡追根問題的同學釋疑，實際上整個調用還是非常的簡單明快的，在request閉包里，我們通過response（記得嗎，實際上就是GetResponse()）,獲得了一個Map結構，這個Map的內部結構實際上是Map<String,Closure>,對「success」和「failure」這兩個key我們分別設置了對應的閉包，這樣就完成了回調的設置，一旦方法成功或者失敗，就可以調用到對應的閉包。
（5）使用了JSON作為返回格式，閉包的第二個參數就是解析好的返回body，就是一個Json對象，是可以直接用點號來訪問的。當然最好不要在失敗的閉包里放這個參數，一般失敗的情況比較多，也許就是一個html返回，格式錯誤那麼測試也就無法按照預期進行了。

❹ 在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來啟用。

❺ 在java中使用groovy怎麼搞

1、靜態編譯，在java工程中直接寫groovy的文件，然後可以在groovy的文件中引用java工程的類，這種方式能夠有效的利用groovy自身的語言特性，例如閉包；

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

packagegroovy_dsl.shell;
importgroovy.lang.Binding;
importgroovy.lang.GroovyShell;
publicclassGroovyShellEx{
publicstaticvoidmain(String[]args){
Bindingbind=newBinding();
bind.setVariable("name","iamzhongyong");
bind.setVariable("age","25");
GroovyShellshell=newGroovyShell(bind);
Objectobj=shell.evaluate("str=name+age;returnstr");
System.out.println(obj);
}
}

3、通過groovyScriptEngine執行文件或者腳本，例如：

packagegroovy_dsl.script;
importgroovy.util.GroovyScriptEngine;
publicclassScriptEngine{
publicstaticvoidmain(String[]args)throwsException{
GroovyScriptEngineengine=newGroovyScriptEngine("");
Objectobj=engine.run("src/main/java/groovy_dsl/script/script_test.groovy","iamzhongyong");
System.out.println(obj);
}
}

4、通過GroovyClassLoader來執行，例如：

packagegroovy_dsl.classloader;
importgroovy.lang.GroovyClassLoader;
importgroovy.lang.GroovyObject;
importjava.io.File;
importjava.io.IOException;
{

publicstaticvoidmain(String[]args)throwsException,IOException{
GroovyClassLoaderloader=newGroovyClassLoader();

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

GroovyObjectclazzObj=(GroovyObject)clazz.newInstance();

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

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

}
}

❻ Java序列化問題和Groovy在Java中使用的問題

proxy對象是不能序列化的，就算能序列化也不能反序列化，因為proxy對象的類是動態生成出來的，序列化後，反序列化時目標jVM肯定沒有載入過這個代理類。
有個變通的方法，就是獲取到對象本身，序列化；反序列化後獲取到原對象，再重新用代理包裝即可獲得反序列化後的代理對象了。不知道是否貼題。下面有個例子，雖然沒有序列化和反序列化，但是基本實現了獲取對象本身這個功能，希望能幫到你。

另外groovy對象也是java對象，應該仍然保持groovy對象本身（個人理解，groovy我也是略懂皮毛），spring應該不會對對象本身動刀子，最多加層代理啥的。
//-------------------------------------------------------------------------------
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class Test implements TestInterface{
public static void main(String[] args) {
final Test t = new Test();
TestInterface t2 = (TestInterface) Proxy.newProxyInstance(
Test.class.getClassLoader(),
Test.class.getInterfaces(),
new InvocationHandler() {

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
try {
return method.invoke(t, args);
} catch(InvocationTargetException ite) {
throw ite.getTargetException();
}
}
}
);
t2.test();
//使用這種方式獲取原對象，序列化原對象後，反序列化原對象 重新構造代理
System.out.println(t2.getThis().getClass());
System.out.println(t2.getClass());

}

public void test() {
System.out.println(1);

}
public Test getThis() {
return this;
}
}

interface TestInterface{
public void test() ;
public Test getThis() ;
}

❼ 怎樣在Groovy中實現Java介面

import org.test.event.Event;
import org.test.Engine;

public class Script implements Event{

def parse(url,userData){
Engine.getContent(url,this);

public void callback(String content){
println("callback function is running now.\r\n"+content);
}

}

❽ 如何在groovy中是實現java介面

import org.test.event.Event;
import org.test.Engine;

public class Script implements Event{

def parse(url,userData){
Engine.getContent(url,this);

public void callback(String content){
println("callback function is running now.\r\n"+content);
}

}

❾ Java程序員為什麼學習Groovy

正如Groovy對Java很多特性進行的包裝優化一樣，基於Groovy的HttpBuilder也包裹了HttpClient，使網路編程變得更加的方便易用，下面稍微來用一個例子看一下。
尋找各種依賴的jar包有時候會讓我們失去耐心，不過值得慶幸的是我們有Maven和Gradle這樣的工具，可以根據配置輕松的幫我們配置好我們需要的數據。下面我們來敘述一下整個過程。
1. 創建文件夾httpbuildertest
2. 創建gradle配置文件，build.gradle，內容如下：
apply plugin: "groovy"apply plugin: "eclipse"repositories { mavenCentral()}dependencies { compile "org.codehaus.groovy:http-builder:0.4.0" compile "org.codehaus.groovy:groovy-all:2.3.3" testCompile "org.spockframework:spock-core:0.7-groovy-2.0"}

gradle我們將做另文介紹
3. 執行gralde eclipse（當然必須先安裝gradle），就可以生成eclipse所需要的.classpath和.project文件，這時候就可以使用eclipse導入功能來import->Existing Projects Into WorkSpace。
4. 創建我們的一個測試，試試看是不是可以使用httpbuilder了
import groovyx.net.http.HTTPBuilderimport spock.lang.Specification;import static groovyx.net.http.Method.*import static groovyx.net.http.ContentType.*class HttpbuildLabSpec extends Specification{HTTPBuilder http = new HTTPBuilder( 'http://m.weather.com.cn' )public void testRequestWeather(){ when: def info ="" http.request( GET, JSON ) { url.path = '/data/101290401.html' headers.'User-Agent' = 'Mozilla/5.0 Ubuntu/8.10 Firefox/3.0.4' response.success = { resp, json -> info = json.weatherinfo.city } response.failure = { resp -> println "Unexpected error: ${resp.statusLine.statusCode} : ${resp.statusLine.reasonPhrase}" } } then:"曲靖"==info}}

打完收工，通過這個小例子我們可以了解到這么一些內容：
（1）HTTPBuilder 是這個框架的核心類（要不然怎麼和框架一個名字），構建這個類的對象的時候，指定要請求的baseUrl。
（2）request方法可以指定請求的method和返回的數據格式，method對應的是GET/PUT/POST/DELETE/HEAD幾個常量，而數據格式目前有JSON/XML/HTML/BINARY/URLENC/ANY幾種。
（3）一個比較有意思的地方是，在http的request方法裡面，彷彿是無根之水一樣突然冒出來了幾個沒有聲明過的變數，看起來連編譯也不會通過的方法，那麼是如何能正常運作的呢？這個我們就要研究到Groovy的Closure（閉包）。Groovy的閉包里包含有一個delegate屬性，一般來說，這個delegate里保存的是閉包使用上下文的對象引用，比如a調用了一個閉包b，則b的delegate就是a的this對象。而在HTTPBuilder對象調用request方法的時候，它把傳入閉包的delegate改成了一個叫做SendDelegate的類對象（這是HTTPBuilder的內部類，他們都是用Java寫的，在新版的HttpBuilder里，已經改名為RequestConfigDelegate），這個類裡面，分別包含了一個叫做getHeaders()的方法，一個叫做getUrL()的方法，一個叫做getResponse()的方法。稍微思索一下我們就可以想到，Groovy里有這樣的特性，如果直接使用一個識別不出來的變數，Groovy會假設它是getter的一種簡寫形式，自動進行補全（當然這也是DSL的常用伎倆，把方法偽裝成短語），而getter並沒有參數，所以其括弧是可以簡寫的，實際上上面的代碼可以寫作getUrl().path = '/data/101290401.html'，這樣就非常符合程序員的視覺體驗了。
（4）第四點羅嗦了不少，主要是為了喜歡追根問題的同學釋疑，實際上整個調用還是非常的簡單明快的，在request閉包里，我們通過response（記得嗎，實際上就是GetResponse()）,獲得了一個Map結構，這個Map的內部結構實際上是Map<String,Closure>,對「success」和「failure」這兩個key我們分別設置了對應的閉包，這樣就完成了回調的設置，一旦方法成功或者失敗，就可以調用到對應的閉包。
（5）使用了JSON作為返回格式，閉包的第二個參數就是解析好的返回body，就是一個Json對象，是可以直接用點號來訪問的。當然最好不要在失敗的閉包里放這個參數，一般失敗的情況比較多，也許就是一個html返回，格式錯誤那麼測試也就無法按照預期進行了。

❿ groovy中使java必須import嗎

第一種是調用groovy官方庫里的類

第二種是調用自己寫的groovy文本的類

缺點: 如果不安裝groovy解釋器和groovy Eclipse插件.就無法享受更多的對jdk 類的擴展, 已經腳本化語法的便捷.

腳本語言特點 無main,直接printf

第二步: jar依賴,maven庫上傳.

第三步: 推廣成員安裝groovy解釋器和groovy Eclipse插件

1. 第一種. 如果用maven的話

在pom的 依賴項里加入.

<groupId>org.codehaus.groovy</groupId>

<artifactId>groovy-all</artifactId>
<version>2.2.2</version>

</dependency>

或者去官網下載grovvy的jar包,導入的eclipse的class依賴中.

就可以直接在java里調用 grovvy庫里的類了.

( 如果Eclipse不會自動 import groovy的類,需要在.project中新增 <nature>org.eclipse.jdt.groovy.core.groovyNature</nature>)

import groovy.util.GroovyCollections;
import java.util.List;
public static void main(String[] args) {
List<Double> lists = new ArrayList<Double>();
lists.add(0.2);
lists.add(0.3);
lists.add(0.2);

Object sum = GroovyCollections.sum(lists);
System.out.println(sum);
}

====

2 第二種. 如果是自己寫的groovy 文件.

假如如下 GrovvySystemConfigRead.groovy代碼

[java]view plain

• /**

• *CreatedbyIntelliJIDEA.

• *User:Web-03

• *Date:11-4-21

• *Time:下午3:43

• *TochangethistemplateuseFile|Settings|FileTemplates.

• */

• classGrovvySystemConfigRead{

• /*

• *讀取郵件驗證訪問路徑,ConfigurationHolder是groovy框架grais里的某個類

• */

• staticString getName(){

• return"csdn" ;

• }

• }

2.1 第一種調用，JAVA類(JavaClassCallGroovy)是可以直接調用GROOVY類(上面寫好的SystemConfigRead)的。

(需要安裝eclipse插件,自動把groovy文本文件編譯為.class ,插件安裝見

[java]view plain

• public class JavaClassCallGroovy{

• public static void main(String[] args) {

• SystemConfigRead.getName();

• }

• }

2.2 第二種,以反射腳本化方式調用(不推薦),實現腳本化調用,即腳本改動後,無需編譯,自動執行的目的.

這種反射化調用不僅可以用在java類調用groovy類,也可以用在java類調用java類,實現java的腳本化.

[java]view plain

• /**

• *JAVA調用GROOVY

• *@throwsIOException

• *@throwsIllegalAccessException

• *@throwsInstantiationException

• *添加人：**

• *添加時間：211-08-3014:27

• */

• publicvoidgroovyToJava()throwsIOException,IllegalAccessException,InstantiationException{

• ClassLoaderparent=getClass().getClassLoader();

• GroovyClassLoaderloader=newGroovyClassLoader(parent);

• //找到指定的groovy類

• ClassgroovyClass=loader.parseClass(newFile("site/grails-app/utils/com/ingping/core/SystemConfigRead.groovy"));

• //將對象實例化並且強制轉換為GroovyObject對象

• GroovyObjectgroovyObject=(GroovyObject)groovyClass.newInstance();

• //readEmailCodeUrl方法名，null參數值，沒有為null

• System.out.println(""+groovyObject.invokeMethod("readEmailCodeUrl",null));

• }