Belajar Groovy - Web & API Development

#Pendahuluan

Groovy tidak hanya untuk scripting dan build — ia juga dipakai untuk membangun aplikasi web dan API. Dengan framework modern, menulis REST API di Groovy bahkan lebih ringkas daripada Java.

Episode 17 membahas penggunaan Groovy dengan Grails dan Micronaut, menulis REST API sederhana dengan JSON serialization, serta deployment ke container, cloud, atau JVM service.

#Framework Web untuk Groovy

#Grails

Grails adalah framework full-stack MVC yang memakai Groovy sebagai bahasa utama. Konsep kuncinya:

• Domain classes: model data ditulis dalam Groovy.
• Controllers: menangani request HTTP.
• GORM: ORM bawaan untuk database relasional.

Grails mengikuti konvensi konfigurasi: file di lokasi yang benar otomatis terhubung, sehingga kalian tidak menulis banyak konfigurasi manual.

#Micronaut

Micronaut adalah framework modern yang juga mendukung Groovy, dengan keunggulan kompilasi saat build (AOT). Micronaut menghasilkan refleksi dan proxy saat kompilasi, sehingga startup-nya sangat cepat dan hemat memory — cocok untuk serverless.

Pilih Grails untuk aplikasi full-stack dengan UI server-side, dan Micronaut untuk microservice dan API ringan.

#Menulis REST API dengan Groovy

#Controller di Micronaut

Micronaut memakai anotasi untuk mendefinisikan endpoint:

import io.micronaut.http.annotation.*
 
@Controller("/sapa")
class SapaController {
 
    @Get("/{nama}")
    String sapa(String nama) {
        "Halo, ${nama}!"
    }
}

@Controller("/sapa") menandai class sebagai handler HTTP, dan @Get("/{nama}") memetakan request GET dengan path parameter. String sapa(String nama) adalah handler yang mengembalikan respons langsung — Groovy mengonversinya ke teks plain.

#Domain Class dengan JSON

Untuk data terstruktur, Micronaut otomatis men-serialize objek Groovy menjadi JSON:

@Canonical
class Pengguna {
    String nama
    int umur
}
 
@Controller("/pengguna")
class PenggunaController {
 
    @Get("/{id}")
    Pengguna ambil(int id) {
        new Pengguna(nama: "Arman", umur: 25)
    }
}

@Canonical membuat toString dan named-constructor otomatis. Pengguna ambil(int id) mengembalikan objek yang di-serialize Micronaut menjadi JSON berkat library Jackson yang terintegrasi.

#JSON Serialization

#JsonOutput dan JsonSlurper

Untuk kontrol manual, Groovy menyediakan JsonOutput untuk serialize dan JsonSlurper untuk parse:

import groovy.json.JsonOutput
import groovy.json.JsonSlurper
 
def data = [nama: "Arman", skill: ["Groovy", "Java"]]
def json = JsonOutput.toJson(data)
println json
 
def hasil = new JsonSlurper().parseText(json)
println hasil.nama
println hasil.skill[0]

JsonOutput.toJson(data) mengubah map menjadi JSON string, dan new JsonSlurper().parseText(json) menguraikannya kembali. hasil.skill[0] mengakses elemen pertama dari list hasil parsing — struktur map dan list Groovy bertahan melewati JSON.

#Deployment ke Container

#Dockerfile untuk Aplikasi Groovy

API berbasis JVM paling umum dideploy sebagai container. Berikut Dockerfile untuk aplikasi Micronaut yang dibangun dengan Gradle:

FROM gradle:8-jdk17 AS build
WORKDIR /app
COPY . .
RUN gradle build --no-daemon
 
FROM eclipse-temurin:17-jre
COPY --from=build /app/build/libs/app-all.jar /app/app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "/app/app.jar"]

FROM gradle:8-jdk17 AS build menggunakan image Gradle untuk tahap build, dan FROM eclipse-temurin:17-jre memakai runtime JRE yang ramping untuk tahap produksi. COPY --from=build ... app.jar menyalin artifact hasil build antar tahap — pola multi-stage yang hemat ukuran.

#Build dan Run

docker build -t sapa-api .
docker run -p 8080:8080 sapa-api

docker build -t sapa-api . membangun image dari Dockerfile, dan docker run -p 8080:8080 sapa-api menjalankan container sambil meneruskan port 8080. docker build -t sapa-api . adalah perintah yang menghasilkan image siap deploy.

#Deployment ke Cloud

#Opsi Target

Setelah image container siap, ada beberapa target deployment:

• Container registry: push ke Docker Hub, GHCR, atau registry cloud.
• Kubernetes: deploy sebagai Deployment dan Service.
• Serverless: platform seperti AWS Lambda atau Google Cloud Run yang mendukung container.

Untuk JVM service sederhana, Cloud Run adalah pilihan hemat karena skala ke nol saat tidak ada traffic. Untuk orkestrasi penuh, Kubernetes memberi kontrol lebih besar.

#Penutup

Episode 17 menghubungkan Groovy dengan dunia web: memilih antara Grails dan Micronaut, menulis REST API dengan controller dan domain class, serialisasi JSON manual maupun otomatis, serta deployment ke container dan cloud.

Inti yang harus dibawa pulang:

• Grails untuk full-stack MVC; Micronaut untuk microservice ringan.
• Anotasi @Controller dan @Get mendefinisikan endpoint REST.
• Micronaut men-serialize objek Groovy menjadi JSON secara otomatis.
• JsonOutput dan JsonSlurper untuk kontrol serialisasi manual.
• Docker multi-stage menghasilkan image yang ramping.
• Container siap dideploy ke registry, Kubernetes, atau serverless.

Di episode 18 selanjutnya kita akan membahas plugin dan extension development — membuat plugin untuk Gradle atau aplikasi Groovy, packaging dan publishing, reuse di build ecosystem, serta berkontribusi ke community plugins dan reusable scripts.