如何从Jackson @JsonCreator构造函数访问Spring Boot环境变量

Question

I have an immutable model class which can be instantiated by Jackson using the @JsonCreator annotated constructor. One of the properties is optional and I want to have a dynamic default value based on a variable in application.yml to replace the fixed value of 30 below.

public class DataRequest {
    private final List<String> fields;
    private final int sessionTimeoutSecs;

    @JsonCreator
    public DataRequest(@JsonProperty("fields") final List<String> fields,
                       @JsonProperty("sessionTimeoutSecs") final Integer sessionTimeoutSecs) {
        this.fields = fields;
        this.sessionTimeoutSecs = MoreObjects.firstNonNull(sessionTimeoutSecs, 30);
    }
}

I tried adding an additional constructor parameter @Value("${default-session-timeout-secs}") final int defaultSessionTimeout but that results in a MessageConversionException when attempting to map.

Answer 1

You can do this by bridging your properties and making use of @JacksonInject . This annotation works well with the object-mapper. I am skipping the part on how to bridge spring to jackson in code, but give you a plain ObjectMapper example. See this code:

package de.pandaadb.jackson;

import java.io.IOException;

import com.fasterxml.jackson.annotation.JacksonInject;
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.databind.InjectableValues;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;

public class DataModel {

    private String test;
    private String optionalValue;

    @JsonCreator
    public DataModel(@JsonProperty("test") String test, @JacksonInject("opt") @JsonProperty(value= "opt", required=false)String opt) {
        this.optionalValue = opt;
        this.test = test;
    }

    @Override
    public String toString() {
        return "test=" + test + " optional=" + optionalValue;
    }


    public static void main(String[] args) throws JsonParseException, JsonMappingException, IOException {
        ObjectMapper mapper = new ObjectMapper();
        InjectableValues.Std std = new InjectableValues.Std();
        std.addValue("opt", "alternative");

        String withOptional = "{\"test\" : \"hello\" ,    \"opt\" : \"optss\"}";
        String withoutOptional = "{\"test\" : \"hello\"}";

        mapper.setInjectableValues(std);

        System.out.println(mapper.readValue(withOptional, DataModel.class));
        System.out.println(mapper.readValue(withoutOptional, DataModel.class));
    }
}

This code prints:

test=hello optional=optss
test=hello optional=alternative

Few notes:

1. The constructor is using the JacksonInject annotation in the constructor in addition to a property. This will inject the configured value first, optionally overwriting it with the json value coming from the input.

2. The ObjectMapper is being fed properties that match the annotation we have

The second part is the most important.

As for making this work with spring, the approach would be to have this code in your configuration:

@Configuration
public class ObjectMapperConfiguration {

    ObjectMapper mapper(@Value("${my.test.string}") String test) {
        ObjectMapper mapper = new ObjectMapper();
        InjectableValues.Std std = new InjectableValues.Std();
        std.addValue("my.test.string", "test");
        mapper.setInjectableValues(std);
        return mapper;
    }
}

You can alternatively also inject ALL properties and feed them back to the object mapper, as to not having to extend this with every new property.

I hope that helps,

Some more reading material here: https://www.concretepage.com/jackson-api/jackson-jacksoninject-example#ObjectMapper

Latest edit: How to do this with only 1 constructor argument, having jackson handle the overwrite itself

-- Artur

Answer 2

You can do this by using two helper classes.

The first is ContextHolder , which allows you to access Spring's ApplicationContext from outside Spring-managed bean:

@Component
public class ContextHolder implements ApplicationContextAware {

    public static ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        ContextHolder.applicationContext = applicationContext;
    }
}

The second is DefaultTimeoutWrapper , which holds default timeout value:

@Component
public class DefaultTimeoutWrapper {
    @Value("${default-session-timeout-secs}")
    private int defaultTimeout;

    public int getDefaultTimeout() {
        return defaultTimeout;
    }
}

Then you need to change your DataRequest class to use them like this:

public class DataRequest {
    private final List<String> fields;
    private final int sessionTimeoutSecs;

    @JsonCreator
    public DataRequest(@JsonProperty("fields") final List<String> fields,
                       @JsonProperty("sessionTimeoutSecs") final Integer sessionTimeoutSecs) {
        DefaultTimeoutWrapper defaultTimeoutWrapper = ContextHolder.applicationContext.getBean(DefaultTimeoutWrapper.class);
        int defaultTimeout = defaultTimeoutWrapper.getDefaultTimeout();

        this.fields = fields;
        this.sessionTimeoutSecs = sessionTimeoutSecs != null ? sessionTimeoutSecs : defaultTimeout;
    }
}

Note that in ContextHolder instance method is used to set value of a static field, which is generally considered to be bad design.