How do I validate incoming JSON data inside a REST service?
I searched for the best practice to enforce validation for incoming json data into a RESTful service. My suggestion is to use a MessageBodyReader which performs the validation inside the readFrom method. Below there is an message-body-reader example which is non-generic for the sake of simplicity.
I also was interesed in finding the best framework for doing json data validation. Because I use the jackson framework (version 1.8.5) for marshaling and unmarshaling between json and java, it would have been nice if this framework would provide a json data validation functionality. Unfortunately I couldn't find any possibility to do this with jackson. Finally I got it working with the json-schema-validator available at https://github.com. The version I use is 2.1.7
import java.io.BufferedReader;import java.io.ByteArrayInputStream;import java.io.FileInputStream;import java.io.IOException;import java.io.InputStream;import java.io.InputStreamReader;import java.lang.annotation.Annotation;import java.lang.reflect.Type;import javax.servlet.ServletContext;import javax.ws.rs.Consumes;import javax.ws.rs.WebApplicationException;import javax.ws.rs.core.Context;import javax.ws.rs.core.MediaType;import javax.ws.rs.core.MultivaluedMap;import javax.ws.rs.ext.MessageBodyReader;import javax.ws.rs.ext.Provider;import org.codehaus.jackson.map.ObjectMapper;import at.fhj.ase.dao.data.Address;import at.fhj.ase.xmlvalidation.msbreader.MessageBodyReaderValidationException;import com.fasterxml.jackson.databind.JsonNode;import com.github.fge.jackson.JsonLoader;import com.github.fge.jsonschema.exceptions.ProcessingException;import com.github.fge.jsonschema.main.JsonSchemaFactory;import com.github.fge.jsonschema.main.JsonValidator;import com.github.fge.jsonschema.report.ProcessingReport;@Provider@Consumes(MediaType.APPLICATION_JSON)public class AddressJsonValidationReader implements MessageBodyReader<Address> { private final String jsonSchemaFileAsString; public AddressJsonValidationReader(@Context ServletContext servletContext) { this.jsonSchemaFileAsString = servletContext .getRealPath("/json/Address.json"); } @Override public boolean isReadable(Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType) { if (type == Address.class) { return true; } return false; } @Override public Address readFrom(Class<Address> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, String> httpHeaders, InputStream entityStream) throws IOException, WebApplicationException { final String jsonData = getStringFromInputStream(entityStream); System.out.println(jsonData); InputStream isSchema = new FileInputStream(jsonSchemaFileAsString); String jsonSchema = getStringFromInputStream(isSchema); /* * Perform JSON data validation against schema */ validateJsonData(jsonSchema, jsonData); /* * Convert stream to data entity */ ObjectMapper m = new ObjectMapper(); Address addr = m.readValue(stringToStream(jsonData), Address.class); return addr; } /** * Validate the given JSON data against the given JSON schema * * @param jsonSchema * as String * @param jsonData * as String * @throws MessageBodyReaderValidationException * in case of an error during validation process */ private void validateJsonData(final String jsonSchema, final String jsonData) throws MessageBodyReaderValidationException { try { final JsonNode d = JsonLoader.fromString(jsonData); final JsonNode s = JsonLoader.fromString(jsonSchema); final JsonSchemaFactory factory = JsonSchemaFactory.byDefault(); JsonValidator v = factory.getValidator(); ProcessingReport report = v.validate(s, d); System.out.println(report); if (!report.toString().contains("success")) { throw new MessageBodyReaderValidationException( report.toString()); } } catch (IOException e) { throw new MessageBodyReaderValidationException( "Failed to validate json data", e); } catch (ProcessingException e) { throw new MessageBodyReaderValidationException( "Failed to validate json data", e); } } /** * Taken from <a href= * "http://www.mkyong.com/java/how-to-convert-inputstream-to-string-in-java/" * >www.mkyong.com</a> * * @param is * {@link InputStream} * @return Stream content as String */ private String getStringFromInputStream(InputStream is) { BufferedReader br = null; StringBuilder sb = new StringBuilder(); String line; try { br = new BufferedReader(new InputStreamReader(is)); while ((line = br.readLine()) != null) { sb.append(line); } } catch (IOException e) { e.printStackTrace(); } finally { if (br != null) { try { br.close(); } catch (IOException e) { e.printStackTrace(); } } } return sb.toString(); } private InputStream stringToStream(final String str) throws UnsupportedEncodingException { return new ByteArrayInputStream(str.getBytes("UTF-8")); }}
import com.github.fge.jsonschema.core.report.ProcessingReport;import com.github.fge.jsonschema.main.JsonSchema;import com.github.fge.jsonschema.main.JsonSchemaFactory;import com.github.fge.jackson.JsonLoader;import com.fasterxml.jackson.databind.JsonNode;public class ValidationJSON { public static void main(String[] arr){ String jsonData = "{\"name\": \"prem\"}"; String jsonSchema = ""; //Schema we can generate online using http://jsonschema.net/ final JsonNode data = JsonLoader.fromString(jsonData); final JsonNode schema = JsonLoader.fromString(jsonSchema); final JsonSchemaFactory factory = JsonSchemaFactory.byDefault(); JsonValidator validator = factory.getValidator(); ProcessingReport report = validator.validate(schema, data); System.out.println(report.isSuccess()); }}
It looks like you're not tied to JSONSchema, though it seems to be your default choice. Tastes differ, but oftentimes it looks more complicated then it could. Besides, personally, I'd love to have both data and validation rules in the same place. And custom validators arguably seem to fit more naturally when used within java code instead of any sort of configuration files.
Here is how this approach looks like. Say, you have the following json object representing some payment (be it a request or response), but consisting only of discount block for brevity:
{ "discount":{ "valid_until":"2032-05-04 00:00:00+07", "promo_code":"VASYA1988" }}Here is what a validation code looks like:
/*1 */ public class ValidatedJsonObjectRepresentingRequestOrResponse implements Validatable<JsonObjectRepresentingRequestOrResponse> { private String jsonString; private Connection dbConnection;/*6 */ public ValidatedJsonObjectRepresentingRequestOrResponse(String jsonString, Connection dbConnection) { this.jsonString = jsonString; this.dbConnection = dbConnection; } @Override/*13*/ public Result<JsonObjectRepresentingRequestOrResponse> result() throws Exception { return/*16*/ new FastFail<>(/*17*/ new WellFormedJson(/*18*/ new Unnamed<>(Either.right(new Present<>(this.jsonRequestString)))/*19*/ ),/*20*/ requestJsonObject ->/*21*/ new UnnamedBlocOfNameds<>( List.of(/*23*/ new FastFail<>(/*24*/ new IsJsonObject(/*25*/ new Required(/*26*/ new IndexedValue("discount", requestJsonObject) ) ),/*29*/ discountObject ->/*30*/ new NamedBlocOfNameds<>(/*31*/ "discount",/*32*/ List.of(/*33*/ new PromoCodeIsNotExpired(/*34*/ new AsString(/*35*/ new Required(/*36*/ new IndexedValue("valid_until", discountObject) ) ) ),/*40*/ new PromoCodeIsNotAlreadyRedeemed(/*41*/ new PromoCodeContainsBothLettersAndDigits(/*42*/ new Required(/*43*/ new IndexedValue("promo_code", discountObject) ) ),/*46*/ this.dbConnection ) ),/*49*/ Discount.class ) ) ),/*53*/ JsonObjectRepresentingRequestOrResponse.class ) ) .result(); } }Let’s see what’s going on here, line by line:
Line 1 Declaration of ValidatedJsonObjectRepresentingRequestOrResponse.Line 6 Its constructor accepts raw json string. It might be either an incoming request or received response, or pretty much anything else.Line 13: Validation starts when this method is invoked.Lines 16: The higher-level validation object is FastFail block. If the first argument is invalid, an error is returned right away.Lines 17-19: json is checked whether it’s well-formed or not. If the latter, validation fails fast and returns a corresponding error.Line 20: if json is well-formed, a closure is invoked, and json data is passed as its single argument.Line 21: json data is validated. Its structure is an unnamed block of named blocks. It corresponds to a JSON Object.Line 26: The first (and the only) block is called discount.Line 25: It’s required.Line 24: It must be a json object.Line 23: If not, an error will be returned right away because it’s a FailFast object.Line 29: Otherwise, a closure is invoked.Line 30: Discount block is a named block consisting of other named entries – objects or scalars.Line 36: The first one is called valid_untilLine 35: It’s required.Line 34: And represented as a string, if it's really a string. If not, an error will be returned.Line 33: Finally, check that it’s not expired.Line 43: Second parameter is called promo_code.Line 42: It’s required as well.Line 41: It must contain both letters and digits.Line 40: And it should not be already redeemed. This fact is certainly persisted in our database, hence …Line 46: … this.dbConnection parameter.Line 49: If all previous validation checks are successful, an object of class Discount is created.Line 53: Finally, JsonObjectRepresentingRequestOrResponse is created and returned.
Here is how a calling code looks when validation is successful:
Result<JsonObjectRepresentingRequestOrResponse> result = new ValidatedJsonObjectRepresentingRequestOrResponse(jsonRequestString).result();result.isSuccessful();result.value().raw().discount().promoCode(); // VASYA1988This example is taken from here. Here you can find a full-fledged json request validation example.