Groovy (.groovy)

Overview

Groovy is a powerful, dynamic programming language for the Java Virtual Machine (JVM) that combines the best features of Java with additional capabilities inspired by languages like Python, Ruby, and Smalltalk. Created by James Strachan in 2003, Groovy offers a concise, readable syntax while maintaining full compatibility with Java code and libraries. It's widely used for scripting, testing, build automation, and rapid application development.

Technical Details

• File Extension: .groovy
• MIME Type: text/x-groovy
• Category: Programming Language
• First Appeared: 2003
• Paradigm: Object-oriented, dynamic, functional
• Platform: Java Virtual Machine (JVM)

Key Features

Java Compatibility

• Seamless integration with existing Java code
• Access to all Java libraries and frameworks
• Compiles to Java bytecode
• Can use Java syntax directly

Dynamic Language Features

• Optional typing with type inference
• Runtime metaprogramming capabilities
• Dynamic method dispatch
• Duck typing support

Concise Syntax

• Reduced boilerplate code
• Optional semicolons and parentheses
• String interpolation
• Closure support

Syntax Examples

Basic Groovy Constructs

// Variables (type inference)
def name = "Groovy"
def version = 4.0
def isAwesome = true

// Explicit typing is optional
String greeting = "Hello, World!"
int count = 42

// Functions/Methods
def greet(name) {
    return "Hello, ${name}!"
}

// Alternative syntax
def add(a, b) { a + b }

// Method calls (parentheses optional)
println greet("World")
println add 5, 3

String Handling

// String interpolation
def name = "Groovy"
def version = 4.0
println "Welcome to ${name} ${version}"

// Multi-line strings
def multiLine = """
This is a
multi-line
string in Groovy
"""

// String methods and operators
def text = "Hello World"
println text.toLowerCase()
println text.split(' ')
println text * 3  // Repeat string 3 times

// Regular expressions
def pattern = ~/\d+/
def text2 = "There are 123 numbers here"
if (text2 ==~ pattern) {
    println "Contains numbers"
}

Collections and Data Structures

// Lists (dynamic arrays)
def numbers = [1, 2, 3, 4, 5]
def names = ["Alice", "Bob", "Charlie"]

// List operations
numbers << 6              // Append
numbers.add(7)           // Another way to append
println numbers[0]       // Access by index
println numbers[-1]      // Last element

// Maps (key-value pairs)
def person = [
    name: "John",
    age: 30,
    city: "New York"
]

// Alternative map syntax
def config = ["host": "localhost", "port": 8080]

// Accessing map values
println person.name
println person["age"]

Closures

// Basic closure
def square = { x -> x * x }
println square(5)  // 25

// Closure with multiple parameters
def multiply = { a, b -> a * b }
println multiply(3, 4)  // 12

// Implicit parameter (it)
def double = { it * 2 }
println double(5)  // 10

// Closures with collections
def numbers = [1, 2, 3, 4, 5]
def doubled = numbers.collect { it * 2 }
def evens = numbers.findAll { it % 2 == 0 }
def sum = numbers.inject(0) { acc, n -> acc + n }

println doubled  // [2, 4, 6, 8, 10]
println evens    // [2, 4]
println sum      // 15

Object-Oriented Programming

// Class definition
class Person {
    String name
    int age
    
    // Constructor
    Person(name, age) {
        this.name = name
        this.age = age
    }
    
    // Method
    def introduce() {
        return "Hi, I'm ${name} and I'm ${age} years old."
    }
    
    // Overloaded method
    def greet(String greeting = "Hello") {
        return "${greeting}, ${name}!"
    }
}

// Creating objects
def john = new Person("John", 30)
println john.introduce()
println john.greet()
println john.greet("Hi")

// Properties with getters/setters (automatically generated)
class Book {
    String title
    String author
    BigDecimal price
    
    def getDiscountedPrice(discount) {
        return price * (1 - discount)
    }
}

def book = new Book(title: "Groovy in Action", author: "Dierk König", price: 45.99)
println book.getDiscountedPrice(0.1)

Metaprogramming

// Adding methods to existing classes
String.metaClass.isPalindrome = {
    delegate == delegate.reverse()
}

