nGrinder是一个基于Grinder的压力测试平台。在此平台上你可以创建测试脚本、执行测试、监控目标服务器，同步的生成测试结果。

nGrinder由两种关键组件：

1. 控制器：提供性能测试的Web接口，支持协调测试进程、收集并展示测试相关的统计信息，允许用户创建或修改测试脚本
2. 代理，可以运行在两种模式下：
   1. Agent：运行线程、进程，将负载施加到目标服务器上
   2. Monitor：监控目标服务器的性能，例如CPU/内存

代理启动后会尝试连接到控制器，然后被添加到AgentControllerServer —— 类似于Agent的池中。当用户发起一个性能测试后，nGrinder会创建一个协调Agents的SingleConsole（和Grinder中的Console作区分，起名叫SingleConsole），所需数量的Agent从AgentControllerServer交付给SingleConsole管理，SingleConsole向Agents发送测试脚本、测试资源，并控制测试流，直到测试完毕。测试完毕后，Agents回到AgentControllerServer的Agent池中，供后续测试重用。SingleConsole则回到ConsoleManager中。

nGrinder和Grinder最大的不同是，前者在控制器中持有多个Console实例、Agents。Console之间是相互独立的，并且可以并行的运行。Agent可以被预先分配给Console，也可以根据需要随时被请求、分配。nGrinder力求对Agent机器的最大化利用。其它测试平台，常常为测试任务预先分配Agents。用户为了争抢资源，常常会提前申请Agent而不充分利用。nGrinder仅在测试运行时才真正动态分配Agent。

从3.1版本开始nGrinder开始支持控制器集群。性能测试可以被集群中的某个控制器调度，可以在多组Agent（称为Region）上执行。

上图的架构中，包含两个控制器组成的集群：

1. 所有控制器共享数据库、网络文件系统。所有控制器的

   ${NGRINDER_HOME}

   必须指向同一NFS路径
2. 每个控制器可以有自己独特的属性、日志输出，这些信息存放在

   ${NGRINDER_EX_HOME}

3. 所有控制器同步EhCache缓存中的共享数据

每个nGrinder控制器实例都可以独立的服务用户，需要注意的是nGrinder没有提供分布式会话，因此切换控制器后你需要重新登陆。

在Quick Start中输入一个URL，可以自动生成一个测试脚本。测试脚本就是一段以Groovy语言编写的JUnit测试。

在Home页面点击Performance Test链接，可以进入已经定义的性能测试的列表。

点击列表项，可以进入单个性能测试的详情页面。其第一个选项卡是Test Configuration：

www.gmem.cc:39.107.94.255 

在Home页面点击Script链接，可以进入已经定义的脚本的列表。

nGrinder内置了一个SVN服务器，用于管理用户编写的脚本文件以及资源，每个用户由独立的SVN存储库。你可以通过SVN客户端签出并管理脚本和资源，也可以通过nGrinder的UI来添加、删除、上传脚本或资源文件或目录。

从3.2版本开始，nGrinder在Jython的基础上支持Groovy作为脚本编写语言。 

Groovy脚本是基于Junit的，因此对熟悉Java单元测试的人很友好。你可以通过SVN版本库管理压测脚本，甚至使用Maven来管理压测脚本的项目、在IDE中执行运行、调试压测脚本。

下面是一个基本的模板：

import static net.grinder.script.Grinder.grinder
import static org.junit.Assert.*
import static org.hamcrest.Matchers.*
import net.grinder.plugin.http.HTTPRequest
import net.grinder.script.GTest
import net.grinder.script.Grinder
import net.grinder.scriptengine.groovy.junit.GrinderRunner
import net.grinder.scriptengine.groovy.junit.annotation.BeforeThread
import net.grinder.scriptengine.groovy.junit.annotation.BeforeProcess

import org.junit.BeforeClass
import org.junit.Test
import org.junit.runner.RunWith

import HTTPClient.HTTPResponse

// 测试用例必须附加如下注解
@RunWith(GrinderRunner)
class Test {

    public static GTest test;
    public static HTTPRequest request;

    // 每个进程被创建之前，执行的方法
    // 类似的还有@AfterProcess
    @BeforeProcess
    public static void beforeClass() {
        // 创建一个GTest实例
        test = new GTest(1, "${name}");
        // 录制对此HTTPRequest的任何调用，每次对它的调用都会增加TPS
        request = new HTTPRequest();
        test.record(request);
        grinder.logger.info("before process.");

        // 如果需要录制多个HTTPRequest，需要使用多个名字不同的GTest实例
    }

    // 每个线程被创建之前，执行的方法
    // 类似的还有@AfterThread 
    @BeforeThread
    public void beforeThread() {
        grinder.statistics.delayReports=true;
        grinder.logger.info("before thread.");
    }

    // 在停止测试之前，带有这个注解的方法会被持续不断的运行
    @Test
    public void test(){
        HTTPResponse result = request.GET("${url}");
        if (result.statusCode == 301 || result.statusCode == 302) {
            grinder.logger.warn("Warning. The response may not be correct. The response code was {}.", result.statusCode);
        } else {
            // 可以进行断言，断言失败则绑定到当前线程的最后一次测试被标记为失败
            assertThat(result.statusCode, is(200));
        }
    }
}

在Test Configuration中指定的单个参数，可以这样获取：

// 名字固定为param
System.getProperty("param", "defaultValue")

实际上，上述param参数是在命令行通过

-Dparam=value

引入Maven依赖ngrinder-groovy，可以调用net.grinder.util.GrinderUtils定义的静态方法，获取参数并进行类型转换。

processnumber=grinder.processNumber                                 //获取当前的进程号，应该会相应返回0,1,2,3,4
totalprocess=grinder.getProperties().getInt("grinder.processes", 1) //获取测试的进程总数，返回5
threadnumber=grinder.threadNumber                                   //获取当前的线程号，应该会相应返回0,1
totalthread=grinder.getProperties().getInt("grinder.threads", 1)    //获取测试的线程总数,应该返回2
run=grinder.runNumber;                                              //获取当前的测试号，应该相应返回1,2,3
totalrun=grinder.getProperties().getInt("grinder.runs", 1);         //返回测试的总数，如3

HTTPPluginControl.getConnectionDefaults().timeout = 6000 

request = new HTTPRequest();
request.POST("http://www.google.com", [new NVPair("key1","value1"), new NVPair("key2":"value2")] as NVPair[])

def result = request.GET("http://www.google.co.kr")
assertThat(result.statusCode, is(200)) // 状态码
assertThat(result.text, containsString("google")) // 响应体

而不是录制HTTPRequest调用：

@RunWith(GrinderRunner)
class TestRunner {
    static GTest test1
    static GTest test2
    @BeforeProcess
    public static void beforeProcess() {
        test1 = new GTest(1,"test1_statistics")
        test2 = new GTest(2,"test2_statistics")
    }
 
    @BeforeThread
    public void beforeThread() {
        test1.record(this, "doTransaction1"); // 录制当前对象的doTransaction1调用到测试test1
        test2.record(this, "doTransaction2"); // 录制当前对象的doTransaction2调用到测试test2
        grinder.statistics.delayReports=true;
    }
 
    @Test
    public void doTransaction1(){
    }
 
    @Test
    public void doTransaction2(){
    }
}

被录制方法的执行耗时会影响测试报告。

你可以设置每个测试方法，占用总计的测试次数的比例：

@RunRate(50)  // 此方法占所有测试次数（runs）的50%
@Test
public void test1() {
}

@RunRate(20)
@Test
public void test2() {
}

如果总和不到100，则会有一定的测试次数（runs）什么都不干。

LoggerFactory.getLogger("worker").setLevel(Level.ERROR)

import groovy.json.JsonSlurper

def message = """
{
  "glossary": {
     "title": "example glossary",
      "GlossDiv": {
           "title": "S"
         }
      }
  }
}"""

def jsonMsg = new JsonSlurper().parseText(message)
grinder.logger.info(jsonMsg.glossary.title)

def hello = new XmlParser().parseText(message);

byte[] buffer = new byte[1000];

HTTPResponse result = request.GET("http://www.google.com");

// 只读取1000字节就结束
def stream = result.getInputStream();
stream.read(buffer);
stream.close();

def threadId;
@BeforeThread
public void beforeThread() {
  threadId = GrinderUtils.threadUniqId; 
}

@Test
public doTest() {
   // 根据threadId进行条件分支
}

有两种方式：

1. 在测试脚本所在目录下，建立lib目录，其中存放jar
2. 使用Maven依赖管理机制 

1. 在测试脚本所在目录下，建立resources目录，其中存放资源文件，然后参考下面的脚本加载资源：
   

   @BeforeProcess
   public static void beforeProcess() {
       text = new File("./resources/resource1.txt").text;
   } 

2. 使用Maven，从类路径下加载：
   

   ReflectionUtils.getCallingClass(0).getResourceAsStream("/resource1.txt");

nGrinder 3.3提供了超过40个REST API，使用这些REST API你可以构建自己的nGrinder前端，或者让其它工具和nGrinder进行集成。REST API的功能包括：

1. 用户管理
2. 代理管理
3. 脚本管理
4. 性能测试管理
5. 系统管理

REST API使用HTTP基本身份验证。

# 克隆现有性能测试，然后启动，226为测试ID
curl -u admin:admin http://ngrinder-host/perftest/api/226/clone_and_start
# 返回JSON形式、新创建的测试
# 你可以传递agentCount、scriptRevision参数来指定代理数量、脚本的修订版

# 查看现有的性能测试
curl -u admin:admin http://ngrinder-host/perftest/api/226

# 查看性能测试列表
curl -u admin:admin http://ngrinder-host/perftest/api

对于nGrinder UI的URL（其URL Path称为topic），后缀以/api通常就是其对应的REST API端点：

参考：https://github.com/naver/ngrinder/wiki/REST-API-PerfTest

The post 基于nGrinder进行负载测试 appeared first on 绿色记忆.

Gradle是近年来流行起来的自动化构建工具，它具有以下特性：

1. 灵活、通用的构建功能，类似Ant
2. 基于约定的构建框架，类似Maven
3. 强大的多工程构建支持
4. 支持基于Apache Ivy的依赖管理，现已使用Gradle自己的依赖处理引擎（dependency resolution engine）
5. 完整的支持既有的Maven或者Ivy构件仓库，且不需要pom.xml或者ivy.xml就可以进行依赖管理
6. 整合型构建工具：
   1. 支持Ant任务，Gradle可以直接引入Ant工程，并在运行时将Ant targets转换为Gradle tasks
   2. 可以自动的把Maven的pom.xml转换为Gradle脚本
7. 基于Groovy的构建脚本。构建脚本可以很容易的维护和重用
8. 用于描述构建的丰富的领域模型
9. Gradle Wrapper：运行在没有安装Gradle的机器上运行Gradle构建

Gradle的核心是一个基于Groovy的、扩展的DSL（Domain Specific Language），而不是向Maven、Ant那样，通过XML去描述构建步骤，具有非常好的灵活性。

1. Gradle Daemon性能增强，让构建速度最快有75%的提升，默认启用
2. 更好的IDE支持
3. 改进并行任务执行
4. 初步的Java 9支持
5. 新的plugins DSL，用于启用插件，代替原先的

   apply plugin

   ：
   

   plugins {
       id 'my.special.plugin' version '1.0' apply false
   } 

6. 改进增量构建
7. 更快的依赖解析
8. 改进eclipse-wtp插件
9. 插件库升级

1. 支持依赖的并行下载
2. 改进构建缓存
3. 添加Google的Maven仓库的快捷方式：
   

   repositories {
       google()
   }

4. 支持使用Gradle属性来配置日志级别，属性名org.gradle.logging.level，支持的值：quiet, warn, lifecycle, info, debug，默认lifecycle

5. 对删除文件的Task进行更好的建模。一个Task可以使用 @Destroys 注解，明确声明自己会删除文件：

   class RemoveTempDirs extends DefaultTask {
       @Destroys
       FileCollection tempDirs
   
       @TaskAction
       void removeDirs() {
           project.delete(tempDirs)
       }
   } 

1. 更快的构建速度
2. 更细粒度的传递性依赖管理
3. 内存使用更高效
4. 新的Gradle调用选项
5. 新的Task/Plugin API

即Gradle Wrapper，是一段脚本，此脚本调用你声明的版本的Gradle，如果目标版本不存在，则从网络上下载。

使用gradlew可以保证构建过程的一致性，但是网络差的话你就得静静的等待下载完成。

要生成gradlew相关的文件，需要本机已经安装任意版本的Gradle。执行命令

gradle wrapper

生成的gradlew文件包括：

1. gradle/wrapper/gradle-wrapper.properties 配置文件
2. gradle/wrapper/gradle-wrapper.jar 包含用于下载Gradle发行版的代码
3. gradlew, gradlew.bat Shell脚本和Windows批处理脚本

