OrderedSetConverter不知道在初始化过程中必须示例化哪种类型。我们需要指导石化过程使用哪种类型。如果你想保持转换器的通用性，你需要在创建转换器时提供这些信息。要扩展默认行为，您需要实现自定义com.fasterxml.jackson.databind.cfg.HandlerInstantiator：

class ConverterHandlerInstantiator extends HandlerInstantiator {

    @Override
    public Converter<?, ?> converterInstance(MapperConfig<?> config, Annotated annotated, Class<?> implClass) {
        if (config instanceof DeserializationConfig) {
            JsonDeserialize jsonDeserialize = annotated.getAnnotation(JsonDeserialize.class);
            Class contentAs = jsonDeserialize.contentAs();
            if (contentAs != Void.class) {
                return new OrderedSetConverter<>(contentAs);
            }
        }
        return super.converterInstance(config, annotated, implClass);
    }

    @Override
    public JsonDeserializer<?> deserializerInstance(DeserializationConfig config, Annotated annotated, Class<?> deserClass) {
        return null;
    }

    @Override
    public KeyDeserializer keyDeserializerInstance(DeserializationConfig config, Annotated annotated, Class<?> keyDeserClass) {
        return null;
    }

    @Override
    public JsonSerializer<?> serializerInstance(SerializationConfig config, Annotated annotated, Class<?> serClass) {
        return null;
    }

    @Override
    public TypeResolverBuilder<?> typeResolverBuilderInstance(MapperConfig<?> config, Annotated annotated, Class<?> builderClass) {
        return null;
    }

    @Override
    public TypeIdResolver typeIdResolverInstance(MapperConfig<?> config, Annotated annotated, Class<?> resolverClass) {
        return null;
    }
}

正如你在上面注意到的，代码使用了来自JsonDeserialize注解的contentAs属性。我们需要在你的类中指定它：

class MyType {
    @JsonSerialize(converter = OrderedSetConverter.class)
    @JsonDeserialize(converter = OrderedSetConverter.class, contentAs = DayOfWeek.class)
    private Set<DayOfWeek> myValues;
}

当我们序列化对象时，这个值是不需要的，所以，我们可以跳过它。现在，我们需要注册我们的自定义instantiator：

ObjectMapper mapper = new ObjectMapper();
mapper.setHandlerInstantiator(new ConverterHandlerInstantiator());

最后，我们的通用转换器：

class OrderedSetConverter<E extends Comparable<? super E>> extends StdConverter<Set<E>, Set<E>> {
    private final Class<E> contentClass;

    OrderedSetConverter() {
        this(null);
    }

    public OrderedSetConverter(Class<E> contentClass) {
        this.contentClass = contentClass;
    }

    @Override
    public Set<E> convert(Set<E> value) {
        return value == null ? null : value.stream()
                .sorted(Comparator.nullsLast(Comparator.naturalOrder()))
                .collect(Collectors.toCollection(LinkedHashSet::new));
    }

    @Override
    public JavaType getInputType(TypeFactory typeFactory) {
        if (contentClass == null) {
            return super.getInputType(typeFactory);
        }
        return typeFactory.constructCollectionType(Set.class, contentClass);
    }
}

Another answer指出，可以使用自定义的JacksonHandlerInstantiator在对象构造时在Converter中设置类型变量。这个答案需要使用@JsonDeserialize.contentAs手动指定集合类型。在尝试了这种方法之后，我发现了一种在HandlerInstantiator中自动推导类型变量的方法：

HandlerInstantiator

public class OrderedSetConverterHandlerInstantiator extends HandlerInstantiator {
    @Override
    public Converter<?, ?> converterInstance(
            MapperConfig<?> config, Annotated annotated, Class<?> implClass) {
        if (OrderedSetJacksonConverter.class.equals(implClass)) {
            return new OrderedSetJacksonConverter<>(
                    getSetContentType(config, annotated));
        } else {
            return null;
        }
    }

