Groovy实战分析

本是古典何须时尚 2022-05-14 01:05 149阅读 0赞

本篇Groovy博文适合有Java+脚本语言（python or ruby）基础的同学快速入门。  
本文不算是系统地学习groovy的教材，而是通过对比和对几个重点的介绍让大家直接上手groovy开发。

1 默认导入

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

就是说.groovy文件在起步阶段就等于.java文件再import进来以上这些常用包，可以省去大量import代码。

2 两种元编程：运行时和编译时元编程。  
编译时元编程本质与java是一样的，提前将.groovy脚本编译成.class文件，然后丢给JVM去执行。  
运行时编程，通过groovy的类加载器在运行时直接加载\*.groovy文件并且生成对象，在这种方式下，没有生成任何\*.class，但是生成了一个java.lang.Class对象的实例，也就是说，当groovy代码中包括一个new MyClass()的表达式时，并且也有一个MyClass.groovy的文件，这个文件将被解释，一个MyClass的类型将被产生并且增加到类加载器中，在代码中将像从\*.class一样获取到MyClass对象。

3 有python功底的同学在玩groovy的集合时不会感到陌生。  
数组初始化  
int\[\] array = \[1,2,3\]   
list初始化  
def list = \[9, 4, 2, 10, 5\]  
Map初始化  
def map = \[name: 'Gromit', likes: 'cheese', id: 1234\]  
空map：def emptyMap = \[:\]  
总之在groovy中不要随便用\{\}大括号，那个是闭包，剩下的关于集合的操作根python差不多。

4 属性创建  
默认一个private属性加public的get set  
这样也是为了减少代码量

5 GString与String  
groovy中双引号是GString，可以引用$的变量  
单引号是普通的java String，当字符串处理  
例如如下代码：  
log.error("Error occurred handling request for $\{request.requestURL\}", ex)  
如果是单引号当不会做$的转译，直接当纯字符串去处理  
如够长字符串跨多行，那就跟python一样使用三引号,例如：

new File(baseDir,'haiku.txt') << '''Into the ancient pond
    A frog jumps
    Water’s sound!'''

6 闭包代替lambda

java代码：
    Runnable run = () -> System.out.println("Run");
    groovy代码：
    Runnable run = { println 'run' }

闭包是groovy的核心，有点像java的statc静态代码块，用\{\}括起来的部分是一个闭包，代表某个逻辑运算。  
闭包比起lambda可读性更强，开发起来也更简单，闭包是groovy最重要的知识点，一定要掌握，特别是配合集合和map时的使用

def subtemplates = (Map<String, String>) templates.findAll { it.key != "main"}.collectEntries {k, v -> [(k): objectMapper.writeValueAsString(v)]}

这行代码用到了2个闭包，一个是过滤key值，一个是做value的json转换，设想这行代码用java来写大约要写多少行。

7 判断相等  
java中的== 在groovy中要用is 这点与python一样。  
groovy中的==是值相等，不是引用相等。

8 trait  
java中只有class和interface，groovy中新增了一个trait  
虽然对trait的引用也是implements这种方式，但是trait和interface的意义是不一样的。  
interface的意义是抽象以及共有部分的实现（jdk1.8的default），而trait的意义是能力的嵌入。implements进来某个trait，就说明当前类具备了这个能力，并不是实现、集成的意思。

9 特殊符号

range = 5..<8 半包括

range = 5..8 全包括

<< 赋值或者添加到集合

def list = []
    list << 5

\*展开运算符

class Person{  
        String name  
        int age  
        String toString(){  
            return "${name}:${age}"  
        }  
    }  
      
    def people = [new Person(name:'阿大',age:24),new Person(name:'阿二',age:18)]  
    println people*.toString()  
      
    result:  
      
    ["阿大:24", "阿二:18"]

?: 二元运算符

groovy代码：  
description.check = description.check ?: oldDescription.check  
如果description.check为空那么用oldDescription.check的值代替。  
如果用java写：  
description.check = description.check!=null ? description.check: oldDescription.check  
java是三元运算，groovy是二元运算，因为groovy对boolean的判断与python是一样的“非空既真”，所以省去了非空的情况下是true还是false这层判断，减少了一元。

