Groovy và sự khác biệt với Java

Groovy – một ngôn ngữ lập trình động chạy trên nền máy ảo Java, có các tính năng tương tự như Python hoặc Ruby. Nó hỗ trợ đến 99% cú pháp của Java, do đó việc bạn paste 1 đoạn code Java để chạy trên Groovy là điều hết sức đơn giản và thân thiện với Java Developer.

Làm việc với Groovy từ năm 2013 khi Google IO công bố Android Studio sử dụng Gradle build với groovy script. Mình đã có cơ hội sử dụng Groovy như một ngôn ngữ thay thế trong dự án thực tế. Mọi thứ với mình vẫn chỉ dừng lại ở việc config build script trong Gradle hoặc Jenkins pipeline. Vì vậy, với tất cả những gì mình tìm hiểu và một chút kinh nghiệm của bản thân, hy vọng các bạn cùng đóng góp ý kiến nếu có điều gì không đúng. Xin cảm ơn!!

Tính khác biệt giữa Groovy và Java

Việc import package mỗi khi sử dụng class chẳng hạn như java.io.File vẫn thường là bắt buộc cho mỗi Java Developer. Nhưng trong groovy thì không cần làm điều đó, mặc định các packages sau đã imported:

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

Giả sử chúng ta có đoạn code với 2 method nạp chồng như sau:

int method(String arg) {
    return 1;
}

int method(Object arg) {
    return 2;
}

Object o = "Object";
int result = method(o);

Kết quả:

• Java result sẽ là 2.
• Groovy result sẽ là 1.

Với Java, các method sẽ được chọn khi compile, dựa trên data type đã khai báo trong ví dụ trên là Object. Còn với Groovy, các method sẽ được chọn khi runtime, nó cũng dựa trên data type đã khai báo. Nhưng khi runtime, o lúc này là String object. Vì vậy 1 là kết quả trên Groovy. Điều này được gọi là runtime dispatch or multi-methods trong Groovy.

Với Java, việc khởi tạo array có thể thực hiện như sau:

int[] array = { 1, 2, 3}

Nhưng trong groovy, nó không được phép. Vì cặp { } chỉ dành riêng cho closures. Thay vì đó sẽ sử dụng như sau để thay thế:

int[] array = [1,2,3]

Trong Java, để khai báo một class, chúng ta cần sử dụng từ khóa class. Ví dụ:

class Person {
    String name
}

Trong groovy, không có khái niệm access modifier dành cho field. Điều đó có nghĩa là, dù bạn có thêm / loại bỏ modifier của field giống như Java thì cũng không ảnh hưởng gì đến khả năng truy xuất của field đó cả. Để làm điều đó, cần sử dụng annotation @PackageScope cái sẽ kết hợp với getter và setter của field đó (getter và setter được ngầm định tạo ra trong groovy). Ví dụ:

class Person {
    @PackageScope
    String name
}

ARM (Automatic Resource Management) được hỗ trợ từ Java 7. Trong khi Groovy lại không hỗ trợ. Thay vào đó groovy cung cấp các cách khác nhau dựa trên closures – cái có hiệu quả tương đương trong khi closures đem lại sự ngắn gọn hơn:

// Java
Path file = Paths.get("/path/to/file");
Charset charset = Charset.forName("UTF-8");
try (BufferedReader reader = Files.newBufferedReader(file, charset)) {
    String line;
    while ((line = reader.readLine()) != null) {
        System.out.println(line);
    }
} catch (IOException e) {
    e.printStackTrace();
}

// Groovy
new File('/path/to/file').eachLine('UTF-8') { println it }

// Hoặc closer to Java
new File('/path/to/file').withReader('UTF-8') { reader -> reader.eachLine { println it } }

Việc tạo một anonymous inner classes và nested classes vẫn tuân thủ theo quy tắc của Java. Tuy nhiên trong groovy cú pháp có phần đơn giản hơn và loại bỏ một số syntax , không bổ từ truy xuất, biến local không cần là final:

// Static inner classes
class A {
    static class B {}
}

new A.B()

// Anonymous Inner Classes
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)

// Tạo instances of Non-Static Inner Classes
// Java
public class Y {
    public class X {}
    public X foo() {
        return new X();
    }
    public static X createX(Y y) {
        return y.new X();
    }
}

// Groovy
public class Y {
    public class X {}
    public X foo() {
        return new X()
    }
    public static X createX(Y y) {
        return new X(y)
    }
}

Groovy và Lambdas

Trong Java 8, có sự hiện diện của Lambdas. Tương tự, trong Groovy, chúng ta có Closures. Dưới đây là cách sử dụng của Lambdas trong Java 8:

Runnable run = () -> System.out.println("Run");
list.forEach(System.out::println);

Còn với Groovy:

Runnable run = { println 'run' }
list.each { println it }
// or list.each(this.&println)

String manipulation

Trong Java, để nối các string với nhau chúng ta thường dùng toán tử + để nối chuỗi, giống như thế này:

String name = "Nguyen Van Manh";
System.out.println("Xin chao " + name + "!");

Còn trong groovy thì đơn giản và dễ dàng hơn rất nhiều:

String name = "Nguyen Van Manh";
println "Xin chao ${name}!"

Và cặp Double-quoted string literals ${} như trên được gọi là GString value.