    private JavaType getSetContentType(MapperConfig<?> config, Annotated annotated) {
        Type setType = getPropertyType(config, annotated);
        return TypeFactory.defaultInstance().constructType(setType).getContentType();
    }

    private Type getPropertyType(MapperConfig<?> config, Annotated annotated) {
        // TODO: Enhance to handle other cases, such as annotated constructor parameter
        BeanPropertyDefinition beanPropertyDefinition =
                SimpleBeanPropertyDefinition.construct(config, 
                        (AnnotatedMember) annotated);
        AnnotatedMember setter = beanPropertyDefinition.getSetter();
        AnnotatedMember getter = beanPropertyDefinition.getGetter();
        AnnotatedMember field = beanPropertyDefinition.getField();

        Type setType;
        if (setter != null) {
            setType = ((Method) setter.getMember()).getGenericParameterTypes()[0];
        } else if (getter != null) {
            setType = ((Method) getter.getMember()).getGenericReturnType();
        } else if (field != null) {
            setType = ((Field) field.getMember()).getGenericType();
        } else {
            throw new UnsupportedOperationException(
                    "Annotated type not yet supported: " + annotated.getClass());
        }
        return setType;
    }
    
    // Implement other required methods such as serializerInstance to return null
}

Converter

public class OrderedSetConverter<T extends Comparable<? super T>> 
        extends StdConverter<Set<T>, Set<T>> {
    private final JavaType contentType;

    public OrderedSetJacksonConverter(JavaType contentType) {
        this.contentType = contentType;
    }

    @Override
    public Set<T> convert(Set<T> value) {
        return value == null ? null : value.stream()
                .sorted(Comparator.nullsLast(Comparator.naturalOrder()))
                .collect(Collectors.toCollection(LinkedHashSet::new));
    }

    @Override
    public JavaType getInputType(TypeFactory typeFactory) {
        return typeFactory.constructCollectionType(Set.class, contentType);
    }

    @Override
    public JavaType getOutputType(TypeFactory typeFactory) {
        return typeFactory.constructCollectionType(Set.class, contentType);
    }
}

ObjectMapper配置

JsonMapper jsonMapper = JsonMapper.builder()
            .handlerInstantiator(new OrderedSetConverterHandlerInstantiator())

解决方案的一个笨拙之处在于确定属性类型的方式，因为它手动迭代Annotated值可能是（getter/setter/field）的所有可能的注解元素类型来确定元素类型。希望有一个更干净，更习惯的方法，虽然如果有，我还没有找到它。

在Spring framework中注册转换器

Spring Web附带了自己的HandlerInstantiator，SpringHandlerInstantiator，它会自动应用到由Jackson2ObjectMapperBuilder创建的ObjectMapper。此处理程序使用HandlerInstantiator提供的类型的类路径中的任何相关bean。
为了在使用自定义类型的同时保持这种行为，可以编写一个HandlerInstantiator类，在适当的时候使用自定义转换器，否则回退到默认的SpringHandlerInstantiator。实现这一点的一种方式如下：

public class DelegatingHandlerInstantiator extends SpringHandlerInstantiator {
    private final OrderedSetConverterHandlerInstantiator handler =
            new OrderedSetConverterHandlerInstantiator();

    public DelegatingHandlerInstantiator(AutowireCapableBeanFactory beanFactory) {
        super(beanFactory);
    }

    @Override
    public Converter<?, ?> converterInstance(
            MapperConfig<?> config, Annotated annotated, Class<?> implClass) {
        Converter<?, ?> converter =
                handler.converterInstance(config, annotated, implClass);
        return Objects.requireNonNullElseGet(converter,
                () -> super.converterInstance(config, annotated, implClass));
    }
}

然后，应用程序使用的Jackson2ObjectMapperBuilder应该配置为使用此处理程序。如果应用程序是Spring Boot应用程序，则可以创建Jackson2ObjectMapperBuilderCustomizer bean，以在Jackson2ObjectMapperBuilder bean中设置HandlerInstantiator。