?. 非空占位符,简化空指针判断

java代码：
    if (description!=null){
    	System.out.println(description.check)
    }
    等效的groovy代码：
    println description?.check

& 闭包调用，有点像jdk1.8新特性方法的调用->

//我定义了一个方法：
    AzureApplication translate(CacheData cacheData) {XXX}
    //我这里有个集合
    ollection<CacheData> applications = XXX;
    //我想遍历集合的元素调用上面的translate方法并拼装成一个新集合
    applications.collect this.&translate

10   
很多开发者往往会同时使用 def 和类型，但这里的 def 是多余的。因此，要么使用 def，要么使用类型。   
所以不要这样写：   
def String name = "Guillaume"   
这样写就足够了：   
String name = "Guillaume"  
在 Groovy 中使用 def 时，实际的类型持有者是 Object，所以可以将任何对象赋予利用 def 定义的变量，如果一个方法声明为返回 def 类型值，则它会返回任何类型的对象。   
是用default还是用类型来修饰变量，这点也是灵活与可读性的博弈，按groovy的设计希望大家用default，但是如果你可以笃定你的类型，适当的用类型也是不错的选择。

以上是groovy语法上的学习，实战中groovy还提供了很多便捷的annotation供开发者使用

1  
@Memoized 作用在方法上  
groovy.transform.Memoized  
把方法的执行结果缓存起来，下次调用时，如果参数一样，那方法就不再计算而是直接返回结果了

2  
@Slf4j 作用在类上  
groovy.util.logging.Slf4j  
相当于private  final Logger logger = LoggerFactory.getLogger(XXX.class)

3   
@ToString 作用在类上  
groovy.transform.ToString  
相当于自动重写了toString：格式是全类名(属性信息)  
com.xiaonanzhi.transform.model.Person(xiaoming, 网商路599号, 100)  
参数includeNames=true可以把属性显示出来  
com.xiaonanzhi.transform.model.Person(name:xiaoming, address:网商路599号, age:100)  
示例代码：

@ToString(includeNames = true, includePackage = false)
      static class DeployServerGroup {
        String region
        String name
      }

4 @EqualsAndHashCode 作用在类上  
groovy.transform.EqualsAndHashCode  
相当于重写了equals方法，它认为toString相等的对象就相等

5 @TupleConstructor 作用在类上  
groovy.transform.TupleConstructor  
groovy默认可以给对象提供new object(key1:value1, key2:value2, key3:value3)这种方式的构造器，  
如果添加@TupleConstructor就会提供一个更简洁的构造方式：new object(value1，value2， value3)  
但是这种方式的缺点是可读性不好，需要与属性定义的位置一一对应。

6 @Canonical 作用在类上  
groovy.transform.Canonical   
相当于@ToString+@EqualsAndHashCode+@TupleConstructor

7  
@Delegate作用在属性上

groovy.lang.Delegate
    class A(){
        function a(){}
    }
    class B(){
        @Delegate
         A a = new A()
    
        funtion b(){}
    }

通过B既可以调用b()方法，也可以调用a()方法，当自身找不到某个方法或属性时去delegate里去找。一个类可以设置N多个代理属性。  
但是这种对于习惯Java规范的人来说是一种很难理解的行为，可读性会变很差。

8  
@Builder 作用在类上  
groovy.transform.builder.Builder  
被Builder修饰的类在创建时可以被builder了~ 语法如下：

@Builder
    class OpenstackInstanceType implements InstanceType, Serializable {
      String account
      String region
      String id
      String name
      int ram
      int vcpus
      int disk
      int swap
      int ephemeral
      boolean available
      boolean disabled
    }
    
    OpenstackInstanceType.builder()
          .account(accountName)
          .region(region)
          .id(flavor.id)
          .name(flavor.name)
          .available(flavor.isPublic())
          .disabled(flavor.isDisabled())
          .disk(flavor.disk)
          .ephemeral(flavor.ephemeral)
          .ram(flavor.ram)
          .swap(flavor.swap)
          .vcpus(flavor.vcpus)
          .build()
      }

9  
@Immutable 作用在类上  
groovy.transform.Immutable  
相当于声明class为final类型，不允许改变