Partner – Moderne – NPI EA (cat=Spring Boot)
announcement - icon

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Course – Black Friday 2026 – NPI EA – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

1. Overview

In this tutorial, we’ll see how we can use Java’s Validation API to validate objects after deserialization.

2. Trigger Validation Manually

Java’s API for bean validation is defined in the JSR 380. A common use of it is @Valid annotated parameters in Spring controllers. However, in this article, we’ll focus on validation outside of controllers.

First, let’s write a method that will validate that the content of an object complies with its validations constraints. To do this, we’ll get the Validator from the default validator factory. Then, we’ll apply the validate() method to the object. This method returns a Set of ConstraintViolation. A ConstraintViolation encapsulates some hints about the validation error. To keep it simple, we’ll just throw a ConstraintViolationException in case any validation problem occurs:

<T> void validate(T t) {
    Set<ConstraintViolation<T>> violations = validator.validate(t);
    if (!violations.isEmpty()) {
        throw new ConstraintViolationException(violations);
    }
}

If we call this method on an object, it will throw if the object doesn’t respect any validation constraints. This method can be called at any point on an existing object with attached constraints.

3. Incorporate the Validation into the Deserialization Process

Our goal is now to incorporate the validation into the deserialization process. Concretely, we’ll override Jackson‘s deserializer to perform the validation right after the deserialization. This will ensure that any time we deserialize an object, we don’t allow any further treatment if it’s not compliant.

First, we need to override the default BeanDeserializer. A BeanDeserializer is a class that can deserialize objects. We’ll want to call the base deserialization method and then apply our validate() method to the created instance. Our BeanDeserializerWithValidation looks like this:

public class BeanDeserializerWithValidation extends BeanDeserializer {

    protected BeanDeserializerWithValidation(BeanDeserializerBase src) {
        super(src);
    }

    @Override
    public Object deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
        Object instance = super.deserialize(p, ctxt);
        validate(instance);
        return instance;
    }

}

The next step is to implement our own BeanDeserializerModifier. This will allow us to alter the deserialization process with the behavior defined in BeanDeserializerWithValidation:

public class BeanDeserializerModifierWithValidation extends BeanDeserializerModifier {

    @Override
    public JsonDeserializer<?> modifyDeserializer(DeserializationConfig config, BeanDescription beanDesc, JsonDeserializer<?> deserializer) {
        if (deserializer instanceof BeanDeserializer) {
            return new BeanDeserializerWithValidation((BeanDeserializer) deserializer);
        }

        return deserializer;
    }

}

Lastly, we need to create an ObjectMapper and register our BeanDeserializerModifier as a Module. A Module is a way to extend Jackson’s default functionalities. Let’s wrap it in a method:

ObjectMapper getObjectMapperWithValidation() {
    SimpleModule validationModule = new SimpleModule();
    validationModule.setDeserializerModifier(new BeanDeserializerModifierWithValidation());
    ObjectMapper mapper = new ObjectMapper();
    mapper.registerModule(validationModule);
    return mapper;
}

4. Example Usage: Read and Validate Object from File

We’ll now showcase a small example of how to use our custom ObjectMapper. First, let’s define a Student object. A Student has a name. The name length must be between 5 and 10 characters:

public class Student {

    @Size(min = 5, max = 10, message = "Student's name must be between 5 and 10 characters")
    private String name;

    public String getName() {
        return name;
    }

}

Let’s now create a validStudent.json file that contains the JSON representation of a valid Student object:

{
  "name": "Daniel"
}

We’ll read the content of this file in an InputStream. First, let’s define the method that parses an InputStream to a Student object and validates it at the same time. For this, we want to use our ObjectMapper:

Student readStudent(InputStream inputStream) throws IOException {
    ObjectMapper mapper = getObjectMapperWithValidation();
    return mapper.readValue(inputStream, Student.class);
}

We can now write a test in which we’ll:

  • start by reading the content of the file into an InputStream
  • convert the InputStream to a Student object
  • check that the content of the Student object is coherent with what’s expected

This test looks like this:

@Test
void givenValidStudent_WhenReadStudent_ThenReturnStudent() throws IOException {
    InputStream inputStream = getClass().getClassLoader().getResourceAsStream(("validStudent.json");
    Student result = readStudent(inputStream);
    assertEquals("Daniel", result.getName());
}

Similarly, we can create an invalid.json file containing the JSON representation of a Student with a name with less than 5 characters:

{
  "name": "Max"
}

Now we need to adapt our test to check that a ConstraintViolationException is indeed thrown. Additionally, we can check that the error message is correct:

@Test
void givenStudentWithInvalidName_WhenReadStudent_ThenThrows() {
    InputStream inputStream = getClass().getClassLoader().getResourceAsStream("invalidStudent.json");
    ConstraintViolationException constraintViolationException = assertThrows(ConstraintViolationException.class, () -> readStudent(inputStream));
    assertEquals("name: Student's name must be between 5 and 10 characters", constraintViolationException.getMessage());
}

5. Conclusion

In this article, we’ve seen how to override Jackson’s configuration to validate an object right after deserializing it. Thus, we can guarantee that it’s impossible to work on an invalid object afterwards.

The code backing this article is available on GitHub. Once you're logged in as a Baeldung Pro Member, start learning and coding on the project.
Partner – Moderne – NPI EA (tag=Refactoring)
announcement - icon

Modern Java teams move fast — but codebases don’t always keep up. Frameworks change, dependencies drift, and tech debt builds until it starts to drag on delivery. OpenRewrite was built to fix that: an open-source refactoring engine that automates repetitive code changes while keeping developer intent intact.

The monthly training series, led by the creators and maintainers of OpenRewrite at Moderne, walks through real-world migrations and modernization patterns. Whether you’re new to recipes or ready to write your own, you’ll learn practical ways to refactor safely and at scale.

If you’ve ever wished refactoring felt as natural — and as fast — as writing code, this is a good place to start.

Course – Black Friday 2026 – NPI EA – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW