Jackson DTO deep copy: non-invasively ignore specific types and their array fields

This article explores how to non-intrusively ignore non-serializable fields when doing DTO deep copies with Jackson, especially when those fields are arrays of a specific type. Through `ObjectMapper#addMixIn()` and `@JsonIgnoreType`, types such as `MultipartFile` and its array `MultipartFile[]` can be flexibly excluded, thereby avoiding serialization exceptions and achieving smooth cloning of DTOs. The article also pointed out that the use of generic collections (such as `List `) limitations.

In modern Java application development, especially under the Spring Boot framework, deep copying of data transfer objects (DTO) is a common requirement. For example, when processing web requests, we may need to copy a DTO containing a user-uploaded file (such as MultipartFile) for subsequent processing or state snapshots. However, objects such as MultipartFile are usually non-serializable, and direct cloning using ObjectOutputStream and ObjectInputStream will result in NotSerializableException.

When the DTO class definition cannot be modified (that is, the transient keyword or the @JsonIgnore annotation cannot be added), Jackson's ObjectMapper provides a powerful non-intrusive solution: the Mix-in mechanism .

Overview of Jackson Mix-in Mechanism

Jackson's Mix-in mechanism allows us to add or override Jackson's serialization/deserialization behavior for the target class without modifying the source code. This is accomplished by mapping a "Mix-in" interface or abstract class to the target class. Mix-in classes can contain any Jackson annotations, which will be considered part of the target class.

To ignore a field of a specific type, we can define an empty Mix-in class annotated with @JsonIgnoreType and apply it to the target type. The @JsonIgnoreType annotation instructs Jackson to completely ignore the serialization and deserialization of this type and all its instances.

 import com.fasterxml.jackson.annotation.JsonIgnoreType;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.web.multipart.MultipartFile;

//Define a Mix-in interface for ignoring specific types @JsonIgnoreType
abstract class JacksonMixInForIgnoreType {}

Ignore a single field of a specific type

Suppose our DTO contains a field of type MultipartFile. We can map JacksonMixInForIgnoreType to MultipartFile.class through the ObjectMapper#addMixIn() method.

 public class DtoCloner {

    private Object makeClone(Object obj) {
        ObjectMapper mapper = new ObjectMapper();
        //Apply JacksonMixInForIgnoreType to the MultipartFile class so that it is ignored mapper.addMixIn(MultipartFile.class, JacksonMixInForIgnoreType.class);
        try {
            // First serialize to JSON string, then deserialize back to object to achieve deep copy return mapper.readValue(mapper.writeValueAsString(obj), obj.getClass());
        } catch (JsonProcessingException e) {
            throw new RuntimeException("DTO cloning failed", e);
        }
    }

    // ...other methods}

This approach works well for situations where a single MultipartFile field is included in the DTO. When Jackson tries to serialize obj and encounters a field of type MultipartFile, it will be ignored directly according to the Mix-in configuration, thus avoiding serialization exceptions.

Solve the problem of ignoring array type fields

However, when the DTO contains fields of type MultipartFile[] (MultipartFile array), the above strategy will fail. When Jackson serializes an array, it attempts to serialize each element in the array. Since we only added a Mix-in to MultipartFile.class and MultipartFile[] itself is a different type (array type), Jackson will try to serialize the MultipartFile instances in the array and still end up throwing an InvalidDefinitionException because it cannot find the serializer for some non-serializable fields inside MultipartFile (such as the FileDescriptor in the inputStream).

To solve this problem, we need to add a Mix-in to the array type itself. This means that if a DTO contains a field like MultipartFile[] fileArray;, we not only have to ignore MultipartFile.class, but also explicitly ignore MultipartFile[].class.

 public class DtoCloner {

    private Object makeClone(Object obj) {
        ObjectMapper mapper = new ObjectMapper();
        // Ignore a single MultipartFile type mapper.addMixIn(MultipartFile.class, JacksonMixInForIgnoreType.class);
        //Additionally ignore the MultipartFile array type mapper.addMixIn(MultipartFile[].class, JacksonMixInForIgnoreType.class);
        try {
            return mapper.readValue(mapper.writeValueAsString(obj), obj.getClass());
        } catch (JsonProcessingException e) {
            throw new RuntimeException("DTO cloning failed", e);
        }
    }

    //Define a Mix-in interface for ignoring specific types @JsonIgnoreType
    abstract class JacksonMixInForIgnoreType {}
}

By adding JacksonMixInForIgnoreType to both MultipartFile.class and MultipartFile[].class, Jackson will directly ignore these two types when encountering them, thus successfully achieving deep copying of DTOs.

Notes on collection type fields (such as List)

It is worth noting that this addMixIn strategy does not apply to the direct ignoring of generic collections (such as List, Set). Jackson's Mix-in mechanism mainly acts on specific classes or interface types. List is a List type at runtime, and its generic parameter MultipartFile does not directly participate in Mix-in type matching after type erasure.

This means that even if you try mapper.addMixIn(List.class, JacksonMixInForIgnoreType.class) this will just ignore all List instances, which is generally not the desired behavior as it will ignore all lists, not just the one containing a MultipartFile. Currently, there is no direct, general way to ignore the collection type of a specific generic parameter via ObjectMapper#addMixIn(). For cases like this, other strategies may need to be considered, such as using @JsonIgnore at the DTO level (if the DTO is modifiable), or writing custom serializers/deserializers to handle fields containing these specific collections.

Complete sample code

Here is a complete example code covering all the key points mentioned above, showing how to use Jackson to do a deep copy of a DTO, ignoring the MultipartFile and its array:

import com.fasterxml.jackson.annotation.JsonIgnoreType;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.web.multipart.MultipartFile;

import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;

/**
 * Demonstrate how to use Jackson to perform DTO deep copy and ignore specific

The above is the detailed content of Jackson DTO deep copy: non-invasively ignore specific types and their array fields. For more information, please follow other related articles on the PHP Chinese website!