#Tue Jun 25 10:21:26 CST 2019
distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists
# 从何处下载
# 后缀 -all 表示包含源码，-bin 表示不包含源码
distributionUrl=https\://services.gradle.org/distributions/gradle-4.10-all.zip

如果下载缓慢，可以手工拷贝，存放到

~/.gradle/wrapper/dists

执行下面的命令升级到指定版本：

./gradlew wrapper --gradle-version 5.4.1

gradlew的命令行调用格式和gradle完全一致。 

1. 安装Gradle需要JDK/JRE，版本在6.0+。Gradle内置了Groovy库，因此后者不需要
2. 到官网下载Gradle，并解压到某个目录，该目录设置为环境变量

   GRADLE_HOME

    
3. 将

   $GRADLE_HOME/bin

    添加到环境变量PATH中
4. 打开终端，运行

   gradle -v

    验证安装是否成功

可以从Nodeclipse提供的Update Site：http://www.nodeclipse.org/updates/gradle-ide-pack/ 安装Gradle插件。

此站点中杂项内容非常多，可以根据需要，选择性的安装：

打开Window ⇨ Preferences ⇨ Gradle：

1. Gradle Distribution 点选 Folder，填写

   %GRADLE_HOME%

    对应的目录
2. Gradle User Home 点选 Directory，填写

   %USERPROFILE%\.gradle

    

打开Window ⇨ Preferences ⇨ Gradle ⇨ Arguments：

1. Java Home 点选Workspace JRE，选择一个已安装的JRE
2. 默认JVM参数可以根据需要调整

打开Window ⇨ Preferences ⇨ Gradle EnIDE：

1. Gradle Home to use：填写

   %GRADLE_HOME%

    对应的目录

打开Window ⇨ Preferences ⇨ Desktop Environment：

1. 点选 Custom Desktop Environment
2. Start Shell设置为Console2，例如

   D:\Programs\Console2\Console.exe -d ${resource_path}

    

打开File ⇨ New ⇨ Other，选择Gradle/Gradle Project，即可创建Gradle工程，Sample project选择Java Quickstart，点击完成。

初次创建Gradle IDE会去下载一些东西，完毕后，形成类似下面的工程结构：

可以看到，默认配置下Gradle沿用了Maven的工程目录习惯。除了把pom.xml换成build.gradle，Maven工程和Gradle工程的结构完全相同。

Eclipse工程结构和元数据完全根据build.gradle导出，这个和Maven也是类似的。工程根目录右键 ⇨ Gradle ⇨ Refresh All，可以根据当前的build.gradle更新Eclipse工程结构。

要构建Gradle工程，可以工程根目录右键 ⇨ Run As ⇨ Gradle Build。

命令格式：

//可以同时指定多个Task
gradle [option...] [task...]

用法示例：

# 依次调用 compile 和 test 任务
# 它们所依赖的任务会根据依赖图的顺序被依次调用，每个任务只会调用一次
# 只需要声明任务之间的依赖，不需要人工控制任务执行顺序，是相对于Maven的优势
gradle compile test

# 使用-x 排除某个任务
gradle dist -x test

# 默认情况下，一旦有一个任务失败，Gradle就会终止执行，下面的选项禁止此行为
gradle run --continue

# 简化任务名：不需要输入完整，只需要足够避免歧义的前缀
gradle ru
# 简化任务名：驼峰式首字母，下面的命令调用gradle compTest
gradle cT

# Gradle默认依据当前目录下的build.gradle，使用-b可以选择构建其它脚本
gradle -q -b subdir/myproject.gradle hello

# 使用-p，可以选择构建的目录
gradle -q -p subdir hello

# 获取子工程列表
gradle -q projects

# 列出工程中所有任务
gradle tasks
gradle -q tasks --all   #同时显示任务依赖关系

# 显示任务的详细信息
gradle help --task taskName

# 显示工程中所有依赖库的列表
gradle dependencies  #输出依据依赖配置（Dependencies Configuration）分组
# 显示api子工程的所有依赖列表
gradle -q dependencies api:dependencie
# 显示api子工程的、testCompile配置的所有依赖列表
gradle -q api:dependencies --configuration testCompile
# 显示某个特定依赖库的情况，显示groovy依赖库的情况
gradle -q api:dependencyInsight --dependency groovy --configuration compile

# 显示工程属性列表
gradle properties
gradle -q api:propertie #子工程属性列表

# 记录构建日志
gradle run --profile   # 日志存放到build/reports/profile 

# 以特定的工程属性来构建
gradle hello -PskipHello

# 设置JVM属性
gradle hello -Djava.io.tempdir=/tmp

# 丢弃已经编译的脚本缓存
gradle  --recompile--scripts 

# 显示图形界面
gradle --gui 

除了通过gradle命令行参数

-P

gradle.properties

gradlePropertiesProp=gradlePropertiesValue
# 对于根工程，可以设置JVM系统属性，这些属性以systemProp.开头
systemProp.system=systemValue

build.gradle

在当前目录下创建一个UTF-8编码的build.gradle文件，或者通过Eclipse创建一个Gradle工程。打开build.gradle文件，输入下面的内容：

//可以声明工程属性
description = 'Hello project'

//声明一个名为hello的task
//新任务默认是org.gradle.api.DefaultTask的实例
task hello {
    //闭包指定了hello的action
    doLast {
        println 'Hello world!'  //任何Groovy脚本都支持
    }
}

//上述任务也可以用下面的快捷声明方式
task hello << {
    println 'Hello world!'
}

然后，打开终端，pushd到当前目录，运行命令：

gradle -q hello

Hello world!

使用下面的脚本可以指定默认任务，这样，如果

gradle

defaultTasks 'hello', 'run'

对于构建中的每个工程，Gradle都创建了一个

org.gradle.api.Project

build.gradle

apply plugin: 'java'

println this.name     //当前对象——当前工程——的name属性
println name          //自动委托给当前对象
println project.name  //this.project == this，预定义属性
//上面三个语句打印一样的结果

除了上面的name以外，你还可以访问很多Project的属性，例如： 

Project包含很多常用的方法，可以在构建脚本中使用：

每个构建脚本都自动实现

org.gradle.api.Script

在构建脚本中，你可以声明两种变量：

1. 局部变量 ( local ) ：只在局部作用域可见，使用关键字

   def

    声明，例如：
   

   def dest = "dest"
   task copy(type: Copy) {
       form "source"
       into dest
   }

2. 扩展属性 ( extra )：Gradle领域模型中所有增强对象（包括但不限于：projects, tasks, source sets）都可以添加扩展属性，扩展属性在任何地方可见。使用ext脚本块可以同时声明多个属性。下面是一个示例：
   

   ext {
       //为Project添加属性
       springVersion = "3.1.0.RELEASE"
       emailNotification = "build@master.org"
   }
   //也可以这样写
   ext.springVersion = "3.1.0.RELEASE"
   springVersion = "3.1.2.RELEASE"  //声明以后再修改，不需要ext关键字
   
   //这样写会报错，自定义的外部属性，必须首先使用ext声明
   hibernateVersion = "3.6.10.Final"
   
   //设置所有源码集的purpose属性
   sourceSets.all { ext.purpose = null }
   
   sourceSets {
       //分别设置每个源码集的属性
       main {
           purpose = "production"
       }
       test {
           purpose = "test"
       }
       plugin {
           purpose = "production"
       }
   }
   
   task printProperties << {
       println springVersion
       println emailNotification
       sourceSets.matching { it.purpose == "production" }.each { println it.name }
   }

Gradle大量使用了Groovy提供的灵活语法特性和DSL支持。整个构建脚本都是合法的Groovy代码，虽然有时看起来更像是XML那样的配置文件：

//下面的脚本，更像是配置文件
dependencies {
    compile group: 'commons-collections', name: 'commons-collections', version: '3.2'
    testCompile project(':shared')
}

实际上dependencies是Project对象的一个方法，它的签名如下：

public interface Project{
    void dependencies(Closure configureClosure);
}

可以看到，该方法的入参是一个闭包，我们可以把上面的脚本改写的更像C-Style的代码：

dependencies({
    //这里是闭包体，其包含了两个方法调用：
    compile( [ group: 'commons-collections', name: 'commons-collections', version: '3.2' ] )
    testCompile( project(':shared') )
    //那么，闭包里面调用的方法，是哪个对象的呢？是this也就是闭包本身吗？不是……
    //根据Groovy的规则，闭包里面的变量，其Scope由闭包的delegate属性指定，因此上面的调用实际上是：
    delegate.testCompile( project(':shared') )
    //delegate已经由Gradle自动设置为dependencies
})

我们还可以把上述脚本改写为等价的Java语句： 

Closure<Object> c = new Closure<Object>(){

    public Object call( Object... args ){
    
        assert delegate == project.dependencies
        
        Map<String,String> map = new HashMap<String,String>();
        map.put( 'group',   'commons-collections' );
        map.put( 'name',    'commons-collections' );
        map.put( 'version', '3.2' );
        delegate.compile( dep );
        
        delegate.testCompile( project(':shared') )
        
    }
}
c.delegate = project.dependencies
project.dependencies( c );

可以把其它脚本的内容包含到当前构建脚本中：

println "configuring $project"
task hello << {
    println' 'hello form other srcipt'
}

apply from: 'other.gradle'  //包含其它脚本

 其它脚本中定义的任务，可以直接使用：

gradle -q hello

依赖管理是任何一种构建工具的关键特性，Gradle提供了易于理解的、和Maven/Ivy兼容的依赖管理机制。Gradle的依赖管理具有以下特点：

1. 传递性依赖管理
2. 支持非受管的（non-managed）依赖：依赖可以仅仅是位于版本控制工具或者共享磁盘上的文件
3. 支持定制化的依赖定义：可以在构建脚本中描述依赖的层次
4. 完全可定制的依赖解析机制（Dependency Resolution）
5. 与Maven和Ivy完全兼容
6. 与既有的依赖管理工具，例如Maven和Ivy集成

依赖管理分为两部分的内容：

1. 依赖项（dependencies）：当前工程在构建或者运行时需要的东西
2. 发布项（publications）：当前工程的构建的产出，这些产出可能需要上传到仓库

对于依赖项，Gradle采用了类似Maven的方式进行声明，而不像Ant那样指定绝对路径。依赖项的所在位置（远程仓库或者本地目录）另外声明。对于发布项，行为依赖于配置，可能是发布到本地目录，或者远程仓库。

Gradle把依赖按照依赖配置（dependency configuration）分组。每个分组具有一个名称和若干其它属性，分组可以继承其它分组。某些插件会自动引入一些依赖配置，例如Java插件添加了：

除了插件自动引入的依赖配置以外，你还可以在构建脚本中自行添加。自定义依赖配置在很多情况下有用，例如添加一个既不在编译，也不在测试时需要的“运行时”依赖（典型的例子是JDBC驱动程序）到归档文件中。

下面示例了如何声明依赖配置：

configurations {
    compile {
        description = 'compile classpath'
        transitive = true //是否启用传递性依赖
    }
    runtime {
        extendsFrom compile
    }
}

每一个依赖项声明的格式为：

dependencies{
    // 依赖配置名称 依赖项规格说明
}

依赖项规格是什么形式取决于依赖的类型：

dependencies {
    //可以使用group name version字段来指定
    runtime group: 'hibernate', name: 'hibernate-core', version: '3.6.7'
    //也可以使用分号分隔的group:name:version指定
    runtime 'hibernate:hibernate-core:3.6.7','springframework:spring-aop:2.5'
    //可以控制传递性依赖
    runtime('hibernate:hibernate:3.0.5') {
        transitive = true
    }
    //仅构件标记（Artifact only notation），不去下载模块描述符（例如pom.xml），仅仅下载构件本身
    runtime "org.groovy:groovy:2.2.0@jar"
    //使用分类器字段
    otherConf group: 'test', name: 'service', version: '1.0', classifier: 'jdk14'
}

project(':shared')

dependencies {
    runtime files('libs/a.jar', 'libs/b.jar')
    runtime fileTree(dir: 'libs', include: '*.jar')
}

runtime module(group: 'org.apache.ant', name: 'ant', version: '1.9.4') {
    dependencies "org.apache.ant:ant-launcher:1.9.4@jar",
                     "org.apache.ant:ant-junit:1.9.4"
}

dependencies {
    compile gradleApi()
}

dependencies {
    compile localGroovy()
}

configurations {
    //为指定的依赖配置指定传递性依赖的排除规则
    compile.exclude module: 'commons'
    //为所有的依赖配置指定传递性依赖的排除规则
    all*.exclude group: 'org.gradle.test.excludes', module: 'reports'
}

