/** * Helper method that is called if no config has been explicitly configured. */ protected FastJsonConfig locateConfigProvider(Class<?> type, MediaType mediaType) { if (providers != null) { ContextResolver<FastJsonConfig> resolver = providers.getContextResolver(FastJsonConfig.class, mediaType); if (resolver == null) { resolver = providers.getContextResolver(FastJsonConfig.class, null); } if (resolver != null) { return resolver.getContext(type); } } return fastJsonConfig; }
@Provider public class DateRequiredFeature implements DynamicFeature { @Override public void configure(ResourceInfo resourceInfo, FeatureContext context) { if (resourceInfo.getResourceMethod().getAnnotation(DateRequired.class) != null) { context.register(DateNotSpecifiedFilter.class); } } }
@Provider public class DateNotSpecifiedFilter implements ContainerRequestFilter { @Override public void filter(ContainerRequestContext requestContext) throws IOException { final String dateHeader = requestContext.getHeaderString(HttpHeaders.DATE); if (dateHeader == null) { throw new WebApplicationException(new IllegalArgumentException("Date Header was not specified"), Response.Status.BAD_REQUEST); } } }
/** * Prevents Jersey from modification Request's User-Agent header with default value, * to escape the value conflict with Dropwizard */ @Provider public class JerseyIgnoreRequestUserAgentHeaderFilter implements ClientRequestFilter { @Override public void filter(ClientRequestContext requestContext) throws IOException { ((ClientRequest) requestContext).ignoreUserAgent(true); } }
@Provider public class CustomExceptionMapper implements ExceptionMapper<JsonMappingException> { @Override public Response toResponse(JsonMappingException exception) { return Response.status(Response.Status.BAD_REQUEST) .entity(ImmutableMap.of( "error", exception.getMessage() == null ? "unknown json mapping exception" : exception.getMessage() )) .build(); } }
@Provider public class ForbiddenExceptionMapper implements ExceptionMapper<ForbiddenException> { @Override public Response toResponse(ForbiddenException exception) { return Response.status(Response.Status.FORBIDDEN) .type(MediaType.APPLICATION_JSON) .entity(ImmutableMap.of( "Access-Check-Result", exception.getMessage() )) .build(); } }
@Provider public class NotFoundExceptionMapper implements ExceptionMapper<NotFoundException> { @Override public Response toResponse(NotFoundException exception) { final ApiError apiError = ApiError.create(exception.getMessage()); return Response.status(Response.Status.NOT_FOUND).entity(apiError).build(); } }
@Provider public class ElasticsearchExceptionMapper implements ExceptionMapper<ElasticsearchException> { @Override public Response toResponse(ElasticsearchException exception) { final SearchError searchError = SearchError.create(exception.getMessage(), exception.getErrorDetails()); return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(searchError).build(); } }
@Provider public class JsonProcessingExceptionMapper implements ExceptionMapper<JsonProcessingException> { @Override public Response toResponse(JsonProcessingException e) { final String message = firstNonNull(e.getMessage(), "Couldn't process JSON input"); final ApiError apiError = ApiError.create(message); return status(Response.Status.BAD_REQUEST).type(MediaType.APPLICATION_JSON_TYPE).entity(apiError).build(); } }
@Provider public class ValidationExceptionMapper implements ExceptionMapper<ValidationException> { @Override public Response toResponse(ValidationException exception) { final ValidationApiError error = ValidationApiError.create("Validation failed!", exception.getErrors()); return Response.status(Response.Status.BAD_REQUEST) .type(MediaType.APPLICATION_JSON_TYPE) .entity(error) .build(); } }
/** * RESTFul API的异常处理器. * * @author zhangliang */ @Provider public final class RestfulExceptionMapper implements ExceptionMapper<Throwable> { @Override public Response toResponse(final Throwable cause) { return Response.ok(ExceptionUtil.transform(cause), MediaType.TEXT_PLAIN).status(Response.Status.INTERNAL_SERVER_ERROR).build(); } }
@Provider public class HeaderResponseFilter implements ContainerResponseFilter { public static final Logger LOG = LoggerFactory.getLogger(HeaderResponseFilter.class); private final Meter webRequestMeter; @Inject public HeaderResponseFilter(StormMetricsRegistry metricsRegistry) { this.webRequestMeter = metricsRegistry.registerMeter("num-web-requests"); } @Override public void filter(ContainerRequestContext containerRequestContext, ContainerResponseContext containerResponseContext) throws IOException { webRequestMeter.mark(); } }
@Provider public class JacksonPropertyExceptionMapper implements ExceptionMapper<PropertyBindingException> { @Override public Response toResponse(PropertyBindingException e) { final Collection<Object> knownPropertyIds = firstNonNull(e.getKnownPropertyIds(), Collections.emptyList()); final StringBuilder message = new StringBuilder("Unable to map property ") .append(e.getPropertyName()) .append(".\nKnown properties include: "); Joiner.on(", ").appendTo(message, knownPropertyIds); final ApiError apiError = ApiError.create(message.toString()); return status(Response.Status.BAD_REQUEST).type(MediaType.APPLICATION_JSON_TYPE).entity(apiError).build(); } }
/** * This class is intended to catch Early EOF errors that occur when the client disconnects while the server is reading * from the input stream. * * We catch the org.ecplise.jetty.io.EofException rather than the more generic java.io.EOFException to ensure that we're * only catching jetty server based errors where the client disconnects, as specified by {@link EofException}. */ @Provider public class EarlyEofExceptionMapper implements ExceptionMapper<EofException> { private static final Logger LOGGER = LoggerFactory.getLogger(EarlyEofExceptionMapper.class); @Override public Response toResponse(EofException e) { LOGGER.debug("EOF Exception encountered - client disconnected during stream processing.", e); return Response.status(Response.Status.BAD_REQUEST).build(); } }
@Provider public class NeoServerProvider extends InjectableProvider<NeoServer> { public NeoServer neoServer; public NeoServerProvider( NeoServer db ) { super( NeoServer.class ); this.neoServer = db; } @Override public NeoServer getValue( HttpContext httpContext ) { return neoServer; } }
@Provider public class InjectableWrapper extends InjectableProvider<Object> { private final Injectable injectable; public InjectableWrapper( Injectable injectable ) { super( injectable.getType() ); this.injectable = injectable; } @Override public Object getValue( HttpContext c ) { return injectable.getValue(); } }
@Provider public class LoggingProvider extends InjectableProvider<LogProvider> { private final LogProvider logProvider; public LoggingProvider( LogProvider logProvider ) { super( LogProvider.class ); this.logProvider = logProvider; } @Override public LogProvider getValue( HttpContext c ) { return logProvider; } }
@Provider public class DatabaseProvider extends InjectableProvider<Database> { public Database db; public DatabaseProvider( Database db ) { super( Database.class ); this.db = db; } @Override public Database getValue( HttpContext httpContext ) { return db; } }
@Provider public class WebServerProvider extends InjectableProvider<WebServer> { private final WebServer server; public WebServerProvider( WebServer server ) { super( WebServer.class ); this.server = server; } @Override public WebServer getValue( HttpContext c ) { return server; } }
@Provider public static class MockTodoServiceProvider extends SingletonTypeInjectableProvider<Context, LookupReferencesManager> { public MockTodoServiceProvider() { super(LookupReferencesManager.class, lookupReferencesManager); } }