Java ObjectMapper从具有特定名称的字段创建列表

我有一个JSON，我将其解析为结果对象列表。该对象包含5个字符串字段，称为photo1、photo2等（基于JSON），是否可以将它们直接读取到列表字段中

JSON喜欢：

{
    "ErrorMessage": null,
    "Result": [{
        "id": "462290",
        "name_English": "name in english",
        "name_Local": "külföldiül a név",
        "zipcode": "5463",
        "photo1": "dfglkj.com/blabla",
        "photo2": "dfglkj.com/blabla",
        "photo3": "dfglkj.com/blabla",
        "photo4": "dfglkj.com/blabla",
        "photo5": "dfglkj.com/blabla"
    }]
}

我的目标是：

static final class ApiResponse
    {
        public String ErrorMessage;
        public List<Result> Result = new ArrayList<Result>();
    }

 static final class Result
    {
        public String id;
        public String name_English;
        public String name_Local;
        public List<String> photos;
        public String zipcode;
    }

在解析器中：

final ApiResponse ret = OM.readValue(inputStream, ApiResponse.class);

---

我找到的最佳解决方案是为对象映射器定义一个自定义反序列化器

您可以告诉JACKSON使用自定义反序列化器，并在ApiResponse类上对“结果”对象列表进行特定注释：

public class ApiResponse {

    private String errorMessage;

    @JsonDeserialize(using = CustomDeserializer.class)
    private List<Result> result = new ArrayList<Result>();

    public String getErrorMessage() {
        return errorMessage;
    }

    public void setErrorMessage(String arg) {
        errorMessage = arg;
    }

    public List<Result> getResult() {
        if(result==null)
        {
            result = new ArrayList<Result>();
        }
        return result;
    }

    public void setResult(List<Result> arg) {
        result = arg;
    }
}

public class Result {
     private String id;
     private String name_English;
     private String name_Local;
     private List<String> photos;
     private String zipcode;
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getName_English() {
        return name_English;
    }
    public void setName_English(String name_English) {
        this.name_English = name_English;
    }
    public String getName_Local() {
        return name_Local;
    }
    public void setName_Local(String name_Local) {
        this.name_Local = name_Local;
    }
    public List<String> getPhotos() {
        if(photos == null)
        {
            photos = new ArrayList<String>();
        }
        return photos;
    }
    public void setPhotos(List<String> photos) {
        this.photos = photos;
    }
    public String getZipcode() {
        return zipcode;
    }
    public void setZipcode(String zipcode) {
        this.zipcode = zipcode;
    }
}

公共类响应{
私有字符串错误消息；
@JsonDeserialize（使用=CustomDeserializer.class）
私有列表结果=新的ArrayList（）；
公共字符串getErrorMessage（）{
返回错误消息；
}
public void setErrorMessage（字符串arg）{
errorMessage=arg；
}
公共列表getResult（）{
如果（结果==null）
{
结果=新的ArrayList（）；
}
返回结果；
}
公共void setResult（列表参数）{
结果=arg；
}
}
公开课成绩{
私有字符串id；
私有字符串名称\u英语；
私有字符串名称_Local；
私人名单照片；
私有字符串zipcode；
公共字符串getId（）{
返回id；
}
公共无效集合id（字符串id）{
this.id=id；
}
公共字符串getName_English（）{
返回英文名称；
}
public void setName_English（字符串名称_English）{
this.name\u English=name\u English；
}
公共字符串getName_Local（）{
返回本地名称；
}
public void setName_Local（字符串名称_Local）{
this.name\u Local=name\u Local；
}
公共列表getPhotos（）{
如果（照片==null）
{
照片=新的ArrayList（）；
}
归还照片；
}
公众照片（列表照片）{
this.photos=照片；
}
公共字符串getZipcode（）{
返回zipcode；
}
public void setZipcode（字符串zipcode）{
this.zipcode=zipcode；
}
}

请注意java命名约定：

自定义反序列化程序如下所示：

