To explain the differences:

Part 1: registering endpoints

Your code registers an endpoint by using the "@path" annotation in one spot, and applying "@get" on a method.

In Minum the equivalent, as succinctly as possible, is:

var wf = minum.getWebFramework();
wf.registerPath(GET, "hello", r -> Response.htmlOk("<p>Hi there world!</p>"));

And then you could see "Hi there world" when visiting localhost:8080/hello

Note there is no use of reflection in Minum, and no annotations required to use the framework. All code is plain Java (in case you were
curious, it's to make stack traces and debugging clearer).

One of the example projects declares its endpoints here and an example of an endpoint is here

Part 2: parameters in URLs

On the topic of parameters like "id" in URLs, you can specify values easier with query strings than path parameters. If you have an endpoint that takes a parameter of id, it is preferred to be http://foo.com/getbar?id=baz. Note the syntax - the key-value pairs start with a question mark. See here for a description of query strings. To make that happen, the definition of the endpoint handler needs a line like this:

String id = r.requestLine().queryString().get("id");

An example is here where the endpoint will say "hello" to the value assigned to a query string key of "name", for example, "hello foo".

It is possible to use path parameters, but it's harder. Path parameters add complexity for the (questionable) benefit of including parameters where one would (and should) expect path values, due to a (in my opinion, misguided) desire to follow the supposed needs of RESTful patterns. This is against the theme of Minum, which chooses the overall less-complex approach regardless of fashion or convention for the benefit of maintainability. I found it necessary to include this capability in Minum, though, just in order to provide an endpoint for the Acme challenge with Let's Encrypt.

In any case, in order to have path parameters it is necessary to register a "partial path" and then use regular expressions to extract the values. For example, if you were using a pattern like http://foo.com/well-known/acme-challenge/{challengeValue}, it would be registered like this:

webFramework.registerPartialPath(GET, "well-known/acme-challenge", letsEncrypt::challengeResponse);

and then the endpoint would look like this:

Pattern myPattern = Pattern.compile("well-known/acme-challenge/(?<challengeValue>.*$)");
final var myMatcher = myPattern.matcher(request.requestLine().getPathDetails().isolatedPath());

if (! myMatcher.find()) {
    return new Response(StatusLine.StatusCode.CODE_400_BAD_REQUEST);
}

String challengeValue = challengeMatcher.group("challengeValue");

Part 3: Content type

One other item you bring up is specifying the content-type of the response. In your example it was @Produces(JabrefMediaType.BIBTEX) - I think that would be a Mime or content-type of "text/plain" or "application/x-bibtex". The output of the method is basically just text in the Bibtext format. So, just riffing here, the endpoint registration would look like this:

// bibtext stuff
webFramework.registerPath(RequestLine.Method.GET, "bibtex", sd::getBibtex);

And the method would look a bit like this:

public IResponse getBibtex(IRequest request) {
    String id = request.getRequestLine().queryString().get("id");
    // do some bibtex stuff
    String body = """
            @misc{ patashnik-bibtexing,
                   author = "Oren Patashnik",
                   title = "BIBTEXing",
                   year = "1988" }
            """;

    return Response.buildResponse(CODE_200_OK, Map.of("Content-type", "application/x-bibtex"), body);
}

Part 4

The difference in Minum is a consequence of its approach - using annotations like you mentioned ("@get", "@path", etc.) entail extra moving parts which complicate the effort of maintenance.

I took a few shortcuts in explaining all this, so please reply for any points needing greater clarity.