好的，所以，问题正确地说明了这一点：不可能使用键不是字符串的JSON映射。因此，要在javascript中模拟Java Map，必须走更长的路，这通常需要将映射转换为。。。其他的东西。

我选择的是非常常见的阵列阵列：

像这样的地图

{
    a:b,
    c:d,
}

然后将转换为阵列

[
    [a,b],
    [c,d],
]

获得结果所需的详细步骤是什么

配置自定义（反）序列化

这是通过在对象映射器中设置序列化工厂来获得的，正如Jackson doc明确解释的那样：

/**
 * Associates all maps with our custom serialization mechanism, which will transform them into arrays of arrays
 * @see MapAsArraySerializer
 * @return
 */
@Produces
public SerializerFactory createSerializerFactory() {
    CustomSerializerFactory customized = new CustomSerializerFactory();
    customized.addGenericMapping(Map.class, new MapAsArraySerializer());
    return customized;
}
public @Produces ObjectMapper createMapper() {
    ObjectMapper jsonMapper = new ObjectMapper();
    // ....
    // now configure serializer
    jsonMapper.setSerializerFactory(createSerializerFactory());
    // ....
    return jsonMapper;
}

这个过程看起来很简单，主要是因为序列化在序列化中提供了非常正确的多态性特性，而这些特性对反序列化来说并不是很好。事实上，正如doc所说，反序列化需要添加显式的类映射，这些映射不以任何面向对象的方式使用（继承性不支持）

/**
 * Defines a deserializer for each and any used map class, as there is no inheritence support ind eserialization
 * @return
 */
@Produces
public DeserializerProvider createDeserializationProvider() {
    // Yeah it's not even a standard Jackson class, it'll be explained why later
    CustomDeserializerFactory factory = new MapAsArrayDeserializerFactory();
    List<Class<? extends Map>> classesToHandle = new LinkedList<>();
    classesToHandle.add(HashMap.class);
    classesToHandle.add(LinkedHashMap.class);
    classesToHandle.add(TreeMap.class);
    for(Class<? extends Map> c : classesToHandle) {
        addClassMappingFor(c, c, factory);
    }
    // and don't forget interfaces !
    addClassMappingFor(Map.class, HashMap.class, factory);
    addClassMappingFor(SortedMap.class, TreeMap.class, factory);
    return new StdDeserializerProvider(factory);
}
private void addClassMappingFor(final Class<? extends Map> detected, final Class<? extends Map> created, CustomDeserializerFactory factory) {
    factory.addSpecificMapping(detected, new MapAsArrayDeserializer() {
        @Override
        protected Map createNewMap() throws Exception {
            return created.newInstance();
        }
    });
}
// It's the same createMapper() method that was described upper
public @Produces ObjectMapper createMapper() {
    ObjectMapper jsonMapper = new ObjectMapper();
    // ....
    // and deserializer
    jsonMapper.setDeserializerProvider(createDeserializationProvider());
    return jsonMapper;
}

现在我们已经正确地定义了如何自定义（反）序列化，或者我们已经定义了吗？事实上，不：MapAsArrayDeserializerFactory应该有自己的解释。

经过一些调试，我发现当类不存在反序列化程序时，DeserializerProvider会委托给DeserializerFactory，这很酷。但是，DeserializerFactory根据obejct的"种类"创建反序列化器：如果它是一个集合，则将使用CollectionDeserializer（将数组读取到集合中）。如果是地图，则将使用MapDeserializer。

不幸的是，这个解决方案使用了JSON流中给定的java类（尤其是在使用多态反序列化时，我就是这样）。因此，配置自定义反序列化没有任何效果，除非CustomDeserializerFactory是自定义的。。。像这样：

public class MapAsArrayDeserializerFactory extends CustomDeserializerFactory {
    @Override
    public JsonDeserializer<?> createMapDeserializer(DeserializationConfig config, MapType type, DeserializerProvider p) throws JsonMappingException {
        return createBeanDeserializer(config, type, p);
    }
}

是的，我将所有映射反序列化为bean。但现在，我所有的反序列化程序都被正确调用了。

序列化

现在，序列化是一项相当简单的任务：

public class MapAsArraySerializer extends JsonSerializer<Map> {
    @SuppressWarnings("unchecked")
    private Set asListOfLists(Map<?, ?> value) {
        Set returned = new HashSet<>();
        for(Map.Entry e : value.entrySet()) {
            returned.add(Arrays.asList(e.getKey(), e.getValue()));
        }
        return returned;
    }
    @Override
    public void serialize(Map value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonProcessingException {
        Collection entries = asListOfLists(value);
        jgen.writeObjectField("entries", entries);
    }
    @Override
    public void serializeWithType(Map value, JsonGenerator jgen, SerializerProvider provider, TypeSerializer typeSer) throws IOException,
                    JsonProcessingException {
        Collection entries = asListOfLists(value);
        typeSer.writeTypePrefixForObject(value, jgen);
        jgen.writeObjectField("entries", entries);
        typeSer.writeTypeSuffixForObject(value, jgen);
    }
}

反序列化

反序列化并不复杂：

public abstract class MapAsArrayDeserializer<Type extends Map> extends JsonDeserializer<Type> {
    protected Type newMap(Collection c, Type returned) {
        for(Object o : c) {
            if (o instanceof List) {
                List l = (List) o;
                if(l.size()==2) {
                    Iterator i = l.iterator();
                    returned.put(i.next(), i.next());
                }
            }
        }
        return returned;
    }
    protected abstract Type createNewMap() throws Exception;
    @Override
    public Type deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException {
        if(jp.getCurrentToken().equals(JsonToken.START_OBJECT)) {
            JsonToken nameToken = jp.nextToken();
            String name = jp.getCurrentName();
            if(name.equals("entries")) {
                jp.nextToken();
                Collection entries = jp.readValueAs(Collection.class);
                JsonToken endMap = jp.nextToken();
                try {
                    return newMap(entries, createNewMap());
                } catch(Exception e) {
                    throw new IOException("unable to create receiver map", e);
                }
            } else {
                throw new IOException("expected '"entries'", but field name was '""+name+"'"");
            }
        } else {
            throw new IOException("not startying an object ? Not possible");
        }
    }
    @Override
    public Type deserializeWithType(JsonParser jp, DeserializationContext ctxt, TypeDeserializer typeDeserializer) throws IOException,
                    JsonProcessingException {
        Object value = typeDeserializer.deserializeTypedFromObject(jp, ctxt);
        return (Type) value;
    }
}

好吧，预期类是左抽象的，让每个声明的子类型创建右映射实例。

现在

现在它在Java端无缝工作（因为Javascript必须有一个映射等效对象来读取这些数据。