Trong Groovy, Singly-quoted được sử dụng cho String và double-quoted được sử dụng cho String hoặc GString (nếu có interpolation GString ${} ):

assert 'c'.getClass()==String
assert "c".getClass()==String
assert "c${1}".getClass() in GString

Kiểu dữ liệu char chỉ được hiểu chỉ khi khi báo tường minh một biến là char:

char a='a'
assert Character.digit(a, 16)==10 : 'But Groovy does boxing'
assert Character.digit((char) 'a', 16)==10
try {
    assert Character.digit('a', 16)==10
    assert false: 'Need explicit cast'
} catch(MissingMethodException e) { }

Casting Character

Groovy hỗ trợ 2 kiểu casting từ String sang -> char. Ở đây cũng có sự khác biệt trong cách cast:

//Cách 1
assert ((char) "c").class==Character // OK
assert ((char) "cccc").class==Character // Error GroovyCastException
//Cách 2
assert ("c" as char).class==Character // OK
assert ("abc" as char).class==Character // OK, nhưng chỉ lấy ký tự a đầu tiên

Groovy và kiểu dữ liệu

Groovy sử dụng Object cho tất cả mọi thứ, kiểu dữ liệu primitive sẽ tự động wrap tới class wrapper tương ứng.

Bảng so sánh việc chuyển đổi kiểu dữ liệu giữa Java và Groovy:
| | boolean | byte | short | char | int | long | float | double |
|———-|———|——|——-|——|—–|——|——-|——–|
| boolean | – | N | N | N | N | N | N | N |
| byte | N | – | Y | C | Y | Y | Y | Y |
| short | N | C | – | C | Y | Y | Y | Y |
| char | N | C | C | – | Y | Y | Y | Y |
| int | N | C | C | C | – | Y | Y | Y |
| long | N | C | C | C | C | – | T | T |
| float | N | C | C | C | C | C | – | Y |
| double | N | C | C | C | C | C | C | – |

Cùng xem ví dụ bên dưới để thấy sự khác biệt khi runtime sử dụng Java và Groovy:

int i

m(i)

void m(long l) {
    println "in m(long)"
    // method Java sẽ gọi
}

// method Groovy sẽ gọi, auto wrap int -> Integer
void m(Integer i) {
    println "in m(Integer)"
}

Trong Java, so sánh == được hiểu là đang so sánh 2 giá trị primitive hoặc nhận dạng các objects. Trong Groovy == được hiểu là a.compareTo(b)==0 nếu ab là Comparable, ngược lại sẽ được hiểu là a.equals(b).

Bảng so sánh việc chuyển đổi kiểu dữ liệu giữa Java và Groovy:
| | boolean | byte | short | char | int | long | float | double |
|———|———|——|——-|——|—–|——|——-|——–|
| boolean | – | N | N | N | N | N | N | N |
| byte | N | N | C | Y | C | C | C | C |
| short | N | C | N | C | C | C | C | C |
| char | N | Y | Y | N | C | C | C | C |
| int | N | C | C | C | N | C | C | C |
| long | N | C | C | C | C | N | T | T |
| float | N | C | C | C | C | C | N | C |
| double | N | C | C | C | C | C | C | N |

Ngoài các keywords của Java, thì Groovy còn sử dụng thêm một số keywords bên dưới:

• as
• def
• in
• trait

Cũng giống như Java, các keywords cũng không được sử dụng như tên biến.

Với Java, sau mỗi statement sẽ kết thúc bằng 1 dấu chấm phẩy ;. Nhưng với Groovy thì điều đó là không bắt buộc, tất nhiên có cũng được mà không có cũng không sao. Groovy đều hiểu và compile hoàn toàn bình thường. Ví dụ:

static void main(String[] args) {
    int i
    def result = m(i)
    println "Ket qua = ${result}"
}

static int m(Integer i) {
    100
}

Với Groovy, return ở một method không còn là bắt buộc. Điều này rất hữu ích với các block code như closures hoặc các method đơn giản. Tất nhiên, nó không có nghĩa là chúng ta sẽ bỏ return, vì trong một số trường hợp việc sử dụng return vẫn là cần thiết.

Với Groovy, class suffix có thể bỏ qua khi pass như parameter. Như Person.class ví dụ bên dưới:

static void main(String[] args) {
    // có thể hiểu là Person.class
    def p = newInstance(Person)
    println p.name
}

static Person newInstance(Class<Person> clazz) {
    clazz.newInstance()
}

Với Java, bạn cần chỉ định tường minh Exception trong catch. Nhưng với Groovy, đơn giản chỉ cần như sau:

try {
    Integer.parseInt("aaa")
} catch (e) {
    println e.getMessage()
}

Và có thể còn rất nhiều sự khác biệt hay ho nữa trong Groovy. Trên đây chỉ là những gì mình tìm hiểu và viết lại theo ý hiểu của bản thân và một số cái được áp dụng khi làm việc thực tế.

Với Groovy, nó hỗ trợ đến 99% cú pháp của Java, hơn nữa nó mang lại sự ngắn gọn đơn giản trong cú pháp trình bày. Sẽ giúp chúng ta phát triển ứng dụng một phần nào đó nhanh chóng hơn, một khi Groovy ngày càng phổ biến.

Để tìm hiểu Groovy, Learning, Documentation, vv.. bạn có thể tìm hiểu tại dnulib.edu.vn.