JAX-RS - @Provider Examples

package com.logicbig.example;

import javax.ws.rs.ext.ParamConverter;
import javax.ws.rs.ext.ParamConverterProvider;
import javax.ws.rs.ext.Provider;
import java.lang.annotation.Annotation;
import java.lang.reflect.Type;
import java.time.LocalDateTime;

@Provider
public class MyDateConverterProvider implements ParamConverterProvider {
    @Override
    public <T> ParamConverter<T> getConverter(Class<T> rawType, Type genericType,
                                                          Annotation[] annotations) {
        if (rawType == LocalDateTime.class) {
            return (ParamConverter<T>) new MyDateConverter();
        }
        return null;
    }
}

Original Post

package com.logicbig.example;
import javax.ws.rs.container.ContainerRequestContext;
import javax.ws.rs.container.ContainerRequestFilter;
import javax.ws.rs.core.MultivaluedMap;
import javax.ws.rs.ext.Provider;
import java.io.IOException;

@Provider
public class MyFilter implements ContainerRequestFilter {

    @Override
    public void filter(ContainerRequestContext requestContext) throws IOException {
        System.out.println("--request headers-----");
        MultivaluedMap<String, String> headers = requestContext.getHeaders();
        headers.entrySet().forEach(System.out::println);
    }
}

Original Post

Writing an Entity Provider

@Provider
@Consumes({"application/yaml", MediaType.TEXT_PLAIN})
@Produces({"application/yaml", MediaType.TEXT_PLAIN})
public class YamlEntityProvider<T> implements MessageBodyWriter<T>, MessageBodyReader<T> {

    @Override
    public boolean isReadable(Class<?> type, Type genericType, Annotation[] annotations,
                              MediaType mediaType) {
        return true;
    }

    @Override
    public T readFrom(Class<T> type, Type genericType, Annotation[] annotations, MediaType mediaType,
                      MultivaluedMap<String, String> httpHeaders, InputStream entityStream)
            throws IOException, WebApplicationException {
        Yaml yaml = new Yaml();
        T t = yaml.loadAs(toString(entityStream), type);
        return t;
    }

    public static String toString(InputStream inputStream) {
        return new Scanner(inputStream, "UTF-8")
                .useDelimiter("\\A").next();
    }

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

    @Override
    public long getSize(T t, Class<?> type, Type genericType, Annotation[] annotations,
                        MediaType mediaType) {
        return -1;
    }

    @Override
    public void writeTo(T t, Class<?> type, Type genericType, Annotation[] annotations,
                        MediaType mediaType, MultivaluedMap<String, Object> httpHeaders,
                        OutputStream entityStream) throws IOException, WebApplicationException {
        Yaml yaml = new Yaml();
        OutputStreamWriter writer = new OutputStreamWriter(entityStream);
        yaml.dump(t, writer);
        writer.close();
    }
}

Original Post

package com.logicbig.example;

import javax.ws.rs.ext.ContextResolver;
import javax.ws.rs.ext.Provider;

@Provider
public class MyContextResolver implements
        ContextResolver<MyContext> {
    private MyContext context = new MyContextImpl();

    @Override
    public MyContext getContext(Class<?> type) {
        if (type == String.class) {
            return context;
        }
        return null;
    }

    private static class MyContextImpl implements MyContext<String> {
        @Override
        public String get(String key) {
            return "a context value for key=" + key;
        }
    }
}

Original Post

@Provider
public class YamlContextResolver implements
        ContextResolver<YamlContext> {
    private YamlContext defaultContext = new SnakeYamlContext();

    @Override
    public YamlContext getContext(Class<?> type) {
        //we can restrict the return value based on type
        return defaultContext;
    }
}

Original Post

@Provider
@Consumes({"application/yaml", MediaType.TEXT_PLAIN})
@Produces({"application/yaml", MediaType.TEXT_PLAIN})
public class YamlEntityProvider<T> implements MessageBodyWriter<T>, MessageBodyReader<T> {
    @Context
    private Providers providers;

    @Override
    public boolean isReadable(Class<?> type, Type genericType, Annotation[] annotations,
                              MediaType mediaType) {
        return true;
    }

    @Override
    public T readFrom(Class<T> type, Type genericType, Annotation[] annotations, MediaType mediaType,
                      MultivaluedMap<String, String> httpHeaders, InputStream entityStream)
            throws IOException, WebApplicationException {
        ContextResolver<YamlContext> cr = providers.getContextResolver(YamlContext.class, mediaType);
        YamlContext context = cr.getContext(type);
        T t = context.readEntity(entityStream, type);
        return t;
    }

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

    @Override
    public long getSize(T t, Class<?> type, Type genericType, Annotation[] annotations,
                        MediaType mediaType) {
        return -1;
    }

