Groovy 笔记

Groovy 是基于 JVM 的 动态脚本语言，可以与 Java 无缝对接。Groovy 并不替代 Java，而是与 Java 互补

Hello world

下载地址: http://www.groovy-lang.org/download.html 并将 groovy/bin 配置到环境变量中

创建 hello.groovy

println 'Hello world'

执行

$ groovy hello.groovy
Hello world

基本语法

• 数组

  // in java
  int[] arr = {1, 2, 3};
  

  // in groovy
  int[] arr = [1, 2, 3]
  

• POJO

  // 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: '张三')
  

• 包权限

  Groovy 默认是 public 访问权限。这点与 Java 不同

• 变量

  声明时可以省略类型定义，Groovy 会自动判断类型

  def a = 123 // Integer
  def b = '123' // String
  def c = '$123' // GString
  

• 数字类型

  def a = 123i // Integer
  def b = 123l // Long
  def c = 123g // BigInteger
  def d = 12.3g // BigDecimal
  def e = 12.3d // Double
  def f = 12.3f // Float
  

• 字符串

  在Groovy种有两种字符串类型，普通字符串（java.lang.String）和插值字符串（groovy.lang.GString）。

  // 普通字符串
  def a = "world" // 或使用单引号 'world'
  // 插值字符串
  def b = "Hello $a" // 必须双引号
  // 三单引号保持缩进格式
  def c = '''\
  tab 0
  	tab 1
  		tab 2
  '''
  // 声明字符的三种方法
  char c1 = 'A'
  def c2 = 'B' as char
  def c3 = (char) 'C'
  

• 方法

  1. 返回类型可忽略
  2. return 可忽略，默认返回最后一行代码的结果
  3. 参数类型可以忽略

  // 以下两个方法等价
  def method1(a) {
    'hello ' + a
  }
  
  public String method2(int a) {
    return 'hello ' + a
  }
  

• 闭包

  闭包是一段可执行代码，可以像变量一样使用

  //闭包的参数为可选项
  def closure = { [closureParameters -> ] statements }
  

  // 闭包的声明
  def abc = {param1, param2 -> println 'hello ' + param1 + ', ' + param2}
  // 闭包的调用方法
  abc('world1', 'world2')
  abc.call('world1', 'world2')
  abc 'world1'
  

• 列表

  def numbers = [1, 2, 3] // java.util.ArrayList
  

• 数组

  当声明时指定了类型，便会定义成数组

  String[] arrStr = ['Ananas', 'Banana', 'Kiwi'] // String[]
  def numArr = [1, 2, 3] as int[] // int[]
  

• Map

  通过 [key: value] 方式定义 Map，对应 Java 的 java.util.Map，默认类型是 java.util.LinkedHashMap。

  // Map 的 key 声明时不需要写引号，Groovy 会自动添加
  def colors = [red: '#FF0000', green: '#00FF00', blue: '#0000FF']
  
  def key = 'key_name'
  def map = [key: 'some value1'] // 此时 key: 会被转换为 'key'
  def map = [(key): 'some value2'] // 此时key: 会使用 'key_name'
  
  

• 区间

  在 Groovy 中可以使用..操作符来定义一个区间对象。

  def range1 = 0..5 // = def range = [0, 1, 2, 3, 4, 5]
  def range2 = 0..<5 // = def range = [0, 1, 2, 3, 4]
  def range3 = 'a'..'d' // 支持字符类型 ['a', 'b', 'c', 'd']
  

• 与Java集成

  Java 调用 Groovy

  • Eval

    groovy.util.Eval 类是最简单的用来在运行时动态执行 Groovy 代码的类，提供了几个静态工厂方法供使用，内部其实就是对GroovyShell的封装。

  public class GroovyTest {
    public static void main() {
      // 执行 Groovy
      groovy.util.Eval.me("println 'hello world'");
      // 绑定自定义参数
      Object result = Eval.me("age", 22, "if(age < 18){'未成年'}else{'成年'}"); // = 成年
      // 绑定一个名为 x 的参数的简单计算
  		Eval.x(4, "2*x"); // = 8
      //带有三个绑定参数（x、y 和 z）的简单计算
      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
  

转载于:https://my.oschina.net/tonglei0429/blog/3076413