println "radar".isPalindrome()  // true
println "hello".isPalindrome()  // false

// Method missing
class DynamicClass {
    def methodMissing(String name, args) {
        println "You called: ${name} with args: ${args}"
    }
}

def obj = new DynamicClass()
obj.someMethod("arg1", "arg2")  // You called: someMethod with args: [arg1, arg2]

// Property missing
class DynamicProperties {
    def storage = [:]
    
    def propertyMissing(String name) {
        storage[name]
    }
    
    def propertyMissing(String name, value) {
        storage[name] = value
    }
}

def dynObj = new DynamicProperties()
dynObj.dynamicProperty = "Hello"
println dynObj.dynamicProperty  // Hello

File I/O and Text Processing

File Operations

// Reading files
def file = new File("data.txt")
def content = file.text
def lines = file.readLines()

// Writing files
new File("output.txt").text = "Hello, Groovy!"

// Processing file line by line
new File("large-file.txt").eachLine { line, lineNumber ->
    println "${lineNumber}: ${line}"
}

// Working with URLs
def url = new URL("https://api.example.com/data")
def jsonText = url.text

XML Processing

// Parsing XML
def xmlText = '''
<books>
    <book id="1">
        <title>Groovy in Action</title>
        <author>Dierk König</author>
    </book>
    <book id="2">
        <title>Programming Groovy</title>
        <author>Venkat Subramaniam</author>
    </book>
</books>
'''

def books = new XmlSlurper().parseText(xmlText)
books.book.each { book ->
    println "Title: ${book.title}, Author: ${book.author}"
}

// Creating XML
def writer = new StringWriter()
def xml = new groovy.xml.MarkupBuilder(writer)
xml.books {
    book(id: "1") {
        title("Groovy in Action")
        author("Dierk König")
    }
}
println writer.toString()

JSON Processing

import groovy.json.*

// Parsing JSON
def jsonText = '{"name": "John", "age": 30, "city": "New York"}'
def jsonSlurper = new JsonSlurper()
def person = jsonSlurper.parseText(jsonText)
println person.name  // John

// Creating JSON
def jsonBuilder = new JsonBuilder()
jsonBuilder {
    name "Alice"
    age 25
    hobbies(["reading", "swimming", "coding"])
}
println jsonBuilder.toPrettyString()

Build Tools and Frameworks

Gradle Build Scripts

// build.gradle
plugins {
    id 'java'
    id 'application'
}

repositories {
    mavenCentral()
}

dependencies {
    implementation 'org.apache.commons:commons-lang3:3.12.0'
    testImplementation 'junit:junit:4.13.2'
}

application {
    mainClass = 'com.example.Main'
}

task hello {
    doLast {
        println 'Hello, Gradle!'
    }
}

// Custom task
task generateReport {
    def reportFile = file("${buildDir}/reports/custom-report.txt")
    
    doLast {
        reportFile.parentFile.mkdirs()
        reportFile.text = "Report generated at: ${new Date()}"
        println "Report generated: ${reportFile.absolutePath}"
    }
}

Grails Web Framework

// Domain class
class Book {
    String title
    String author
    Date dateCreated
    
    static constraints = {
        title blank: false, maxSize: 255
        author blank: false, maxSize: 100
    }
}

// Controller
class BookController {
    def index() {
        [books: Book.list()]
    }
    
    def show(Long id) {
        def book = Book.get(id)
        if (!book) {
            flash.message = "Book not found"
            redirect(action: "index")
            return
        }
        [book: book]
    }
    
    def save() {
        def book = new Book(params)
        if (book.save(flush: true)) {
            flash.message = "Book saved successfully"
            redirect(action: "show", id: book.id)
        } else {
            render(view: "create", model: [book: book])
        }
    }
}

Spock Testing Framework

import spock.lang.Specification

class CalculatorSpec extends Specification {
    
    def calculator = new Calculator()
    
    def "should add two numbers correctly"() {
        when:
        def result = calculator.add(a, b)
        
        then:
        result == expected
        
        where:
        a  | b  | expected
        1  | 2  | 3
        5  | 3  | 8
        -1 | 1  | 0
    }
    
    def "should throw exception for division by zero"() {
        when:
        calculator.divide(10, 0)
        
        then:
        thrown(ArithmeticException)
    }
    
