Content Negotiation with a Java MicroProfile Application

GET /user/123 HTTP/1.1
Accept: application/json,application/xml;q=0.9
Accept-Encoding: gzip
Accept-Language: en,fr
Host: api.example.com
User-Agent: Client/2.0

                                        HTTP/1.1 200 OK
                                        Content-Type: application/xml
                                        Content-Encoding: gzip
                                        Content-Language: en

                                        <user id="123">
                                          ...
                                        </user>

http :8080/roll dice==2d6 "Accept-Encoding: gzip"

HTTP/1.1 200 OK
Content-Type: application/json
Content-Encoding: gzip (1)
Content-Length: 106

{
    "expression": {
        "numberOfDice": 2,
        "numberOfFaces": 6
    },
    ...
    "value": 9
}

@Path("/lang")
@GET
public Response getLang(@Context Request request) {
    List<Variant> variants = Variant.VariantListBuilder.newInstance() (1)
            .languages(Locale.ENGLISH, Locale.GERMAN) (2)
            .build();

    Variant variant = request.selectVariant(variants); (3)

    if (variant == null) { (4)
        return Response.notAcceptable(variants).build();
    }

    // set the response header, to the client knows which language was selected
    String lang = variant.getLanguageString();
    return Response.ok(lang)
            .header(HttpHeaders.CONTENT_LANGUAGE, lang)
            .build(); (5)
}

http :8080/roll/lang "Accept-Language: de"

HTTP/1.1 200 OK
Content-Language: de (1)
Content-Type: text/plain;charset=UTF-8
Vary: Accept-Language
content-encoding: gzip
content-length: 28

de

package com.example;

import javax.ws.rs.container.*;
import javax.ws.rs.core.*; // wildcard for brevity
import javax.ws.rs.ext.Provider;
import java.util.List;
import java.util.Locale;

@Provider
public class LanguageFilter implements ContainerRequestFilter, ContainerResponseFilter {

    final private static String LANG = "LanguageFilter.lang";

    final public static List<Variant> VARIANTS = Variant.VariantListBuilder.newInstance()
            .languages(Locale.ENGLISH, Locale.GERMAN) (1)
            .build();

    @Override
    public void filter(ContainerRequestContext requestContext) {
        Variant variant = requestContext.getRequest().selectVariant(VARIANTS); (2)

        if (variant == null) { (3)
            // Error, respond with 406
            requestContext.abortWith(Response.notAcceptable(VARIANTS).build());
        } else {
            // keep the resolved lang around for the response
            requestContext.setProperty(LANG, variant.getLanguageString()); (4)
        }
    }

    @Override
    public void filter(ContainerRequestContext requestContext, ContainerResponseContext responseContext) {
        String lang = (String) requestContext.getProperty(LANG);
        responseContext.getHeaders().putSingle(HttpHeaders.CONTENT_LANGUAGE, lang); (5)
    }
}

http :8080/roll dice==2d8+1 "Accept-Language: en"

HTTP/1.1 200 OK
Content-Language: en
Content-Type: application/json
Vary: Accept-Language
content-encoding: gzip
content-length: 154

{
    "expression": {
        "left": {
            "numberOfDice": 2,
            "numberOfFaces": 8
        },
        "operation": "ADD",
        "right": {
            "value": 1
        }
    },
    "results": [
    ...
    ],
    "value": 8
}

package com.example;

import dev.diceroll.parser.Dice;
import dev.diceroll.parser.ResultTree;

import javax.ws.rs.Produces;
import javax.ws.rs.WebApplicationException;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.MultivaluedMap;
import javax.ws.rs.ext.MessageBodyWriter;
import javax.ws.rs.ext.Provider;
import java.io.IOException;
import java.io.OutputStream;
import java.lang.annotation.Annotation;
import java.lang.reflect.Type;
import java.nio.charset.StandardCharsets;

@Provider
@Produces(MediaType.TEXT_PLAIN) (1)
public class TextDiceTreeMessageBodyWriter implements MessageBodyWriter<ResultTree> {

    @Override
    public boolean isWriteable(Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType) {
        return type == ResultTree.class; (2)
    }

    @Override
    public void writeTo(ResultTree resultTree,
                        Class<?> type, Type genericType,
                        Annotation[] annotations,
                        MediaType mediaType,
                        MultivaluedMap<String, Object> httpHeaders,
                        OutputStream entityStream) throws IOException, WebApplicationException {

        String result = Dice.debug(resultTree); (3)
        entityStream.write(result.getBytes(StandardCharsets.UTF_8)); (4)
    }
}

http :8080/roll dice==3d10k2 "Accept: text/plain"

HTTP/1.1 200 OK
Content-Language: en
Content-Type: text/plain;charset=UTF-8
Vary: Accept-Language
content-encoding: gzip
content-length: 69

3d10k2 + 1 = 8
--3d10k2 = 7
----d10 = 4
----d10 = 2
----d10 = 3
--1 = 1

package com.example;

import java.util.Arrays;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public enum Agents {

    CURL("curl"),
    HTTPIE("HTTPie");

    final private String agentName;
    final private static Pattern TOOL_REGEX = Pattern.compile("([^\\/]*)\\/([^ ]*).*"); (1)

    Agents(String agentName) {
        this.agentName = agentName;
    }

    public static Agents parse(String userAgent) { (2)
        Matcher matcher = TOOL_REGEX.matcher(userAgent);
        String name = (matcher.matches()) ? matcher.group(1) : null;
        return Arrays.stream(Agents.values())
                .filter(agent -> agent.agentName.equals(name))
                .findFirst()
                .orElse(null);
    }
}

package com.example;

import javax.ws.rs.core.UriInfo;
import java.text.MessageFormat;
import java.util.Locale;
import java.util.Map;
import java.util.ResourceBundle;

public class Help {

    final static private Map<Agents, String> AGENT_HELP_MAP = Map.of(
            Agents.CURL, "help.curl",
            Agents.HTTPIE, "help.httpie"
    );

    public static String getHelp(String userAgent, UriInfo uriInfo, Locale locale) {

        String url = uriInfo.getBaseUri().resolve("/").toString(); (1)

        Agents agent = Agents.parse(userAgent); (2)

        // look up the help key
        String helpKey = AGENT_HELP_MAP.getOrDefault(agent, "help.generic"); (3)

        // Resource Bundle lookup/formatting
        ResourceBundle resourceBundle = ResourceBundle.getBundle("messages", locale); (4)
        MessageFormat formatter = new MessageFormat(resourceBundle.getString(helpKey), locale);
        return formatter.format(new Object[] { url });
    }
}

package com.example;

import javax.ws.rs.*;
import javax.ws.rs.core.*; // for brevity

@Path("/")
public class HelpResource {

    @GET
    @Produces(MediaType.TEXT_PLAIN)
    public String help(@HeaderParam(HttpHeaders.USER_AGENT) String userAgent, (1)
                       @Context Request request, (2)
                       @Context UriInfo uriInfo) { (3)
        return Help.getHelp(userAgent,
                uriInfo,
                request.selectVariant(LanguageFilter.VARIANTS).getLanguage()); (4)
    }
}

http :8080/ "Accept-Language: en" "Accept: text/plain" "Accept-encoding: gzip"

HTTP/1.1 200 OK
Content-Language: en
Content-Type: text/plain;charset=UTF-8
Vary: Accept-Language
content-encoding: gzip
content-length: 251

Welcome to the Dice Parser!!

Roll dice by making a request:
    http http://localhost:8080/roll?dice=2d6 "Accept: text/plain"

Or get the result in JSON:
    http http://localhost:8080/roll?dice=2d6 "Accept: application/json"