dependencies {
    compile("org.gradle.test.excludes:api:1.0") {
        exclude module: 'shared' //为单个依赖项指定传递性依赖的排除规则
    }
}

Gradle必须知道从哪里下载外部依赖，这是由仓库配置来指定的：

repositories {
    //Maven本地仓库，寻找本地仓库的逻辑与Maven相同
    mavenLocal()
    //Maven中心仓库
    mavenCentral()
    //JCenter仓库
    jcenter()
    //其它Maven远程仓库
    maven {
        //可以指定身份验证信息
        credentials {
            username 'user'
            password 'password'
        }
        url "http://repo.mycompany.com/maven2"
        //如果上面的URL找不到构件，则在下面找
        artifactUrls "http://repo.mycompany.com/jars"
    }
    //Ivy远程仓库
    ivy {
        url "http://repo.mycompany.com/repo"
    }
    //Ivy本地仓库
    ivy {
        url "../local-repo"
    }
    //扁平布局的文件系统仓库
    flatDir {
        dirs 'lib'
    }
    flatDir {
        dirs 'lib1', 'lib2'
    }
}

除了可以发布到本地目录外，Gradle还支持发布构建的产出到Ivy、Maven仓库：

uploadArchives {
    repositories {
        //发布到扁平结构的目录
        flatDir {
            dirs 'repos'
        }
        //发布到Ivy仓库
		ivy {
		    credentials {
		        username "username"
		        password "pw"
		    }
		    url "http://repo.mycompany.com"
		}
		//发布到Maven仓库
		mavenDeployer {
            repository(url: "file://localhost/tmp/myRepo/")
        }
    }
}

 task关键字本质上是Project对象的一组方法：

Task task(String name) throws InvalidUserDataException
Task task(String name, Closure configureClosure)
Task task(Map<String,?> args, String name) throws InvalidUserDataException
Task task(Map<String,?> args, String name, Closure configureClosure)

 下面列举了不同风格的Task定义：

// 操作符“<<”被Task重载过，它接受一个闭包，该闭包可以对当前Task进行任意操作
// 直接使用不带引号的hello0，会被解释为this.hello0，Gradle可能进行了Groovy元编程，让不存在的变量指定作为当前project的属性看待

// 不带括号
task hello0 << {
    description 'Hello task'   // 可以给Task添加描述
    println "hello"
}
// 带括号
task(hello1) << {
    println "hello1"
}
// 任务名带引号
task('hello2') <<
{
    println "hello2"
}
//指定任务类型
task('copy', type: Copy) {
    //闭包的delegate是task对象，注意Gradle的这种风格，与上面章节dependencies中的闭包delegate指向是一个风格
    from(file('srcDir'))
    into(buildDir)
}
//这样也可以
tasks.create(name: 'hello') << {
    println "hello"
}

首先，任何Task都作为Project的属性看待：

task hello
//作为当前工程的属性来获得Task的引用
println hello.name
println project.hello.name

也可以通过

org.gradle.api.tasks.TaskContainer

task hello
//作为TaskContainer的属性访问
println tasks.hello.name
println tasks['hello'].name

project(':projectA') {
    task hello
}

//也可以调用getByPath()方法
//路径根部的:可以省略
println tasks.getByPath('hello').path  //:hello
println tasks.getByPath(':hello').path //:hello
println tasks.getByPath('projectA:hello').path  //:projectA:hello
println tasks.getByPath(':projectA:hello').path //:projectA:hello

 下面实例了指定Task的类型为

org.gradle.api.tasks.Copy

//Copy任务用来拷贝文件到目标目录中，支持过滤和重命名

//指定任务类型
task myCopy(type: Copy)

//同时设置属性
Copy myCopy = task(myCopy, type: Copy)
myCopy.from 'resources'
myCopy.into 'target'
myCopy.include('**/*.txt', '**/*.xml', '**/*.properties')

//闭包方式，再次注意闭包的delegate指向是当前task，delegate在Minimalist Gradle Editor中常常显示为关键字
task copy(type: Copy) {
   from 'resources'
   into 'target'
   include('**/*.txt', '**/*.xml', '**/*.properties')
}

//声明任务intro依赖于hello
task intro(dependsOn: 'hello') << { //如果被依赖任务在后面定义，则这里引用的任务名必须加引号
    println "I'm Gradle"
}
//被依赖的任务可以在后面定义
task hello << {
    println 'Hello world!'
}
//访问Task的方法也可以添加依赖
intro.dependsOn hello
//也可以通过闭包添加依赖
intro.dependsOn {
    tasks.findAll { task -> task.name.startsWith('lib') }
}

project('projectA') {
    //要依赖其它项目中的任务，必须指定任务的路径
    task taskX(dependsOn: ':projectB:taskY') << {
        println 'taskX'
    }
}
project('projectB') {
    task taskY << {
        println 'taskY'
    }
}

task copy(type: Copy)
task copy(overwrite: true) << { //必须设置overwrite为true
    println('I am the new one.')
}

Gradle提供几种方式，来绕过某个任务的执行： 

