Question

我有几个对象 - 使用Json导入的A类。每个都有2个字段。

Several Objects (of Class A)
  - field-1
  - field-2

在程序中 - 字段的值会发生变化。然后返回这些对象以及更新的字段。

在程序中 - 我们需要为每个对象“创建并跟踪”少数“临时”字段 - 例如

Several Objects (of Class A)
  - field-1
  - field-2
  - Temp-field-3
  - Temp-field-4

跑完之后。使用原始字段（即字段-1和字段-2）发回对象。

A类 - 被多个程序使用，因此我们无法将“Temp”字段添加到Class定义本身。

现在 - 我将A类对象（2个字段）映射到B类对象（其中包含4个字段 - 包括临时字段;程序本地）。在运行结束时 - 使用来自B类的相应对象的字段值更新A类对象。

有更好的方法吗？

Answer 1

Json is a lightweight data-interchange format.，因此没有变量定义或处理数据的方法。

您所描述的是您想要读取初始值，然后更改它，然后保存它们......这些更改似乎适合在程序内部完成，然后根据需要存储输出。这种方式的执行方式在很大程度上取决于您的需求。

如果你拥有的只是一台机器执行所有必需的操作，那么让Class A JSON持有两个字段，然后执行所有操作，然后再次输出Class A JSON，而不是Class B JSON

但是，如果inbetween文件很重要，那么使用Class B JSON是一个很好的方法。

如果可以，请说明最符合您需求的条件。否则，我们只能猜出你想要的东西，从而表明我们对它的看法。

Answer 2

如果您的代码有特殊需求，最好隔离并内化该需求，而不是污染类空间。

您可以通过在想要跟踪临时值的类中保留map.remove(obj)来实现此目的。地图的关键是要处理的对象。地图的值包含临时值。

当您不再需要临时值时，请致电{{1}}。

Answer 3

我不太明白你想要做什么，但我希望这会有所帮助：

abstract class A{
    int a;
    int b;
    public void update(){
        changeA();
        changeB();
    }
    protected abstract void changeA();
    protected abstract void changeB();
}
class B extends A{
    int c,d;
    protected void changeA(){
        a += c;
    }
    protected void changeB(){
        b += d;
    }
}

Answer 4

您可以通过使用transient或JsonIgnore避免从A映射到B（以及B到A），如下所示。

下面的工作示例解释了它。它是单个对象的帐户，但您可以轻松地为对象列表扩展它。

这样你仍然可以控制扩展类，但性能明智，它不会产生任何开销。并且您的序列化代码不受A类中任何更改的影响 - 例如添加了新字段。

假设你的班级A有以下字段。

class A {
    String name;
    String id;
    public String getName() {return name;}
    public void setName(String name) {this.name = name;}
    public String getId() {return id;}
    public void setId(String id) {this.id = id;}
}

如下定义B类

class B extends A {
    @JsonIgnore
    transient String temp_1;
    @JsonIgnore
    transient String temp_2;
    //Getter and setters
    public String getTemp_1() {return temp_1;}
    public void setTemp_1(String temp_1) {this.temp_1 = temp_1;}
    public String getTemp_2() {return temp_2;}
    public void setTemp_2(String temp_2) {this.temp_2 = temp_2;}
}

示例代码 - 请注意，它直接反序列化为对象B而不是A.

import java.io.IOException;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;

public class Sample {

    public B fromJson(String jsonA) throws Exception {
        ObjectMapper mapper = new ObjectMapper();
        return mapper.readValue(jsonA, B.class);
    }

    public void doProcess(B b){
        b.setTemp_1("newTemp1");
        b.setName("newName");
    }
    public String toJson(B b) throws JsonProcessingException{
        ObjectMapper mapper = new ObjectMapper();
        return mapper.writeValueAsString(b);
    }

    public static void main(String[] args) 
       throws JsonParseException, JsonMappingException, IOException {

        String incomingJson = "{ \"id\": \"123\",  \"name\" : \"JM\" }";
        System.out.println("Input->  " + incomingJson);
        Sample sample = new Sample();
        B b = sample.fromJson(incomingJson);
        sample.doProcess(b);
        String modifiedJson = sample.toJson(b);
        System.out.println("Output-> "+modifiedJson);
    }
}

输出

Input->  { "id": "123",  "name" : "JM" }
Output-> {"name":"newName","id":"123"}

Java - 处理对象

4 个答案: