前言由于项目需要用到 Groovy 语言，这两天对其进行了粗略的学习，本文是对学习做的一个简单总结，主要内容参考于官方文档（Groovy 的官方文档还是非常不错的，强烈推荐阅读），希望本文对准备学习使用或者对 Groovy 感兴趣的同学有所帮助，如有不对之处还望指出哈，对这门语言的理解还是比较肤浅的，接下来我们就来聊聊关于grooving教程?以下内容大家不妨参考一二希望能帮到您!
grooving教程
前言
由于项目需要用到 Groovy 语言，这两天对其进行了粗略的学习，本文是对学习做的一个简单总结，主要内容参考于官方文档（Groovy 的官方文档还是非常不错的，强烈推荐阅读），希望本文对准备学习使用或者对 Groovy 感兴趣的同学有所帮助，如有不对之处还望指出哈，对这门语言的理解还是比较肤浅的。
简介
Groovy 是 Apache 旗下的一门基于 JVM 平台的动态/敏捷编程语言，在语言的设计上它吸纳了 Python、Ruby 和 Smalltalk 语言的优秀特性，语法非常简练和优美，开发效率也非常高（编程语言的开发效率和性能是相互矛盾的，越高级的编程语言性能越差，因为意味着更多底层的封装，不过开发效率会更高，需结合使用场景做取舍）。并且，Groovy 可以与 java 语言无缝对接，在写 Groovy 的时候如果忘记了语法可以直接按Java的语法继续写，也可以在 Java 中调用 Groovy 脚本，都可以很好的工作，这有效的降低了 Java 开发者学习 Groovy 的成本。Groovy 也并不会替代 Java，而是相辅相成、互补的关系，具体使用哪门语言这取决于要解决的问题和使用的场景。
快速开始
1.下载Groovy开发工具包（GDK）
http://www.groovy-lang.org/download.html
2.创建Groovy项目
使用IDEA的话需要安装Groovy的支持插件，安装完成后在新建项目中便会出现Groovy项目选项，选择Groovy项目并关联Groovy libray即可，当然也可以直接创建.groovy文件用命令行直接运行。
3.Hello World
在Java中要输出“hello world”需要像下面这样，创建一个类，然后创建一个main方法。
public class Hello { public static void main(String[] args) { System.out.println("hello world"); } }
在Groovy中，这些都可以省略，下面这4种方式都可以输出“hello world”。
System.out.println("hello world"); System.out.println "hello world"; println("hello world") println 'hello world'
当然，也可以像Java一样运行在类的main方法中。
class Hello { static void main(args) { println 'hello world' } }
如果 Groovy 脚本文件里只有执行代码，没有类的定义，则 Groovy 编译器会生成一个 Script 的子类，类名和脚本文件的文件名一样，而脚本中的代码会被包含在一个名为run的方法中，同时还会生成一个main方法，作为整个脚本的入口。所以，作为 JVM 平台语言，与 Java 本质上还是一样的。
与Java的一些区别
默认导入
Groovy 会默认导入下面这些包、类，不需要使用import语句显式导入。
java.io.* java.lang.* java.math.BigDecimal java.math.BigInteger java.net.* java.util.* groovy.lang.* groovy.util.*
多重方法
在 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); // In Java assertEquals(2, result); // In Groovy assertEquals(1, result);
产生差异的原因在于，Java 使用静态数据类型，o 被声明为 Object 对象，而 Groovy 会在运行时实际调用方法时进行选择。因为调用的是 String 类型的对象，所以自然调用 String 版本的方法。
数组初始化语法
在 Groovy 中，{...} 语句块是留给闭包（closure）使用的，所以不能像 Java 中一样使用下面这种方式初始化数组
int[] array = { 1, 2, 3}
而应该是下面这样
int[] array = [1,2,3]
POJO
Groovy 默认会隐式的创建getter、setter方法，并且会提供带参的构造器，下面两者是等价的。
// In Java public class Person { private String name; Person(String name) { this.name = name } public String getName() { return name } public void setName(String name) { this.name = name } } // In Groovy class Person { String name } def person = new Person(name: '张三') assert '张三' == person.name person.name = '李四' //person.setName('李四') assert '李四' == person.getName()
包访问权限
在 Java 中如果没有显式的指定访问修饰符（public、protected、private）那么默认是包访问权限，但在 Groovy 中默认是public的，所以需要使用@PackageScope注解。
class Person { @PackageScope String name }
ARM 语句块
ARM（Automatic Resource Management，自动资源管理）语句块（或者叫TWR语法）从 Java 7 开始引入，用于降低IO操作代码的复杂度，但 Groovy 并不支持。相反，Groovy 提供多种基于闭包的方法，不但可以达到同样的效果并且会更加简洁优美。
//In Groovy Path file = Paths.get("/User/lihengming/test.txt"); 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(); } //In Groovy new File('/User/lihengming/test.txt').eachLine('UTF-8') { println it } //或者这样，更接近于Java的方式 new File('/User/lihengming/test.txt').withReader('UTF-8') { reader -> reader.eachLine { println it } } //如果只是为了读取并打印出文本的内容的话，下面是最简洁的方式 print new File('/User/lihengming/test.txt').text
内部类
Groovy 同样支持内部类并且实现跟 Java 是一样的，但不应拿 Java 语言规范来考量它，应对差异情况保持冷静与宽容（keep shaking the head about things that are different）。在Groovy中内部类看起来有点类似 groovy.lang.Closure 类的实现。
//静态内部类 class A { static class B {} } new A.B() //匿名内部类 import java.util.concurrent.CountDownLatch import java.util.concurrent.TimeUnit CountDownLatch called = new CountDownLatch(1) Timer timer = new Timer() timer.schedule(new TimerTask() { void run() { called.countDown() } }, 0) assert called.await(10, TimeUnit.SECONDS)
Lambda 表达式
Java 8 支持 Lambda 表达式和方法引用
Runnable run = () -> System.out.println("Run"); list.forEach(System.out::println);
Java 8 的 lambda 几乎可以认为是匿名内部类。Groovy 并没有采用这种语法，而采用闭包来实现。
Runnable run = { println 'run' } list.each { println it } // or list.each(this.&println)
GString
由于双引号所包括起来的字符串字面量会被解释为 GString 值（即 “Groovy 字符串”的简称），所以如果当某个类中的 String 字面量含有美元字符（$）时，那么利用 Groovy 和 Java 编译器进行编译时，Groovy 很可能就会编译失败，或者产生与 Java 编译所不同的结果。
通常，如果某个 API 声明了形参的类型，Groovy 会自动转换 GString 和 String。要小心那些形参为 Object 的 Java API，需要检查它们的实际类型。
字符串和字符字面量
在 Groovy 中，由单引号所创建的字面量属于 String 类型对象，而双引号创建的字面量则可能是 String 或 GString 对象，具体分类由字面量中是否有插值来决定。
assert 'c'.getClass()==String assert "c".getClass()==String assert "c${1}".getClass() in GString
基础语法
- Groovy 语句无需使用分号（;）结尾，当然加上也不会报错，毕竟完全兼容 Java 的语法。
- Groovy 中==等价于 Java 中的equals方法。
注释
注释和 Java 一样，支持单行（//）、多行（/* */）和文档注释（/** */)
除此之外还支持 Shebang line（UNIX系统支持一种特殊的单行注释叫作 Shebang line，用于指明脚本的运行环境，便于在终端中可以直接运行）#号必须是文件的第一个字符。
#!/usr/bin/env groovy println "Hello from the shebang line"
变量
Groovy 中定义变量默认访问修饰符是public，变量定义时遵循 Java 变量命名规范，变量名以字母、下划线或美元符号$开始，可以包含字母、数字、下划线和美元符号$，但关键字除外。除了这些规则之外，Groovy 定义变量时如果是一行定义一个类型，末尾的分号可以省略，但是如果多个变量占一行，变量之间必须以分号分割。
Groovy 定义变量的方式和 Java 是类似的，区别在于 Groovy 提供了def关键字供使用，它可以省略变量类型的定义，根据变量的值进行类型推导。
def a = 123 def b = 'b' def c = true boolean d = false int e = 123
如果定义变量的字面量值为数字时，类型会根据数字的大小自动调整
def a = 1 assert a instanceof Integer // Integer.MAX_VALUE def b = 2147483647 assert b instanceof Integer // Integer.MAX_VALUE 1 def c = 2147483648 assert c instanceof Long // Long.MAX_VALUE def d = 9223372036854775807 assert d instanceof Long // Long.MAX_VALUE 1 def e = 9223372036854775808 assert e instanceof BigInteger
对于浮点型字面量为了精度 Groovy 默认使用的类型为 BigDecimal
def decimal = 123.456 println decimal.getClass() // class java.math.BigDecimal
Groovy为 数字类型提供一种更简单的声明类型的方式：类型后缀
- Integer 使用I或i - Long 使用L或l - BigInteger 使用G或g - BigDecimal 使用G或g - Double 使用D或d - Float 使用F或f
使用例子
def a = 123I assert a instanceof Integer def b= 123L assert b instanceof Long
字符串
在Groovy种有两种字符串类型，普通字符串（java.lang.String）和插值字符串（groovy.lang.GString）。
普通字符串使用单引号
println 'hello'
插值字符串使用双引号
def name = '张三' println "hello $name"
除此之外，还支持三单引号的写法，可以保留文本的换行及缩进格式
def strippedFirstNewline = '''line one line two line three ''' println strippedFirstNewline // 可以写成下面这种形式，可读性更好 def strippedFirstNewline2 = '''\ line one line two line three ''' println strippedFirstNewline2
字符
在 Groovy 中并没有明确的字符字面量表示形式，需要显示的指定，有三种方式
char c1 = 'A' // 声明类型 assert c1 instanceof Character def c2 = 'B' as char // 用as关键字 assert c2 instanceof Character def c3 = (char) 'C' // 强制类型转换 assert c3 instanceof Character
方法（函数）
Groovy 方法的默认访问修饰符是public，方法的返回类型可以不需要声明，但需添加def关键字。有返回值的方法return可以被省略，默认返回最后一行代码的运行结果，如果使用了return关键字则返回指定的返回值。
String method1() { return 'hello' } assert method1() == 'hello'; def method2() { return 'hello' } assert method2() == 'hello'; def method3() { 'hello' } assert method3() == 'hello';
Groovy 方法的参数类型可以被省略，默认为Object类型。
def add(int a, int b) { return a b } //与上面的等价 def add(a, b) { a b }
Groovy 方法的其他特性与Java一样，比如支持重载、不定长参数（...）等。
闭包
Groovy 提供了闭包的支持，语法和 Lambda 表达式有些类似，简单来说就是一段可执行的代码块或函数指针。闭包在 Groovy 中是groovy.lang.Closure类的实例，这使得闭包可以赋值给变量，或者作为参数传递。Groovy 定义闭包的语法很简单，就像下面这样。
//闭包的参数为可选项 def closure = { [closureParameters -> ] statements }
闭包可以访问外部变量，而方法（函数）则不能。
def str = 'hello' def closure={ println str } closure()//hello
闭包调用的方式有两种，闭包.call(参数)或者闭包(参数)，在调用的时候可以省略圆括号。
def closure = { param -> println param } closure('hello') closure.call('hello') closure 'hello'
闭包的参数是可选的，如果没有参数的话可以省略->操作符。
def closure = {println 'hello'} closure()
多个参数以逗号分隔，参数类型和方法一样可以显式声明也可省略。
def closure = { String x, int y -> println "hey ${x} the value is ${y}" }
如果只有一个参数的话，也可省略参数的定义，Groovy提供了一个隐式的参数it来替代它。
def closure = { it -> println it } //和上面是等价的 def closure = { println it } closure('hello')
闭包可以作为参数传入，闭包作为方法的唯一参数或最后一个参数时可省略括号。
def eachLine(lines, closure) { for (String line : lines) { closure(line) } } eachLine('a'..'z',{ println it }) //可省略括号，与上面等价 eachLine('a'..'z') { println it }
Lists
Groovy 定义 List 的方式非常简洁，使用中括号([])，以逗号(,)分隔元素即可。Groovy中的 List 其实就是java.util.List，实现类默认使用的是java.util.ArrayList。
def numbers = [1, 2, 3] assert numbers instanceof List assert numbers.class == java.util.ArrayList assert numbers.size() == 3
Arrays
Groovy 定义数组的语法和 List 非常类似，区别在于数组的定义必须指定类型为数组类型，可以直接定义类型或者使用def定义然后通过as关键字来指定其类型。
String[] arrStr = ['Ananas', 'Banana', 'Kiwi'] //直接声明类型为数组类型 String[] assert arrStr instanceof String[] assert !(arrStr instanceof List) def numArr = [1, 2, 3] as int[] //痛过as关键字指定类型为数组类型 int[] assert numArr instanceof int[] assert numArr.size() == 3
Maps
Groovy 定义 Map 的方式非常简洁，通过中括号包含key、val的形式，key和value以冒号分隔([key:value])。Groovy中的Map其实就是java.util.Map，实现类默认使用的是java.util.LinkedHashMap。
// key虽然没有加引号，不过Groovy会默认将其转换为字符串 def colors = [red: '#FF0000', green: '#00FF00', blue: '#0000FF'] assert colors['red'] == '#FF0000' // 使用中括号访问 assert colors.green == '#00FF00' // 使用点表达式访问 colors['pink'] = '#FF00FF' // 使用中括号添加元素，相当于Java Map 的 put(key,value)方法 colors.yellow = '#FFFF00'// 使用点表达式添加元素 assert colors.pink == '#FF00FF' assert colors['yellow'] == '#FFFF00' assert colors instanceof java.util.LinkedHashMap // 默认使用LinkedHashMap类型 // Groovy Map的key默认语法不支持变量，这里的key时间上是字符串'keyVal'而不是keyVal变量的值'name' def keyVal = 'name' def persons = [keyVal: 'Guillaume'] assert !persons.containsKey('name') assert persons.containsKey('keyVal') //要使用变量作为key，需要使用括号 def keyVal = 'name' def persons = [(keyVal): 'Guillaume'] assert persons.containsKey('name') assert !persons.containsKey('keyVal')
Range
在 Groovy 中可以使用..操作符来定义一个区间对象，简化范围操作的代码。
def range = 0..5 assert (0..5).collect() == [0, 1, 2, 3, 4, 5] assert (0..<5).collect() == [0, 1, 2, 3, 4] // 相当于左闭右开区间 assert (0..5) instanceof List // Range实际上是List接口的实现 assert (0..5).size() == 6 assert ('a'..'d').collect() == ['a','b','c','d']//也可以是字符类型 //常见使用场景 for (x in 1..10) { println x } ('a'..'z').each { println it } def age = 25; switch (age) { case 0..17: println '未成年' break case 18..30: println '青年' break case 31..50: println '中年' break default: println '老年' }
常见使用场景
Grails
Grails 是一个基于 Groovy 语言，构建于 Spring/Spring boot、Hibernate 之上的高生产力、一站式 Web 开发框架。特别适合小型团队进行敏捷开发，效率非常高。由于性能和学习成本的原因，普及率比较低，大分部公司还是更倾向于选择 Spring Boot 作为开发框架。
Gradle
Gradle 是一个基于 Apache Ant 和 Apache Maven 概念的项目自动化构建工具。它使用一种基于 Groovy 的特定领域语言(DSL)来进行构建配置，抛弃了基于XML的各种繁琐配置，主要以面向Java应用为主，支持从 Maven 仓库下载依赖。现在越来越多的项目（Android项目居多）使用Gradle 来作为项目的构建工具，相信未来 Gradle 也会逐渐代替 Maven，就像 Maven 代替 Ant 那样。
使用Maven构建项目
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>com.vs</groupId> <artifactId>com.vs.maven.gradle</artifactId> <version>1.0</version> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>1.2.6.RELEASE</version> </parent> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa </artifactId> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.25</version> </dependency> </dependencies> <properties> <java.version>1.8</java.version> </properties> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build> </project>
使用Gradle构建项目
buildscript { repositories { mavenCentral() } dependencies { classpath("org.springframework.boot:spring-boot-gradle-plugin:1.2.6.RELEASE") } } dependencies { compile("org.springframework.boot:spring-boot-starter-web") { exclude module: "spring-boot-starter-tomcat" } compile("org.springframework.boot:spring-boot-starter-security") compile("org.springframework.boot:spring-boot-starter-data-jpa") testCompile("mysql:mysql-connector-java:5.1.25") }
Spring 支持
从 Spring 2.0 版本开始对动态脚本语言进行了支持（Spring 官方文档该部分地址），其中便包括 Groovy ，Spring 提供了<lang:groovy/>标签来定义 Groovy Bean 。Groovy Bean 可以通过script-source属性加载脚本文件，脚本源文件可以来自本地或者网络，并且可以通过refresh-check-delay属性监听脚本内代码变更重新装载 Bean 实现动态 Bean 。
// from the file '/java/Calculator.java' public interface Calculator { int add(int x, int y); } // from the file '/resources/CalculatorGroovyImpl.groovy' class CalculatorGroovyImpl implements Calculator { int add(int x, int y) { x y } } <-- from the file 'beans.xml' 省略 xmlns --> <?xml version="1.0" encoding="UTF-8"?> <beans> <lang:groovy id="calculator" script-source="classpath:CalculatorGroovyImpl.groovy" refresh-check-delay="1000"/> </beans> public class Tester { public static void main(String[] args) throws InterruptedException { ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml"); Calculator calculator = (Calculator)context.getBean("calculator"); //尝试修改CalculatorGroovyImpl.groovy，将 x y，修改为x * y。 while (true){ System.out.println(calculator.add(1, 1)); TimeUnit.SECONDS.sleep(1); } } }
从 Spring 4.0 版本开始 Spring 支持使用 Groovy DSL 来定义 Bean 的配置，详见 Spring 官方文档该部分 。
beans { //beanName(type) dataSource(BasicDataSource) { //注入属性 driverClassName = "org.hsqldb.jdbcDriver" url = "jdbc:hsqldb:mem:grailsDB" username = "sa" password = "" settings = [mynew:"setting"] } sessionFactory(SessionFactory) { //注入属性，引用其他Bean dataSource = dataSource } myService(MyService) { //使用闭包定义嵌套的Bean nestedBean = { AnotherBean bean -> dataSource = dataSource } } } ApplicationContext context = new GenericGroovyApplicationContext("beans.groovy"); MyService myService = context.getBean(MyService.class);
与Java集成
Groovy非常容易集成在Java环境中，利用其动态性来做规则引擎、流程引擎、动态脚本环境，非常适合那些不不需要经常发布但又经常变更的场景下使用。在Java中集成（调用）Groovy 代码有下面几种方式。
Eval
groovy.util.Eval 类是最简单的用来在运行时动态执行 Groovy 代码的类，提供了几个静态工厂方法供使用，内部其实就是对Groovyshell的封装。
//执行Groovy代码 Eval.me("println 'hello world'"); //绑定自定义参数 Object result = Eval.me("age", 22, "if(age < 18){'未成年'}else{'成年'}"); assertEquals(result, "成年"); //绑定一个名为 x 的参数的简单计算 assertEquals(Eval.x(4, "2*x"), 8); //带有两个名为 x 与 y 的绑定参数的简单计算 assertEquals(Eval.xy(4, 5, "x*y"), 20); //带有三个绑定参数（x、y 和 z）的简单计算 assertEquals(Eval.xyz(4, 5, 6, "x*y z"), 26);
GroovyShell
groovy.lang.GroovyShell除了可以执行 Groovy 代码外，提供了更丰富的功能，比如可以绑定更多的变量，从文件系统、网络加载代码等。
GroovyShell shell = new GroovyShell(); //可以绑定更多变量 shell.setVariable("age",22); //直接求值 shell.evaluate("if(age < 18){'未成年'}else{'成年'}"); //解析为脚本，延迟执行或者缓存起来 Script script = shell.parse("if(age < 18){'未成年'}else{'成年'}"); assertEquals(script.run(), "成年"); //可以从更多位置加载/执行脚本 //shell.evaluate(new File("script.groovy")); //shell.evaluate(new URI("http://wwww.a.com/script.groovy"));
GroovyClassLoader
groovy.lang.GroovyClassLoader是一个定制的类加载器，可以在运行时加载 Groovy 代码，生成 Class 对象。
GroovyClassLoader groovyClassLoader = new GroovyClassLoader(); String scriptText = "class Hello { void hello() { println 'hello' } }"; //将Groovy脚本解析为Class对象 Class clazz = groovyClassLoader.parseClass(scriptText); //Class clazz = groovyClassLoader.parseClass(new File("script.groovy")); assertEquals(clazz.getName(),"Hello"); clazz.getMethod("hello").invoke(clazz.newInstance());
GroovyScriptEngine
groovy.util.GroovyScriptEngine能够处理任何 Groovy 代码的动态编译与加载，可以从统一的位置加载脚本，并且能够监听脚本的变化，当脚本发生变化时会重新加载。
//script/groovy/hello.groovy println "hello $name" GroovyScriptEngine scriptEngine = new GroovyScriptEngine("script/groovy"); Binding binding = new Binding(); binding.setVariable("name", "groovy"); while (true){ scriptEngine.run("hello.groovy", binding); TimeUnit.SECONDS.sleep(1); } //输出 hello groovy hello groovy .... //将hello.groovy内代码修改为println "hi $name"， GroovyScriptEngine会重新进行加载 hi groovy hi groovy
JSR 223 javax.script API
JSR-223 是 Java 中调用脚本语言的标准 API。从 Java 6 开始引入进来，主要目的是用来提供一种统一的框架，以便在 Java 中调用多种脚本语言。JSR-223 支持大部分流行的脚本语言，比如JavaScript、Scala、JRuby、Jython和Groovy等。
ScriptEngine engine = new ScriptEngineManager().getEngineByName("groovy"); Bindings bindings = new SimpleBindings(); bindings.put("age", 22); Object value = engine.eval("if(age < 18){'未成年'}else{'成年'}",bindings); assertEquals(value,"成年"); //script/groovy/hello.groovy //println "hello world" engine.eval(new FileReader("script/groovy/hello.groovy")); //hello world
由于 Groovy 自身已经提供了更丰富的集成机制，如果在 Java 应用中只是使用 Groovy 一种脚本语言的话，使用 Groovy 提供的集成机制可能会更合适一点。
,