task hello << {
    println 'hello world'
//只有当工程没有属性“skipHello”的时候，才会执行hello
hello.onlyIf { !project.hasProperty('skipHello') }
//运行gradle hello -q -PskipHello 不会打印任何信息

//也可以使用StopExecutionException异常跳过任务
hello.doFirst{ //添加如下逻辑到Task最前面
     if (true) { throw new StopExecutionException() }
}

//还可以设置enabled属性，为false则不会执行
hello.enabled = false

Gradle判断任务是否已经是最新状态的依据是：如果任务的输入没有变化，那么当前任务不需要执行（也就是up-to-date）。更进一步说，Gradle的判断规则如下：

1. Task执行前，获得输入文件的散列值
2. Task执行完毕后，存储输出文件的散列值
3. Task执行前，如果输入、输出的散列值和上一次执行相比，没有变化，那么任务是up-to-date 

可以看到，如果任务没有输出，那么它永远不会被看做是up-to-date的。如何声明任务的输入输出呢？

task transform {
    ext.srcFile = file('mountains.xml')
    ext.destDir = new File(buildDir, 'generated')
    
    //下面两行定义了当前任务的输入和输出
    inputs.file srcFile
    outputs.dir destDir
    
    doLast {
       //Task的逻辑
    }
}

上述脚本设置了Task的inputs、outputs属性，如果没必要执行，那么Gradle会自动跳过此任务。

对于复杂的场景，可以调用

TaskOutputs.upToDateWhen()

//动态创建4个任务task1 ... task3
4.times { counter ->
    task "task$counter" << {
        println "I'm task number $counter"
    }
}

//基于规则的动态任务
//对于任何pingXxx，都作为任务看待
tasks.addRule("Pattern: ping<ID>") { String taskName ->
    if (taskName.startsWith("ping")) {
        task(taskName) << {
            println "Pinging: " + (taskName - 'ping')
        }
    }
}
//执行命令 gradle -q pingServer1
//输出 Pinging: Server1

//这些动态任务甚至还可以用做任务依赖
task groupPing {
    dependsOn pingServer1, pingServer2
}

类似于Java的

finally

task taskX << {
    throw new RuntimeException()
}
task taskY << {
    println 'taskY'
}

taskX.finalizedBy taskY
//运行 gradle -q taskX
//输出 taskY

由于大多数构建都需要操作文件，因此Gradle定义了一些额外的文件操作API。

/************************ 文件定位 ***************************/
// 使用一个相对路径
File configFile = project.file('src/config.xml')
// 使用一个绝对路径
configFile = file('file:/some/path.xml')
configFile = file('F:/config.xml')



/************************ 文件集合 ***************************/
FileCollection collection = files(
    'src/file1.txt',
    new File('src/file2.txt'),
    ['src/file3.txt', 'src/file4.txt'] //会被自动展开
)
//迭代集合
collection.each {File file ->
    println file.name
}
//类型转换
List list = collection as List
String path = collection.asPath
File file = collection.singleFile
//添加、去除文件元素
def union = collection + files('src/file3.txt')
def different = collection - files('src/file3.txt')


/************************ 文件树 ***************************/
//从相对目录创建
FileTree tree = fileTree(dir: 'src/main')
tree.include '**/*.java'
tree.exclude '**/Abstract*'
//从归档文件创建
FileTree zip = zipTree('someFile.zip')
FileTree tar = tarTree('someFile.tar')
//遍历
tree.each {File file ->
    println file
}
//过滤
FileTree filtered = tree.matching {
    include 'org/gradle/api/**'
}
//合并
FileTree sum = tree + fileTree(dir: 'src/test')


/************************ 复制文件 ***************************/
//各种文件来源
task copyTask(type: Copy) {
    //复制目录下所有文件
    from 'src/main/webapp'
    //复制单个单独文件
    from 'src/staging/index.html'
    //从一个任务的输出复制
    from copyTask
    //从一个任务的outputs属性复制
    from copyTaskWithPatterns.outputs
    //复制归档文件中的内容
    from zipTree('src/main/assets.zip')
    //最终指定目标目录
    into { getDestDir() }
}
//文件过滤
task copyTaskWithPatterns(type: Copy) {
    from 'src/main/webapp'
    into 'build/explodedWar'
    include '**/*.html'
    include '**/*.jsp'
    exclude { details -> details.file.name.endsWith('.html') }
}
//复制的过程中重命名
task rename(type: Copy) {
    //闭包指定重命名规则
    rename { String fileName -> fileName.replace('-staging-', '') } 
    //使用正则表达式指定映射规则
    rename(/(.+)-staging-(.+)/, '$1$2')
}
//处理文件内容
task filter(type: Copy) {
    //替换文件中的标记，标记必须是@tokenName@的形式
    expand(copyright: '2009', version: '2.3.1')
    expand(project.properties)
    //使用闭包处理每一行
    filter { String line -> "[$line]" }
    //使用闭包删除行
    filter { String line ->  line.startsWith('-') ? null : line  }
}


/************************ 同步两个目录 ***************************/
task libs(type: Sync) {
    from configurations.runtime
    into "$buildDir/libs"
}


/************************ 创建归档文件 ***************************/
task zip(type: Zip) {
    from 'src/dist'
    into('libs') {
        from configurations.runtime //指定依赖配置类型
    }
    baseName = 'customName' //指定归档文件名
}

Gradle支持以下日志记录级别：

在打印日志的同时，还可以指定命令行参数：

1. -s  --stacktrace：打印调用栈
2. -S  --full-stacktrace：打印完整调用栈

可以向标准输出打印日志：

println 'A message which is logged at QUIET level'

或者通过

logger

logger.quiet('An info log message which is always logged.')
logger.error('An error log message.')
logger.warn('A warning log message.')
logger.lifecycle('A lifecycle info log message.')
logger.info('An info log message.')
logger.debug('A debug log message.')
logger.trace('A trace log message.')

还可以使用外部日志工具：

import org.slf4j.Logger
import org.slf4j.LoggerFactory

Logger slf4jLogger = LoggerFactory.getLogger('some-logger')
slf4jLogger.info('An info log message logged using SLF4j')

就像Maven一样，Gradle核心本身也不能做多少有意义的事情，实际的构建工作都是由插件完成的。Gradle允许插件：

1. 扩展Gradle的DSL模型，例如可以配置新的DSL元素
2. 应用“约定由于配置”原则，为工程提供缺省配置
3. 引入新的默认任务集

Gradle插件分为两类：

1. 脚本插件：本质上是额外的构建脚本，可以进一步的配置构建逻辑
2. 二进制插件：是接口

   org.gradle.api.Plugin

    的实现，以编程的的方式操控构建

使用方法

Project.apply()

/** 应用一个脚本插件 **/
// 实际上就是include一段脚本
apply from: 'other.gradle'

/** 应用二进制插件 **/
apply plugin: 'java'  //基于短名
apply plugin: JavaPlugin //基于插件类，org.gradle.api.plugins包内的插件不需要全名
//通过构建脚本块可以引入插件依赖，并使用插件
buildscript {
    repositories {
        jcenter()
    }
    dependencies {
        classpath "com.jfrog.bintray.gradle:gradle-bintray-plugin:0.4.1"
    }
}
apply plugin: "com.jfrog.bintray"

Gradle构建分为三个独立的阶段：

1. Initialization：Gradle支持多工程构建。在初始化阶段，Gradle会确定有哪些工程参与构建，并为它们创建Project实例
2. Configuration：在此阶段，所有的Project对象被合理配置，每个Project的构建脚本（build script，即build.gradle）被执行
3. Execution：Gradle依据命令行参数、当前所在目录决定需要执行的Task的子集。Task的全集在Configuration阶段已经生成

下面示意构建脚本的不同部分在哪个阶段执行：

println '该代码在配置阶段执行'
task configured {
	println '该代码在配置阶段执行'
}
task test << {
	println '该代码在执行阶段执行'
}
task testBoth {
	doFirst {
	  println '该代码在执行阶段执行，最先执行'
	}
	doLast {
	  println '该代码在执行阶段执行，最后执行'
	}
	println '该代码在配置阶段执行'
}

在初始化阶段，Gradle必须确定进行的单工程还是多工程构建（参见下一章）。多工程的设置总是存放在settings.gradle，Gradle自动的寻找该文件的顺序如下：

1. 在当前目录下寻找
2. 在同级的、名为master的目录中寻找
3. 到父目录中寻找

如果找到settings.gradle，Gradle寻找被构建工程是否存在于settings.gradle所声明的工程树中，如果是，则执行多工程构建。否则，执行单工程构建。找不到settings.gradle则一定执行单工程构建。

注意，上述自动寻找settings.gradle的逻辑，仅在多工程满足下面条件之一时发生：

1. 工程物理位置与工程树结构对应
2. 或者，使用扁平目录结构，并且用master目录表示主工程

否则，你必须在settings.gradle所在目录执行Gradle命令以触发多工程构建。

在初始化结束之后，如果时单工程构建，其过程很简单。Gradle会寻找命令行传入的任务名，并把每个任务作为单独的构建执行。

在生命周期各关键点前后，Gradle会发布多种事件（通知），你可以在构建脚本中对这些事件进行处理：

allprojects {
	afterEvaluate { project ->
		println '$it evaluated'
	}
}

tasks.whenTaskAdded { task ->
    task.ext.srcDir = 'src/main/java'
}

gradle.taskGraph.beforeTask { Task task ->
	println "executing $task ..."
}

gradle.taskGraph.afterTask { Task task, TaskState state ->
	if (state.failure) {
		println "FAILED"
	}
}

所谓多工程构建，是指在执行单次Gradle命令时，同时完成多个工程（一个root工程，外加若干个子工程，每个子工程也可以具有自己的子工程）的构建。必须通过

settings.gradle

org.gradle.api.initialization.Settings

假设有一个包含四个子工程的工程，结构如下：

multiproject/
  api/                      #生成一个JAR包，提供WebService客户端的功能
  services/webservice/      #WebService服务端
  shared/                   #其它三个工程依赖该工程
  services/shared/

要启用多工程的支持，必须在工程集的根目录添加

settings.gradle

include "shared", "api", "services:webservice", "services:shared"

 根目录通常作为工程的容器，其中可以通过

subprojects

//所有子目录下的工程都获得下列配置信息：
subprojects {
    apply plugin: 'java'
    apply plugin: 'eclipse-wtp'

    repositories {
       mavenCentral()
    }

    dependencies {
        testCompile 'junit:junit:4.12'
    }

    version = '1.0'

    jar {
        manifest.attributes provider: 'gradle'
    }
}
//注意，由于是在subprojects段设置，因此根工程不会获得这些配置

可以声明子工程之间的依赖：

dependencies {
    compile project(':shared')
}

上面的设置可以确保shared总是在api前面构建，因为后者依赖于前者。 

默认的，Gradle使用全量配置方式：在任何Task执行之前，所有工程都被配置完毕。如果工程数量达到上百个，这会导致配置阶段耗费的时间过于漫长。对不参与本次构建的工程进行配置是不必要的，因此，Gradle 1.4引入了按需配置（Configuration on demand）模式，按需配置仅仅去配置那些与被请求执行任务相关的工程。在未来，按需配置可能变为默认或者唯一的配置模式。

在按需配置模式下，工程按照下面的规则配置：

1. 根工程总是被配置，这保证典型的公共配置脚本被支持（allprojects和subprojects脚本块）
2. 如果Gradle命令没有指定目标，则当前目录对应的工程被配置。这保证工程默认任务（Default tasks）可以正常工作
3. 依赖工程被配置，如果projectA在编译时依赖于projectB，那么构建projectA会导致projectB也被配置
4. 依赖任务所在工程被配置，例如

   taskA.dependsOn(":projectB:taskB1")

    导致构建taskA时projectB被配置
5. 通过命令行指定Task的路径，那么路径中牵涉到的工程都会被配置，例如

   gradle projectA:projectB:someTask

    导致projectB被配置

在配置文件

gradle.properties

org.gradle.configureondemand

以一个简单的多工程为例，根工程root包含一个子工程sub0：

root/
  build.gradle
  settings.gradle
  sub0/

settings.gradle的内容如下：

include 'sub0'

Closure cl = { task -> println "I'm $task.project.name" }
task hello << cl
project(':sub0') {
    task hello << cl
}
# 在根工程目录运行gradle -q hello输出如下：
# I'm root
# I'm sub0
# 注意，所有子工程同名Task会自动执行

其实，Gradle允许在任何一个工程的构建脚本中访问所有工程，只要调用

project(projectName)

下面的脚本块可以为所有工程添加公共行为：

allprojects {
    task hello << { task -> println "I'm $task.project.name" }
}

下面的脚本则为所有子工程添加公共行为：

subprojects {
    hello << { println "I'm $it.project.name" }
}

还可以依据各种条件进行过滤，针对符合条件的工程添加行为：

//根据子工程的名称进行过滤
configure(subprojects.findAll {it.name != 'sub1'}) {
    hello << { println '$it.project.name' }
}

当在根工程目录执行

gradle taskA

Gradle支持指定Task的绝对路径：

gradle -q :hello   //根工程的hello任务
:sub0:hello        //sub0工程的hello任务
hello              //当前工程的hello任务

如果路径以分号开始，则表示是绝对路径（相当于根）。根工程是唯一不需要以名称指代的工程。 

要确定Task的执行顺序，可以使用

dependsOn

//跨工程的任务依赖
task consume(dependsOn: ':producer:produce') << {
    println("Consuming message: ${rootProject.producerMessage}")
}

被依赖的Task总是先被执行。

库依赖（lib  dependency）是一种特殊的执行依赖。以Java构建为例，工程构建时，要求作为库的Jar已经生成好（此Jar可能传递性的依赖于其它Jar）并且添加到当前工程的Classpath中。如果这些库作为多工程构建的子工程存在，这就意味着工程之间存在依赖，这种依赖使用

dependencies

subprojects {
    // 子工程公共属性
    apply plugin: 'java'
    group = 'cc.gmem.study.gradle'
    version = '1.0'
}

project(':api') {
    configurations {
        spi  //声明一个依赖配置（dependency configurations）
    }
    dependencies {
        compile project(':shared') //声明库依赖：编译时依赖于shared工程
    }
    task spiJar(type: Jar) {
        baseName = 'api-spi'
        dependsOn classes
        from sourceSets.main.output
        include('org/gradle/sample/api/**')
    }
    //声明产出构件
    artifacts {
        spi spiJar
    }
}

project(':services:personService') {
    dependencies {
        compile project(':shared') //声明库依赖
        compile project(path: ':api', configuration: 'spi') //声明库依赖，并指定配置
        testCompile "junit:junit:4.12", project(':api')
    }
}

如果要禁止依赖工程的构建，可以使用gradle命令的

-a

Gradle自带了很多插件，这些插件可以完成不同领域的构建任务。Gradle从一开始就很好的支持Java的构建，支持编译、打包、单元测试都构建动作。 

类似与Maven，Gradle的Java插件也是遵从“约定优于配置”的理念，因而Java插件生成了类似Maven的工程结构。

要添加Java插件的支持，在build.gradle中需要声明：

apply plugin: 'java'

1. 自动设置src/main/java为Java源码目录，src的其它子目录布局和Maven一致
2. 自动添加若干可用的Task，运行

   gradle tasks

    可以看到这些Task的详细说明

下表列出Java插件提供的常用任务：

与Maven类似，默认有src/main|test/java|resourcs目录，其它源码集存放在：

src/sourceSetName/java

src/sourceSetName/resources

sourceSets {
    main {
        java {
            srcDir 'src/java'
        }
        resources {
            srcDir 'src/resources'
        }
    }
}

Gradle维护一个和Maven Repository类似的依赖库，默认位于

%USERPROFILE%/.gradle/caches/

repositories {
    mavenCentral()
}

使用下面的方式声明当前工程的依赖库：

dependencies {
    compile group: 'commons-collections', name: 'commons-collections', version: '3.2'
    testCompile group: 'junit', name: 'junit', version: '4.+'
}

Java插件默认给工程添加了很多属性，通过命令

gradle properties

sourceCompatibility = 1.5
version = '1.0'

也可以在jar的manifest中添加属性：

jar {
    manifest {
        attributes 'Implementation-Title': 'Gradle Quickstart',
                   'Implementation-Version': version
    }
}

或者在测试阶段添加一个系统属性：

test {
    systemProperties 'property': 'value'
}

可以声明把构建结果发布到仓库中，下面示例了如何发布到本地目录：

uploadArchives {
    repositories {
       flatDir {
           dirs 'repos'
       }
    }
}

添加插件：

apply plugin: 'eclipse'

gradle eclipse

Annotation processing是Java 1.5引入的功能，允许在编译期进行代码检查、代码生成等操作。

要让Gradle能自动调用注解处理器，可以使用net.ltgt.apt插件：

buildscript {
  repositories {
    maven {
      url "https://plugins.gradle.org/m2/"
    }
  }
  dependencies {
    classpath "net.ltgt.gradle:gradle-apt-plugin:0.21"
  }
}

apply plugin: "net.ltgt.apt"

然后，执行gradle build会调用注解处理器。

如果使用Intellij IDEA作为开发工具，可以将插件更换为：

apply plugin: "net.ltgt.apt-idea"

这样，如果注解处理器生成了源代码，这些源代码的目录自动变为source root。

task fatJar( type: Jar ) {
    manifest {
        attributes 'Implementation-Title': project.name,
                   'Implementation-Version': version,
                   'Main-Class': 'cc.gmem.yun.alcm.repository.source.GrpcServer'
    }
    baseName = project.name + '-all'
    from {
        configurations.compile.collect {
            it.isDirectory() ? it : zipTree( it ).matching {
                it.exclude(
                    'META-INF/*.SF', 'META-INF/*.DSA', 'META-INF/*.RSA', 'META-INF/DEPENDENCIES', 'META-INF/INDEX.LIST',
                    'META-INF/LICENSE*', 'META-INF/NOTICE*', 'META-INF/README*'
                )
            }
        }
    }
    with jar
} 

如果你希望把构件安装到Maven本地仓库，则需要此插件：

apply plugin: 'maven'

安装此插件后，可以使用如下任务：

-Dmaven.repo.local=the/path/of/the/folder

需要使用到插件：

apply plugin: 'maven-publish'

publishing {
    publications {
        maven( MavenPublication ) {
            // 源码在哪
            from components.java
            // 发布JavaDocs和源码
            artifact javadocJar
            artifact sourcesJar

            // 编辑POM内容
            pom {
                name = project.group + ":" + project.name
                url = 'https://github.com/grpc/grpc-java'
                afterEvaluate {
                    description = project.description
                }

                scm {
                    connection = 'scm:git:https://github.com/grpc/grpc-java.git'
                    developerConnection = 'scm:git:git@github.com:grpc/grpc-java.git'
                    url = 'https://github.com/grpc/grpc-java'
                }

                licenses {
                    license {
                        name = 'Apache 2.0'
                        url = 'https://opensource.org/licenses/Apache-2.0'
                    }
                }

                developers {
                    developer {
                        id = "grpc.io"
                        name = "gRPC Contributors"
                        email = "grpc-io@googlegroups.com"
                        url = "https://grpc.io/"
                        organization = "gRPC Authors"
                        organizationUrl = "https://www.google.com"
                    }
                }

                withXml {
                    if ( !( project.name in
                        [
                            "grpc-stub",
                            "grpc-protobuf",
                            "grpc-protobuf-lite",
                        ] ) ) {
                        asNode().dependencies.'*'.findAll() { dep ->
                            dep.artifactId.text() in [ 'grpc-api', 'grpc-core' ]
                        }.each() { core ->
                            core.version*.value = "[" + core.version.text() + "]"
                        }
                    }
                }
            }
        }
    }
    // 远程仓库配置
    repositories {
        maven {
                credentials {
                    if ( rootProject.hasProperty( 'pacloudUsername' ) && rootProject.hasProperty( 'pacloudPassword' ) ) {
                        username = rootProject.pacloudUsername
                        password = rootProject.pacloudPassword
                    }
                }
                def releaseUrl = 'https://nexus.pacloud.io/repository/maven-releases/'
                def snapshotUrl = 'https://nexus.pacloud.io/repository/maven-snapshots/'
                url = version.endsWith( 'SNAPSHOT' ) ? snapshotUrl : releaseUrl
            }
        }
    }
}

执行下面的命令，完成打包和发布：

