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

release-notes/CREDITS-2.x

@@ -1945,6 +1945,17 @@ Ryan Schmitt (@rschmitt)
   (2.19.0)
 
 Giulio Longfils (@giulong)
+ * Contributed #1381: Add a way to specify "inject-only" with `@JacksonInject`
+  (2.20.0)
+ * Contributed fix for #2678: `@JacksonInject` added to property overrides value
+   from the JSON even if `useInput` is `OptBoolean.TRUE`
+  (2.20.0)
  * Contributed #3072: Allow specifying `@JacksonInject` does not fail when there's no
    corresponding value
   (2.20.0)
+
+Plamen Tanov (@ptanov)
+ * Reported #2678: `@JacksonInject` added to property overrides value from the JSON even if
+  `useInput` is `OptBoolean.TRUE`
+  (2.20.0)
+

release-notes/VERSION-2.x

@@ -6,6 +6,12 @@ Project: jackson-databind
 
 2.20.0 (not yet released)
 
+#1381: Add a way to specify "inject-only" with `@JacksonInject`
+ (contributed by Giulio L)
+#2678: `@JacksonInject` added to property overrides value from the JSON even if
+  `useInput` is `OptBoolean.TRUE`
+ (reported by Plamen T)
+ (fix contributed by Giulio L)
 #3072: Allow specifying `@JacksonInject` does not fail when there's no
   corresponding value
  (requested by Lavender S)

src/main/java/com/fasterxml/jackson/databind/deser/BeanDeserializerFactory.java

@@ -817,11 +817,23 @@ protected void addInjectables(DeserializationContext ctxt,
             for (Map.Entry<Object, AnnotatedMember> entry : raw.entrySet()) {
                 AnnotatedMember m = entry.getValue();
                 final JacksonInject.Value injectableValue = introspector.findInjectableValue(m);
-                final Boolean optional = injectableValue == null ? null : injectableValue.getOptional();
+                final Boolean optional;
+                final Boolean useInput;
 
-                builder.addInjectable(PropertyName.construct(m.getName()),
-                        m.getType(),
-                        beanDesc.getClassAnnotations(), m, entry.getKey(), optional);
+                if (injectableValue == null) {
+                    optional = null;
+                    useInput = null;
+                } else {
+                    optional = injectableValue.getOptional();
+                    useInput = injectableValue.getUseInput();
+                }
+
+                // 04-Jun-2025, tatu: [databind#1381]: default for "useInput" is false
+                if (!Boolean.TRUE.equals(useInput)) {
+                    builder.addInjectable(PropertyName.construct(m.getName()),
+                            m.getType(),
+                            beanDesc.getClassAnnotations(), m, entry.getKey(), optional);
+                }
             }
         }
     }

src/main/java/com/fasterxml/jackson/databind/deser/CreatorProperty.java

@@ -280,6 +280,11 @@ public Object getInjectableValueId() {
         return (_injectableValue == null) ? null : _injectableValue.getId();
     }
 
+    @Override
+    public JacksonInject.Value getInjectableValue() {
+        return _injectableValue;
+    }
+
     @Override
     public boolean isInjectionOnly() {
         return (_injectableValue != null) && !_injectableValue.willUseInput(true);

src/main/java/com/fasterxml/jackson/databind/deser/SettableBeanProperty.java

@@ -3,6 +3,7 @@
 import java.io.IOException;
 import java.lang.annotation.Annotation;
 
+import com.fasterxml.jackson.annotation.JacksonInject;
 import com.fasterxml.jackson.core.*;
 import com.fasterxml.jackson.databind.*;
 import com.fasterxml.jackson.databind.deser.impl.FailingDeserializer;
@@ -458,6 +459,14 @@ public int getCreatorIndex() {
      */
     public Object getInjectableValueId() { return null; }
 
+    /**
+     * Accessor for injectable value, if this bean property supports
+     * value injection.
+     *
+     * @since 2.20
+     */
+    public JacksonInject.Value getInjectableValue() { return null; }
+
     /**
      * Accessor for checking whether this property is injectable, and if so,
      * ONLY injectable (will not bind from input).

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.SettableAnyProperty;
@@ -218,6 +219,25 @@ public Object[] getParameters(SettableBeanProperty[] props)
         if (_anyParamSetter != null) {
             _creatorParameters[_anyParamSetter.getParameterIndex()] = _createAndSetAnySetterValue();
         }
+
+        for (int ix = 0; ix < props.length; ++ix) {
+            final SettableBeanProperty prop = props[ix];
+            final AnnotatedMember member = prop.getMember();
+
+            if (member != null) {
+                final JacksonInject.Value injectableValue = prop.getInjectableValue();
+
+                if (injectableValue != null && !Boolean.TRUE.equals(injectableValue.getUseInput())) {
+                    final Object injectedValue = _context.findInjectableValue(
+                            injectableValue.getId(), prop, member, injectableValue.getOptional());
+
+                    if (injectedValue != JacksonInject.Value.empty()) {
+                        _creatorParameters[ix] = injectedValue;
+                    }
+                }
+            }
+        }
+
         if (_context.isEnabled(DeserializationFeature.FAIL_ON_NULL_CREATOR_PROPERTIES)) {
             for (int ix = 0; ix < props.length; ++ix) {
                 if (_creatorParameters[ix] == null) {

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

@@ -0,0 +1,178 @@
+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 = newJsonMapper()
+            .disable(DeserializationFeature.FAIL_ON_UNKNOWN_INJECT_VALUE);
+    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());
+    }
+}