OpenParable
Skip to content
← Back to skills

Java Developer

Development
java-developer

Java Developer is an Agent Skill for development published in the apache/grails-core repository on GitHub: a SKILL.md instruction file an AI agent can load to do this task.

Guide for developing on the Java 21 baseline, including modern features, best practices, and integration with Groovy/Grails projects

View on GitHub ↗
QUICK START

How to use this skill

Bring this guide into your coding agent with a prompt tailored to the tool you use.

  1. Open your project in Codex.
  2. Copy and paste the prompt below.
  3. Review files and risks before approving any action.
Prompt to paste
Inspect the Agent Skill at https://github.com/apache/grails-core/blob/HEAD/.agents/skills/java-developer/SKILL.md and all supporting files. Report provenance, permissions, scripts, dependencies, and security risks. Propose an exact installation into .agents/skills/java-developer, but wait for my approval before writing files or running scripts.

Copying this prompt does not install or run the skill. Review third-party files before use.

What I Do

  • Provide guidance on Java 21 syntax, features, and APIs for use in Grails/Groovy projects.
  • Assist with code generation, refactoring, and debugging using modern Java features like records, sealed classes, pattern matching, and text blocks.
  • Recommend best practices for Java code that interoperates with Groovy in mixed-language projects.
  • Guide on tooling: Gradle builds, JDK setup, testing with JUnit 5/Spock, and profiling.

When to Use Me

Use this skill when working on Java code within this repository, especially for:

  • Writing Java classes that will be used alongside Groovy code.
  • Implementing features using records, sealed classes, or pattern matching for instanceof.
  • Migrating older Java code (e.g., Java 8/11/17) to Java 21 idioms.
  • Performance optimization, security hardening, or module system (JPMS) questions.
  • Understanding how Java code integrates with Groovy's dynamic features.

Java 21 Baseline Features

Records (JEP 395)

Immutable data carriers with auto-generated constructors, accessors, equals, hashCode, and toString:

public record Book(String title, String author, int year) {
    // Compact constructor for validation
    public Book {
        if (title == null || title.isBlank()) {
            throw new IllegalArgumentException("Title cannot be blank");
        }
    }
}

Sealed Classes (JEP 409)

Restrict which classes can extend or implement a type:

public sealed interface Shape permits Circle, Rectangle, Triangle {
    double area();
}

public final class Circle implements Shape {
    private final double radius;
    public Circle(double radius) { this.radius = radius; }
    public double area() { return Math.PI * radius * radius; }
}

public non-sealed class Rectangle implements Shape {
    // Can be further extended
}

Pattern Matching for instanceof (JEP 394)

Eliminate redundant casts:

// Before pattern matching
if (obj instanceof String) {
    String s = (String) obj;
    System.out.println(s.length());
}

// Modern Java
if (obj instanceof String s) {
    System.out.println(s.length());
}

Text Blocks (JEP 378)

Multi-line string literals with proper formatting:

String json = """
    {
        "name": "Grails",
        "version": "7.0"
    }
    """;

String sql = """
    SELECT id, name, created_at
    FROM users
    WHERE status = 'ACTIVE'
    ORDER BY created_at DESC
    """;

Switch Expressions (JEP 361)

Use switch as an expression with arrow syntax:

String result = switch (day) {
    case MONDAY, FRIDAY, SUNDAY -> "Relaxed";
    case TUESDAY -> "Productive";
    case THURSDAY, SATURDAY -> "Moderate";
    case WEDNESDAY -> {
        var temp = calculateWorkload();
        yield temp > 5 ? "Busy" : "Normal";
    }
};

Enhanced NullPointerException Messages (JEP 358)

Detailed NPE messages showing exactly which variable was null:

Cannot invoke "String.length()" because "user.getAddress().getCity()" is null

Helpful Stream and Collection APIs

// Stream.toList() - unmodifiable list
List<String> names = users.stream()
    .map(User::getName)
    .toList();

// Collectors improvements
Map<Status, List<User>> byStatus = users.stream()
    .collect(Collectors.groupingBy(User::getStatus));

Java/Groovy Interoperability

Calling Java from Groovy

Groovy seamlessly calls Java code:

// Java record used in Groovy
def book = new Book("Grails Guide", "Author", 2024)
println book.title()  // Groovy can use property syntax too
println book.title    // Also works

Calling Groovy from Java

// Groovy classes are just Java classes
GroovyService service = new GroovyService();
service.process(data);

// Working with Groovy closures in Java
Closure<String> closure = ...;
String result = closure.call("input");

Best Practices for Mixed Projects

  • Use Java for performance-critical code with @CompileStatic equivalent behavior.
  • Use Java records for DTOs shared between Java and Groovy code.
  • Prefer Java interfaces that Groovy classes implement.
  • Avoid Groovy-specific features (like categories) in APIs consumed by Java.

Build and Testing

Gradle Configuration

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(17)
    }
}

tasks.withType(JavaCompile).configureEach {
    options.encoding = 'UTF-8'
    options.compilerArgs += ['-parameters']  // Preserve parameter names
}

Testing with JUnit 5

@Test
@DisplayName("Book record should validate title")
void bookShouldValidateTitle() {
    assertThrows(IllegalArgumentException.class, () ->
        new Book("", "Author", 2024)
    );
}

@ParameterizedTest
@ValueSource(strings = {"", " ", "  "})
void blankTitlesShouldBeRejected(String title) {
    assertThrows(IllegalArgumentException.class, () ->
        new Book(title, "Author", 2024)
    );
}

Testing with Spock (from Groovy)

def "Java record should work in Spock tests"() {
    when:
    def book = new Book("Test", "Author", 2024)

    then:
    book.title() == "Test"
    book.author() == "Author"
}

Performance and Profiling

JVM Options for Java 21

# Recommended GC for most workloads
-XX:+UseG1GC

# For low-latency requirements
-XX:+UseZGC

# Memory settings
-Xms512m -Xmx2g

# Enable JFR for profiling
-XX:StartFlightRecording=duration=60s,filename=recording.jfr

Profiling Tools

  • JDK Flight Recorder (JFR): Built-in low-overhead profiler
  • VisualVM: GUI-based monitoring and profiling
  • async-profiler: Low-overhead sampling profiler

Common Patterns

Null Handling with Optional

public Optional<User> findById(Long id) {
    return Optional.ofNullable(repository.get(id));
}

// Usage
String name = findById(id)
    .map(User::getName)
    .orElse("Unknown");

Resource Management with try-with-resources

try (var reader = new BufferedReader(new FileReader(path));
     var writer = new BufferedWriter(new FileWriter(output))) {
    reader.lines()
        .map(String::toUpperCase)
        .forEach(line -> writer.write(line + "\n"));
}

Immutable Collections

// Create immutable collections
List<String> list = List.of("a", "b", "c");
Set<String> set = Set.of("x", "y", "z");
Map<String, Integer> map = Map.of("one", 1, "two", 2);

// Copy to immutable
List<String> copy = List.copyOf(mutableList);

Code Style Guidelines

  • Follow existing patterns in the codebase.
  • Use var for local variables when the type is obvious from context.
  • Prefer records for simple data carriers.
  • Use sealed classes to model restricted type hierarchies.
  • Add @Override annotation when overriding methods.
  • Use meaningful parameter names (preserved with -parameters flag).

Resources