gradle sourceJar
gradle publishToMavenLocal

Gradle提供了Groovy插件：

apply plugin: 'eclipse'
apply plugin: 'groovy'

repositories {
    mavenCentral()
}

dependencies {
    compile 'org.codehaus.groovy:groovy-all:2.3.7'
    testCompile 'junit:junit:4.11'
}

该插件引入了以下任务： 

Groovy工程的目录布局与Java工程类似，新引入src/main/groovy、src/test/groovy目录存放Groovy源码。

如果要改变默认工程目录布局，可以：

sourceSets {
    main {
        groovy {
            srcDirs = ['src/groovy']
        }
    }

    test {
        groovy {
            srcDirs = ['test/groovy']
        }
    }
}

Gradle提供了两个和Web应用相关的插件：

1. War插件：在Java插件的基础上进行扩展，支持构建war包 
2. Jetty插件：允许发布War到Jetty容器

要添加War插件，可以：

apply plugin: 'war'
//注意，该插件会自动引入Java插件

运行

gradle build

War插件引入以下任务：

Web资源，例如JavaScript、CSS、HTML、JSP等，默认存放到src/main/webapp目录中。

War插件引入了两个新的依赖配置：

下面的脚本示例了如何定制War插件的属性：

configurations {
   moreLibs
}

repositories {
   flatDir { dirs "lib" } //把lib目录作为依赖仓库
   mavenCentral()
}
dependencies {
    providedCompile "javax.servlet:servlet-api:2.5"
}

war {
    from 'src/rootContent' // 添加文件集到war中 
    webInf { from 'src/additionalWebInf' } // 添加文件夹到WEB-INF目录下
    classpath fileTree('additionalLibs') // 添加文件夹
    classpath configurations.moreLibs // 添加一个配置到WEB-INF/lib目录下
    webXml = file('src/someWeb.xml') // 拷贝文件为WEB-INF/web.xml
}

Jetty插件继承自War插件，可以通过下面的脚本添加该插件：

apply plugin: 'jetty'

运行

gradle jettyRunWar

Jetty插件引入以下任务：

下面的脚本示例了如何定制Jetty插件的属性：

jetty {
    contextPath '上下文路径，默认war的名称'
    httpPort '监听端口，默认8080'
    stopPort '管理端口'
    stopKey  '要求Jetty停止时，传递给他的key'
}

Gradle是当前Android官方IDE—— Android Studio内置的构建工具，你可以脱离AS，直接通过命令行调用Gradle，完成Android工程的构建。

通过编写构建脚本， 你可以配置Android构建的如下几个方面：

1. 构建变体（Build variants）：可以生成多个不同配置的APK，例如Debug/Release配置，又例如针对不同的体系结构（x86、arm）
2. Android库依赖
3. Manifest条目：可以在构建变体配置中覆盖AndroidManifest.xml中某些元素的取值。如果需要创建多个具有不同应用名称、最小SDK版本要求、目标SDK版本的APK，可以设置Manifest条目。如果有多个Manifest文件，会根据buildType、productFlavor、/main Manifest、library Manifest的优先顺序自动合并
4. 签名：可以指定数字签名参数，在构建过程中对APK进行签名
5. ProGuard：允许配置ProGuard，对APK进行混淆、裁剪和优化

Android Studio区分工程（Project）、模块（两个概念）：

1. 工程：表示一个顶级的Android开发结构（相当于Gradle的根工程），一个工程中可以包含多个模块（相当于Gradle子工程）
2. 模块：表示一个可以独立构建、测试、调试的组件

AS支持以下类型的模块：

1. Android Application Module：包含手机、电视 或手表的程序代码和资源，依赖于Library Module。构建系统为此类模块生成APK归档
2. Android Library Module：可重用的Android程序代码和资源。构建系统为此类模块生成AAR（Android ARchive）归档
3. App Engine Module：包含用于与Google App Engine集成的代码和资源
4. Java Library Module：包含可重用的Java代码。构建系统为此类模块生成JAR归档

AS为工程和每个模块都生成Gradle构建脚本（build.gradle），这些脚本完全遵守Gradle的规范。

Android Studio工程包含了一个Gradle Wrapper，此Wrapper包含一个Gradle jar、一个属性文件、Windows/Linux的Shell脚本。使用Gradle Wrapper可以确保总是运行 

local.properties

可以指定Android工程的依赖，以及所有模块的公共依赖：

//构建本身的依赖配置
buildscript {
    repositories {
        jcenter()
    }
    dependencies {
        //使用特定版本的Gradle
        classpath 'com.android.tools.build:gradle:1.0.1'
    }
}
//针对Android工程和所有模块的依赖配置
allprojects {
   repositories {
       jcenter()
   }
}

每个模块都可以有自己的构建脚本，要对模块启用Android构建的支持，必须应用android插件：

//注意，不得同时应用java插件，会导致构建错误
apply plugin: 'android'
//或者：
apply plugin: 'com.android.application'

可以在构建脚本中覆盖src/main/AndroidManifest.xml中的设置，或者对打包选项进行定制：

android {
    //Android 基本设置
    compileSdkVersion 16
    buildToolsVersion "23.0.2"
    
    //覆盖AndroidManifest.xml中的manifest properties设置
    defaultConfig {
        applicationId "cc.gmem.androidstudy"
        minSdkVersion 15
        targetSdkVersion 16
        versionCode 1
        versionName "1.0"
    }
    //构建类型设置
    //默认情况下，Android插件同时创建两个构建类型：Debug、Release。两者的主要区别是：
    //Debug使用自动创建的密钥签名，而Release版本在构建时不签名
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
        debug {
            debuggable true
            //设置ApplicationId，这样设备上可以同时安装Debug版本和Release版本的APK
            applicationIdSuffix ".debug"
        }
        //从debug衍生一个构建类型
        jnidebug {
            initWith(buildTypes.debug)
            packageNameSuffix ".jnidebug"
            jniDebuggable true
        }
    }
}
//声明一些依赖项
dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    testCompile 'junit:junit:4.12'
    compile 'com.android.support:appcompat-v7:16.+'
}

对于每个新创建的构建类型，Android插件自动创建Task：

assemble<BuildTypeName>

Android插件默认使用如下的工程结构：

如果默认工程结构不能满足需要，可以使用如下脚本定制：

android {
    sourceSets {
        //此闭包修改源码集的默认设置
        main {
            manifest.srcFile 'AndroidManifest.xml' //指定Manif文件名称
            //指定子目录位置
            java.srcDirs = ['src']
            resources.srcDirs = ['src']
            aidl.srcDirs = ['src']
            renderscript.srcDirs = ['src']
            res.srcDirs = ['res']
            assets.srcDirs = ['assets']
        }
        androidTest.setRoot('tests') //把整个androidTest源码集移动到tests目录
    }
}

Android插件自动引入以下Task：

默认的，Debug构建的keystore存放在

$HOME/.android/debug.keystore

android {
    signingConfigs {
        debug {
            storeFile file("debug.keystore")
        }
        //创建新的签名配置
        myConfig {
            storeFile file("other.keystore")
            storePassword "android"
            keyAlias "androiddebugkey"
            keyPassword "android"
        }
    }

    buildTypes {
        foo {
            //应用签名配置
            signingConfig signingConfigs.myConfig
        }
    }
}

The post Gradle学习笔记 appeared first on 绿色记忆.

定位到Window ⇨ Preferences -Groovy进行设置：

1. Groovy Content Assist options... ：可以让代码风格更加Groovy化，根据需要设置
2. Compiler子菜单：可以切换Groovy编译器版本，必须和Groovy运行时依赖的版本保持兼容
3. Formatter子菜单：设置代码格式化规则，可以设置的内容很少：
   1. Position of the opening braces：起始括号是否换行
   2. Remove unnecessary semicolons：移除不必要的分号

<dependencies>
    <dependency>
        <groupId>org.codehaus.groovy</groupId>
        <artifactId>groovy-all</artifactId>
        <version>2.3.7</version>
    </dependency>
    <!-- 如果要支持Project Lombok -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
       <version>1.14.8</version>
    </dependency>
</dependencies>
<build>
    <plugins>
        <plugin>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.1</version>
            <configuration>
                <!-- maven-compiler-plugin 实际不做任何编译工作，它总是把工作委派给真正的编译器，例如javac/groovyc-->
                <compilerId>groovy-eclipse-compiler</compilerId>
                <!-- 如果要支持Project Lombok，添加： -->
                <verbose>true</verbose>
                <compilerArguments>
                    <javaAgentClass>lombok.core.Agent</javaAgentClass>
                </compilerArguments>
                <fork>true</fork>
            </configuration>
            <dependencies>
                <dependency>
                    <groupId>org.codehaus.groovy</groupId>
                    <artifactId>groovy-eclipse-compiler</artifactId>
                    <version>2.9.1-01</version>
                </dependency>
                <dependency>
                    <groupId>org.codehaus.groovy</groupId>
                    <artifactId>groovy-eclipse-batch</artifactId>
                    <version>2.3.7-01</version>
                </dependency>
            </dependencies>
        </plugin>
        <plugin>
            <!-- 为Groovy源文件分配单独的存放目录 -->
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>build-helper-maven-plugin</artifactId>
            <version>1.5</version>
            <executions>
                <execution>
                    <id>add-source</id>
                    <phase>generate-sources</phase>
                    <goals>
                        <goal>add-source</goal>
                    </goals>
                    <configuration>
                        <sources>
                            <source>src/main/groovy</source>
                        </sources>
                    </configuration>
                </execution>
                <execution>
                    <id>add-test-source</id>
                    <phase>generate-test-sources</phase>
                    <goals>
                        <goal>add-test-source</goal>
                    </goals>
                    <configuration>
                        <sources>
                            <source>src/test/groovy</source>
                        </sources>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

将上述内容添加到一个Maven工程的POM中以后，Update Project，该工程自动变为 Groovy Project，工程结构如下：

可以把executie目录绑定到任何阶段，如果不绑定，可以运行命令

mvn gplus:execute

使用下面的POM配置可以包含Groovy脚本到pom.xml中：

<plugin>
    <groupId>org.codehaus.gmavenplus</groupId>
    <artifactId>gmavenplus-plugin</artifactId>
    <version>1.5</version>
    <executions>
        <execution>
            <goals>
                <goal>execute</goal>
            </goals>
        </execution>
    </executions>
    <configuration>
        <scripts>
            <script>
                <![CDATA[
                    //Script content
                ]]>
            </script>
            <!-- 亦可外链脚本文件 -->
            <script>file:///${project.basedir}/src/main/resources/scr.groovy</script>
        </scripts>
    </configuration>
    <dependencies>
        <dependency>
            <groupId>org.codehaus.groovy</groupId>
            <artifactId>groovy-all</artifactId>
            <version>2.3.7</version>
            <scope>runtime</scope>
        </dependency>
    </dependencies>
</plugin>

目标compile附加到Maven声明周期的相应阶段，只需要执行默认的

mvn compile

下面是一个典型的POM配置：

<build>
    <plugins>
        <plugin>
            <groupId>org.codehaus.gmavenplus</groupId>
            <artifactId>gmavenplus-plugin</artifactId>
            <version>1.5</version>
            <executions>
                <execution>
                    <goals>
                        <!-- 添加Groovy源码到Maven的main源码清单，打包source jar时有用 -->
                        <goal>addSources</goal>
                        <!-- 添加Groovy源码到Maven的test源码清单，打包source jar时有用 -->
                        <goal>addTestSources</goal>
                        <!-- 生成main Groovy代码的Java Stub，这些存根随即被加到main源码清单，以便Java编译器可以使用之 -->
                        <!-- 如果不进行Java/Groovy混合编程，可以忽略这一目标 -->
                        <goal>generateStubs</goal>
                        <!-- 在编译Groovy main源码前，Java main代码会和Stub一起被编译 -->
                        <!-- 编译Groovy main源码 -->
                        <goal>compile</goal>
                        <!-- 移除main存根，因为存根只在编译Java代码时用到，如果不移除，导致souce jar中包含存根代码 -->
                        <goal>removeStubs</goal>
                        <!-- 生成test源码的存根 -->
                        <goal>testGenerateStubs</goal>
                        <!-- 编译test源码，与main源码类似 -->
                        <goal>testCompile</goal>
                        <!-- 移除test存根 -->
                        <goal>removeTestStubs</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-source-plugin</artifactId>
            <version>2.4</version>
            <executions>
                <execution>
                    <id>attach-sources</id>
                    <goals>
                        <!-- 使用该目标，防止Groovy源码和Java Stub都被包含到source jar -->
                        <goal>jar-no-fork</goal>
                        <goal>test-jar-no-fork</goal>
                    </goals>
                </execution>
            </executions>
            <configuration>
                <!-- 添加下面的配置以支持JDK 1.7+的InvokeDynamic特性，但是目标JVM必须为JDK 1.7+-->
                <invokeDynamic>true</invokeDynamic>
                <!-- 可以使用Groovy配置脚本（configuration script）-->
                <configScript>config.groovy</configScript>
            </configuration>
        </plugin>
    </plugins>
