Skip to content

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

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
wants to merge 1 commit into
base: 2.x
Choose a base branch
from
Open

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

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
19 changes: 15 additions & 4 deletions src/main/java/com/fasterxml/jackson/databind/deser/BeanDeserializerFactory.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -817,11 +817,22 @@ 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();
}

if (!Boolean.TRUE.equals(useInput)) {
builder.addInjectable(PropertyName.construct(m.getName()),
m.getType(),
beanDesc.getClassAnnotations(), m, entry.getKey(), optional);
}
}
}
}
Expand Down
123 changes: 123 additions & 0 deletions src/test/java/com/fasterxml/jackson/databind/deser/inject/JacksonInject1381Test.java
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,123 @@
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.core.JsonProcessingException;
import com.fasterxml.jackson.databind.InjectableValues;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.exc.MissingInjectableValueExcepion;
import com.fasterxml.jackson.databind.json.JsonMapper;
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 JacksonInject1381Test extends DatabindTestUtil {

private static class InputDefault {

@JacksonInject(value = "key")
private final String field;

@JsonCreator
public InputDefault(@JsonProperty("field") final String field) {
this.field = field;
}

public String getField() {
return field;
}
}

private static class InputTrue {

@JacksonInject(value = "key", useInput = OptBoolean.TRUE)
private final String field;

@JsonCreator
public InputTrue(@JsonProperty("field") final String field) {
this.field = field;
}

public String getField() {
return field;
}
}

private static class InputFalse {

@JacksonInject(value = "key", useInput = OptBoolean.FALSE)
private final String field;

@JsonCreator
public InputFalse(@JsonProperty("field") final String field) {
this.field = field;
}

public String getField() {
return field;
}
}

private final String empty = "{}";
private final String input = "{\"field\": \"input\"}";

private final ObjectMapper plainMapper = JsonMapper.builder().build();
private final ObjectMapper injectedMapper = JsonMapper.builder()
.injectableValues(new InjectableValues.Std().addValue("key", "injected"))
.build();

@Test
@DisplayName("input NO, injectable NO, useInput DEFAULT|TRUE|FALSE => exception")
void test1() {
assertThrows(MissingInjectableValueExcepion.class,
() -> plainMapper.readValue(empty, InputDefault.class));

assertThrows(MissingInjectableValueExcepion.class,
() -> plainMapper.readValue(empty, InputTrue.class));

assertThrows(MissingInjectableValueExcepion.class,
() -> plainMapper.readValue(empty, InputFalse.class));
}

@Test
@DisplayName("input NO, injectable YES, useInput DEFAULT|TRUE|FALSE => injected")
void test2() throws JsonProcessingException {
assertEquals("injected", injectedMapper.readValue(empty, InputDefault.class).getField());
assertEquals("injected", injectedMapper.readValue(empty, InputTrue.class).getField());
assertEquals("injected", injectedMapper.readValue(empty, InputFalse.class).getField());
}

@Test
@DisplayName("input YES, injectable NO, useInput DEFAULT|FALSE => exception")
void test3() {
assertThrows(MissingInjectableValueExcepion.class,
() -> plainMapper.readValue(input, InputDefault.class));

assertThrows(MissingInjectableValueExcepion.class,
() -> plainMapper.readValue(input, InputFalse.class));
}

@Test
@DisplayName("input YES, injectable NO, useInput TRUE => input")
void test4() throws JsonProcessingException {
assertEquals("input", plainMapper.readValue(input, InputTrue.class).getField());
}

@Test
@DisplayName("input YES, injectable YES, useInput DEFAULT|FALSE => injected")
Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

According to useInput's javadocs:

Default is OptBoolean.DEFAULT, which translates to OptBoolean.TRUE: this is
for backwards compatibility (2.8 and earlier always allow binding input value).

This combination: input YES, injectable YES, useInput DEFAULT should actually behave as if we had useInput = TRUE, that is dropping the injected value and returning the input.

Nevertheless, since useInput never worked that way, this would mean introducing breaking changes. My suggestion is to keep things as per this test and change the javadoc accordingly:

Default is OptBoolean.DEFAULT, which translates to OptBoolean.FALSE

void test5() throws JsonProcessingException {
assertEquals("injected", injectedMapper.readValue(input, InputDefault.class).getField());
assertEquals("injected", injectedMapper.readValue(input, InputFalse.class).getField());
}

@Test
@DisplayName("input YES, injectable YES, useInput TRUE => input")
void test6() throws JsonProcessingException {
assertEquals("input", injectedMapper.readValue(input, InputTrue.class).getField());
}
}
115 changes: 115 additions & 0 deletions ...t/java/com/fasterxml/jackson/databind/deser/inject/JacksonInject1381WithOptionalTest.java
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,115 @@
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.core.JsonProcessingException;
import com.fasterxml.jackson.databind.InjectableValues;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.exc.MissingInjectableValueExcepion;
import com.fasterxml.jackson.databind.json.JsonMapper;
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 JacksonInject1381WithOptionalTest extends DatabindTestUtil {
Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

This class shows how the behavior changes for all the combinations of the other test class when all injected fields are optional. Do you think we still need a required property in the annotation?

I feel like combining useInput and optional would cover all cases, also because optional should drive the same logic (but reversed) of required. Given this, adding a required property would make things unclear for the users, and the internal logic would be quite messy. Does this make sense?


private static class InputDefault {

@JacksonInject(value = "key", optional = OptBoolean.TRUE)
private final String field;

@JsonCreator
public InputDefault(@JsonProperty("field") final String field) {
this.field = field;
}

public String getField() {
return field;
}
}

private static class InputTrue {

@JacksonInject(value = "key", useInput = OptBoolean.TRUE, optional = OptBoolean.TRUE)
private final String field;

@JsonCreator
public InputTrue(@JsonProperty("field") final String field) {
this.field = field;
}

public String getField() {
return field;
}
}

private static class InputFalse {

@JacksonInject(value = "key", useInput = OptBoolean.FALSE, optional = OptBoolean.TRUE)
private final String field;

@JsonCreator
public InputFalse(@JsonProperty("field") final String field) {
this.field = field;
}

public String getField() {
return field;
}
}

private final String empty = "{}";
private final String input = "{\"field\": \"input\"}";

private final ObjectMapper plainMapper = JsonMapper.builder().build();
private final ObjectMapper injectedMapper = JsonMapper.builder()
.injectableValues(new InjectableValues.Std().addValue("key", "injected"))
.build();

@Test
@DisplayName("optional YES, input NO, injectable NO, useInput DEFAULT|TRUE|FALSE => exception")
void test1() {
assertThrows(MissingInjectableValueExcepion.class,
() -> plainMapper.readValue(empty, InputDefault.class));

assertThrows(MissingInjectableValueExcepion.class,
() -> plainMapper.readValue(empty, InputTrue.class));

assertThrows(MissingInjectableValueExcepion.class,
() -> plainMapper.readValue(empty, InputFalse.class));
}

@Test
@DisplayName("optional YES, input NO, injectable YES, useInput DEFAULT|TRUE|FALSE => injected")
void test2() throws JsonProcessingException {
assertEquals("injected", injectedMapper.readValue(empty, InputDefault.class).getField());
assertEquals("injected", injectedMapper.readValue(empty, InputTrue.class).getField());
assertEquals("injected", injectedMapper.readValue(empty, InputFalse.class).getField());
}

@Test
@DisplayName("optional YES, input YES, injectable NO, useInput DEFAULT|TRUE|FALSE => input")
void test3() throws JsonProcessingException {
assertEquals("input", plainMapper.readValue(input, InputDefault.class).getField());
assertEquals("input", plainMapper.readValue(input, InputFalse.class).getField());
assertEquals("input", plainMapper.readValue(input, InputTrue.class).getField());
}

@Test
@DisplayName("optional YES, input YES, injectable YES, useInput DEFAULT|FALSE => injected")
void test4() throws JsonProcessingException {
assertEquals("injected", injectedMapper.readValue(input, InputDefault.class).getField());
assertEquals("injected", injectedMapper.readValue(input, InputFalse.class).getField());
}

@Test
@DisplayName("optional YES, input YES, injectable YES, useInput TRUE => input")
void test5() throws JsonProcessingException {
assertEquals("input", injectedMapper.readValue(input, InputTrue.class).getField());
}
}
6 changes: 1 addition & 5 deletions ...databind/tofix/JacksonInject2678Test.java → ...d/deser/inject/JacksonInject2678Test.java
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,4 +1,4 @@
package com.fasterxml.jackson.databind.tofix;
package com.fasterxml.jackson.databind.deser.inject;
Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

moved since this should not fail anymore


import java.util.Objects;

Expand All @@ -10,7 +10,6 @@
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.json.JsonMapper;
import com.fasterxml.jackson.databind.testutil.DatabindTestUtil;
import com.fasterxml.jackson.databind.testutil.failure.JacksonTestFailureExpected;

import static org.junit.jupiter.api.Assertions.assertEquals;

Expand Down Expand Up @@ -41,7 +40,6 @@ public String getField2() {
}

// [databind#2678]
@JacksonTestFailureExpected
@Test
void readValueInjectables() throws Exception {
final InjectableValues injectableValues =
Expand All @@ -57,8 +55,6 @@ void readValueInjectables() throws Exception {
final Some actualValuePresent = mapper.readValue(
"{\"field1\": \"field1value\", \"field2\": \"field2value\"}", Some.class);
assertEquals("field1value", actualValuePresent.getField1());

// if I comment @JacksonInject that is next to the property the valid assert is the correct one:
assertEquals("field2value", actualValuePresent.getField2());
}
}