public class CustomDeserializer extends StdDeserializer<List<Result>> {

private static final long serialVersionUID = -3483096770025118080L;

public CustomDeserializer() {
    this(null);
}

public CustomDeserializer(Class<?> vc) {
    super(vc);
}

@Override
public List<Result> deserialize(JsonParser jp, DeserializationContext ctxt)
        throws IOException, JsonProcessingException {
    JsonNode node = jp.getCodec().readTree(jp);

    List<Result> listResult = new ArrayList<Result>();
    for (JsonNode interNode : node) {

        Result result = new Result();           

        if (interNode.get("id") != null) {
            result.setId(interNode.get("id").asText());
        }
        if (interNode.get("name_English") != null) {
            result.setName_English(interNode.get("name_English").asText());
        }
        if (interNode.get("name_Local")!= null) {
            result.setName_Local(interNode.get("name_Local").asText());
        }
        if (interNode.get("zipcode") !=null ) {
            result.setZipcode(interNode.get("zipcode").asText());
        }

        // photo array
        if (interNode.get("photo1") != null) {
            result.getPhotos().add(interNode.get("photo1").asText());
        }
        if (interNode.get("photo2") != null) {
            result.getPhotos().add(interNode.get("photo2").asText());
        }
        if (interNode.get("photo3") != null) {
            result.getPhotos().add(interNode.get("photo3").asText());
        }
        if (interNode.get("photo4") != null) {
            result.getPhotos().add(interNode.get("photo4").asText());
        }
        if (interNode.get("photo5") != null) {
            result.getPhotos().add(interNode.get("photo5").asText());
        }

        listResult.add(result);
    }

    return listResult;
}

public类自定义反序列化程序扩展StdDeserializer{
私有静态最终长serialVersionUID=-34830967700251180L；
公共CustomDeserializer（）{
这个（空）；
}
公共自定义反序列化程序（vc类）{
超级（vc）；
}
@凌驾
公共列表反序列化（JsonParser jp，反序列化上下文ctxt）
抛出IOException、JsonProcessingException{
JsonNode节点=jp.getCodec（）.readTree（jp）；
List listResult=新建ArrayList（）；
for（JsonNode节间：node）{
结果=新结果（）；
if（interNode.get（“id”）！=null）{
result.setId（interNode.get（“id”）.asText（））；
}
if（interNode.get（“name_English”）！=null）{
result.setName_-English（interNode.get（“name_-English”）.astex（））；
}
if（interNode.get（“name_Local”）！=null）{
result.setName_Local（interNode.get（“name_Local”）.astex（））；
}
if（interNode.get（“zipcode”）！=null）{
result.setZipcode（interNode.get（“zipcode”）.asText（））；
}
//照片阵列
if（节间get（“photo1”）！=null）{
result.getPhotos（）.add（interNode.get（“photo1”）.astex（））；
}
if（interNode.get（“photo2”）！=null）{
result.getPhotos（）.add（interNode.get（“photo2”）.astex（））；
}
if（interNode.get（“photo3”）！=null）{
result.getPhotos（）.add（interNode.get（“photo3”）.astex（））；
}
if（节间get（“photo4”）！=null）{
result.getPhotos（）.add（interNode.get（“photo4”）.astex（））；
}
if（节间get（“photo5”）！=null）{
result.getPhotos（）.add（interNode.get（“photo5”）.astex（））；
}
listResult.add（结果）；
}
返回列表结果；
}

如果您可以更改POJO代码，那么最简单的选择就是使用

@JsonAnySetter

和

@JsonAnyGetter

并在那里编写自定义代码。（如建议的那样），但别忘了

@JsonIgnore

列出照片

@Data // lombok.Data; for getters and setters
public static final class Result {
    public String id;
    public String name_English;
    public String name_Local;
    @JsonIgnore
    public List<String> photos = new ArrayList<>();
    public String zipcode;

    @JsonAnySetter
    public void setOther(String key, String value){
        photos.add(value);
    }
    @JsonAnyGetter
    public Map<String,String> getOther(){
        Map<String,String> map = new HashMap<>();
        for (int i = 0;i<photos.size();i++)
            map.put("photo" + i + 1, photos.get(i));
        return map;
    }
}

@Data//lombok.Data；用于getter和setter
公开静态最终课堂结果{
公共字符串id；
公共字符串名称\u英语；
公共字符串名称\u Local；
@杰索尼奥雷
公共列表照片=新建ArrayList（）；
公共字符串zipcode；
@JSONANYSETER
public void setOther（字符串键、字符串值）{
照片。增加（价值）；
}
@JsonAnyGetter
公共地图getOther（）{
Map Map=newhashmap（）；
对于（inti=0；i基于Gaetano的回答，我写了一个更一般的解决方案（任意数量的照片，任意数量的其他字段）

@Override public List<Result> deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException
        {
            JsonNode node = jp.getCodec().readTree(jp);
            List<Result> listResult = new ArrayList<Result>();

            for (JsonNode interNode : node)
            {
                Result result = new Result();

                for (int i = 1; i < 30; i++)
                {
                    if (interNode.get("photo" + i) != null)
                    {
                        result.photos.add(interNode.get("photo" + i).getTextValue());
                    }
                    else
                    {
                        break;
                    }
                }

                for (Field field : result.getClass().getDeclaredFields())
                {
                    if (interNode.get(field.getName()) != null)
                    {
                        try
                        {
                            field.set(result, interNode.get(field.getName()).getTextValue());
                        }
                        catch (IllegalAccessException e)
                        {
                            e.printStackTrace();
                        }
                    }
                }

                listResult.add(result);
            }

            return listResult;
        }

@重写公共列表反序列化（JsonParser jp，反序列化上下文ctxt）引发IOException，JsonProcessingException
{
JsonNode节点=jp.getCodec（）.readTree（jp）；
List listResult=新建ArrayList（）；
for（JsonNode节间：node）
{
结果=新结果（）；
对于（int i=1；i<30；i++）
{
if（节间get（“photo”+i）！=null）
{
result.photos.add（interNode.get（“photo”+i.getTextValue（））；
}
其他的
{
打破
}
}
for（字段：result.getClass（）.getDeclaredFields（））
{
if（interNode.get（field.getName（））！=null）
{
尝试
{
set（result，interNode.get（field.getName（））.getTextValue（））；
}
捕获（非法访问例外e）
@Override public List<Result> deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException
        {
            JsonNode node = jp.getCodec().readTree(jp);
            List<Result> listResult = new ArrayList<Result>();

            for (JsonNode interNode : node)
            {
                Result result = new Result();

                for (int i = 1; i < 30; i++)
                {
                    if (interNode.get("photo" + i) != null)
                    {
                        result.photos.add(interNode.get("photo" + i).getTextValue());
                    }
                    else
                    {
                        break;
                    }
                }

                for (Field field : result.getClass().getDeclaredFields())
                {
                    if (interNode.get(field.getName()) != null)
                    {
                        try
                        {
                            field.set(result, interNode.get(field.getName()).getTextValue());
                        }
                        catch (IllegalAccessException e)
                        {
                            e.printStackTrace();
                        }
                    }
                }

                listResult.add(result);
            }

            return listResult;
        }