</build>
<dependencies>
    <dependency>
        <groupId>org.codehaus.groovy</groupId>
        <artifactId>groovy-all</artifactId>
        <version>2.3.7</version>
    </dependency>
</dependencies>

如果是纯粹的Groovy工程，不包含Java代码，可以这样配置Goal：

<goals>
    <goal>addSources</goal>
    <goal>addTestSources</goal>
    <goal>compile</goal>
    <goal>testCompile</goal>
</goals>

要为Android平台编译Groovy，只需要指定适用于该平台的Groovy的JAR即可：

<dependency>
      <groupId>org.codehaus.groovy</groupId>
      <artifactId>groovy</artifactId>
      <version>2.4.4</version>
      <classifier>grooid</classifier>
</dependency>

如果你的Groovy源码不使用标准的.groovy扩展名，或者不存放在src/[main|test]/groovy目录下，必须通知GMavenPlus：

<configuration>
    <sources>
        <source>
            <directory>${project.basedir}/src/main/groovy</directory>
            <includes>
                <include>**/*.groovy</include>
            </includes>
        </source>
        <source>
            <directory>${project.basedir}/src/additional</directory>
            <includes>
                <include>groovy/**/*.groovy</include>
                <include>gvy/**/*.gvy</include>
            </includes>
        </source>
    </sources>
    <testSources>
        <testSource>
            <directory>${project.basedir}/src/test/groovy</directory>
            <includes>
                <include>**/*.groovy</include>
            </includes>
        </testSource>
    </testSources>
</configuration>

如果可以调试正规化的Groovy类（与Java类一样，遵循存储路径与类全限定名称的对应关系），但是不能调试脚本，可能是因为当前脚本不在Classpath下面。

解决办法：编写脚本时，要进行包声明，例如：

package cc.gmem.study.groovy

The post 基于Eclipse和Maven的Groovy开发 appeared first on 绿色记忆.

Groovy诞生于2004年， 它是可选类型的（optionally typed）动态语言，是最流行的JVM语言之一，比起其它语言，Groovy能够与Java无缝集成、相互调用，这是它的最大优势。

Groovy可以作为脚本语言使用（但是执行时，即便是脚本也会编译为Java类），也可以编译为Java类。在运行时，你只需要把

groovy-all-*.jar

使用Groovy，你可以：

1. 让Java代码更加简洁
2. 自动化重复的任务
3. 使用DSLs（domain-specific languages）进行业务建模
4. 执行即席的脚本任务

Groovy有以下高级特性：

1. 支持闭包（Closures）
2. 支持动态方法（dynamic methods）
3.  为Java平台引入元对象协议（MOP，Meta Object Protocol）

可以到官网下载Groovy运行时，并将安装目录设置为环境变量

GROOVY_HOME

$GROOVY_HOME/bin

1. 预编译模式（Precompiled mode）：使用Groovy编译器——groovyc，把*.groovy编译为*.class文件。并把*.class放置到Classpath下，通过Java的类加载器加载这些类并运行
2. 直接模式（Direct mode）：通过groovy的类加载器，在运行时直接加载*.groovy文件，并动态的生成JVM对象，这种情况下，没有生成.class文件，但是在JVM中是有对应的java.lang.Class实例的

Groovy在源代码级别增强了Java，但是两者的字节码格式是完全相同的。

GDK即Groovy Development Kit，是Groovy对JDK的补充，引入了一些新的类，并为已经现有的一些Java类增强了功能。下面列出GDK的一些特性：

1. 为所有类型引入

   size()

    方法
2. 简化的数据库访问
3. 简化的XML处理

动态性是指在运行时修改程序结构的能力。

Groovy生成的字节码，会在运行时转换为普通的Java类。除非使用特殊的机制影响JVM，那么这些已加载的Java类的结构是无法动态改变的。

Groovy为什么能具有动态语言的特征，是因为其生成的字节码，不是直接调用方法，而是像这样：

getMetaClass().invokeMethod(this, "method", EMPTY_PARAMS_ARRAY)

也就是说，方法调用以反射的方式转给对象的MetaClass进行处理， 这就类似于Cglib等字节码增强工具一样，可以在运行时拦截、重定向、增加/删除方法。

Groovy和Java在语法上的共同点包括：

1. 相同的包处理机制（包括包的声明和import语句）
2. 类和方法的定义（嵌套类除外）
3. 控制结构语句（经典的C风格for循环除外）
4. 操作符、表达式和赋值
5. 异常处理
6. 变量声明
7. 对象实例化，引用和取消引用对象
8. 方法调用

Groovy和Java在语法上的差异点包括：

1. 非静态内部类的实例化语法：
   

   new OuterClass.NonStaticInnerClass( outClassInstance,args )

Groovy还引入了新的语法特性：

1. 通过新的表达式和操作符访问Java对象
2. 更多的对象声明方式
3. 引入新的控制结构
4. 引入新的数据类型、操作符和表达式
5. 顶级表达式中的方法调用的括号可以省略，前提是被调用方法有至少一个参数（这是为了防止与属性访问歧义，该限制可以通过元编程突破）。链式方法调用与该规则配合使用，可以形成自然语言风格，在DSL中常用
6. 作为最后一个入参的闭包，可以放在方法调用括号的外面，这一规则可以和上一条联用
7. 方法重载发生在运行期而非编译期

groovy.lang.* 
groovy.util.* 
java.lang.* 
java.util.* 
java.net.* 
java.io.* 
java.math.BigInteger 
java.math.BigDecimal

上述包和类自动导入，而Java仅仅导入java.lang包。

package cc.gmem.study.groovy
//声明类
class Person
{
    //声明成员变量
    private int id
    //声明一个属性
    String name
    /**
     * GroovyDoc注释
     * @param name 名称
     */
    Person(String name)
    {
        this.name = name
    }
    /* 程序入口点：main方法 */
    static main(args)
    {
        //方法调用的括号，在不引起歧义的前提下可以省略
        System.out.println  'Groovy'  //字符串可以用单引号界定

        // 多个参数
        httpRequest "https://blog.gmem.cc", "application/json"
        // 命令参数
        httpRequest url: "https://blog.gmem.cc",
                    acceptType:"application/json"

        1.equals( 1 )  //万物皆对象

        //断言
        assert 1 == 1  // ==调用equals()方法进行判断，而不是比较对象地址
        xx = 1  // 如果局部变量xx不存在，等价于this.xx = 1
        //def用于声明“动态类型”
        def x = 1
        //打印变量的值
        println x

        def person = new Person('Alex')
        person.setName( 'Alex Wong' ) //getter/setter直接可以用，不需要编写方法
        person.name = 'Alex Wong' //与上面效果一样，会访问setter而不是直接访问属性

        def sls = '单引号字符串等价于java.lang.String'
        char a = 'x'  //字符类型必须静态声明，或者  'x' as char
        //groovy.lang.GString：双引号字符串中的占位符可以动态解释，在必要时，Groovy可以在GString和String之间进行转换
        println "Hello $person.name" //占位符以$开始，支持属性导航，可以使用${}形式，{}中可以是任何表达式
        def mls = '''多行
字符串'''

        //语言级别的正则式支持
        // =~表示查找操作符
        assert person.name =~ /\sWong/  //斜线界定的字符串，表示不转义反斜杠（\），在正则式中特别有用
        assert 'Alex Wang' == person.name.replaceAll( /Wong/, 'Wang' ) //替换

        //java.math.BigInteger、java.math.BigDecimal直接量
        def bigInt = 1000g
        def bigDec = 1000.01g

        //列表直接量
        def roman = ['', 'I', 'II', 'III', 'IV', 'V', 'VI', 'VII']
        assert roman[4] == 'IV' //数字索引语法访问元素
        roman[8] = 'VIII' //自动扩展列表

        //映射（字典直接量）
        def http = [
            100 : 'CONTINUE',
            200 : 'OK',
        ]
        assert http[200] == 'OK'
        http[400] = 'BAD REQUEST' //动态插入键值对

        //语言级别的范围（range）支持
        def range = 1..10
        assert range.contains(5)
        assert range.contains(15) == false
        assert range.size() == 10
        assert range.from == 1
        assert range.to == 10
        assert range.reverse() == 10..1

        //闭包支持，闭包是花括号限定的代码块，其入参列表以 ->结束
        def c = {el ->  println el }
        [1, 2, 3].each (c)
    }
}

"Alex Wong" - 'Alex ' == 'Wong'

自己实现操作符重载时，可以重载上述方法，以便针对具体类型实现二元操作符，例如： 

class Currency
{
    int rate
    int amount
    Currency(int rate,int amount)
    {
        this.rate = rate
        this.amount = amount
    }

    Currency plus(Currency c)
    {
        //注意这里体现了Groovy的类型转换原则：返回一个更一般的类型
        def add = (amount + c.amount*c.rate / rate) as int
        return new Currency(rate, add)
    }
    Currency plus(Integer c)
    {
        return new Currency(rate, amount + c)
    }
    @Override
    public String toString()
    {
        return amount
    }
}

def usd = new Currency(6, 60 )
def cny = new Currency(1, 60 )
println usd + cny
println usd + 60

Groovy在语言层面支持一套数据类型，包括字符串、正则式、数字、范围、列表、映射等。此外，不像Java，Groovy不存在所谓基本类型。 

在groovy中，万事万物皆对象，这与Java不同，后者包含若干基本类型（int/double/char/byte），基本类型是专有类型，其它类型是引用类型。 这些专有类型：

1. 其变量存放了数据本身，而不是数据的地址
2. 不能应用面向对象的编程风格——方法调用、属性导航。不能从java.lang.Object继承方法
3. 能应用多种运算符，而对应的引用类型则基本不能应用这些运算符

Groovy扩展了Java数字类型的直接量表示：

612g,1106G

3.14, 6.02E23, 94605.56G

Groovy调用Java方法时，数字类型的拆装箱完全自动进行。

Groovy的变量声明可以没有类型信息，以

def

def dynaVar = 10G
//改变对象类型
dynaVar = "$dynaVar"

//如果声明为静态类型，则不能改变
BigDecimal bd = 10G
bd = "" // 报错：Cannot cast object '' with class 'java.lang.String' to class 'java.math.BigDecimal'

Groovy引入了

groovy.lang.GString 

1. 单引号包围的字符串：不支持占位符替换，相当于Java的字符串。如果要表示

   char

    类型，则必须静态声明或者使用

   as

    操作符Cast
2. 双引号包围的字符缓存：支持占位符变量替换，占位符形式为：

   $varName

    或

   ${obj.propName}

    
3. 三引号包围的字符串：支持多行。如果是三个双引号，则支持占位符替换
4. 斜杠包围的字符串：不需要对反斜杠进行转义，主要用于正则式

Groovy为字符串引入了一些新方法，包括：

toInteger, toLong, toFloat, toDouble

可以对字符串进行追加、修改等操作：

greeting = 'Hello'
greeting <<= ' Groovy' //可以对字符串进行内容追加
//追加后自动转换为StringBuffer
assert greeting instanceof java.lang.StringBuffer
greeting << '!'
assert greeting.toString() == 'Hello Groovy!' //不会自动转回String，因此需要调用toString()
greeting[1..4] = 'i' //可以用这种语法替换范围指定的子串
assert greeting.toString() == 'Hi Groovy!'

Groovy引入了三个操作符，专用于正则式处理 

下面是一些示例代码：

import java.util.regex.Matcher;

def pattern = /W.ng/
def name = 'Alex Wong Wang'
def lname = 'Wang'

//完整匹配，返回值是一个Boolean对象
matcher =  lname ==~ pattern
assert matcher instanceof Boolean

//子串匹配，返回值是一个matcher对象
matcher = ( name =~ pattern )
assert matcher instanceof Matcher
//支持使用索引语法访问匹配的子串
assert matcher[0] == 'Wong'
assert matcher.count == 2

//预编译正则式
pattern = ~/W.ng/
pattern.matcher( 'Alex Wong' )[0]

Groovy中的数字处理更加直观和符合预期，例如

1/2

在Groovy中，

+ - *

1. 如果有一个数为Float或者Double，那么结果是Double
2. 否则，如果一个操作数为BigDecimal，结果为BigDecimal
3. 否则，如果一个操作数为BigInteger，结果为BigInteger
4. 否则，如果一个操作数为Long，那么结果为Long
5. 否则，结果为一个Integer

对于

/

