Document why Jackson annotations on types are not used for JSON serialization

[mikovsky]

Hello!
Is there any way to wire a custom JsonSerializer to the spring-graphql? I have a custom serializer for setting the precision of double values. For example:

class Response {
    @JsonSerialize(using = CustomFormatter::class)
    @Precision(2)
    val number: Double,
}

If for example, number has a value 2.8503471831075 it will shrink precision to the 2.85.
I have a similar serializer for an application with rest api using JsonSerializer and ContextualSerializer, but I can't make it work in a project with spring-graphql. Maybe there is a different way to achieve this functionality?

[bclozel]

This is handled at the web layer - if you're using Spring Boot, you might want to look into how to register custom serializers or configure the ObjectMapper directly.

Having the annotation present directly on the type should work as Jackson is really in charge here. I'm not familiar with this @Precision annotation. Could you share a sample application we could use to reproduce the problem?

[mikovsky]

@Precision is my custom annotation for specifying how many decimals should a number of type Double have. The whole implementation looks like this:

@Target(allowedTargets = [AnnotationTarget.FIELD, AnnotationTarget.FUNCTION])
@Retention(value = AnnotationRetention.RUNTIME)
annotation class Precision(val value: Int)

class FormattedDoubleSerializer(private val precision: Int = 0) : JsonSerializer<Double>(), ContextualSerializer {
    override fun serialize(value: Double?, generator: JsonGenerator?, provider: SerializerProvider?) {
        if (value == null) {
            generator?.writeNull()
        } else if (value.isNaN() || value.isInfinite()) {
            generator?.writeNull()
        } else if (precision == 0) {
            generator?.writeNumber(value)
        } else {
            val bigDecimal = BigDecimal(value)
                .setScale(precision, RoundingMode.HALF_UP)
            generator?.writeNumber(bigDecimal.toDouble())
        }
    }

    override fun createContextual(provider: SerializerProvider?, property: BeanProperty?): JsonSerializer<*> {
        val precision = property?.getAnnotation(Precision::class.java) ?: return this
        return FormattedDoubleSerializer(precision.value)
    }
}

And then on my data classes, I use it like this:

data class SensorsListItem(
    @JsonSerialize(using = FormattedDoubleSerializer::class)
    @Precision(value = 6)
    val latitude: Double,

    @JsonSerialize(using = FormattedDoubleSerializer::class)
    @Precision(value = 2)
    val someValue: Double,
)

So, if for example, under the hood latitude = 50.123412341234 and someValue=12.43123543524 the response should look like this:

{
    "data": {
        "dummyQuery": {
            "latitude": 50.123456,
            "someValue": 12.43
         }
    }
}

UPDATE:

I prepared a simple app with 1 GraphQL query and 1 REST Endpoint to show what I'm struggling with.

@SpringBootApplication
class GraphqlSerializerTestApplication

fun main(args: Array<String>) {
    runApplication<GraphqlSerializerTestApplication>(*args)
}

@RestController
class MeasurementsRestController {

    @GetMapping("/measurements")
    fun getMeasurements(): Measurements {
        return Measurements(
            latitude = 50.123456789,
            longitude = 19.987654321,
            value = 12.43123456789,
        )
    }
}

@Controller
class MeasurementsController {
    @QueryMapping
    fun measurements(): Measurements {
        return Measurements(
            latitude = 50.123456789,
            longitude = 19.987654321,
            value = 12.43123456789,
        )
    }
}

data class Measurements(
    @JsonSerialize(using = FormattedDoubleSerializer::class)
    @Precision(value = 6)
    val latitude: Double,

    @JsonSerialize(using = FormattedDoubleSerializer::class)
    @Precision(value = 6)
    val longitude: Double,

    @JsonSerialize(using = FormattedDoubleSerializer::class)
    @Precision(value = 2)
    val value: Double,
)

class FormattedDoubleSerializer(private val precision: Int = 0) : JsonSerializer<Double>(), ContextualSerializer {
    override fun serialize(value: Double?, generator: JsonGenerator?, provider: SerializerProvider?) {
        if (value == null) {
            generator?.writeNull()
        } else if (value.isNaN() || value.isInfinite()) {
            generator?.writeNull()
        } else if (precision == 0) {
            generator?.writeNumber(value)
        } else {
            val bigDecimal = BigDecimal(value)
                .setScale(precision, RoundingMode.HALF_UP)
            generator?.writeNumber(bigDecimal.toDouble())
        }
    }

    override fun createContextual(provider: SerializerProvider?, property: BeanProperty?): JsonSerializer<*> {
        val precision = property?.getAnnotation(Precision::class.java) ?: return this
        return FormattedDoubleSerializer(precision.value)
    }
}

@Target(allowedTargets = [AnnotationTarget.FIELD, AnnotationTarget.FUNCTION])
@Retention(value = AnnotationRetention.RUNTIME)
annotation class Precision(val value: Int)

Schema:

type Measurements {
    latitude: Float!
    longitude: Float!
    value: Float!
}

type Query {
    measurements: Measurements!
}

Response from GraphQL:

{
  "data": {
    "measurements": {
      "latitude": 50.123456789,
      "longitude": 19.987654321,
      "value": 12.43123456789
    }
  }
}

Response from Rest API:

{
    "latitude": 50.123457,
    "longitude": 19.987654,
    "value": 12.43
}

[bclozel]

Apologies for the confusion, Spring GraphQL (and here, it's really GraphQL Java) does not handle Jackson annotations on types. Let me explain why.

GraphQL is transport agnostic and its specification enforces particular behavior about null, types and so on. This is why Spring GraphQL is using graphql.ExecutionResult#toSpecification to serialize data as JSON maps.

We want to avoid a case where changing your Jackson configuration in your application suddenly changes the JSON response for clients (that would not be in line with your schema) or worse, sending different JSON responses depending on the transport being used.

For your use case, the custom JsonSerializer should be instead turned into a "scalar" that is both described in the schema and implemented for coercing values in and out.

type Query {
    random: myFloat
}

"""
Float with precision 2
"""
scalar myFloat

You can register your new scalar like so:

@Bean
public RuntimeWiringConfigurer customScalar() {
	return builder -> builder.scalar(CustomScalars.MYFLOAT);
}

While this is mostly covered in the GraphQL spec and GraphQL Java docs, I think we should add a note about this in our reference documentation here. I'll turn this into a documentation issue.

[mikovsky]

Thanks a lot for your time and help @bclozel, all is clear now.

[bclozel]

Reopening to address the documentation issue.