groovy多核编译

⑴ groovy语言主要是用来干什么，和java的区别是什么

先说区别吧：java是编译性语言，就是得编译后才能运行。groovy语言是动态语言。

Groovy 是 JVM 的一个替代语言 — 替代 是指可以用 Groovy 在 Java 平台上进行 Java 编程，使用方式基本与使用 Java 代码的方式相同。
Groovy 的一个好处是，它的语法与 Java 语言的语法很相似。虽然 Groovy 的语法源于 Smalltalk 和 Ruby 这类语言的理念，但是可以将它想象成 Java 语言的一种更加简单、表达能力更强的变体。（在这点上，Ruby 与 Groovy 不同，因为它的语法与 Java 语法差异很大。）

⑵ maven 里怎么自动编译 groovy

1. 首先确定使用 Groovy 的版本

<properties>
<groovy.version>2.4.3</groovy.version>
</properties>

2. 配置项目依赖 Groovy 包和模块，这个看实际情况增加相关的依赖

<dependency>
<groupId>org.codehaus.groovy</groupId>
<artifactId>groovy</artifactId>
<version>${groovy.version}</version>
</dependency>
<dependency>
<groupId>org.codehaus.groovy</groupId>
<artifactId>groovy-json</artifactId>
<version>${groovy.version}</version>
</dependency>
...

3. 关键的步骤是使用 gmavenplus 插件，绑定 maven 的编译和执行周期

<plugin>
<groupId>org.codehaus.gmavenplus</groupId>
<artifactId>gmavenplus-plugin</artifactId>
<version>1.5</version>
<dependencies>
<dependency>
<groupId>org.codehaus.groovy</groupId>
<artifactId>groovy-ant</artifactId>
<version>${groovy.version}</version>
</dependency>
<dependency>
<groupId>org.codehaus.groovy</groupId>
<artifactId>groovy-all</artifactId>
<version>${groovy.version}</version>
</dependency>
</dependencies>
<executions>
<execution>
<goals>
<goal>addSources</goal>
<goal>addStubSources</goal>
<goal>compile</goal>
<goal>execute</goal>
</goals>
</execution>
</executions>
</plugin>

⑶ 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返回，格式错误那么测试也就无法按照预期进行了。

⑷ groovy classloader 和java一样吗

不一样，groovy相当于java的扩展，但有些指令作了改变，在groovy中的写法与java中的写法不一致，这样的代码要改写。
所以说，groovy不能百分百load java编译的class。java肯定不能load groovy编译的class.

⑸ 关于groovy和java混合编译，大家有没有更好

其实groovy需要挺好用，还有就是 kotlin

⑹ Assert 在Java和Groovy中的区别 / 蓝讯

与 Java 的区别
Groovy 试图尽可能地让 Java 开发者快速适应。在设计 Groovy 时，我们努力不让用户感到惊讶，即遵循“最小惊讶”原则，特别是针对那些此前有 Java 开发背景的 Groovy 初学者。
下面讲讲 Groovy 与 Java 的主要不同点。
1. 默认导入
下面这些包和类都是默认导入的，也就是说，不用再显式地使用 import 语句了：
java.io.*
java.lang.*
java.math.BigDecimal
java.math.BigInteger
java.net.*
java.util.*
groovy.lang.*
groovy.util.*
2. 多重方法
在 Groovy 中，调用的方法将在运行时被选择。这种机制被称为运行时分派或多重方法（multi-methods），是根据运行时实参（argument）的类型来选择方法。Java 采用的是相反的策略：编译时根据声明的类型来选择方法。
下面的 Java 代码可以用 Java 和 Groovy 来编译，但两种编译结果截然不同：
int method(String arg) {
return 1;
}
int method(Object arg) {
return 2;
}
Object o = "Object";
int result = method(o);

用 Java 编译的结果如下：
assertEquals(2, result);
用 Groovy 编译的结果则为：
assertEquals(1, result);
产生差异的原因在于，Java 使用静态数据类型，o 被声明为 Object 对象，而 Groovy 会在运行时实际调用方法时进行选择。因为调用的是 String 类型的对象，所以自然调用 String 版本的方法。
3. 数组初始化表达式
在 Groovy 中，{...} 语句块是留给闭包（Closure）使用的，这意味着你不能使用以下这种格式来创建数组：
int[] array = { 1, 2, 3}
正确的方式是这样的：
int[] array = [1,2,3]
4. 包范围可见性
在 Groovy 中，如果某个字段缺失了修饰符，并不会导致像在 Java 中那样形成包的私有字段：
class Person {
String name
}

相反，它会用来创建一个属性（property），也就是一个私有字段（private field），以及一个关联的 getter 和一个关联的 setter。
在 Groovy 中创建包私有字段，可以通过标注 @PackageScope 来实现。
class Person {
@PackageScope String name
}

5. ARM 语句块
ARM（Automatic Resource Management，自动资源管理）语句块从 Java 7 开始引入，但 Groovy 并不支持。相反，Groovy 提供多种基于闭包的方法，效果相同但却合乎习惯。例如：
Path file = Paths.get("/path/to/file");
Charset charset = Charset.forName("UTF-8");
try (BufferedReader reader = Files.newBufferedReader(file, charset)) {
String line;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}

} catch (IOException e) {
e.printStackTrace();
}

可以写成下面这样的代码：
new File('/path/to/file').eachLine('UTF-8') {
println it
}

或者，如果你想让它更接近于 Java 的惯用形式，可以这样写：
new File('/path/to/file').withReader('UTF-8') { reader ->
reader.eachLine {
println it
}
}

⑺ java和groovy能混编吗

答案是肯定的，java & groovy混编：一种最“势利”的折衷
而groovy，说它是java++也不为过，因为java代码直接就可以被groovy编译, groovy完全兼容java语法, 对一般java开发人员来说，这真是太亲切了

⑻ 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返回，格式错误那么测试也就无法按照预期进行了。