@Configuration
public class JacksonConfig {
    @Bean
    public Jackson2ObjectMapperBuilderCustomizer jacksonCustomizer(
            AutowireCapableBeanFactory beanFactory) {
        return b -> b.handlerInstantiator(
                new DelegatingHandlerInstantiator(beanFactory));
    }
}

一种解决方案是使用JsonSerializer，而不是Converter。

public class MyType {
    @JsonSerialize(using = OrderedSetSerializer.class)
    private Set<DayOfWeek> myValues;
}

import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.ser.ContextualSerializer;
import com.fasterxml.jackson.databind.ser.std.CollectionSerializer;
import com.fasterxml.jackson.databind.ser.std.StdSerializer;

import java.io.IOException;
import java.util.Objects;
import java.util.Set;

public class OrderedSetSerializer<T extends Comparable<? super T>> 
        extends StdSerializer<Set<T>> implements ContextualSerializer {
    private final CollectionSerializer collectionSerializer;

    /**
     * For Jackson to instantiate and call 
     * {@link #createContextual(SerializerProvider, BeanProperty)}.
     */
    public OrderedSetSerializer() {
        super(Set.class, false);
        this.collectionSerializer = null;
    }

    public OrderedSetSerializer(JavaType valueType, 
                                CollectionSerializer collectionSerializer) {
        super(valueType);
        this.collectionSerializer =
                Objects.requireNonNull(collectionSerializer);
    }

    @Override
    public void serialize(Set<T> value, JsonGenerator gen, 
                          SerializerProvider provider) throws IOException {
        Objects.requireNonNull(collectionSerializer,
                "No-arg OrderedSetSerializer cannot be used for serialization, and exists for createContextual");

        Set<T> sorted = value == null ? null : value.stream()
                .sorted(Comparator.nullsLast(Comparator.naturalOrder()))
                .collect(Collectors.toCollection(LinkedHashSet::new));

        collectionSerializer.serialize(sorted, gen, provider);
    }

    @Override
    public JsonSerializer<?> createContextual(SerializerProvider prov, 
                                              BeanProperty property) throws JsonMappingException {
        CollectionSerializer collectionSerializer = 
        new CollectionSerializer(property.getType(), false,
                prov.findTypeSerializer(property.getType()),
                prov.findValueSerializer(property.getType().findTypeParameters(Set.class)[0]));
        return new OrderedSetSerializer<>(property.getType(), collectionSerializer);
    }
}

同样地，为了强制执行格式化顺序，可以使用JsonDeserializer。

public class MyType {
    @JsonDeserialize(using = OrderedSetDeserializer.class)
    private Set<DayOfWeek> myValues;
}

import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.BeanProperty;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.deser.ContextualDeserializer;
import com.fasterxml.jackson.databind.deser.std.StdDeserializer;

import java.io.IOException;
import java.util.Set;

public class OrderedSetDeserializer<T extends Comparable<? super T>> 
        extends StdDeserializer<Set<T>> implements ContextualDeserializer {
    /**
     * For Jackson to instantiate and call
     * {@link #createContextual(DeserializationContext, BeanProperty)}.
     */
    public OrderedSetDeserializer() {
        super(Set.class);
    }

    public OrderedSetDeserializer(JavaType valueType) {
        super(valueType);
    }

    @Override
    public Set<T> deserialize(JsonParser parser, 
                              DeserializationContext context) throws IOException {
        JavaType parameterizedSet = context.getTypeFactory()
                .constructParametricType(Set.class, getValueType().getBindings());
        Set<T> value = context.readValue(parser, parameterizedSet);

        return value == null ? null : value.stream()
                .sorted(Comparator.nullsLast(Comparator.naturalOrder()))
                .collect(Collectors.toCollection(LinkedHashSet::new));
    }

    @Override
    public JsonDeserializer<?> createContextual(DeserializationContext context, 
                                                BeanProperty property) {
        return new OrderedSetDeserializer<>(context.getContextualType());
    }
}