When it comes to building reliable Java applications, data integrity can’t be overlooked. Enter Micronaut – a modern Java framework that packs a punch when it comes to data validation. In this write-up, we’re diving deep into Micronaut’s validation features to see how they help keep data in check, ensuring it’s clean and correct right from the compile time.

Getting Going with Micronaut

So, whether you’re a seasoned pro or just starting out, setting up Micronaut is pretty straightforward. You’ve got two main routes: the Micronaut Command Line Interface (CLI) or Micronaut Launch. A quick and simple command can get you started:

mn create-app example.micronaut.micronautguide --features=junit-params,validation --build=gradle --lang=java --test=junit

Boom! You’ve got a Micronaut app with validation ready to roll.

Adding the Essentials

To unlock Micronaut’s validation magic, you’ve got to add some dependencies to your project. If you’re using Gradle, toss these into your build file:

dependencies {
    implementation "io.micronaut.validation:micronaut-validation"
    annotationProcessor "io.micronaut.validation:micronaut-validation-processor"
}

Going the Maven route? Here’s what you need:

<dependency>
    <groupId>io.micronaut.validation</groupId>
    <artifactId>micronaut-validation</artifactId>
</dependency>
<dependency>
    <groupId>io.micronaut.validation</groupId>
    <artifactId>micronaut-validation-processor</artifactId>
    <scope>annotationProcessor</scope>
</dependency>

These dependencies are key to enabling validation features and, importantly, ensuring annotations get validated right when you’re compiling your code.

Validation Annotations to the Rescue

Micronaut doesn’t mess around with data. Using validation annotations from the jakarta.validation package, you can impose serious constraints on your data fields. Let’s look at a quick example with a User class:

import io.micronaut.core.annotation.Introspected;
import jakarta.validation.constraints.NotBlank;

@Introspected
public class User {
    @NotBlank
    private String username;

    @NotBlank
    private String email;

    // Getters and setters
}

In this scenario, the @NotBlank annotation makes sure the username and email fields aren’t blank, keeping things tidy and error-free. If any field is blank, Micronaut’s going to throw a fit – a validation error, to be precise.

Rolling Out Your Own Custom Annotations

Sometimes, basic validation doesn’t cut it. No worries, though. Micronaut lets you whip up your custom validation logic. Say you want to validate phone numbers in E.164 format – here’s how to set up a custom annotation for that:

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import jakarta.validation.Constraint;
import jakarta.validation.Payload;

@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy = PhoneValidator.class)
public @interface E164 {
    String message() default "must be a phone in E.164 format";
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};
}

Next, create a validator class:

import io.micronaut.validation.validator.constraints.ConstraintValidator;
import jakarta.validation.ConstraintValidatorContext;

public class PhoneValidator implements ConstraintValidator<E164, String> {
    @Override
    public boolean isValid(String phoneNumber, ConstraintValidatorContext context) {
        // Implement your E.164 validation logic here
        return phoneNumber.matches("\\+\\d{1,3}[-\\.\\s]?\\(\\d{1,3}\\)?[-\\.\\s]?\\d{1,4}[-\\.\\s]?\\d{1,4}[-\\.\\s]?\\d{1,9}");
    }
}

Now, your custom annotation is ready for action:

@Introspected
public class Contact {
    @E164
    private String phoneNumber;

    // Getters and setters
}

Throw an invalid phone number at it, and Micronaut won’t let it slide. Expect a nice, clear validation error.

Compile-Time Validation is a Game-Changer

One killer feature of Micronaut is its compile-time validation. Thanks to the micronaut-validation-processor, it checks annotation values during compile time and stops the build if there are constraint violations. This is a massive win, catching potential errors early in the development process.

Take a custom @TimeOff annotation with a constraint on its duration field for instance:

@Retention(RetentionPolicy.RUNTIME)
public @interface TimeOff {
    @DurationPattern
    String duration();
}

// Attempting to use @TimeOff with an invalid duration
@TimeOff(duration = "junk")
public class InvalidUsage {
    // This will fail compilation
}

Using @TimeOff with “junk” as its duration fails the compilation, ensuring no bad data makes it through.

Putting Validation to the Test

To make sure your validation is on point, you need to test it. Micronaut’s Validator interface makes this a walk in the park. Here’s a sample for testing a Contact object:

import io.micronaut.test.annotation.MicronautTest;
import jakarta.validation.ConstraintViolation;
import jakarta.validation.Validator;

@MicronautTest
public class ContactTest {

    @Inject
    private Validator validator;

    @Test
    public void testValidation() {
        Contact contact = new Contact();
        contact.setPhoneNumber("invalid-phone-number");

        Set<ConstraintViolation<Contact>> violations = validator.validate(contact);
        assertTrue(violations.size() > 0);
        assertEquals("must be a phone in E.164 format", violations.iterator().next().getMessage());
    }
}

This snippet guarantees that the phoneNumber field is validated properly and that the expected error message pops up.

Wrapping It Up

Micronaut’s validation makes sure your Java applications are as robust as they can be. By leveraging both standard and custom validation annotations, you can keep data integrity issues at bay. The added bonus of compile-time validation means fewer bugs and more reliable applications. Following these steps and examples, you can harness the full power of Micronaut’s validation features and create rock-solid apps.