Spring Boot PATCH Endpoint With JSON Merge Patch (RFC 7386)

@Service
public class JsonMergePatchService {

    private final ObjectMapper mapper;
    private final Validator validator;

    public JsonMergePatchService(ObjectMapper mapper, Validator validator) {
        this.mapper = mapper;
        this.validator = validator;
    }

    public <T> T applyPatch(JsonMergePatch patch, T target, Class<T> type) {
        JsonValue source = toJsonValue(target);
        JsonValue patched = patch.apply(source);

        T result = fromJsonValue(patched, type);

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

    private <T> JsonValue toJsonValue(T target) {
        try {
            String json = mapper.writeValueAsString(target);
            try (JsonReader reader = Json.createReader(new StringReader(json))) {
                return reader.readValue();
            }
        } catch (JsonProcessingException e) {
            throw new IllegalStateException("Unable to serialize target for patch", e);
        }
    }

    private <T> T fromJsonValue(JsonValue value, Class<T> type) {
        try {
            return mapper.readValue(value.toString(), type);
        } catch (JsonProcessingException e) {
            throw new IllegalArgumentException("Patched document is not valid for " + type.getSimpleName(), e);
        }
    }
}

@Entity
@Table(name = "products")
public class Product {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @NotBlank
    @Size(max = 120)
    private String name;

    @Size(max = 2000)
    private String description; // nullable: a patch may legitimately clear it

    @NotNull
    @DecimalMin(value = "0.0", inclusive = false)
    private BigDecimal price;

    @Min(0)
    private int stock;

    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }

    public String getName() { return name; }
    public void setName(String name) { this.name = name; }

    public String getDescription() { return description; }
    public void setDescription(String description) { this.description = description; }

    public BigDecimal getPrice() { return price; }
    public void setPrice(BigDecimal price) { this.price = price; }

    public int getStock() { return stock; }
    public void setStock(int stock) { this.stock = stock; }
}

@Configuration
public class JacksonConfig {

    @Bean
    public ObjectMapper objectMapper() {
        return new ObjectMapper()
                .disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)
                .disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)
                .registerModule(new JavaTimeModule());
    }

    @Bean
    public HttpMessageConverter<JsonMergePatch> mergePatchConverter() {
        return new AbstractHttpMessageConverter<JsonMergePatch>(
                MediaType.valueOf("application/merge-patch+json")) {

            @Override
            protected boolean supports(Class<?> clazz) {
                return JsonMergePatch.class.isAssignableFrom(clazz);
            }

            @Override
            protected JsonMergePatch readInternal(Class<? extends JsonMergePatch> clazz,
                                                  HttpInputMessage in) throws IOException {
                try (JsonReader reader = Json.createReader(in.getBody())) {
                    return Json.createMergePatch(reader.readValue());
                }
            }

            @Override
            protected void writeInternal(JsonMergePatch patch, HttpOutputMessage out) {
                throw new UnsupportedOperationException("read-only converter");
            }
        };
    }
}