Generate UUID in Groovy

Since Groovy is a JVM-based language, we can use the same libraries and methods we would have used in Java to generate UUIDs, as long as we do so in Groovy syntax. The following code snippet produces a valid version 4 UUID:

import java.util.UUID
println UUID.randomUUID()

If you need to generate a specific UUID version, you need to use a third-party library such as uuid-creator which offers more flexible options:

import com.github.f4b6a3.uuid.UuidCreator

//generate UUID version 1
var uuid = UuidCreator.getTimeBased()

//generate UUID version 2
var uuid = UuidCreator.getDceSecurity(UuidLocalDomain.LOCAL_DOMAIN_PERSON, 1234)

//generate UUID version 3
var uuid = UuidCreator.getNameBasedMd5(UuidNamespace.NAMESPACE_URL, "https://github.com/")

//generate UUID version 4
var uuid = UuidCreator.getRandomBased()

//generate UUID version 5
var uuid = UuidCreator.getNameBasedSha1(UuidNamespace.NAMESPACE_URL, "https://github.com/")

//generate UUID version 6
var uuid = UuidCreator.getTimeOrdered()

//generate UUID version 7
var uuid = UuidCreator.getTimeOrderedEpoch()

Installation & Setup

Gradle:

dependencies {
    implementation 'com.github.f4b6a3:uuid-creator:5.3.2'
}

Maven:

<dependency>
    <groupId>com.github.f4b6a3</groupId>
    <artifactId>uuid-creator</artifactId>
    <version>5.3.2</version>
</dependency>

Advanced Groovy Usage

UUID Service with Groovy Features:

import java.util.UUID
import com.github.f4b6a3.uuid.UuidCreator

class UUIDService {
    
    static String generateV4() {
        UUID.randomUUID().toString()
    }
    
    static String generateV7() {
        UuidCreator.getTimeOrderedEpoch().toString()
    }
    
    static boolean isValidUUID(String uuidString) {
        try {
            UUID.fromString(uuidString)
            return true
        } catch (IllegalArgumentException e) {
            return false
        }
    }
    
    static Integer getUUIDVersion(String uuidString) {
        try {
            return UUID.fromString(uuidString).version()
        } catch (IllegalArgumentException e) {
            return null
        }
    }
}

// Groovy extension methods
String.metaClass.isValidUUID = {
    UUIDService.isValidUUID(delegate)
}

// Usage
def uuid = UUIDService.generateV4()
println "Valid UUID: ${uuid.isValidUUID()}"

Grails Integration:

// Domain Class
class User {
    String id = UUID.randomUUID().toString()
    String name
    String email
    Date dateCreated
    Date lastUpdated
    
    static constraints = {
        id blank: false, unique: true
        name blank: false
        email email: true, unique: true
    }
    
    static mapping = {
        id generator: 'assigned'
    }
}

// Controller
class UUIDController {
    
    def generateUUID() {
        render([
            uuid: UUID.randomUUID().toString(),
            timestamp: new Date().format("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'")
        ] as JSON)
    }
    
    def generateNamedUUID(String name) {
        def namespace = UUID.fromString("6ba7b810-9dad-11d1-80b4-00c04fd430c8")
        def namedUUID = UUID.nameUUIDFromBytes("${namespace}${name}".bytes)
        
        render([
            uuid: namedUUID.toString(),
            name: name,
            deterministic: true
        ] as JSON)
    }
}

Spock Testing:

import spock.lang.Specification
import java.util.UUID

class UUIDServiceSpec extends Specification {
    
    def "should generate valid UUID v4"() {
        when:
        def uuid = UUIDService.generateV4()
        
        then:
        uuid != null
        uuid.isValidUUID()
        UUIDService.getUUIDVersion(uuid) == 4
    }
    
    def "should validate UUID format"() {
        expect:
        UUIDService.isValidUUID(validUUID) == expectedResult
        
        where:
        validUUID                              | expectedResult
        "550e8400-e29b-41d4-a716-446655440000" | true
        "invalid-uuid"                         | false
        ""                                     | false
        null                                   | false
    }
}

UUID Version Comparison

Choose the right version for your Groovy application:

• Version 1 - Time-based, includes MAC address
• Version 3 - MD5 namespace-based, deterministic
• Version 4 - Random, most popular choice
• Version 5 - SHA-1 namespace-based, more secure than v3
• Version 6 - Time-ordered, better than v1 for databases
• Version 7 - Modern time-based with improved sorting

For Groovy applications:

• Grails web apps: Use Version 4 for domain object IDs
• Build scripts: Consider Version 5 for deterministic build artifacts
• Testing frameworks: Use Version 1 for test execution tracking

How do I generate UUID in other languages?

JVM ecosystem:

• Java - Enterprise applications
• Kotlin - Modern JVM development
• Scala - Functional programming and big data

Scripting and web:

• JavaScript - crypto.randomUUID() & uuid library
• Python - Built-in uuid module
• PHP - Built-in functions & ramsey/uuid

← Back to Online UUID Generator