    @Override
    public void writeTo(T t, Class<?> type, Type genericType, Annotation[] annotations,
                        MediaType mediaType, MultivaluedMap<String, Object> httpHeaders,
                        OutputStream entityStream) throws IOException, WebApplicationException {
        ContextResolver<YamlContext> cr = providers.getContextResolver(YamlContext.class, mediaType);
        YamlContext context = cr.getContext(type);
        context.writeEntity(entityStream, t);

    }
}

Original Post

package com.logicbig.example;

import javax.ws.rs.core.Response;
import javax.ws.rs.ext.ExceptionMapper;
import javax.ws.rs.ext.Provider;

@Provider
public class InvalidIdExceptionMapper
        implements ExceptionMapper<InvalidIdException> {


    @Override
    public Response toResponse(InvalidIdException exception) {
        return Response.status(Response.Status.NOT_FOUND)
                       .entity(prepareMessage(exception))
                       .type("text/plain")
                       .build();
    }

    private String prepareMessage(InvalidIdException exception) {

        String m = exception.getMessage();
        String r = "Invalid request.\n";
        r += String.format("Error Message: %s.%nError Type: %s.%n"
                        + "You may contact admin@example.com for more questions.",
                m, exception.getClass());
        return r;
    }
}

Original Post

@Provider
@Logged
public class LogFilter implements ContainerRequestFilter, ContainerResponseFilter {

    @Override
    public void filter(ContainerRequestContext reqContext) throws IOException {
        System.out.println("-- req info --");
        UriInfo uriInfo = reqContext.getUriInfo();
        log(uriInfo, reqContext.getHeaders());
    }

    @Override
    public void filter(ContainerRequestContext reqContext,
                       ContainerResponseContext resContext) throws IOException {
        System.out.println("-- res info --");
        UriInfo uriInfo = reqContext.getUriInfo();
        log(uriInfo, resContext.getHeaders());
    }

    private void log(UriInfo uriInfo, MultivaluedMap<String, ?> headers) {
        System.out.println("Path: " + uriInfo.getPath());
        headers.entrySet().forEach(h -> System.out.println(h.getKey() + ": " + h.getValue()));
    }
}

import javax.ws.rs.NameBinding;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@NameBinding
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(value = RetentionPolicy.RUNTIME)
public @interface Logged {
}

Original Post

import javax.ws.rs.container.DynamicFeature;
import javax.ws.rs.container.ResourceInfo;
import javax.ws.rs.core.FeatureContext;
import javax.ws.rs.ext.Provider;
import java.lang.reflect.Method;

@Provider
public class FilterRegistrationFeature implements DynamicFeature {
    @Override
    public void configure(ResourceInfo resourceInfo, FeatureContext context) {
        if (MyResource.class.isAssignableFrom(resourceInfo.getResourceClass())) {
            Method method = resourceInfo.getResourceMethod();
            if (method.getName().toLowerCase().contains("order")) {
                System.out.println("registering LogFilter");
                context.register(new LogFilter());
            }
        }
    }
}

Original Post

@Priority(1)
@Provider
public class InvalidRequestFilter implements ContainerRequestFilter {

    @Override
    public void filter(ContainerRequestContext reqContext) throws IOException {
        Response responseForInvalidRequest = validateRequest(reqContext);
        if (responseForInvalidRequest != null) {
            reqContext.abortWith(responseForInvalidRequest);
        }
    }

    private Response validateRequest(ContainerRequestContext reqContext) {
        UriInfo uriInfo = reqContext.getUriInfo();
        String path = uriInfo.getPath();
        if (path.equals("orders/history")) {
            String msg = String.format("The feature is not yet supported: %s%n", path);
            CacheControl cc = new CacheControl();
            cc.setNoStore(true);
            Response response = Response.status(Response.Status.NOT_IMPLEMENTED)
                                        .cacheControl(cc)
                                        .entity(msg)
                                        .build();
            return response;
        }
        return null;
    }
}

Original Post

@Priority(2)
@Provider
public class LogFilter implements ContainerRequestFilter, ContainerResponseFilter {

    @Override
    public void filter(ContainerRequestContext reqContext) throws IOException {
        System.out.println("-- request info --");
        UriInfo uriInfo = reqContext.getUriInfo();
        log(uriInfo, reqContext.getHeaders());
    }

    @Override
    public void filter(ContainerRequestContext reqContext,
                       ContainerResponseContext resContext) throws IOException {
        System.out.println("-- response info --");
        UriInfo uriInfo = reqContext.getUriInfo();
        log(uriInfo, resContext.getHeaders());
    }

    private void log(UriInfo uriInfo, MultivaluedMap<String, ?> headers) {
        System.out.println("Path: " + uriInfo.getPath());
        System.out.println("HEADERS:");
        headers.entrySet().forEach(h -> System.out.println(h.getKey() + ": " + h.getValue()));
    }
}

Original Post

JAX-RS - @Provider Examples

See Also