Building robust and scalable web apps can sometimes feel like trying to herd cats—it’s tricky, chaotic, and downright exhausting. But with Micronaut’s modern JVM-based architecture, you’ve struck gold. It’s packed with tools that make advanced routing and filtering a breeze. So let’s break down how to set up and use these tools in the easiest way possible without getting bogged down in jargon and technical mumbo jumbo.

First things first—set up your Micronaut application. Lucky for us, Micronaut CLI makes it a cinch. Run this command:

$ mn create-app hello-world

And boom! You’ve got yourself a new Micronaut app called hello-world with all the baseline code you need to hit the ground running. Now, let’s dive into the good stuff—routing in Micronaut.

Micronaut makes routing straightforward. For example, to create routes in your app, you can toss some annotations onto your controller classes like this:

import io.micronaut.http.annotation.Controller;
import io.micronaut.http.annotation.Get;
import io.micronaut.http.annotation.PathVariable;

@Controller("/users")
public class UserController {

    @Get("/{id}")
    public String getUser(@PathVariable Long id) {
        return "User ID: " + id;
    }
}

The @Controller annotation is basically like setting up an address; it marks the base path for your controller. The @Get annotation? That’s your mailman—delivering GET requests with a little path variable called id.

But what if you need to get a bit fancier with your routes, handling path variables and query parameters? Fear not. Here’s how you can do it:

import io.micronaut.http.annotation.Controller;
import io.micronaut.http.annotation.Get;
import io.micronaut.http.annotation.PathVariable;
import io.micronaut.http.annotation.QueryValue;

@Controller("/users")
public class UserController {

    @Get("/{id}")
    public String getUser(@PathVariable Long id) {
        return "User ID: " + id;
    }

    @Get("/search")
    public String searchUsers(@QueryValue("name") String name) {
        return "Searching for users with name: " + name;
    }
}

In this snippet, @PathVariable grabs those juicy path variables while @QueryValue handles query parameters. Easy peasy.

Now let’s talk filters, the unsung heroes of web applications. These bad boys let you intercept and tweak incoming requests and outgoing responses. You can create a basic filter like this:

import io.micronaut.http.HttpRequest;
import io.micronaut.http.HttpResponse;
import io.micronaut.http.annotation.Filter;
import io.micronaut.http.filter.HttpServerFilter;
import io.micronaut.http.filter.ServerFilterChain;

@Filter("/**")
public class MyFilter implements HttpServerFilter {

    @Override
    public Publisher<HttpResponse<?>> doFilter(HttpRequest<?> request, ServerFilterChain chain) {
        Object uriRouteMatch = request.getAttribute(io.micronaut.web.router.UriRouteMatch.ATTRIBUTE);
        if (uriRouteMatch != null) {
            io.micronaut.web.router.UriRouteMatch match = (io.micronaut.web.router.UriRouteMatch) uriRouteMatch;
            Map<String, Object> pathVariables = match.getVariables();
            // Do something with path variables if needed
        }
        
        return chain.proceed(request);
    }
}

This filter captures all incoming requests and lets you access path variables using the UriRouteMatch attribute. Pretty slick, huh?

Now that you’re getting the hang of basic filters, let’s get wild and modify some requests and responses. Want to slap a custom header onto all responses? Check this out:

import io.micronaut.http.HttpRequest;
import io.micronaut.http.HttpResponse;
import io.micronaut.http.annotation.Filter;
import io.micronaut.http.filter.HttpServerFilter;
import io.micronaut.http.filter.ServerFilterChain;
import io.micronaut.http.MutableHttpResponse;

@Filter("/**")
public class ResponseHeaderFilter implements HttpServerFilter {

    @Override
    public Publisher<MutableHttpResponse<?>> doFilter(HttpRequest<?> request, ServerFilterChain chain) {
        return chain.proceed(request)
            .map(response -> response.header("Custom-Header", "Value"));
    }
}

This will ensure every response that cruises through this filter gets a shiny new custom header. Nice and easy, right?

But wait, there’s more! What if you need to tap into external services? Micronaut’s got your back with its powerful HTTP client. Here’s how you set up a simple HTTP client:

import io.micronaut.http.annotation.Get;
import io.micronaut.http.client.annotation.Client;
import io.micronaut.http.client.annotation.Path;

@Client("https://api.example.com")
public interface ExampleClient {

    @Get("/users/{id}")
    String getUser(@Path Long id);
}

You can then inject this client into your controllers or services and start fetching data from external APIs like a pro:

import io.micronaut.inject.Inject;
import io.micronaut.http.annotation.Controller;
import io.micronaut.http.annotation.Get;

@Controller("/users")
public class UserController {

    @Inject
    private ExampleClient exampleClient;

    @Get("/{id}")
    public String getUser(@PathVariable Long id) {
        return exampleClient.getUser(id);
    }
}

Now you’re rolling, fetching data from external services effortlessly. But hey, not everything’s rainbows and butterflies. Sometimes things go wrong. Handling errors and exceptions properly is key to building a solid app. Micronaut helps you out here as well. You can throw an error handler into the mix like this:

import io.micronaut.http.HttpRequest;
import io.micronaut.http.HttpResponse;
import io.micronaut.http.annotation.Error;
import io.micronaut.http.server.exceptions.ExceptionHandler;

@Controller
public class ErrorHandler {

    @Error
    public HttpResponse<String> error(HttpRequest<?> request, Throwable exception) {
        return HttpResponse.serverError("An error occurred: " + exception.getMessage());
    }
}

This handler catches those pesky unhandled exceptions and serves up a server error response, keeping your app from crashing and burning.

To wrap things up, getting a grip on Micronaut’s advanced routing and filtering will supercharge your ability to build modern web applications. Micronaut’s HTTP client and server features provide all the tools you need to create efficient, scalable, and maintainable applications. From handling path variables, modifying requests and responses to managing errors—Micronaut’s got you covered.

The framework’s swift startup times, low memory footprint, and minimal reflection usage make Micronaut an exceptional choice for everything from serverless functions to microservices. So gear up and dive into the Micronaut world—it’s definitely worth the plunge.