1. 如果任何一个数是Float（或者Double）类型，那么运算结果为Double类型
2. 否则，结果为BigDecimal类型，精度以两个数的精度值较大的为准，采用四舍五入的方式，结尾没有无效的0
3. 整数除法可以使用

   as

    转换，或者使用

   intdiv()

    方法

当运算结果超过类型表示范围后，不会自动提升类型，幂运算除外。幂运算根据需要依

Integer,Long,Double

 Groovy引入一个groovy.lang.Range类，表示一个连续的对象范围，并在语法级别上支持范围的直接量：

left = 0
right = 10
Range r = left..right
r = (left..right)
//小于号表示右排除范围，即范围不包含right这个值
r = (left..<right)
//起始值大于结束值的范围称为“反向范围”
r = 10..0

范围的元素不一定是数字。 日期、字符也可以：

assert ('a'..'d').size() == 4

def today = new Date()
def tomorrow = today + 1
assert (today..tomorrow).size() == 2

Range的

toList()

可以使用下面的方式遍历Range：

//遍历Range
for ( day in today..tomorrow) println day
//使用闭包遍历
(today..tomorrow).each { day -> println day }

Groovy把Java数字和List的优点融合到了一起：基于索引的操作、动态增减元素。Groovy在语法上修改了List直接量的声明方式：

list = [1, 2, 3]

 Groovy缺省使用的List实现是

java.util.ArrayList

[]

list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
//基于Range的范围访问
assert list[2..4]  == [2, 3, 4] //getAt
//基于索引集合的访问
assert list[2, 3, 4]  == [2, 3, 4]

list[2..4]  = [2, 3, 4] //setAt 设置元素
list[5..9] = []  //移除元素
println list // [0, 1, 2, 3, 4]
list[1..<1] = [9, 9, 9] //在索引1上插入多个元素
println list // [0, 9, 9, 9, 2, 3, 4]

List支持多种操作符：

list = []
list += 1 // [1]
list += [2, 3] // [1, 2, 3]
list << 4 << 5 // [1, 2, 3, 4, 5]
list -= [1, 2, 3, 4] // [5]
list * 3 // [5, 5, 5]

与List类似，Groovy也从语法上支持Map。和其它语言使用的花括号不同，Groovy用方括号界定Map：

map = [
    'Alex' : 'Wong',
    'Meng' : 'Lee'
]

如果要声明一个空的Map，使用

[:]

assert ['a':1] == [a:1]

除了数组语法外，还可以使用点号导航来访问Map元素：

myMap = ['a.b':1] 
assert myMap.'a.b' == 1

所谓闭包（Closure），就是绑定了上下文中变量的匿名函数。闭包在很多语言中都可以见到，但是在Java领域，直到Java 8才通过Lambda语法提供闭包特性。Groovy引入

groovy.lang.Closure

list = [1, 2, 3]
counter = 0
// 闭包语法： {入参列表 -> 语句列表}
Closure  c = {val -> counter++; ++val} //闭包的最后一个表达式，作为默认的返回值，任何时候可以显式的return
list.each c

// 匿名的闭包
list.each {val -> ++val}
// 小箭头也可以省略
def c = { println it }

// 作为参数的闭包，可以使用注解说明其入参类型，这些注解主要供IDE的智能提示
static int shell(@ClosureParams( value = SimpleType.class, options = "java.io.Reader" ) Closure stdoutReader){}
// 多参数闭包入参类型提示
class Lists {
  static <T,U> List<T> randomInstances(List<U> listToIterate, final Builder<T> builder, 
        @ClosureParams(value = FromString, options = ["T,U", "T"]) final Closure<T> postProcessor = null) {
    }
  }
}

// 闭包的返回值，可以在其泛型参数中声明
public abstract class Closure<V> extends GroovyObjectSupport{}

注意，闭包具有访问上下文中变量的能力（上面第4行），这意味着上下文变量以引用的形式（而不是值）传递给闭包。特别是，即使上下文变量的Scope已经终结，被闭包引用的那些变量依然存在：

def genCloseure(){
    def i = 10
    return {println i++}
}
def c = genCloseure() //i作为局部变量，正常情况下应该在调用完毕即销毁
c() // 10，i还存活着
c() // 11

在闭包中，关键字：

1. this

    表示声明闭包的对象或者类

2. owner

    表示直接包含闭包的对象或类

3. delegate

    默认值为owner，该变量用于重新定位闭包体中引用的上下文变量，将它们解析为自己的属性/方法

下面的例子说明这三者的关系：

package cc.gmem.study.groovy
def cc = { // 外层闭包
    return {  // 内层闭包
        if (printhis){
            println this      //当前对象cc.gmem.study.groovy.GroovyStudy@4485af5c
            println owner     //外层闭包cc.gmem.study.groovy.GroovyStudy$_run_closure1@15b734b
            println delegate  //默认就是owner，可以运行时替换
        }else{
            println name      //自动解析的上下文变量
        }
    }
}
def c = cc()

printhis = true
c()
printhis = false

// 修改delegate对象
c.delegate = [name : 'DelegateObject']
c() // 打印DelegateObject
c.name = 'InnerClosure' //设置内层闭包的属性
/**
 * 下面两行打印：
 * name of inner closure is InnerClosure
 * name of enclosing closure is InnerClosure
 * name of current object is InnerClosure
 * 可以看到，设置闭包的xxx属性，那么owner.xxx也被设置，且这一过程会递归进行
 * 在闭包里，this.xxx和owner.xxx是同义词，但是this和owner则可能不是一个对象
 */
println "name of inner closure is $c.name"
println "name of enclosing closure is $cc.name"
println "name of current object is $name"

c() // 打印InnerClosure

设置闭包的

resolveStrategy

1. OWNER_FIRST

    ：默认，优先搜索owner

2. OWNER_ONLY

    ：仅搜索owner

3. DELEGATE_FIRST

    ：优先搜索delegate

4. DELEGATE_ONLY

    ：仅搜索delegate

5. TO_SELF

    ：owner、delegate都不搜索

当然，你随时可以使用

this

owner

delegate

1. 当前闭包自己定义的局部变量优先级最高
2. 定义了当前闭包的函数/闭包——即owner——其局部变量的优先级次之。这是闭包的重要特点：在声明时绑定（back reference）owner定义的局部变量
3. 多层函数/闭包嵌套时，越外层的局部变量，优先级越低
4. 找不到局部变量，则在this、owner、delegate等上下文对象中寻找属性

如果闭包只有一个参数，那么不需要显式声明，Groovy允许使用

it

可以把对象方法（不支持静态方法）作为闭包引用：

def closure = reference.&methodName

//方法闭包限制在实例方法上
class Lad{
    def sayHello(){
        sayHello('Hello')
    }
    def sayHello(def hello){
        println hello
    }
}
def c = new Lad().&sayHello //c引用哪个方法在此并不确定

// 运行时重载示意：
// 闭包支持直接“调用”，这又是操作符重载的威力。相比之下Java 8 Lambda则不能直接“调用”
c()     // 零参版本
c('Hi') // 一参版本

Groovy为闭包提供了以下重要方法：

def add = {x, y -> return x + y}
def addOne = add.curry( 1 ) //绑定第一个参数
println addOne(100) // 101

def i = 10
switch(i)
{
    //闭包作为分类器
    case { it%2 == 0 }: println true; break
}

在Groovy中可以和Java一样，声明和使用注解。下表列出重要的内置注解：