    def "should handle multiple scenarios"() {
        given:
        def numbers = [1, 2, 3, 4, 5]
        
        when:
        def sum = numbers.sum()
        def max = numbers.max()
        
        then:
        sum == 15
        max == 5
        numbers.size() == 5
    }
}

Database Access

GORM (Grails Object Relational Mapping)

// Domain class with relationships
class Author {
    String name
    String email
    
    static hasMany = [books: Book]
    
    static constraints = {
        name blank: false
        email email: true, unique: true
    }
}

class Book {
    String title
    String isbn
    Date publishedDate
    
    static belongsTo = [author: Author]
    
    static constraints = {
        title blank: false
        isbn matches: /\d{13}/
    }
}

// Database operations
def author = new Author(name: "John Doe", email: "[email protected]")
author.save()

def book = new Book(title: "Groovy Guide", isbn: "1234567890123", publishedDate: new Date())
book.author = author
book.save()

// Queries
def authors = Author.list()
def booksByAuthor = Book.findAllByAuthor(author)
def recentBooks = Book.findAllByPublishedDateGreaterThan(Date.parse('yyyy-MM-dd', '2020-01-01'))

SQL Integration

import groovy.sql.Sql

// Database connection
def sql = Sql.newInstance("jdbc:h2:mem:testdb", "sa", "", "org.h2.Driver")

// Create table
sql.execute('''
    CREATE TABLE users (
        id INT PRIMARY KEY,
        name VARCHAR(50),
        email VARCHAR(100)
    )
''')

// Insert data
sql.execute("INSERT INTO users VALUES (?, ?, ?)", [1, "John Doe", "[email protected]"])

// Query data
def users = sql.rows("SELECT * FROM users WHERE name LIKE ?", ["%John%"])
users.each { user ->
    println "User: ${user.name}, Email: ${user.email}"
}

// Close connection
sql.close()

Development Tools

IDEs and Editors

• IntelliJ IDEA: Excellent Groovy support
• Eclipse with Groovy-Eclipse plugin
• VSCode with Groovy extensions
• NetBeans with Groovy support

Build and Dependency Management

• Gradle: Build automation tool (written in Groovy)
• Maven: Can be used with Groovy projects
• Grape: Dependency management for scripts

Testing Tools

• Spock: BDD testing framework
• JUnit: Standard Java testing (works with Groovy)
• TestNG: Alternative testing framework

Scripting and Automation

Command-Line Scripts

#!/usr/bin/env groovy

// Simple file processing script
def inputFile = args[0]
def outputFile = args[1]

new File(inputFile).eachLine { line ->
    def processedLine = line.toUpperCase().reverse()
    new File(outputFile) << processedLine + "\n"
}

println "Processing complete: ${inputFile} -> ${outputFile}"

System Administration

// Process management
def process = "ls -la".execute()
process.waitFor()
println process.text

// File system operations
def dir = new File("/path/to/directory")
dir.eachFileRecurse { file ->
    if (file.name.endsWith('.log')) {
        println "Log file: ${file.absolutePath}"
    }
}

// Environment variables
println System.getenv('PATH')
println System.getProperty('user.home')

Common Use Cases

Build Automation

• Gradle build scripts
• CI/CD pipeline scripting
• Deployment automation
• Code generation

Testing and Quality Assurance

• Unit testing with Spock
• Integration testing
• Test data generation
• Performance testing scripts

Web Development

• Grails applications
• RESTful web services
• Template processing
• Configuration management

Data Processing

• ETL operations
• Log file analysis
• Report generation
• Data transformation

Notable Applications

• Netflix: Build and deployment automation
• LinkedIn: Gradle build system
• Gradle Inc.: Build automation platform
• Oracle: Internal tooling and automation
• Various Jenkins plugins: CI/CD automation

Learning Resources

• "Groovy in Action" by Dierk König
• "Programming Groovy 2" by Venkat Subramaniam
• "Making Java Groovy" by Ken Kousen
• Official Groovy documentation
• Groovy community forums and mailing lists

Groovy continues to be popular for build automation, testing, and rapid application development, offering Java developers a more concise and expressive language while maintaining full compatibility with the Java ecosystem.