JSON Schema Validation helper method This is what I wrote to validate JSON to the given schema.

public void validateJsonSchema(ObjectNode jsonSchema, ObjectNode json) throws InvalidRequestException {

    String errorMessage = null;

    if (json != null) {

        if(jsonSchema == null) {
            errorMessage = "json exist in request but there is no schema to validate it against";
        }
        else {
            try {
                JsonSchema jsonSchema = JsonSchemaFactory.byDefault().getJsonSchema(jsonSchema);
                ProcessingReport processingReport = jsonSchema.validate(json);

                if (!processingReport.isSuccess()) {

                    StringBuilder sb = new StringBuilder();
                    processingReport.forEach(jsonError -&gt; sb.append(String.format("[%s] ", jsonError)));

                    errorMessage = String.format("json validation failed. Errors: %s", sb.toString());
                }

            } catch (ProcessingException e) {
                errorMessage = String.format("json validation threw ProcessingException. Error Message: %s", e.getMessage());
            }
        }
    }

    if (errorMessage != null) {
        throw new InvalidRequestException(errorMessage);
    }

}


Here are few things that I had in my mind while writing this code:


I don't want to return anything from the method. Schema is either valid or invalid. In case of invalid, I just throw an exception. Since it's part of a Helper class, I think it's okay to put some business logic (throwing exception) with in this code. 
I like 1 point of return or 1 point of exception throwing. Thats why I am using errorMessage to capture any error and if it exists, throw it at the end. By this approach, the code readability is much better. 
The jsonSchema and json both are optional. In case if json doesn't exist, there is no point of getting into validation.
Contrary to Julien Rousé and you, I'm rather against the "1 point of return" policy. It doesn't make it more readable. It might make it a bit easier to formally prove correctness of the code, but I have never seen someone do that outside of an academic context.

As it is now, when looking at what would happen if the json == null you'd first encounter the if(json != null) line. Then you scroll down 20 or more lines to find the end of that if block finding that there's no else block. But the method doesn't end here yet. There's another if (message != null) line where I forgot if I had encountered any initialisation in the meantime so I have to go over the entire method again to see if it is null or not ...

Compare that with a method that starts with:

public void validateJsonSchema(ObjectNode jsonSchema, ObjectNode json) throws InvalidRequestException {
    if (json == null) {
        return;
    } 


By writing in this "return as early as possible" style, you immediatly see that empty json objects are always valid. If at some point it's clear what the result of the method should be, then I want that to be clear explicitly at that point. I don't want to tire myself constantly looking up and down the method to see if I didn't miss anything (for example: was this message really still null when we got here?).

That's why I would prefer to structure the method like this:

public void validateJsonSchema(ObjectNode jsonSchema, ObjectNode json) throws InvalidRequestException {
    if (json == null) {
        return;
    }

    if(jsonSchema == null) {
        throw new InvalidRequestException("json exist in request but there is no schema to validate it against");
    }

    try {
        JsonSchema jsonSchema = JsonSchemaFactory.byDefault().getJsonSchema(jsonSchema);
        ProcessingReport processingReport = jsonSchema.validate(json);

        if (!processingReport.isSuccess()) {

            StringBuilder sb = new StringBuilder();
            processingReport.forEach(jsonError -&gt; sb.append(String.format("[%s] ", jsonError)));

            throw new InvalidRequestException(String.format("json validation failed. Errors: %s", sb.toString()));
        }

    } catch (ProcessingException e) {
        throw new InvalidRequestException(String.format("json validation threw ProcessingException. Error Message: %s", e.getMessage()));
    }
}


I'd say this is more readable and especially easier to find out what the result is of the special cases. Not that I had any trouble reading/understanding your code ofcourse. I just prefer the way that takes a little bit less effort to understand completely.