注解	说明
@Immutable	标记一个类型为不变类型：为class和所有字段添加final标记，对于那些本身可变的对象，Groovy会强制defensive copying。例如： import groovy.transform.Immutable @Immutable class ClassRoom { Map<Integer,String> students = new HashMap(); } ClassRoom cr = new ClassRoom(); //Caught: java.lang.UnsupportedOperationException cr.students.put( 020, "Alex Wong" );
@Grab	在脚本中显式的声明依赖，使其自包含。 @Grab('commons-lang:commons-lang:2.4') import org.apache.commons.lang.ClassUtils  IDE或者Maven、Ivy等工具负责识别和定位依赖
@Category	用于声明一个Category，注解参数说明this指向的类型： @Category(Integer) class IntegerMarshal { String marshal() { toString() } } use (IntegerMarshal) { assert 1.marshal() == "1" }
@Mixin	轻松的把其他类定义的方法添加到某个类中： @Mixin(MessageFeature) class Test { void testWithMixinUsage() { send "Called from Test" } } class MessageFeature { void send(String msg) { } } 该特性自2.3开始已经废弃，由 trait  代替
@Delegate	自动添加被代理对象的全部行为到当前类： class CountingList { int counter = 0 //获得list的全部行为，即，默认的把所有调用转发给list @Delegate LinkedList list = new LinkedList<>() //覆盖下面的行为 boolean addAll(Collection<? extends E> c) { counter += c.size() list.addAll(c) } boolean addAll(int index, Collection<? extends E> c) { counter += c.size() list.addAll(index, c) } } 在实现装饰、代理等模式时，可以避免写大量重复性代码

需要注意的是，在if语句中，赋值不能作为顶级表达式。这样会导致编译错误：

def var ; if( var = 1 ){}

但是，Groovy优雅的增强了Java中的switch-case语句。其引入了灵活分类器机制——任何实现了

isCase()

case

switch (candidate)
{
    case classifier1 : handle1() ; break
    case classifier2 : handle2() ; break
    default : handleDefault()
}
//上面的语句等价于：
if (classifier1.isCase(candidate)) handle1() 
else if (classifier2.isCase(candidate)) handle2() 
else handleDefault()

只要isCase()返回true，那么当前case就匹配。Groovy中下面的类实现了isCase()： 

Groovy中没有Java的

do{}while(condition)

for(;;)

while(condition)

for (variable in iterable) { body }

def list = [0, 1, 2, 3, 4]

//while循环，注意任何对象都可以作为测试条件
while(list) list.remove( 0 ) //移除直到为空
//for循环
for(item in list) println item 

//下面的for循环与Java的for(int i = 0;i < 10; i++)类似
for(i in 0..<10) println i

//基于闭包的循环
(0..<10).each { println it }

在Groovy中，文件和类声明的关系不像Java那样的固定。一个Groovy文件可以包含多个public类声明：

1. 如果.groovy文件中不包含类声明，它被作为脚本处理。Groovy会生成一个名称与文件名一致的Script类，脚本内容被包含在

   run()

    方法中，并且新建一个main方法调用之
2. 如果.groovy文件中只包含一个类声明，并且起名称与文件名相同，那么和Java一样，具有一一对应关系
3. 如果.groovy文件中包含多个不同访问限定符的类，Groovy会分别生成.class
4. 如果.groovy文件中混合了脚本和类声明，脚本代码将变成和文件同名的类被执行。此时声明的类不应当和文件同名

import javax.lang.*
//使用import as可以定义别名，别名可以避免名字冲突，或者避免不合理的名字
import java.lang.AssertionError as AErr 

Groovy的类声明语法和Java很类似，但是需要注意：

1. 属性、本地变量在使用前必须声明（注意在Groovy脚本中这不是必须的）
2. 支持Java的访问限定符

   private protected public

    ，如果不加限定符：
   1. 对于成员变量，默认限定符为

      private

      ，Groovy会自动生成Getter/Setter方法
   2. 对于成员方法，默认作为

      public

       的
3. 成员变量或者方法返回值可以声明为动态类型，使用关键字def
4. 静态变量或者方法返回值可以声明为动态类型，使用关键字static
5. 方法参数的类型是可选的，如果不指定，默认Object
6. 方法参数可以提供默认值
7. 方法参数可以声明为单个Map，调用时使用命名参数方式传递

下面是一个类定义的例子：

package cc.gmem.study.groovy
class Person
{
    def name
    def age
    //构造器
    Person(name = 'Alex', age = 29) //参数默认值
    {
        this.name = name
        this.age = age
    }
    def listArgs(List l){ }
    def namedArgs(Map m){ }
}

这里我们使用前面定义的新类：

def p = new Person()
p.namedArgs( key1 : 0, key2 : 1 ) //命名参数方式传参
p.listArgs( [1, 2, 3])
p.listArgs() //任何参数都是可选的

 在Groovy中，对象属性/方法的访问，可以使用点号导航或者下标语法，甚至，点号导航中可以使用变量：

def methodName = 'listArgs'
new Person()."$methodName"()."$methodName"()

构造Groovy对象，除了使用Java的构造器调用外，还有更多方式：

//as关键字进行强制转型列表为对象，列表为构造器入参
Person p = ['Alex', 29] as Person
//使用命名参数的方式访问构造器
p = new Person(age : 29, name : 'Alex')
//隐式构造
Person p = ['Alex', 29]

在进行多级点号导航的访问时，一旦路径上的对象为null，就会导致NullPointerException（NPE）的出现。在Java中这需要很繁琐的处理，在入参规格无法确定的情况下，方法实现者可能需要进行多次空指针检查。

Groovy引入特殊的操作符

?.

class Contact{
    class Address{
        class Tel{
            def zoneCode
        }
        Tel tel
    }
    Address address 
}
def c = new Contact()
assert c?.address?.tel?.zoneCode == null

Groovy完整的支持Java的继承和接口机制，并且两者的代码可以几乎完美的交互。

但是Groovy提供了更加动态的能力，你可以把Map或者Closure强制转型为目标接口：

interface Person
{
    def sayHello(String content);
}
interface Greeter extends Person
{
    def getName();
}
// 对于单方法接口，可以从Closure转型得到
Person p = { content -> println content } as Person
// 对于多方法接口，可以从Map转型得到
Greeter g = [
    sayHello : { content -> println content },
    getName : { 'Alex' }
] as Person

// 注意：仅仅调用的方法才需要实现，其它方法不实现也不影响编译

trait用于代替旧的Mixin机制，实现（而不是仅仅像接口那样声明）可共享的、可组合的行为，和Java 8 的Default method类似：

trait HasId
{
    long id
}
trait HasVersion
{
    long version
}
trait Persistent
{
    boolean save()
    {
        println "saving ${this.dump()}"
    }
}
//trait与接口很类似，但是它可以包含字段、方法实现
trait Entity implements Persistent, HasId, HasVersion
{
    //覆盖父trait的行为
    boolean save()
    {
        version++
        Persistent.super.save()
    }
}
//类可以实现trait，就像可以实现interface一样
class Publication implements Entity
{
    String title
}
class Book extends Publication
{
    String isbn
}

我们知道，Java的重载是静态的——调用哪个重载版本在编译期就确定，依据方法入参的声明类型来决定链接到哪个方法：

public class HelloJava
{
    public void m( Object o )
    {
        System.out.println( "Object" );
    }

    public void m( String s )
    {
        System.out.println( "String" );
    }

    public static void main( String[] args )
    {
        HelloJava hj = new HelloJava();
        Object o0 = new Object();
        Object o1 = new String();
        hj.m( o0 ); //Object
        hj.m( o1 ); //Object
    }
}

Groovy在这一点上与之完全相反，重载方法的选择是依据变量的运行时类型，动态决定的：

class HelloGroovy
{
    def m( Object o )
    {
        System.out.println( "Object" );
    }

    def  m( String s )
    {
        System.out.println( "String" );
    }

    static  main( String[] args )
    {
        HelloGroovy hg = new HelloGroovy();
        Object o0 = new Object();
        Object o1 = new String();
        hg.m( o0 ); //Object
        hg.m( o1 ); //String
    }
}

前面已经提到过，Groovy会默认访问限定符的实例变量自动生成getter/setter。另外需要注意：

1. 在类外部，

   ref.fieldName

    会自动映射为getter/setter调用，要想规避这一点，必须使用特殊操作符：

   ref.@fieldName

    
2. 在类内部，

   ref.fieldName

    直接访问字段

任何类都可以实现

getProperty(name)

setProperty(name,value)

类似于Xpath，Gpath是Groovy语言强大的对象导航结构，它引入一个展开点操作符：

*.

对于列表来说：

list*.property

list.collect{ item -> item?.property }

println this //当前类：HelloGroovy@14a2f921
println this.class //调用getClass()：class HelloGroovy
println this.class.methods //调用getClass().getMethod()：很长的一个list
//*.操作符，对集合的每个元素调用.name
println this.class.methods*.name
//上述*.操作符可以简写为.
println this.class.methods.name

println this.class.methods.name.grep(~/get.*/).sort() //[getBinding, getClass, getMetaClass, getProperty]

可以使用

*

def sum (a,b,c)
{
    a + b + c
}
assert 6 == sum( *[1, 2, 3])

def range = (1..3)
assert [0, 1, 2, 3] == [0, *range]

def map = [a:1,b:2] 
assert [a:1, b:2, c:3] == [c:3, *:map]

Groovy为Object类添加了一个

use()

class StringPlusCategory
{
    static def plus(String self, String operand)
    {
        return self.toInteger() + operand.toInteger()
    }
}
assert '33' == '3' + '3'
//临时改变String的+操作符的行为
use(StringPlusCategory) 
{ 
    assert 6 == '3' + '3' 
}

assert '33' == '3' + '3'

需要注意的是，use导致的扩展/修改是临时的，不会产生全局性的影响。 

如果一个链式调用（chain-of-method）类似：

link(producer).to(consumer)

则Groovy允许你将其编写为：

link producer to consumer

move(10, forward).painting(color:blue)
//支持多参数调用，支持命名参数
move 10, forward painting color:blue

Groovy还允许把作为最后一个入参的闭包置于括号外面，有时可以达到很奇特的效果：

def when(expr,closure)
{
    if(expr) closure()
}

//这里好像我们自己发明了新的控制结构一样
when(true)
{
    println 'OK' ;
}

所谓动态编程，是指在运行时修改对象结构（添加状态、改变行为）的编程风格，是动态语言的优势所在。

当Groovy调用方法时，它不会直接调用，而是总是把调用请求转交给一个中间层——MOP——处理。MOP由相应的API定义。其一系列规则，这些规则限定了：

1. Groovy运行时如何处理方法调用请求
2. 如何控制中间层

为了寻找正确的目标方法，MOP需要很多信息，这些信息存放在元类中。元类可以在运行时改变或者替换，从而改变对象的行为。

即使不改变元类，Groovy也允许通过一系列钩子方法改变对象的行为。

@TupleConstructor(excludes=['lastName'])
class Person {
    String firstName
    String lastName
}

class SomeBean {
    @IndexedProperty String[] someArray = new String[2]
    @IndexedProperty List someList = []
}

def bean = new SomeBean()
bean.setSomeArray(0, 'value')
bean.setSomeList(0, 123)

class SomeBean {
    @Lazy LinkedList myField
}

// 等价于
List $myField
List getMyField() {
    if ($myField!=null) { return $myField }
    else {
        $myField = new LinkedList()
        return $myField
    }
}

@Newify([Tree,Leaf])
class TreeBuilder {
    Tree tree = Tree(Leaf('A'),Leaf('B'),Tree(Leaf('C')))
}

@Newify([Tree,Leaf])
class TreeBuilder {
    Tree tree = Tree.new(Leaf.new('A'),Leaf.new('B'),Tree.new(Leaf.new('C')))
}

@Builder(builderStrategy=SimpleStrategy)
class Person {
    String first
    String last
    Integer born
}
def p1 = new Person().setFirst('Johnny').setLast('Depp').setBorn(1963)


@Builder(builderStrategy=SimpleStrategy, prefix="")
class Person {
    String first
    String last
    Integer born
}
def p = new Person().first('Johnny').last('Depp').born(1963)

这些注解用于简化设计模式的实现。

注解	说明
@groovy.transform.BaseScript	指定脚本需要继承自特定的自定义脚本，而非groovy.lang.Script
@groovy.lang.Delegate	代理模式： class Event { // 生成一个Date when字段，并将对Date方法的调用转发给when @Delegate Date when String title }
@groovy.transform.Immutable	实现不变模式
@groovy.transform.TailRecursive	将尾递归转换为迭代风格，避免栈过深
@groovy.lang.Singleton	实现单例模式： @Singleton class GreetingService { String greeting(String name) { "Hello, $name!" } } assert GreetingService.instance.greeting('Bob') == 'Hello, Bob!'

class Counter {
    int cpt
    @Synchronized
    int incrementAndGet() {
        cpt++
    }
}

// 生成
class Counter {
    int cpt
    private final Object $lock = new Object()

    int incrementAndGet() {
        synchronized($lock) {
            cpt++
        }
    }
}

@Field def x

@Grab(group='org.springframework', module='spring-orm', version='3.2.5.RELEASE')
import org.springframework.jdbc.core.JdbcTemplate

@Grab('org.springframework:spring-orm:3.2.5.RELEASE')

@GrabResolver(name='restlet', root='http://maven.restlet.org/')

@GrabConfig(systemClassLoader=true)
@Grab(group='mysql', module='mysql-connector-java', version='5.1.6')

class Pretender
{
    Object methodMissing(String name, Object arguments){
        println "Method $name called"
    }
}
def p = new Pretender();
p.hello()

def propertyMissing(String name)
{
    int result = 0
    name.each
    {
        result <<= 1
        if (it == 'I') result++
    }
    return result
}
assert IIOI + IOI == IOOIO

通过把逻辑委托给一个闭包，可以针对一个对象实例（而不是类），在运行时动态修改逻辑：

class DynamicPretender
{
    Closure whatToDo = { name -> "accessed $name"} //默认钩子实现
    def propertyMissing(String name)
    {
        whatToDo(name)
    }
}
def one = new DynamicPretender()
assert one.hello == 'accessed hello'
//修改钩子实现
one.whatToDo = { name -> name.size() }
assert one.hello == 5

所有由Groovy类都实现了下面的接口（继承了

GroovyObjectSupport

public interface GroovyObject
{
    Object invokeMethod(String methodName, Object args);
    Object getProperty(String propertyName);
    void setProperty(String propertyName, Object newValue);
    MetaClass getMetaClass();
    void setMetaClass(MetaClass metaClass);
}

任何该接口的子类，都遵守下面的规则：

1. 对其属性的访问，委托给getter/setter
2. 对任何不存在的方法的调用，委托给invokeMethod()
3. 如果子类实现了GroovyInterceptable，那么对任何方法的调用委托给invokeMethod()

缺省适配

GroovyObjectSupport

public Object invokeMethod(String name, Object args)
{
    return getMetaClass().invokeMethod(this, name, args);
}

class NoParens
{
    def getProperty(String propertyName)
    {
        if (metaClass.hasProperty(this, propertyName))
        {
            return metaClass.getProperty(this, propertyName)
        }
        invokeMethod propertyName, null
    }
}
class PropUser extends NoParens
{
    boolean existingProperty = true
}

def user = new PropUser()
assert user.existingProperty
//现在可以免括号调用0参方法了
assert user.toString() == user.toString

上面演示的动态编程方式，都是“侵入性”的——需要修改目标类的源码。Groovy还允许修改元类本身，来实现“非侵入性”的动态编程。

Groovy为任何一个类维护一个元类（metaclass）信息，元类使用类型

groovy.lang.MetaClass

一般情况下，类的所有实例共享一个元类，但是Groovy支持通过

setMetaClass( metaClass )

你可以很容易的和元类交互，例如：

MetaClass mc = String.metaClass
final Object[] NO_ARGS = []
//检查方法的可用性
assert 1 == mc.respondsTo("toString", NO_ARGS).size()
//检查属性、方法的数量
assert 3 == mc.properties.size()
assert 74 == mc.methods.size()
//检查Groovy动态添加的元方法的数量
assert 176 == mc.metaMethods.size()
//调用方法、静态方法、构造器
assert "" == mc.invokeMethod("","toString", NO_ARGS)
assert null == mc.invokeStaticMethod(String, "println", NO_ARGS)
assert "" == mc.invokeConstructor(NO_ARGS)

默认情况下，

getMetaClass()

MetaClassRegistry

Groovy内置了若干元类实现：

1. 默认实现

   MetaClassImpl

    ，大部分情况下使用

2. ExpandoMetaClass

    用于扩展状态和行为

3. ProxyMetaClass

    装饰一个元类，作为拦截器使用
4. 其它内部、测试用的元类

class InspectMe
{
    def method()
    {
    }
}
def tracer = new TracingInterceptor(writer: new StringWriter())

def proxyMetaClass = ProxyMetaClass.getInstance(InspectMe)
proxyMetaClass.interceptor = tracer //设置拦截器

InspectMe inspectMe = new InspectMe()
inspectMe.metaClass = proxyMetaClass //运行时修改元类

inspectMe.method()
println tracer.writer.toString()

为元类添加状态/行为后，元类自动成为

ExpandoMetaClass

assert String.metaClass =~ /MetaClassImpl/
//为元类添加方法
String.metaClass.low = {-> delegate.toLowerCase() } //闭包的delegate自动指定指向当前对象
assert String.metaClass =~ /ExpandoMetaClass/ //元类已经自动修改
assert "ALEX".low() == "alex"

使用

Expando

class Person extends Expando
{}
def person = new Person()
person.name = 'Alex'
person.sayHello = { -> println 'Hello ' + delegate.name }
person.sayHello()

//修改元类，同时添加多个状态/行为
String.metaClass
{
    shift = -1
    low {-> delegate.toLowerCase() }
}
assert "".shift == -1
assert "ALEX".low() == 'alex'

//修改元类，添加静态成员
Integer.metaClass.static.answer = {-> 42}
assert Integer.answer() == 42

The post Groovy学习笔记 appeared first on 绿色记忆.