java - 使用 Jackson 在运行时将实体动态序列化为其 ID 或其完整表示

Question

我们正在使用 Java EE 7 (RESTEasy/Hibernate/Jackson) 开发 RESTful API。

我们希望 API 默认使用其 ID 序列化所有子实体。我们这样做主要是为了与我们坚持接收 ID 的反序列化策略保持一致。

但是，我们还希望我们的用户能够选择通过自定义端点或查询参数(未定)获取我们任何子实体的扩展 View 。例如:

// http://localhost:8080/rest/operator/1
// =====================================
{
    "operatorId": 1,
    "organization": 34,
    "endUser": 23
}

// http://localhost:8080/rest/operator/1?expand=organization
// =====================================
{
    "operatorId": 1,
    "organization": {
        "organizationId": 34,
        "organizationName": "name"
    },
    "endUser": 23
}

// http://localhost:8080/rest/operator/1?expand=enduser
// =====================================
{
    "operatorId": 1,
    "organization": 34,
    "endUser": {
        "endUserId": 23,
        "endUserName": "other name"
    }
}

// http://localhost:8080/rest/operator/1?expand=organization,enduser
// =====================================
{
    "operatorId": 1,
    "organization": {
        "organizationId": 34,
        "organizationName": "name"
    },
    "endUser": {
        "endUserId": 23,
        "endUserName": "other name"
    }
}

有没有办法动态更改 Jackson 的行为以确定指定的 AbstractEntity 字段是以完整形式还是作为其 ID 序列化？如何实现？

---

附加信息

我们知道有几种使用 ID 序列化子实体的方法，包括:

public class Operator extends AbstractEntity {
    ...
    @JsonIdentityInfo(generator=ObjectIdGenerators.PropertyGenerator.class, property="organizationId")
    @JsonIdentityReference(alwaysAsId=true)
    public getOrganization() { ... }
    ...
}

和

public class Operator extends AbstractEntity {
    ...
    @JsonSerialize(using=AbstractEntityIdSerializer.class)
    public getOrganization() { ... }
    ...
}

其中 AbstractEntityIdSerializer 使用其 ID 序列化实体。

问题是我们不知道有什么方法可以让用户覆盖默认行为并恢复到标准 Jackson 对象序列化。理想情况下，他们还能够选择以完整形式序列化哪些子属性。

如果可能的话，在运行时为任何属性动态切换 @JsonIdentityReference 的 alwaysAsId 参数会很棒，或者对 ObjectMapper/ObjectWriter 进行等效更改。

---

更新:工作(？)解决方案我们还没有机会对此进行全面测试，但我一直在研究一种解决方案，该解决方案利用重写 Jackson 的 AnnotationIntrospector 类。它似乎按预期工作。

public class CustomAnnotationIntrospector extends JacksonAnnotationIntrospector {
    private final Set<String> expandFieldNames_;

    public CustomAnnotationIntrospector(Set<String> expandFieldNames) {
        expandFieldNames_ = expandFieldNames;
    }

    @Override
    public ObjectIdInfo findObjectReferenceInfo(Annotated ann, ObjectIdInfo objectIdInfo) {
        JsonIdentityReference ref = _findAnnotation(ann, JsonIdentityReference.class);
        if (ref != null) {

            for (String expandFieldName : expandFieldNames_) {
                String expandFieldGetterName = "get" + expandFieldName;
                String propertyName = ann.getName();

                boolean fieldNameMatches = expandFieldName.equalsIgnoreCase(propertyName);
                boolean fieldGetterNameMatches = expandFieldGetterName.equalsIgnoreCase(propertyName);

                if (fieldNameMatches || fieldGetterNameMatches) {
                    return objectIdInfo.withAlwaysAsId(false);
                }
            }

            objectIdInfo = objectIdInfo.withAlwaysAsId(ref.alwaysAsId());
        }

        return objectIdInfo;
    }
}

在序列化时，我们复制 ObjectMapper(以便 AnnotationIntrospector 再次运行)并应用 CustomAnnotationIntrospector，如下所示:

@Context
private HttpRequest httpRequest_;

@Override
writeTo(...) {
    // Get our application's ObjectMapper.
    ContextResolver<ObjectMapper> objectMapperResolver = provider_.getContextResolver(ObjectMapper.class,
                                                                                      MediaType.WILDCARD_TYPE);
    ObjectMapper objectMapper = objectMapperResolver.getContext(Object.class);

    // Get Set of fields to be expanded (pre-parsed).
    Set<String> fieldNames = (Set<String>)httpRequest_.getAttribute("ExpandFields");

    if (!fieldNames.isEmpty()) {
        // Pass expand fields to AnnotationIntrospector.
        AnnotationIntrospector expansionAnnotationIntrospector = new CustomAnnotationIntrospector(fieldNames);

        // Replace ObjectMapper with copy of ObjectMapper and apply custom AnnotationIntrospector.
        objectMapper = objectMapper.copy();
        objectMapper.setAnnotationIntrospector(expansionAnnotationIntrospector);
    }

    ObjectWriter objectWriter = objectMapper.writer();
    objectWriter.writeValue(...);
}

这种方法有什么明显的缺陷吗？它看起来相对简单并且是完全动态的。

Answer 1

答案是Jackson's mixin feature :

您创建一个简单的 Java 类，它具有与实体的注释方法完全相同的方法签名。您使用修改后的值注释该方法。方法的主体是微不足道的(它不会被调用):

public class OperatorExpanded {
    ...
    @JsonIdentityInfo(generator=ObjectIdGenerators.PropertyGenerator.class, property="organizationId")
    @JsonIdentityReference(alwaysAsId=false)
    public Organization getOrganization() { return null; }
    ...
}

您使用 Jackson 的模块系统将 mixin 绑定(bind)到要序列化的实体:这可以在运行时决定

ObjectMapper mapper = new ObjectMapper();
if ("organization".equals(request.getParameter("exapnd")) {
    SimpleModule simpleModule = new SimpleModule();
    simpleModule.setMixInAnnotation(Operator.class, OperatorExpanded.class);
    mapper.registerModule(simpleModule);
}

现在，映射器将从 mixin 中获取注释，但会调用实体的方法。