feat(#1381): Add a way to specify "inject-only" with @JacksonInject

release-notes/CREDITS-2.x

@@ -1966,6 +1966,8 @@ Giulio Longfils (@giulong)
  * Contributed #4218: If `@JacksonInject` is specified for field and deserialized by
    the Creator, the inject process will be executed twice
   (2.20.0)
+ * Contributed #1381: Add a way to specify "inject-only" with `@JacksonInject`
+  (2.21.0)
 
 Plamen Tanov (@ptanov)
  * Reported #2678: `@JacksonInject` added to property overrides value from the JSON

release-notes/VERSION-2.x

@@ -6,6 +6,8 @@ Project: jackson-databind
 
 2.21.0 (not yet released)
 
+#1381: Add a way to specify "inject-only" with `@JacksonInject`
+ (fix by Giulio L)
 #1547: Un-deprecate `SerializationFeature.WRITE_EMPTY_JSON_ARRAYS`
 #5045: If there is a no-parameter constructor marked as `JsonCreator` and
   a constructor reported as `DefaultCreator`, latter is incorrectly used

src/main/java/com/fasterxml/jackson/databind/DeserializationContext.java

@@ -469,10 +469,12 @@ public final Object findInjectableValue(Object valueId,
         throws JsonMappingException
     {
         if (_injectableValues == null) {
-            // `optional` comes from property annotation (if any); has precedence
-            // over global setting.
-            if (Boolean.TRUE.equals(optional)
-                    || (optional == null && !isEnabled(DeserializationFeature.FAIL_ON_UNKNOWN_INJECT_VALUE))) {
+            // `useInput` and `optional` come from property annotation (if any);
+            // they have precedence over global setting.
+            if (Boolean.TRUE.equals(useInput)
+                    || Boolean.TRUE.equals(optional)
+                    || ((useInput == null || optional == null)
+                            && !isEnabled(DeserializationFeature.FAIL_ON_UNKNOWN_INJECT_VALUE))) {
                 return JacksonInject.Value.empty();
             }
             throw missingInjectableValueException(String.format(

src/main/java/com/fasterxml/jackson/databind/deser/impl/PropertyValueBuffer.java

@@ -3,6 +3,7 @@
 import java.io.IOException;
 import java.util.BitSet;
 
+import com.fasterxml.jackson.annotation.JacksonInject;
 import com.fasterxml.jackson.core.JsonParser;
 import com.fasterxml.jackson.databind.*;
 import com.fasterxml.jackson.databind.deser.*;
@@ -90,7 +91,8 @@ public class PropertyValueBuffer
     protected PropertyValue _anyParamBuffered;
 
     /**
-     * Indexes properties that are injectable, if any; {@code null} if none.
+     * Indexes properties that are injectable, if any; {@code null} if none,
+     * cleared as they are injected.
      *
      * @since 2.21
      */
@@ -229,8 +231,19 @@ public Object[] getParameters(SettableBeanProperty[] props)
         if (_anyParamSetter != null) {
             _creatorParameters[_anyParamSetter.getParameterIndex()] = _createAndSetAnySetterValue();
         }
+
+        // [databind#1381] handle inject-only (useInput = false) properties
+        if (_injectablePropIndexes != null) {
+            int ix = _injectablePropIndexes.nextSetBit(0);
+            while (ix >= 0) {
+                _inject(props[ix]);
+                ix = _injectablePropIndexes.nextSetBit(ix + 1);
+            }
+        }
+
         if (_context.isEnabled(DeserializationFeature.FAIL_ON_NULL_CREATOR_PROPERTIES)) {
-            for (int ix = 0; ix < props.length; ++ix) {
+            final int len = _creatorParameters.length;
+            for (int ix = 0; ix < len; ++ix) {
                 if (_creatorParameters[ix] == null) {
                     SettableBeanProperty prop = props[ix];
                     _context.reportInputMismatch(prop,
@@ -239,6 +252,7 @@ public Object[] getParameters(SettableBeanProperty[] props)
                 }
             }
         }
+
         return _creatorParameters;
     }
 
@@ -279,6 +293,8 @@ protected Object _findMissing(SettableBeanProperty prop) throws JsonMappingExcep
         // First: do we have injectable value?
         Object injectableValueId = prop.getInjectableValueId();
         if (injectableValueId != null) {
+            // 10-Nov-2025: [databind#1381] Is this needed?
+            _injectablePropIndexes.clear(prop.getCreatorIndex());
             return _context.findInjectableValue(prop.getInjectableValueId(),
                     prop, null, null, null);
         }
@@ -313,6 +329,30 @@ protected Object _findMissing(SettableBeanProperty prop) throws JsonMappingExcep
         }
     }
 
+    /**
+     * Method called to inject value for given property, possibly overriding
+     * assigned (from input) value.
+     *
+     * @since 2.21
+     */
+    private void _inject(final SettableBeanProperty prop) throws JsonMappingException {
+        final JacksonInject.Value injection = prop.getInjectionDefinition();
+
+        if (injection != null) {
+            final Boolean useInput = injection.getUseInput();
+
+            if (!Boolean.TRUE.equals(useInput)) {
+                final Object value = _context.findInjectableValue(injection.getId(),
+                        prop, prop.getMember(), injection.getOptional(), useInput);
+
+                if (value != JacksonInject.Value.empty()) {
+                    int ix = prop.getCreatorIndex();
+                    _creatorParameters[ix] = value;
+                }
+            }
+        }
+    }
+
     /*
     /**********************************************************
     /* Other methods
@@ -392,6 +432,7 @@ public boolean assignParameter(SettableBeanProperty prop, Object value)
                 _paramsSeenBig.set(ix);
                 if (--_paramsNeeded <= 0) {
                     // 29-Nov-2016, tatu: But! May still require Object Id value
+                    return (_objectIdReader == null) || (_idValue != null);
                 }
             }
         }

src/main/java/com/fasterxml/jackson/databind/deser/impl/ValueInjector.java

@@ -69,7 +69,15 @@ public void inject(DeserializationContext context, Object beanInstance)
         throws IOException
     {
         final Object value = findValue(context, beanInstance);
-        if (!JacksonInject.Value.empty().equals(value)) {
+
+        if (value == JacksonInject.Value.empty()) {
+            if (Boolean.FALSE.equals(_optional)) {
+                throw context.missingInjectableValueException(
+                        String.format("No injectable value with id '%s' found (for property '%s')",
+                                _valueId, getName()),
+                        _valueId, null, beanInstance);
+            }
+        } else if (!Boolean.TRUE.equals(_useInput)) {
             _member.setValue(beanInstance, value);
         }
     }

src/test/java/com/fasterxml/jackson/databind/deser/inject/JacksonInject1381DeserializationFeatureDisabledTest.java

@@ -0,0 +1,179 @@
+package com.fasterxml.jackson.databind.deser.inject;
+
+import com.fasterxml.jackson.annotation.JacksonInject;
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.annotation.OptBoolean;
+import com.fasterxml.jackson.databind.DeserializationFeature;
+import com.fasterxml.jackson.databind.InjectableValues;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.exc.ValueInstantiationException;
+import com.fasterxml.jackson.databind.testutil.DatabindTestUtil;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+class JacksonInject1381DeserializationFeatureDisabledTest extends DatabindTestUtil {
+    static class InputDefault {
+        @JacksonInject(value = "key")
+        @JsonProperty("field")
+        private final String _field;
+
+        @JsonCreator
+        public InputDefault(@JsonProperty("field") final String field) {
+            _field = field;
+        }
+
+        public String getField() {
+            return _field;
+        }
+    }
+
+    static class InputDefaultConstructor {
+        private final String _field;
+
+        @JsonCreator
+        public InputDefaultConstructor(@JacksonInject(value = "key")
+                                       @JsonProperty("field") final String field) {
+            _field = field;
+        }
+
+        public String getField() {
+            return _field;
+        }
+    }
+
+    static class InputTrue {
+        @JacksonInject(value = "key", useInput = OptBoolean.TRUE)
+        @JsonProperty("field")
+        private final String _field;
+
+        @JsonCreator
+        public InputTrue(@JsonProperty("field") final String field) {
+            _field = field;
+        }
+
+        public String getField() {
+            return _field;
+        }
+    }
+
+    static class InputTrueConstructor {
+        private final String _field;
+
+        @JsonCreator
+        public InputTrueConstructor(@JacksonInject(value = "key", useInput = OptBoolean.TRUE)
+                                    @JsonProperty("field") final String field) {
+            _field = field;
+        }
+
+        public String getField() {
+            return _field;
+        }
+
+    }
+
+    static class InputFalse {
+        @JacksonInject(value = "key", useInput = OptBoolean.FALSE)
+        @JsonProperty("field")
+        private final String _field;
+
+        @JsonCreator
+        public InputFalse(@JsonProperty("field") final String field) {
+            _field = field;
+        }
+
+        public String getField() {
+            return _field;
+        }
+    }
+
+    static class InputFalseConstructor {
+        private final String _field;
+
+        @JsonCreator
+        public InputFalseConstructor(@JacksonInject(value = "key", useInput = OptBoolean.FALSE)
+                                     @JsonProperty("field") final String field) {
+            _field = field;
+        }
+
+        public String getField() {
+            return _field;
+        }
+    }
+
+    private final String empty = "{}";
+    private final String input = "{\"field\": \"input\"}";
+
+    private final ObjectMapper plainMapper = jsonMapperBuilder()
+            .disable(DeserializationFeature.FAIL_ON_UNKNOWN_INJECT_VALUE)
+            .build();
+    private final ObjectMapper injectedMapper = jsonMapperBuilder()
+            .injectableValues(new InjectableValues.Std().addValue("key", "injected"))
+            .disable(DeserializationFeature.FAIL_ON_UNKNOWN_INJECT_VALUE)
+            .build();
+
+    @Test
+    @DisplayName("FAIL_ON_UNKNOWN_INJECT_VALUE NO, input NO, injectable NO, useInput DEFAULT|TRUE|FALSE => exception")
+    void test1() {
+        assertThrows(ValueInstantiationException.class,
+                () -> plainMapper.readValue(empty, InputDefault.class));
+        assertThrows(ValueInstantiationException.class,
+                () -> plainMapper.readValue(empty, InputDefaultConstructor.class));
+
+        assertThrows(ValueInstantiationException.class,
+                () -> plainMapper.readValue(empty, InputTrue.class));
+        assertThrows(ValueInstantiationException.class,
+                () -> plainMapper.readValue(empty, InputTrueConstructor.class));
+
+        assertThrows(ValueInstantiationException.class,
+                () -> plainMapper.readValue(empty, InputFalse.class));
+        assertThrows(ValueInstantiationException.class,
+                () -> plainMapper.readValue(empty, InputFalseConstructor.class));
+    }
+
+    @Test
+    @DisplayName("FAIL_ON_UNKNOWN_INJECT_VALUE NO, input NO, injectable YES, useInput DEFAULT|TRUE|FALSE => injected")
+    void test2() throws Exception {
+        assertEquals("injected", injectedMapper.readValue(empty, InputDefault.class).getField());
+        assertEquals("injected", injectedMapper.readValue(empty, InputDefaultConstructor.class).getField());
+        assertEquals("injected", injectedMapper.readValue(empty, InputTrue.class).getField());
+        assertEquals("injected", injectedMapper.readValue(empty, InputTrueConstructor.class).getField());
+        assertEquals("injected", injectedMapper.readValue(empty, InputFalse.class).getField());
+        assertEquals("injected", injectedMapper.readValue(empty, InputFalseConstructor.class).getField());
+    }
+
+    @Test
+    @DisplayName("FAIL_ON_UNKNOWN_INJECT_VALUE NO, input YES, injectable NO, useInput DEFAULT|FALSE => exception")
+    void test3() throws Exception {
+        assertEquals("input", plainMapper.readValue(input, InputDefault.class).getField());
+        assertEquals("input", plainMapper.readValue(input, InputDefaultConstructor.class).getField());
+        assertEquals("input", plainMapper.readValue(input, InputFalse.class).getField());
+        assertEquals("input", plainMapper.readValue(input, InputFalseConstructor.class).getField());
+    }
+
+    @Test
+    @DisplayName("FAIL_ON_UNKNOWN_INJECT_VALUE NO, input YES, injectable NO, useInput TRUE => input")
+    void test4() throws Exception {
+        assertEquals("input", plainMapper.readValue(input, InputTrue.class).getField());
+        assertEquals("input", plainMapper.readValue(input, InputTrueConstructor.class).getField());
+    }
+
+    @Test
+    @DisplayName("FAIL_ON_UNKNOWN_INJECT_VALUE NO, input YES, injectable YES, useInput DEFAULT|FALSE => injected")
+    void test5() throws Exception {
+        assertEquals("injected", injectedMapper.readValue(input, InputDefault.class).getField());
+        assertEquals("injected", injectedMapper.readValue(input, InputDefaultConstructor.class).getField());
+        assertEquals("injected", injectedMapper.readValue(input, InputFalse.class).getField());
+        assertEquals("injected", injectedMapper.readValue(input, InputFalseConstructor.class).getField());
+    }
+
+    @Test
+    @DisplayName("FAIL_ON_UNKNOWN_INJECT_VALUE NO, input YES, injectable YES, useInput TRUE => input")
+    void test6() throws Exception {
+        assertEquals("input", injectedMapper.readValue(input, InputTrue.class).getField());
+        assertEquals("input", injectedMapper.readValue(input, InputTrueConstructor.class).getField());
+    }
+}